Пример #1
0
    public void RefreshTools()
    {
        if (m_ToolsGrids.Count == 0)
        {
            return;
        }

        if (m_Farm == null)
        {
            return;
        }

        for (int i = 0; i < CSFarm.PLANTS_TOOLS_COUNT; i++)
        {
            ItemObject io = m_Farm.GetPlantTool(i);
            m_ToolsGrids[i].m_Grid.SetItem(io);
        }
    }
Пример #2
0
    private void _farmWorkStyle()
    {
        CSFarm farm = WorkRoom as CSFarm;

        if (farm == null)
        {
            return;
        }

        FarmPlantLogic plant = null;

        CSMgCreator mgCreator = m_Creator as CSMgCreator;

        // Only watering and weeding
        if (m_WorkMode == CSConst.pwtFarmForMag)
        {
            if (m_FarmWorkMap.Count != 0)
            {
                return;
            }

            ItemObject waterItem   = farm.GetPlantTool(0);
            ItemObject weedingItem = farm.GetPlantTool(1);

            // Watering
            plant = waterItem == null ? null : farm.AssignOutWateringPlant();
            if (plant != null)
            {
                FarmWorkInfo fwi = new FarmWorkInfo(plant);
                m_FarmWorkMap.Add(EFarmWorkType.Watering, fwi);

                //_sendToWorkOnFarm(fwi.m_Pos);
            }
            else
            {
                // Weeding
                plant = weedingItem == null ? null : farm.AssignOutCleaningPlant();

                if (plant != null)
                {
                    FarmWorkInfo fwi = new FarmWorkInfo(plant);
                    m_FarmWorkMap.Add(EFarmWorkType.Cleaning, fwi);

                    //_sendToWorkOnFarm(fwi.m_Pos);
                }
                //else
                //    Idle(0.0f, false);
            }
        }
        else if (m_WorkMode == CSConst.pwtFarmForHarvest)
        {
            if (m_FarmWorkMap.Count != 0)
            {
                return;
            }

            CSStorage storage = null;

            foreach (CSStorage css in farm.Assembly.m_BelongObjectsMap[CSConst.ObjectType.Storage])
            {
                SlotList slotList = css.m_Package.GetSlotList();
                if (slotList.GetVacancyCount() >= 2)
                //if (css.m_Package.GetEmptyGridCount() >= 2)
                {
                    storage = css;
                    break;
                }
            }

            if (storage != null)
            {
                plant = farm.AssignOutRipePlant();

                if (plant != null)
                {
                    FarmWorkInfo fwi = new FarmWorkInfo(plant);
                    m_FarmWorkMap.Add(EFarmWorkType.Harvesting, fwi);
                    //_sendToWorkOnFarm(fwi.m_Pos);
                }
                //else
                //    Idle(0.0f, false);
            }
            //else
            //    Idle(0.0f, false);
        }
        else if (m_WorkMode == CSConst.pwtFarmForPlant)
        {
            // Planting
            if (m_FarmWorkMap.Count == 0)
            {
#if NEW_CLOD_MGR
                ClodChunk cc = mgCreator.m_Clod.FindCleanChunk(farm.Assembly.Position, farm.Assembly.Radius);
#else
                ClodChunk cc = CSClodMgr.FindCleanChunk(farm.Assembly.Position, farm.Assembly.Radius);
#endif

                if (farm.HasPlantSeed() && cc != null)
                {
                    Vector3 pos;
                    bool    flag = cc.FindCleanClod(out pos);
                    if (flag)
                    {
#if NEW_CLOD_MGR
                        mgCreator.m_Clod.DirtyTheChunk(cc.m_ChunkIndex, true);
#else
                        CSClodMgr.DirtyTheChunk(cc.m_ChunkIndex, true);
#endif
                        FarmWorkInfo fwi = new FarmWorkInfo(cc, pos);
                        m_FarmWorkMap.Add(EFarmWorkType.Planting, fwi);

                        _sendToWorkOnFarm(fwi.m_Pos);
                    }
                }
                //else
                //    Idle(0.0f, false);
            }
            else if (m_FarmWorkMap.ContainsKey(EFarmWorkType.Planting) &&
                     m_FarmWorkMap[EFarmWorkType.Planting].m_Pos == Vector3.zero)
            {
                if (farm.HasPlantSeed())
                {
                    FarmWorkInfo fwi  = m_FarmWorkMap[EFarmWorkType.Planting];
                    bool         flag = fwi.m_ClodChunk.FindCleanClod(out fwi.m_Pos);

                    if (flag)
                    {
                        //_sendToWorkOnFarm(fwi.m_Pos);
                    }
                    else
                    {
                        m_FarmWorkMap.Remove(EFarmWorkType.Planting);
                    }
                }
                else
                {
                    FarmWorkInfo fwi = m_FarmWorkMap[EFarmWorkType.Planting];
#if NEW_CLOD_MGR
                    mgCreator.m_Clod.DirtyTheChunk(fwi.m_ClodChunk.m_ChunkIndex, false);
#else
                    CSClodMgr.DirtyTheChunk(fwi.m_ClodChunk.m_ChunkIndex, false);
#endif
                    m_FarmWorkMap.Remove(EFarmWorkType.Planting);
                }
            }

            if (!m_FarmWorkMap.ContainsKey(EFarmWorkType.Planting))
            {
                //Idle(0.0f, false);
            }
        }
    }
Пример #3
0
    public void SetFarm(CSEntity enti)
    {
        if (enti == null)
        {
            Debug.LogWarning("Reference Entity is null.");
            return;
        }

        m_Entity = enti;
        CSFarm farm = enti as CSFarm;

        m_SequentialPlantingCB.isChecked = farm.Data.m_SequentialPlanting;

        if (farm == m_Farm)
        {
            return;
        }

        if (m_Farm != null)
        {
            m_Farm.CreatePlantEvent     -= OnCreatePlant;
            m_Farm.RemovePlantEvent     -= OnRemovePlant;
            m_Farm.CreatePlantListEvent -= OnCreatAllPlants;
            m_Farm.ClearAllPlantEvent   -= OnClearAllPlants;
            m_Farm.RemoveEventListener(OnEntityEvent);
        }

        m_Farm = farm;

        m_Farm.CreatePlantEvent     += OnCreatePlant;
        m_Farm.RemovePlantEvent     += OnRemovePlant;
        m_Farm.CreatePlantListEvent += OnCreatAllPlants;
        m_Farm.ClearAllPlantEvent   += OnClearAllPlants;
        m_Farm.AddEventListener(OnEntityEvent);

        int i = 0;

        foreach (FarmPlantLogic p in farm.Plants.Values)
        {
            if (i < m_PlantGrids.Count)
            {
            }
            else
            {
                CSUI_PlantGrid pg = _createPlantGrid(p);

                UICheckbox cb = pg.gameObject.GetComponent <UICheckbox>();
                if (i == 0)
                {
                    cb.startsChecked = true;
                }
            }
            i++;
        }

        for (int j = i; j < m_PlantGrids.Count;)
        {
            GameObject.Destroy(m_PlantGrids[j].gameObject);
            m_PlantGrids.RemoveAt(j);
        }

        m_PlantPart.m_Root.repositionNow = true;


        // Seed an tool grid
        for (int j = 0; j < CSFarm.PLANTS_SEEDS_COUNT; j++)
        {
            ItemObject io = m_Farm.GetPlantSeed(j);
            m_SeedsGrids[j].m_Grid.SetItem(io);
        }

        for (int j = 0; j < CSFarm.PLANTS_TOOLS_COUNT; j++)
        {
            ItemObject io = m_Farm.GetPlantTool(j);
            m_ToolsGrids[j].m_Grid.SetItem(io);
        }
    }