public static int ChangeKind(int sourceKId, Kind kind)
		{
			if (sourceKId == InvalidKId)
				return InvalidKId;

			return sourceKId & 0x00ffffff | (int)kind;
		}

 public Card(int kind, int rank)
 {
     _kind = (Kind)kind;
     _rank = (CardRank)rank;
     _image = new Image();
     _image.Stretch = Stretch.Fill;
 }

    /// <summary>
    /// Translate the skin string, create the skin string if not found.
    /// </summary>
    /// <param name="line"></param>
    /// <param name="kind"></param>
    /// <returns></returns>
    public static int TranslateSkinString(string line, Kind kind)
    {
      Dictionary<int, SkinString>.Enumerator enumer = _skinStringSettings.GetEnumerator();
      while (enumer.MoveNext())
      {
        SkinString skin = enumer.Current.Value;
        if (skin.Name == line)
        {
          return enumer.Current.Key;
        }
      }

      SkinString newString = new SkinString();
      newString.Name = line;
      newString.Value = line;
      newString.Kind = kind;

      // Create the setting as a property if not already present.
      if (!GUIPropertyManager.PropertyIsDefined(newString.Name))
      {
        GUIPropertyManager.SetProperty(newString.Name, newString.Value);
      }
      else
      {
        newString.Value = GUIPropertyManager.GetProperty(newString.Name);
      }

      int key;
      lock (_skinStringSettings) //Lock the dictionary, it might be getting saved at the moment
      {
        key = _skinStringSettings.Count;
        _skinStringSettings[key] = newString;
      }
      return key;
    }

        public void AddStat(Kind kind, int amount, int turn)
        {
            if(turn >= MAX_TURNS)
                throw new Exception("Statistic can have only " + MAX_TURNS + " columns");

            statistic[(int)kind][turn] += amount;
        }

 private object CreateSinkOrSource(Kind kind, bool isOut)
 { 
     switch (kind)
     {
         case Kind.Stream:
             return isOut ? new MemoryStream() : new MemoryStream(Encoding.Default.GetBytes(Content));
         case Kind.File:
             var path = GetPath(isOut);
             if (!isOut)
             {
                 File.WriteAllText(path, Content);
             }
             return new FileInfo(path);
         case Kind.ReaderWriter:
             return isOut ? new StringWriter() : new StringReader(Content).As<object>();
         case Kind.String:
             return Content;
         case Kind.Chars:
             return isOut ? new List<char>() : Content.ToCharArray().As<object>();
         case Kind.Lines:
             return isOut ? new List<string>() : Content.Split(new[] { Environment.NewLine }, StringSplitOptions.None).As<object>();
         default:
             throw new InvalidOperationException();
     }
 }

 public void StopEmotion(Kind k)
 {
     if( emotionRequests.Contains(k) ) {
         emotionRequests.RemoveAll(x => x == k);
         _PlayEmotionOfLastCapables();
     }
 }

 internal void SwitchKind()
 {
     if (!changed)
     {
         if ((int)kind < 2)
         {
             kind++;
         }
         else
         {
             kind = (Kind)0;
         }
         switch (kind)
         {
             case Kind.Rock:
                 couleur = Color.Red;
                 chiffre = 0;
                 break;
             case Kind.Turret:
                 couleur = Color.Green;
                 chiffre = 2;
                 break;
             case Kind.Creep:
                 couleur = Color.White;
                 chiffre = 1;
                 break;
             default:
                 break;
         }
         changed = true;
     }
 }

 private bool _IsOnceAnimation(Kind k)
 {
     switch(k) {
     case Kind.Exclamation:
         return true;
     case Kind.Question:
         return true;
     case Kind.Berserk:
         return false;
     case Kind.Hungry:
         return false;
     case Kind.Kirakira:
         return false;
     case Kind.Ohana:
         return false;
     case Kind.Onpu:
         return true;
     case Kind.Paralize:
         return false;
     case Kind.Poison:
         return false;
     case Kind.Sleep:
         return false;
     case Kind.Star:
         return false;
     case Kind.Wakatta:
         return true;
     }
     return false;
 }

 /// <summary>
 /// Writes a binary field to data file.
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="kind"></param>
 /// <param name="offset"></param>
 /// <param name="v"></param>
 public static void BinWrite(FileStream stream, Kind kind, long offset, object v)
 {
     var v_str = v.ToString();
     stream.Position = offset;
     var writer = new BinaryWriter(stream);
     switch (kind)
     {
         case Kind.Byte:
             writer.Write(byte.Parse(v_str));
             break;
         case Kind.Int16:
             writer.Write(short.Parse(v_str));
             break;
         case Kind.Int32:
             writer.Write(int.Parse(v_str));
             break;
         case Kind.Int64:
             writer.Write(long.Parse(v_str));
             break;
         case Kind.Single:
             writer.Write(float.Parse(v_str));
             break;
         case Kind.Double:
             writer.Write(double.Parse(v_str));
             break;
         default:
             throw new Exception("Invalid type code.");
     }
     writer.Flush();
 }

 //     INITIALIZATION
 //_________________________________________________________________________________________
 /// <summary>
 /// Creates a new set iterator.
 /// </summary>
 /// <param name="prototype"> The next object in the prototype chain. </param>
 /// <param name="set"> The set to iterate over. </param>
 /// <param name="list"> The linked list to iterate over. </param>
 /// <param name="kind"> The type of values to return. </param>
 internal SetIterator(ObjectInstance prototype, SetInstance set, LinkedList<object> list, Kind kind)
     : base(prototype)
 {
     this.set = set;
     this.set.BeforeDelete += Set_BeforeDelete;
     this.list = list;
     this.kind = kind;
 }

 public VariableDeclaration(string name, string type, bool isArray,
     Kind kind, int row, int col)
     : base(name, type, isArray, row, col)
 {
     VariableKind = kind;
     LocalIndex = 0;
     Used = false;
 }

 public Outcome(string type, Kind kind, Vector vector, string message, int nesting = 0)
 {
     this.Type = type;
     this.Kind = kind;
     this.Vector = vector;
     this.Message = message;
     this.Nesting = nesting;
 }

 //     INITIALIZATION
 //_________________________________________________________________________________________
 /// <summary>
 /// Creates a new map iterator.
 /// </summary>
 /// <param name="prototype"> The next object in the prototype chain. </param>
 /// <param name="map"> The map to iterate over. </param>
 /// <param name="list"> The linked list to iterate over. </param>
 /// <param name="kind"> The type of values to return. </param>
 internal MapIterator(ObjectInstance prototype, MapInstance map, LinkedList<KeyValuePair<object, object>> list, Kind kind)
     : base(prototype)
 {
     this.map = map;
     this.map.BeforeDelete += Map_BeforeDelete;
     this.list = list;
     this.kind = kind;
 }

        public Concept(string name, Kind kind)
        {
            id = 0;
            this.name = name;

            this.kind = kind;

            loaded = false;
        }

 public CleanupWorkItem(Kind task, string relativePath, string physicalPath)
 {
     this.task = task;
     this.relativePath = relativePath;
     this.physicalPath = physicalPath;
     if (this.relativePath.StartsWith("/")) {
         Debug.WriteLine("Invalid relativePath value - should never have leading slash!");
     }
 }

 public void Add(string type, Kind kind, Vector vector, string message, params object[] args)
 {
     Outcome outcome;
     outcome.Type = type;
     outcome.Vector = vector;
     outcome.Message = string.Format(message, args);
     outcome.Kind = kind;
     outcome.Nesting = this.nesting;
     Outcomes.Add(outcome);
 }

 public Weapon(Kind kind, string name, string modelName, int baseDamage, float attackInterval, string attackSound, Vector3 firstPersonPosition)
 {
     this.WeaponKind = kind;
     this.Name = name;
     this.ModelName = modelName;
     this.BaseDamage = baseDamage;
     this.AttackInterval = attackInterval;
     this.AttackSound = attackSound;
     this.FirstPersonPosition = firstPersonPosition;
 }

        public RangedWeapon(Kind kind, string name, string modelName, int baseDamage, float attackInterval, string attackSound, Vector3 firstPersonPosition,
			float minInaccuracy, float maxInaccuracy, float inaccuracyGrowth, float maxRecoil, float recoilGrowth, Vector3 MuzzleFlashPosition)
            : base(kind, name, modelName, baseDamage, attackInterval, attackSound, firstPersonPosition)
        {
            this.MinInaccuracy = minInaccuracy;
            this.MaxInaccuracy = maxInaccuracy;
            this.InaccuracyGrowth = inaccuracyGrowth;
            this.MaxRecoil = maxRecoil;
            this.RecoilGrowth = recoilGrowth;
            this.MuzzleFlashPosition = MuzzleFlashPosition;
        }

        public override Style FromString(string s)
        {
            s = s.Trim();

            Kind result;
            if (!Enum.TryParse<Kind>(s, true, out result))
                throw new Exception("Invalid white-space value: " + s);

            this.Value = result;
            return this;
        }

 public Move(string name, string description, int damage, int accuracy, int uses, Kind kind, Type type)
 {
     Name = name;
     Description = description;
     BaseDamage = damage;
     Accuracy = accuracy;
     Uses = uses;
     MaxUses = uses;
     Kind = kind;
     Type = type;
 }