public InventoryComponent(GameEntity entity, int cap, int perSlot = 5)
     : base(entity)
 {
     capacity_ = cap;
     items_ = new GameEntity[capacity_];
     numberPerSlot_ = perSlot;
 }

 public PhysicsComponent(GameEntity entity, Vector2 velocity, float spin, Vector2 growth)
     : this(entity)
 {
     velocity_ = velocity;
     spin_ = spin;
     growth_ = growth;
 }

 public TileCoord(GameEntity entity, Point coord, Point size, TileSystemComponent tileSystem)
     : base(entity)
 {
     tileSystem_ = tileSystem;
     coord_ = coord;
     size_ = size;
 }

 public override void InstantControl( GameEntity control, TimeSpan gameTime )
 {
     float closestDistance = -1; // The distance to the closest tank
     Tank closestTank = null; // The closest tank
     // Find the closest living tank
     foreach ( Tank t in Tanks )
     {
         float dist = Vector2.DistanceSquared( Owner.Position, t.Position );
         if ( t.IsAlive )
         {
             if ( ( closestTank == null || dist < closestDistance ) )
             {
                 closestDistance = dist;
                 closestTank = t;
             }
         }
     }
     if ( closestTank != null ) // If no tank is alive don't do anything
     {
         // Set owner's angle
         float ang = Tools.Angle( control.Position, closestTank.Position );
         DeflectorController c = new DeflectorController( ang );
         control.AppendController( c );
     }
 }

 public override bool Control( GameEntity control, TimeSpan gameTime, Microsoft.Xna.Framework.Input.KeyboardState keyState )
 {
     if ( control is Projectile )
     {
         HashSet<Tank> tanks = new HashSet<Tank>();
         if ( control.Variables.ContainsKey( "Hypnotize" ) )
         {
             tanks = ( ( HashSet<Tank> )control.Variables[ "Hypnotize" ] );
         }
         if ( Vector2.Distance( control.Position, Owner.Position ) < rad )// && !Tools.IsGoingTowardsMe( Owner.Position, control.Angle, control.Position ) )
         {
             if ( !control.Variables.ContainsKey( "Hypnotize" ) || !tanks.Contains( Owner ) )
             {
                 DeflectorController d = new DeflectorController( Tools.Angle( Owner.Position, control.Position ) );
                 control.AppendController( d );
                 tanks.Add( Owner );
             }
         }
         else
         {
             tanks.Remove( Owner );
         }
         control.Variables[ "Hypnotize" ] = tanks;
     }
     return base.Control( control, gameTime, keyState );
 }

 public DriftPhysics(GameEntity entity, Vector2 drift, Vector2 speed, float d_speed)
     : base(entity, Vector2.Zero, 0, Vector2.Zero)
 {
     max_drift = drift;
     max_speed = speed;
     drift_speed = d_speed;
 }

        public void Use(Seizonsha game, GameEntity entity)
        {
            // entity is whatever is using this

            //			if (entity.isFrozen())
            //			{
            //				return;
            //			}
            recharged = 0;
            // entity.Freeze(recharge_time);
            int damageType = Static.DAMAGE_TYPE_NO_DAMAGE;
            if (entity.getTargetType() == Static.TARGET_TYPE_FRIENDLY){
                damageType = Static.DAMAGE_TYPE_FRIENDLY;
            }
            if (entity.getTargetType() == Static.TARGET_TYPE_ENEMY){
                damageType = Static.DAMAGE_TYPE_ENEMY;
            }
            Rectangle slashBounds = new Rectangle(	entity.getCenterX(),
                                                    entity.getCenterY(),
                                                    Static.PLAYER_WIDTH/2,
                                                    Static.PLAYER_HEIGHT/2);

            //Rectangle bulletBounds = new Rectangle(

            game.Spawn(new Bullet(game, game.getTestSprite(slashBounds, Color.Red), slashBounds, damage, damageType, 1, bulletSpeed, entity.alexDirection));

            // game sprite bounds amount dmgAmount dmgType duration bulletSpeed
        }

 public void Update(Seizonsha game, GameEntity entity)
 {
     if (recharged < recharge_time)
     {
         recharged++;
     }
 }

 public SpatialComponent(GameEntity entity, Vector2 translation, float rotation, Vector2 scale)
     : base(entity)
 {
     translation_ = translation;
     rotation_ = rotation;
     scale_ = scale;
 }

 public override bool Control( GameEntity control, TimeSpan gameTime, Microsoft.Xna.Framework.Input.KeyboardState keyState )
 {
     if ( selectedTank == null )
     {
         List<Tank> TanksCopy = new List<Tank>( Tanks );
         if ( TanksCopy.Count == 0 )
             return true;
         int i = r.Next( TanksCopy.Count );
         while ( TanksCopy[ i ].Controller is MindController )
         {
             TanksCopy.RemoveAt( i );
             i = r.Next( TanksCopy.Count );
             if ( TanksCopy.Count == 0 )
                 return true;
         }
         selectedTank = TanksCopy[ i ];
     }
     if ( controlKeys == null )
     {
         controlKeys = selectedTank.Keys;
         selectedTank.Keys = Owner.Keys;
         Owner.Keys = new KeySet( Keys.None, Keys.None, Keys.None, Keys.None, Owner.Keys.KeyPlace, Keys.None );
     }
     base.Control( control, gameTime, keyState );
     return true;
 }

 public PumpController(GameEntity e)
     : base(e)
 {
     processTime_ = 1;
     isDrawn = true;
     search = true;
 }

        public WorldController(GameEntity entity, Point screen)
            : base(entity)
        {
            screen_ = screen;

            Locator.getMessageBoard().register(listen);
        }

 public GameEntity createEndGameFlame()
 {
     GameEntity e = new GameEntity();
     e.render = new RenderComponent(e, Locator.getTextureManager().loadTexture("flame"), 0, new Vector2(96, 40), Color.White);
     e.spatial = new SpatialComponent(e, Locator.getShip().entity_.spatial, new Vector2(-16, 336), 0, Vector2.One);
     return e;
 }

        public override void ExitState(GameEntity unit)
        {
            base.ExitState(unit);

            unit.StopMovement();
            Debug.Log("Stopping chasing enemy");
        }

        public GameEntity CreateEntityWithId(string id, string name)
        {
            // look in the pool
            if (deadEntityPool.ContainsKey(name) && deadEntityPool[name].Any())
            {
                var entity = deadEntityPool[name].Pop();
                BindEntityEventRegistration(id, entity);
                return entity;
            }
            else
            {
                // clone it
                GameEntity entity = new GameEntity();
                GameEntity source = _entitySource.GetOriginalEntity(name);

                if (GetNumberAlive(name) >= source.MaxAlive) return null;

                foreach (Component c in source.Components)
                {
                    entity.AddComponent(c.Clone());
                }
                entity.Name = source.Name;
                entity.OnDeath = source.OnDeath;
                entity.IsGravitySensitive = source.IsGravitySensitive;

                BindEntityEventRegistration(id, entity);

                return entity;
            }
        }

 public Removing(GameEntity entity)
 {
     entity_ = entity;
     currentTime_ = 0;
     processTime_ = 0.5f;
     bar_ = new UI.ProgressBar(50);
 }

        public override void UpdateState(GameEntity unit)
        {
            base.UpdateState(unit);

            if (_unitToAttack == null || _unitToAttack.IsDead())
            {
                unit.GetStateMachine().ChangeState(new RestState());
                return;
            }

            Vector3 unitToAttackPos = _unitToAttack.GetPos();

            // As the unit must move towards a dynamic position.
            unit.MoveTo(unitToAttackPos);

            float extra = _unitToAttack is GameBuilding ? GameBuilding.EXTRA_ATTACK_DIST : 0.0f;
            float attackRange = unit.GetAttackRange() + extra;

            // Is the unit within attacking distance of the unit to attack?
            float distance = Vector3.Distance(unitToAttackPos, unit.GetPos());
            if (distance < (attackRange - ARRIVE_THRESHOLD))
            {
                // Start attacking the other object.
                unit.GetStateMachine().ChangeState(new AttackState(_unitToAttack));
            }
        }

 public void refresh(GameEntity item)
 {
     item_ = item;
     count_.text_ = "" + item.item.number_;
     count_.pack();
     count_.loc_ = new Vector2(buttonSize) - count_.size;
 }

 public PlayerControllerComponent(GameEntity entity)
     : base(entity)
 {
     keys = new bool[4];
     direction = Vector2.Zero;
     dir_dirty = true;
 }

 public ProductionComponent(GameEntity entity, ItemInfo input, ItemInfo output, float productionTime)
     : base(entity, 2)
 {
     input_ = input;
     output_ = output;
     productionTime_ = productionTime;
 }