public virtual void addMovement(WorldObject worldObject)
 {
     ////Debug.Log("addMovementWO");
     additionalTargetRange = ResourceManager.GetRadius(worldObject.WObjectName);
     target = worldObject;
     addMovement(worldObject._transform.position);
 }

 public static void Update(UpdateValuesDto dto, WorldObject obj)
 {
     switch(obj.TypeId) {
     case ObjectTypeId.Item:
         UpdateItem(dto, (Item)obj);
         break;
     case ObjectTypeId.Container:
         UpdateContainer(dto, (Container)obj);
         break;
     case ObjectTypeId.Unit:
         UpdateUnit(dto, (Unit)obj);
         break;
     case ObjectTypeId.Player:
         UpdatePlayer(dto, (Player)obj);
         break;
     case ObjectTypeId.GameObject:
         UpdateGameObject(dto, (GameObject)obj);
         break;
     case ObjectTypeId.DynamicObject:
         UpdateDynamicObject(dto, (DynamicObject)obj);
         break;
     case ObjectTypeId.Corpse:
         UpdateCorpse(dto, (Corpse)obj);
         break;
     case ObjectTypeId.Object:
     case ObjectTypeId.AIGroup:
     case ObjectTypeId.AreaTrigger:
         UpdateObject(dto, obj);
         break;
     default:
         throw new ArgumentOutOfRangeException();
     }
 }

        public Boolean CanFit(WorldObject wObj, Vector2f position)
        {
            foreach (BBoundingBox BB in wObj.BBoundingBoxes)
            {
                IntRect rect = BB.GetNextTRect(position);

                for (int y = rect.Top; y < rect.Bottom + 1; ++y)
                {
                    for (int x = rect.Left; x < rect.Right + 1; ++x)
                    {
                        if (GetBlock(x, y))
                        {
                            return false;
                        }

                        IEnumerator<BBoundingBox> mapBBsEnum = GetBBoundingBoxesEnumerator(x, y, 0);
                        while (mapBBsEnum.MoveNext())
                        {
                            if (BB.Holder == mapBBsEnum.Current.Holder)
                                continue;

                            if (!BB.BoundingBoxTest(mapBBsEnum.Current, position))
                                continue;

                            return false;
                        }
                    }
                }
            }

            return true;
        }

		public static MyWorldObject Create(WorldObject wo)
		{
			MyWorldObject mwo = new MyWorldObject();

			Dictionary<int, bool> boolValues = new Dictionary<int,bool>();
			Dictionary<int, double> doubleValues = new Dictionary<int,double>();
			Dictionary<int, int> intValues = new Dictionary<int, int>();
			Dictionary<int, string> stringValues = new Dictionary<int,string>();
			List<int> activeSpells = new List<int>();
			List<int> spells = new List<int>();

			foreach (var key in wo.BoolKeys)
				boolValues.Add(key, wo.Values((BoolValueKey)key));

			foreach (var key in wo.DoubleKeys)
				doubleValues.Add(key, wo.Values((DoubleValueKey)key));

			foreach (var key in wo.LongKeys)
				intValues.Add(key, wo.Values((LongValueKey)key));

			foreach (var key in wo.StringKeys)
				stringValues.Add(key, wo.Values((StringValueKey)key));

			for (int i = 0 ; i < wo.ActiveSpellCount ; i++)
				activeSpells.Add(wo.ActiveSpell(i));

			for (int i = 0; i < wo.SpellCount; i++)
				spells.Add(wo.Spell(i));

			mwo.Init(wo.HasIdData, wo.Id, wo.LastIdTime, (int)wo.ObjectClass, boolValues, doubleValues, intValues, stringValues, activeSpells, spells);

			return mwo;
		}

        private bool DoesBuildingHaveNecessaryMaterialsForCrafting(Building b, WorldObject obj)
        {
            bool does = true;
            bool haveRequested = TaskManager.IsAlreadyGettingNecessaryBuildingMaterials(b, obj);

            int counter = 0;

            if (obj.ElementType == MapElementType.Meal)
            {
                foreach (KeyValuePair<MapElementType, List<WorldObject>> keyValue in b.DepositedWorldObjects)
                {
                    foreach (WorldObject depobj in keyValue.Value)
                    {
                        if (depobj.GetType().IsSubclassOf(typeof(Food)))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            else
            {
                foreach (KeyValuePair<MapElementType, int> materials in obj.NeededForCrafting)
                {
                    if (b.DepositedWorldObjects.ContainsKey(materials.Key) == false)
                    {
                        for (int i = 0; i < materials.Value; i++)
                        {
                            if (haveRequested == false)
                            {
                                TaskManager.AddTask(new GetBuildingMaterialTask(materials.Key, obj.Level, b));
                                counter++;
                            }
                            does = false;
                        }
                    }
                    else
                    {
                        for (int i = 0; i < materials.Value - b.GetNumberOfDepositedMaterial(materials.Key, obj.Level); i++)
                        {
                            if (haveRequested == false)
                            {
                                TaskManager.AddTask(new GetBuildingMaterialTask(materials.Key, obj.Level, b));
                                counter++;
                            }
                            does = false;
                        }
                    }
                }
            }

            if (counter == 1)
            {

            }

            return does;
        }

 public void AddObject(WorldObject obj, string prefab)
 {
     if (!_entities.ContainsKey(obj.InstanceId))
     {
         _entities.Add(obj.InstanceId, obj);
     }
 }

        public static void ResolveCollision(WorldObject objectTriggering, WorldObject objectHit)
        {
            if (objectTriggering is PlayerShip)
            {
                if (objectHit is Asteroid)
                {
                    objectTriggering.DestroySelf();
                    objectHit.DefaultDestructAction(); ;
                }
                if (objectHit is Ring)
                {
                    objectHit.DestroySelf();
                }
            }

            if (objectTriggering is Laser)
            {
                if (objectHit is Asteroid) { objectHit.DestroySelf(); objectTriggering.DestroySelf(); }
            }

            if (objectTriggering is Bomb)
            {
                if (objectHit is Asteroid) { objectHit.DestroySelf(); }
            }
        }

 public CollectFoodFromPastureTask(PastureSim pasture, WorldObject foodItem)
 {
     pasture.Building.TasksAssociatedWithBuilding.Add(this);
     Pasture = pasture;
     FoodItem = foodItem;
     TaskType = TaskType.CollectFoodFromPasture;
 }

 public MoveCraftedResourceToDepotTask(Building craftBuilding, WorldObject obj)
 {
     DwarfConsole.WriteLine("Move crafted", ConsoleColor.Red);
     CraftBuilding = craftBuilding;
     Obj = obj;
     TaskType = Tasks.TaskType.MoveCraftedResource;
 }

        public void AddObject(WorldObject obj)
        {
            this.allObjects.Add(obj);

            IControllable objAsControllable = obj as IControllable;
            if (objAsControllable != null)
            {
                this.controllables.Add(objAsControllable);
            }

            IResource objAsResource = obj as IResource;
            if (objAsResource != null)
            {
                this.resources.Add(objAsResource);
            }

            //IGatherer objAsGatherer = obj as IGatherer;
            //if (objAsGatherer != null)
            //{
            //    this.gatherers.Add(objAsGatherer);
            //}

            //IFighter objAsFighter = obj as IFighter;
            //if (objAsFighter != null)
            //{
            //    this.fighters.Add(objAsFighter);
            //}
        }

 /*** Private worker methods ***/
 private void ChangeSelection(WorldObject worldObject, Player controller)
 {
     //this should be called by the following line, but there is an outside chance it will not
     SetSelection(false);
     if(controller.SelectedObject) controller.SelectedObject.SetSelection(false);
     controller.SelectedObject = worldObject;
     worldObject.SetSelection(true);
 }

 public AttackCommand(Unit unit, WorldObject target)
 {
     this.target = target;
     this.unit = unit;
     targetRotation = Quaternion.LookRotation (target.transform.position - unit.transform.position);
     targetOneCommand = new TargetOneCommand (unit, target);
     unit.IssueSubCommand (targetOneCommand);
 }

 public void LoadContent()
 {
     mPlayerTexture = Game.Content.Load<Texture2D>("blue");
     mPlayerBulletTexture = Game.Content.Load<Texture2D>("spark");
     mPlayer = new WorldObject(mPlayerTexture);
     //mPlayer.Position = new Vector2(0, 0);
     mWorld.SetPlayerComponent(mPlayer);
 }

		public ItemInfoIdentArgs(WorldObject identifiedItem, bool dontShowIfItemHasNoRule = false, bool dontShowIfIsSalvageRule = false)
		{
			IdentifiedItem = identifiedItem;

			DontShowIfItemHasNoRule = dontShowIfItemHasNoRule;

			DontShowIfIsSalvageRule = dontShowIfIsSalvageRule;
		}

        public EBoundingBox(EBoundingBox copy, WorldObject holder)
            : base(copy, holder)
        {
            Type = copy.Type;

            Events = new List<ObjectEvent>(copy.Events);
            EventsToRemove = new Queue<ObjectEvent>();
        }

        public static void SaveWorldObject(JsonWriter writer, WorldObject worldObject)
        {
            if (writer == null || worldObject == null) return;

            writer.WriteStartObject();
            worldObject.SaveDetails(writer);
            writer.WriteEndObject();
        }

        /// <summary>
        /// Add this CollisionObject to bucket.
        /// </summary>
        internal override void AddToBucket(WorldObject worldObject)
        {
            int bottomLeftX = (int)(worldObject.Pos.X + TL.X) / (int)Collision.CellWidth;
            int bottomLeftY = (int)(worldObject.Pos.Y + BR.Y) / (int)Collision.CellHeight;
            int topRightX = (int)(worldObject.Pos.X + BR.X) / (int)Collision.CellWidth;
            int topRightY = (int)(worldObject.Pos.Y + TL.Y) / (int)Collision.CellHeight;

            AddToBucket(worldObject, bottomLeftX, bottomLeftY, topRightX, topRightY);
        }

        /// <summary>
        /// Add this CollisionObject to bucket.
        /// </summary>
        internal override void addToBucket(WorldObject worldObject)
        {
            int bottomLeftX = (int)(worldObject.Pos.X + centerPointOffset.X - radius) / (int)Collision.gridCellWidth;
            int bottomLeftY = (int)(worldObject.Pos.Y + centerPointOffset.Y - radius) / (int)Collision.gridCellHeight;
            int topRightX = (int)(worldObject.Pos.X + centerPointOffset.X + radius) / (int)Collision.gridCellWidth;
            int topRightY = (int)(worldObject.Pos.Y + centerPointOffset.Y + radius) / (int)Collision.gridCellHeight;

            AddToBucket(worldObject, bottomLeftX, bottomLeftY, topRightX, topRightY);
        }

        public override void DepositWorldObject(WorldObject worldObject)
        {
            if (worldObject.ElementType == MapElementType.Beer)
            {

            }
            //PrintDepositedWorldObjects();
            base.DepositWorldObject(worldObject);
        }

 public override void SetBuilding(Building project, WorldObject worldObject)
 {
     base.SetBuilding (project, worldObject);
     currentProject = project;
     target = worldObject;
     addMovement(worldObject);
     amountBuilt = 0.0f;
     building = true;
 }