public override void ExecuteCommand(ICharacter character, Identity target, string[] args)
 {
     Vendor v = Pool.Instance.GetObject<Vendor>(character.Playfield.Identity, target);
     if (v != null)
     {
         int pfid = character.Playfield.Identity.Instance;
         StatelData sd =
             PlayfieldLoader.PFData[pfid].Statels.FirstOrDefault(x => x.Identity.Equals(v.OriginalIdentity));
         if (sd != null)
         {
             int instance = (((sd.Identity.Instance) >> 16) & 0xff
                             | (character.Playfield.Identity.Instance << 16));
             DBVendor dbv = new DBVendor();
             dbv.Id = instance;
             dbv.Playfield = pfid;
             dbv.X = sd.X;
             dbv.Y = sd.Y;
             dbv.Z = sd.Z;
             dbv.HeadingX = sd.HeadingX;
             dbv.HeadingY = sd.HeadingY;
             dbv.HeadingZ = sd.HeadingZ;
             dbv.HeadingW = sd.HeadingW;
             dbv.Name = "New shop, please fill me";
             dbv.TemplateId = sd.TemplateId;
             dbv.Hash = "";
             VendorDao.Instance.Delete(dbv.Id);
             VendorDao.Instance.Add(dbv, dontUseId: false);
         }
     }
 }

        private void Input(ICharacter player)
        {
            var info = Console.ReadKey();

            switch (info.Key)
            {
                case ConsoleKey.Spacebar:
                    var ninja = Enemies.FirstOrDefault();

                    player.Atack(ninja);

                    if (ninja != null && ninja.Blood == 0)
                    {
                        Enemies.Remove(ninja);
                    }
                    break;

                case ConsoleKey.LeftArrow:
                    player.Move(Direction.Left);
                    break;

                case ConsoleKey.UpArrow:
                    player.Move(Direction.Up);
                    break;

                case ConsoleKey.RightArrow:
                    player.Move(Direction.Right);
                    break;

                case ConsoleKey.DownArrow:
                    player.Move(Direction.Down);
                    break;
            }
        }

		public void AddText(ICharacter character, params string[] sentences)
		{
			foreach (string sentence in sentences)
			{
				Actions.Add(new AGSDialogAction (character, sentence));
			}
		}

    /// <summary>
    /// Sets the stat scaling on this weapon based on the user character's selected attribute. </summary>
    /// <param name='userStats'> User character's stat module. </param>
    public void SetScaling(ICharacter user)
    {
        switch (scalingAttribute) {
                case CharacterAttribute.AttributeName.Vitality:
                        _scalingAtt = user.CharStats.Vitality;
                        break;
                case CharacterAttribute.AttributeName.Endurance:
                        _scalingAtt = user.CharStats.Endurance;
                        break;
                case CharacterAttribute.AttributeName.Spirit:
                        _scalingAtt = user.CharStats.Spirit;
                        break;
                case CharacterAttribute.AttributeName.Strength:
                        _scalingAtt = user.CharStats.Strength;
                        break;
                case CharacterAttribute.AttributeName.Dexterity:
                        _scalingAtt = user.CharStats.Dexterity;
                        break;
                case CharacterAttribute.AttributeName.Mind:
                        _scalingAtt = user.CharStats.Mind;
                        break;
                default:
                        _scalingAtt = null;
                        break;
                }

                if (_scalingAtt == null)
                        Debug.Log ("no scaling attribute set!");
    }

        public virtual int Hit(ICharacter enemy)
        {
            int damage = (this.Damage +this.Master.AttackPoints/10)*(1000 - enemy.DefencePoints)/1000;
            enemy.HealthPoints -= damage;

            return damage;
        }

        public override void Update(GameTime gameTime, ICharacter character)
        {
            this.TimeSinceLastFrame += gameTime.ElapsedGameTime.Milliseconds;
            if (this.TimeSinceLastFrame < this.TimePerFrame)
            {
                return;
            }
            this.TimeSinceLastFrame = gameTime.ElapsedGameTime.Milliseconds;

            KeyboardState keyState = Keyboard.GetState();

            bool moving = ((Player)character).KbKeys.Any(key => keyState.IsKeyDown(key));

            if (moving || this.CurrentFrame != 5)
            {
                if (this.reverse)
                {
                    this.CurrentFrame--;
                }
                else
                {
                    this.CurrentFrame++;
                }

                if (this.CurrentFrame == this.TotalFrames - 1 || this.CurrentFrame == 0)
                {
                    this.reverse = !this.reverse;
                }
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="OccupancyChangedEventArgs"/> class.
 /// </summary>
 /// <param name="occupant">The occupant.</param>
 /// <param name="departureRoom">The departure room.</param>
 /// <param name="arrivalRoom">The arrival room.</param>
 public OccupancyChangedEventArgs(ICharacter occupant, ITravelDirection travelDirection, DefaultRoom departureRoom, DefaultRoom arrivalRoom)
 {
     this.Occupant = occupant;
     this.DepartureRoom = departureRoom;
     this.ArrivalRoom = arrivalRoom;
     this.TravelDirection = travelDirection;
 }

 public virtual void MapToEntity(ICharacterModel model, ref ICharacter entity, int currentDepth = 1)
 {
     currentDepth++;
     // Assign Base properties
     NameableEntityMapper.MapToEntity(model, ref entity);
     // Character Properties
     entity.RealName = model.RealName;
     entity.DateOfBirth = model.DateOfBirth;
     // Related Objects
     entity.PrimaryImageFileId = model.PrimaryImageFileId;
     entity.PrimaryImageFile = (ImageFile)model.PrimaryImageFile?.MapToEntity();
     entity.FirstIssueAppearanceId = model.FirstIssueAppearanceId;
     entity.FirstIssueAppearance = (Issue)model.FirstIssueAppearance?.MapToEntity();
     entity.GenderId = model.GenderId;
     entity.Gender = (Gender)model.Gender?.MapToEntity();
     entity.OriginId = model.OriginId;
     entity.Origin = (Origin)model.Origin?.MapToEntity();
     entity.PublisherId = model.PublisherId;
     entity.Publisher = (Publisher)model.Publisher?.MapToEntity();
     // Associated Objects
     entity.CharacterAliases = model.CharacterAliases?.Where(i => i.Active).Select(CharacterAliasMapperExtensions.MapToEntity).ToList();
     entity.CharacterCreators = model.CharacterCreators?.Where(i => i.Active).Select(CharacterCreatorMapperExtensions.MapToEntity).ToList();
     entity.CharacterEnemies = model.CharacterEnemies?.Where(i => i.Active).Select(CharacterEnemyMapperExtensions.MapToEntity).ToList();
     entity.CharacterEnemyTeams = model.CharacterEnemyTeams?.Where(i => i.Active).Select(CharacterEnemyTeamMapperExtensions.MapToEntity).ToList();
     entity.CharacterFriends = model.CharacterFriends?.Where(i => i.Active).Select(CharacterFriendMapperExtensions.MapToEntity).ToList();
     entity.CharacterFriendlyTeams = model.CharacterFriendlyTeams?.Where(i => i.Active).Select(CharacterFriendlyTeamMapperExtensions.MapToEntity).ToList();
     entity.CharacterIssuesAppearedIn = model.CharacterIssuesAppearedIn?.Where(i => i.Active).Select(CharacterAppearedInIssueMapperExtensions.MapToEntity).ToList();
     entity.CharacterIssuesDiedIn = model.CharacterIssuesDiedIn?.Where(i => i.Active).Select(CharacterDiedInIssueMapperExtensions.MapToEntity).ToList();
     entity.CharacterIssues = model.CharacterIssues?.Where(i => i.Active).Select(CharacterIssueMapperExtensions.MapToEntity).ToList();
     entity.CharacterMovies = model.CharacterMovies?.Where(i => i.Active).Select(CharacterMovieMapperExtensions.MapToEntity).ToList();
     entity.CharacterPowers = model.CharacterPowers?.Where(i => i.Active).Select(CharacterPowerMapperExtensions.MapToEntity).ToList();
     entity.CharacterStoryArcs = model.CharacterStoryArcs?.Where(i => i.Active).Select(CharacterStoryArcMapperExtensions.MapToEntity).ToList();
     entity.CharacterTeams = model.CharacterTeams?.Where(i => i.Active).Select(CharacterTeamMapperExtensions.MapToEntity).ToList();
     entity.CharacterVolumes = model.CharacterVolumes?.Where(i => i.Active).Select(CharacterVolumeMapperExtensions.MapToEntity).ToList();
 }

        //TODO:from int to double return type
        public void CheckHandPower(ICharacter player, IList<ICard> tableCards)
        {
            decimal powerToSet = 0;

            powerToSet = CheckFourOfKind(player, tableCards);
            if (powerToSet >= initialPowerFourOfKind)
            {
                player.Power = powerToSet;
                return;
            }

            powerToSet = CheckForFullHouse(player, tableCards);
            if (powerToSet >= initialPowerFullHouse)
            {
                player.Power = powerToSet;
                return;
            }


            powerToSet = CheckForFlush(player, tableCards);
            if (powerToSet >= initialPowerFlush)
            {
                player.Power = powerToSet;
                return;
            }

            powerToSet = CheckForStraight(player, tableCards);
            if (powerToSet >= initialPowerStraight)
            {
                player.Power = powerToSet;
                return;
            }

            powerToSet = CheckForThreeOfKind(player, tableCards);
            if (powerToSet >= initialPowerThreeOfKind)
            {
                player.Power = powerToSet;
                return;
            }

            powerToSet = CheckForTwoPair(player, tableCards);
            if (powerToSet >= initialPowerTwoPair)
            {
                player.Power = powerToSet;
                return;
            }

            powerToSet = CheckForOnePair(player, tableCards);
            if (powerToSet >= initialPowerOnePair)
            {
                player.Power = powerToSet;
                return;
            }

            powerToSet = CheckForHighCard(player);
            if (powerToSet >= 1)
            {
                player.Power = powerToSet;
            }
        }

 //
 // This constructor's purpose is entirely for making a deep copy of the object type
 //
 public Character(ICharacter c)
 {
     foreach (var property in typeof(Character).GetProperties())
     {
         property.SetValue(this, property.GetValue(c));
     }
 }

        private int Choose(ICharacter player)
        {
            ICharacter target = new Enemy();

            var random = new Random();

            ConsoleKeyInfo option = Console.ReadKey(true);

            switch (option.Key)
            {
                case ConsoleKey.Escape:
                    Environment.Exit(0);
                    break;

                case ConsoleKey.A:
                    player.Move(Direction.Up);
                    break;

                case ConsoleKey.B:
                    player.Atack(target);
                    break;
                
            }

            return random.Next(0, 1980);
        }

 public static void ToStringModelView(ICharacter c, int nest, StringBuilder sb, out bool oneLiner)
 {
     if (c is Sprite)
     {
         ((Sprite)c).ToStringModelView(nest, sb, out oneLiner);
     }
     else if (c is EditText)
     {
         ((EditText)c).ToStringModelView(nest, sb, out oneLiner);
     }
     else if (c is StaticText)
     {
         ((StaticText)c).ToStringModelView(nest, sb, out oneLiner);
     }
     else if (c is IImage)
     {
         ((IImage)c).ToStringModelView(nest, sb, out oneLiner);
     }
     else if (c is IShape)
     {
         ((IShape)c).ToStringModelView(nest, sb, out oneLiner);
     }
     else
     {
         throw new Exception("*** ERROR: CAN'T DUMP: " + c.ToString());
     }
 }

 public override void Decide(ICharacter character, IList<ICard> cardCollection,
                            int firstCard, int secondCard, int botChips,
                            bool isFinalTurn, Label hasFolded, int botIndex,
                            double botPower, double behaviourPower, int callSum)
 {
     this.IsOnTurn = true;
 }

 public void RaiseAction(ICharacter character, int raise, ISingleBet bet)
 {
     character.HasRaised = true;
     character.Raise(raise);
     bet.AddBet(raise);
     bet.LastBet = raise;
 }

	public EnemyAI(ICharacter Character, Vector3 AttackPosition):base(Character)
	{
		m_AttackPosition = AttackPosition;

		// 一開始起始的狀態
		ChangeAIState(new IdleAIState());
	}

 public void ModifyOnCreation(ICharacter subject)
 {
     subject.Hitpoints.Max = HitDie + subject.Constitution.Modifier;
     subject.Hitpoints.Current = subject.Hitpoints.Max;
     subject.Skills.AddRanks(GetSkillPointsCreation(subject));
     ClassModifyOnCreation(subject);
 }

        public void Add(ICharacter character)
        {
            if (character == null) throw new ArgumentNullException("character");

            lock (_characters)
                _characters.Add(character.Id, character);
        }

 public CommandCompletionArgs(string command, ICharacter owner, IEnumerable<string> args, InputCommandResult result)
 {
     this.Command = command;
     this.Arguments = args;
     this.Owner = owner;
     this.CommandResult = result;
 }

        public static bool CanCharacterIdentifyDestination(IMap map, ICharacter viewer, int targetX, int targetY)
        {
            //checks to see if it's one tile beyond sight
            int viewerX = viewer.X;
            int viewerY = viewer.Y;

            //adjust for screen endings
            if (viewerX < 10) viewerX = 10;
            if (viewerX > map.MaxX - 9) viewerX = map.MaxX - 9;
            if (viewerY < 7) viewerY = 7;
            if (viewerY > map.MaxY - 7) viewerY = map.MaxY - 7;

            //check to see if the target would be in the viewer's screen
            if (targetX > viewerX + 10) return false;
            if (targetX < viewerX - 11) return false;
            if (targetY > viewerY + 8) return false;
            if (targetY < viewerY - 8) return false;

            int darkness;
            if (viewer.Darkness > -2) {
                darkness = viewer.Darkness;
            } else {
                darkness = map.Darkness;
            }

            if (darkness > -1) {
                int distance = (int)System.Math.Ceiling(2 * System.Math.Sqrt(System.Math.Pow(viewer.X - targetX, 2) + System.Math.Pow(viewer.Y - targetY, 2)));
                if (distance > darkness - 1) return false;
            }

            return true;
        }

 public void Draw(ICharacter character, SpriteBatch spriteBatch)
 {
     foreach (IStat stat in Stats)
     {
         stat.Draw(character, spriteBatch);
     }
 }