Пример #1
0
        protected override void Validate()
        {
            ItemsNeeded?.ForEach(t => t.IsValid());
            ItemsNeeded?.ForEach(t => ValidationResult.Add(t.ValidationResult.Errors));

            Owners?.ForEach(t => t.IsValid());
            Owners?.ForEach(t => ValidationResult.Add(t.ValidationResult.Errors));

            new OrganizationHasValidAddressValidation().Validate(this);
            new OrganizationHasValidNameValidation().Validate(this);
        }
        public static void RecalculateItemsNeeded()
        {
            ItemsNeeded.Clear();

            foreach (var colony in ServerManager.ColonyTracker.ColoniesByID.Values)
            {
                if (colony != null && StorageFactory.CrateLocations.TryGetValue(colony, out var dict))
                {
                    foreach (var crate in dict.Keys)
                    {
                        foreach (var request in StorageFactory.CrateRequests)
                        {
                            var needed = request.GetItemsNeeded(crate);

                            foreach (var need in needed)
                            {
                                if (!ItemsNeeded.TryGetValue(crate, out var items))
                                {
                                    items = new Dictionary <ushort, StoredItem>();
                                    ItemsNeeded[crate] = items;
                                }

                                if (items.TryGetValue(need.Key, out var storedItem))
                                {
                                    storedItem.Add(needed.Count);
                                }
                                else
                                {
                                    items[need.Key] = need.Value;
                                }
                            }
                        }
                    }
                }
            }
        }
        public void PerformGoal(ref NPCBase.NPCState state)
        {
            state.JobIsDone = true;

            if (WalkingTo == StorageType.Stockpile)
            {
                if (CrateFull)
                {
                    Job.NPC.Inventory.Dump(Job.Owner.Stockpile);
                    CrateFull = false;
                }

                WalkingTo = StorageType.Crate;
                var nexPos = Vector3Int.invalidPos;

                foreach (var location in ClosestLocations)
                {
                    if (!LastCratePosition.Contains(location) &&
                        !InProgress.Contains(location) &&
                        StorageFactory.CrateLocations[Job.Owner].TryGetValue(location, out var inv) &&
                        !inv.IsAlmostFull &&
                        ItemsNeeded.TryGetValue(location, out var itemsNeeded))
                    {
                        nexPos = location;
                        InProgress.Add(location);

                        var addToInv  = StorageFactory.TryTakeItems(Job.Owner, itemsNeeded.Values);
                        var leftovers = new List <StoredItem>();

                        foreach (var item in addToInv)
                        {
                            if (Job.NPC.Inventory.Full)
                            {
                                leftovers.Add(item);
                            }
                            else
                            {
                                Job.NPC.Inventory.Add(item);
                            }
                        }

                        StorageFactory.StoreItems(Job.Owner, leftovers);
                        break;
                    }
                }

                CurrentCratePosition = nexPos;

                if (nexPos == Vector3Int.invalidPos)
                {
                    LastCratePosition.Clear();
                    state.SetCooldown(5);
                }
                else
                {
                    state.SetCooldown(1);
                    state.SetIndicator(new Shared.IndicatorState(5, ItemId.GetItemId(StockpileBlock.Name).Id));
                }
            }
            else
            {
                if (StorageFactory.CrateLocations[Job.Owner].TryGetValue(CurrentCratePosition, out var crateInventory))
                {
                    WalkingTo = StorageType.Stockpile;
                    var leftovers = crateInventory.TryAdd(Job.NPC.Inventory.Inventory.Select(ii => new StoredItem(ii, int.MaxValue, StorageType.Crate)).ToArray());
                    state.SetCooldown(1);
                    state.SetIndicator(new Shared.IndicatorState(5, ColonyBuiltIn.ItemTypes.CRATE.Id));
                    if (leftovers.Count > 0)
                    {
                        Job.NPC.Inventory.Inventory.Clear();

                        foreach (var item in leftovers)
                        {
                            Job.NPC.Inventory.Add(item);
                        }

                        CrateFull = true;
                    }
                }
                else
                {
                    CrateFull = true;
                    state.SetCooldown(1);
                    state.SetIndicator(new Shared.IndicatorState(5, ColonyBuiltIn.ItemTypes.CRATE.Id, false, false));
                }
            }
        }
Пример #4
0
        public void OnTimedUpdate()
        {
            try
            {
                foreach (var job in PorterJobSettings.PorterJobs)
                {
                    var settings = job.Settings as PorterJobSettings;

                    if (settings.CurrentGoal.TryGetValue(job, out var goal) &&
                        job != null &&
                        job.Owner != null &&
                        StorageFactory.CrateLocations.TryGetValue(job.Owner, out var crateLocations))
                    {
                        if (goal is CrateToStockpikeGoal cts)
                        {
                            cts.ClosestLocations = job.Position.SortClosestPositions(crateLocations.Keys);
                        }
                        else if (goal is StockpikeToCrateGoal stc)
                        {
                            stc.ClosestLocations = job.Position.SortClosestPositions(crateLocations.Keys);
                        }
                    }
                }

                int retry = 0;

                while (retry < 3)
                {
                    ItemsNeeded.Clear();

                    foreach (var colony in ServerManager.ColonyTracker.ColoniesByID.Values)
                    {
                        if (colony != null && StorageFactory.CrateLocations.TryGetValue(colony, out var dict))
                        {
                            foreach (var crate in dict.Keys)
                            {
                                foreach (var request in StorageFactory.CrateRequests)
                                {
                                    var needed = request.GetItemsNeeded(crate);

                                    foreach (var need in needed)
                                    {
                                        if (!ItemsNeeded.TryGetValue(crate, out var items))
                                        {
                                            items = new Dictionary <ushort, StoredItem>();
                                            ItemsNeeded[crate] = items;
                                        }

                                        if (items.TryGetValue(need.Key, out var storedItem))
                                        {
                                            storedItem.Add(needed.Count);
                                        }
                                        else
                                        {
                                            items[need.Key] = need.Value;
                                        }
                                    }
                                }
                            }
                        }
                    }

                    retry = int.MaxValue;
                }
            }
            catch (Exception ex)
            {
                CivLogger.LogError(ex);
            }
        }