public List <GItem> GetResources(List <ResourceAmount> resources)
{
return((from r in resources
where r.NumResources > 0
let resource = ResourceLibrary.GetResourceByName(r.ResourceType)
select new GItem(resource, resource.Image, resource.Tint, 0, 1000, r.NumResources, resource.MoneyValue)).ToList());
}
public CraftResourceTask(CraftItem selectedResource, int NumRepeats, List <ResourceAmount> SelectedResources, int id = -1)
{
this.NumRepeats = NumRepeats;
Category = TaskCategory.CraftItem;
TaskID = id < 0 ? MaxID : id;
MaxID++;
Item = new CraftDesignation()
{
ItemType = selectedResource,
Location = VoxelHandle.InvalidHandle,
Valid = true,
SelectedResources = SelectedResources
};
Name = String.Format("Craft order {0}", TaskID);
Priority = PriorityType.Low;
noise = ResourceLibrary.GetResourceByName(Item.ItemType.ResourceCreated).Tags.Contains(Resource.ResourceTags.Edible)
? "Cook"
: "Craft";
AutoRetry = true;
BoredomIncrease = 0.2f;
if (selectedResource.IsMagical)
{
Category = TaskCategory.Research;
}
}
public bool Pickup(Item item)
{
if (item == null || item.UserData == null || item.UserData.IsDead)
{
return(false);
}
bool success = Resources.AddResource
(new ResourceAmount
{
NumResources = 1,
ResourceType = ResourceLibrary.GetResourceByName(item.UserData.Tags[0])
});
if (!success)
{
return(false);
}
if (item.IsInZone)
{
item.Zone = null;
}
item.UserData.GetRootComponent().Delete();
return(true);
}
public List <ResourceAmount> ListResourcesWithTag(Resource.ResourceTags tag, bool allowHeterogenous = true)
{
Dictionary <string, ResourceAmount> resources = ListResources();
if (allowHeterogenous)
{
return((from pair in resources
where ResourceLibrary.GetResourceByName(pair.Value.ResourceType).Tags.Contains(tag)
select pair.Value).ToList());
}
ResourceAmount maxAmount = null;
foreach (var pair in resources)
{
var resource = ResourceLibrary.GetResourceByName(pair.Value.ResourceType);
if (!resource.Tags.Contains(tag))
{
continue;
}
if (maxAmount == null || pair.Value.NumResources > maxAmount.NumResources)
{
maxAmount = pair.Value;
}
}
return(maxAmount != null ? new List <ResourceAmount>()
{
maxAmount
} : new List <ResourceAmount>());
}
public CraftResourceTask(CraftItem selectedResource, int NumRepeats, List <ResourceAmount> SelectedResources, int id = -1)
{
this.NumRepeats = NumRepeats;
TaskID = id < 0 ? MaxID : id;
MaxID++;
Item = new CraftDesignation()
{
ItemType = selectedResource,
Location = VoxelHandle.InvalidHandle,
Valid = true,
SelectedResources = SelectedResources
};
Name = String.Format("Craft order {0}: {1} {2}s", TaskID, NumRepeats, selectedResource.DisplayName);
Priority = PriorityType.Medium;
if (ResourceLibrary.GetResourceByName(Item.ItemType.ResourceCreated).Tags.Contains(Resource.ResourceTags.Edible))
{
noise = "Cook";
Category = TaskCategory.Cook;
}
else
{
noise = "Craft";
Category = selectedResource.IsMagical ? TaskCategory.Research : TaskCategory.CraftItem;
}
AutoRetry = true;
BoredomIncrease = GameSettings.Default.Boredom_NormalTask;
}
public bool Remove(IEnumerable <Quantitiy <Resource.ResourceTags> > amount, RestockType type)
{
foreach (var quantity in amount)
{
for (int i = 0; i < quantity.NumResources; i++)
{
int kRemove = -1;
for (int k = 0; k < Resources.Count; k++)
{
if (type == RestockType.None && Resources[k].MarkedForRestock)
{
continue;
}
else if (type == RestockType.RestockResource && !Resources[k].MarkedForRestock)
{
continue;
}
if (!ResourceLibrary.GetResourceByName(Resources[k].Resource)
.Tags.Contains(quantity.ResourceType))
{
continue;
}
kRemove = k;
break;
}
if (kRemove < 0)
{
return(false);
}
Resources.RemoveAt(kRemove);
}
}
return(true);
}
public bool Pickup(Item item)
{
if (item == null || item.UserData == null || item.UserData.IsDead)
{
return(false);
}
bool success = Resources.AddResource
(new ResourceAmount
{
NumResources = 1,
ResourceType = ResourceLibrary.GetResourceByName(item.UserData.Tags[0])
});
if (!success)
{
return(false);
}
if (item.IsInZone)
{
item.Zone = null;
}
TossMotion toss = new TossMotion(0.5f + MathFunctions.Rand(0.05f, 0.08f),
1.0f, item.UserData.GlobalTransform, Position);
item.UserData.AnimationQueue.Add(toss);
toss.OnComplete += () => item.UserData.GetRootComponent().Delete();
return(true);
}
public List <ResourceAmount> GetResources(Quantitiy <Resource.ResourceTags> quantitiy, RestockType type = RestockType.RestockResource)
{
return((from resource in Resources where
ResourceLibrary.GetResourceByName(resource.Resource).Tags.Contains(quantitiy.ResourceType) && ((type == RestockType.RestockResource &&
resource.MarkedForRestock) || (type == RestockType.None && !resource.MarkedForRestock) || (type == RestockType.Any))
select new ResourceAmount(resource.Resource)).ToList());
}
public List <ResourceAmount> GetResources(Quantitiy <Resource.ResourceTags> tags)
{
List <ResourceAmount> toReturn = new List <ResourceAmount>();
int amountLeft = tags.NumResources;
foreach (ResourceAmount resourceAmount in Resources.Values)
{
if (amountLeft <= 0)
{
break;
}
if (resourceAmount.NumResources == 0)
{
continue;
}
if (ResourceLibrary.GetResourceByName(resourceAmount.ResourceType).Tags.Contains(tags.ResourceType))
{
int amountToRemove = Math.Min(tags.NumResources, amountLeft);
if (amountToRemove > 0)
{
toReturn.Add(new ResourceAmount(resourceAmount.ResourceType, amountToRemove));
amountLeft -= amountToRemove;
}
}
}
return(toReturn);
}
public Resource GetResource()
{
if (_value == null)
{
return(null);
}
return(ResourceLibrary.GetResourceByName(_value));
}
public override void CreateCosmeticChildren(ComponentManager manager)
{
base.CreateCosmeticChildren(manager);
Resource type = ResourceLibrary.GetResourceByName(Resource.ResourceType);
Tinter sprite = null;
if (type.CompositeLayers == null || type.CompositeLayers.Count == 0)
{
sprite = AddChild(new SimpleSprite(Manager, "Sprite",
Matrix.CreateTranslation(Vector3.UnitY * 0.25f),
false,
new SpriteSheet(type.Image.AssetName, 32),
new Point(type.Image.SourceRect.X / 32, type.Image.SourceRect.Y / 32))
{
OrientationType = SimpleSprite.OrientMode.Spherical,
WorldHeight = 0.75f,
WorldWidth = 0.75f,
}) as Tinter;
sprite.LocalTransform = Matrix.CreateTranslation(Vector3.UnitY * 0.25f);
}
else
{
var layers = new List <LayeredSimpleSprite.Layer>();
foreach (var layer in type.CompositeLayers)
{
if (layer.Value != null)
{
layers.Add(new LayeredSimpleSprite.Layer
{
Sheet = new SpriteSheet(layer.Value, 32),
Frame = layer.Key
});
}
}
sprite = AddChild(new LayeredSimpleSprite(Manager, "Sprite",
Matrix.CreateTranslation(Vector3.UnitY * 0.25f),
false,
layers)
{
OrientationType = LayeredSimpleSprite.OrientMode.Spherical,
WorldHeight = 0.75f,
WorldWidth = 0.75f,
}) as Tinter;
}
sprite.Tint = type.Tint;
sprite.SetFlag(Flag.ShouldSerialize, false);
sprite.AddChild(new Bobber(Manager, 0.05f, 2.0f, MathFunctions.Rand() * 3.0f, sprite.LocalTransform.Translation.Y)).SetFlag(Flag.ShouldSerialize, false);
}
public override void CreateCosmeticChildren(ComponentManager manager)
{
base.CreateCosmeticChildren(manager);
var type = ResourceLibrary.GetResourceByName(Resource.ResourceType);
Tinter sprite = null;
int numSprites = Math.Min(Resource.NumResources, 3);
for (int i = 0; i < numSprites; i++)
{
// Minor optimization for single layer resources.
if (type.CompositeLayers.Count == 1)
{
var layer = type.CompositeLayers[0];
sprite = AddChild(new SimpleBobber(Manager, "Sprite",
Matrix.CreateTranslation(Vector3.UnitY * 0.25f),
new SpriteSheet(layer.Asset, layer.FrameSize.X, layer.FrameSize.Y),
layer.Frame, 0.15f, MathFunctions.Rand() + 2.0f, MathFunctions.Rand() * 3.0f)
{
OrientationType = SimpleSprite.OrientMode.Spherical,
WorldHeight = 0.75f,
WorldWidth = 0.75f,
}) as Tinter;
sprite.LocalTransform = Matrix.CreateTranslation(Vector3.UnitY * 0.25f + MathFunctions.RandVector3Cube() * 0.1f);
}
else
{
var layers = new List <LayeredSimpleSprite.Layer>();
foreach (var layer in type.CompositeLayers)
{
layers.Add(new LayeredSimpleSprite.Layer
{
Sheet = new SpriteSheet(layer.Asset, layer.FrameSize.X, layer.FrameSize.Y),
Frame = layer.Frame
});
}
sprite = AddChild(new LayeredBobber(Manager, "Sprite",
Matrix.CreateTranslation(Vector3.UnitY * 0.25f + MathFunctions.RandVector3Cube() * 0.1f),
layers, 0.15f, MathFunctions.Rand() + 2.0f, MathFunctions.Rand() * 3.0f)
{
OrientationType = LayeredSimpleSprite.OrientMode.Spherical,
WorldHeight = 0.75f,
WorldWidth = 0.75f,
}) as Tinter;
}
sprite.LightRamp = type.Tint;
sprite.SetFlag(Flag.ShouldSerialize, false);
}
}
override public void Update(DwarfTime gameTime, ChunkManager chunks, Camera camera)
{
base.Update(gameTime, chunks, camera);
LifeTimer.Update(gameTime);
if (LifeTimer.HasTriggered)
{
Die();
}
this.SetVertexColorRecursive(ResourceLibrary.GetResourceByName(this.Resource.ResourceType).Tint);
}
public override IEnumerable <Status> Run()
{
if (Zone == null)
{
Creature.DrawIndicator(IndicatorManager.StandardIndicators.Question);
yield return(Status.Fail);
yield break;
}
if (Resource.NumResources <= 0)
{
yield return(Status.Success);
yield break;
}
List <Body> createdItems = Creature.Inventory.RemoveAndCreate(Resource, Inventory.RestockType.RestockResource);
if (createdItems.Count == 0)
{
yield return(Status.Success);
}
foreach (Body b in createdItems)
{
if (Zone.AddItem(b))
{
Creature.Stats.NumItemsGathered++;
}
}
Creature.NoiseMaker.MakeNoise("Stockpile", Creature.AI.Position);
Creature.CurrentCharacterMode = Creature.AttackMode;
Creature.Sprite.ResetAnimations(Creature.AttackMode);
Creature.Sprite.PlayAnimations(Creature.AttackMode);
while (!Creature.Sprite.AnimPlayer.IsDone())
{
yield return(Status.Running);
}
var resource = ResourceLibrary.GetResourceByName(Resource.ResourceType);
if (resource.Tags.Contains(DwarfCorp.Resource.ResourceTags.Corpse))
{
Creature.AddThought(Thought.ThoughtType.BuriedDead);
}
yield return(Status.Running);
Creature.CurrentCharacterMode = CharacterMode.Idle;
yield return(Status.Success);
}
public List <ResourceAmount> GetResourcesWithTags(List <Quantitiy <Resource.ResourceTags> > tags)
{
Dictionary <Resource.ResourceTags, int> tagsRequired = new Dictionary <Resource.ResourceTags, int>();
Dictionary <Resource.ResourceTags, int> tagsGot = new Dictionary <Resource.ResourceTags, int>();
Dictionary <ResourceLibrary.ResourceType, ResourceAmount> amounts = new Dictionary <ResourceLibrary.ResourceType, ResourceAmount>();
foreach (Quantitiy <Resource.ResourceTags> quantity in tags)
{
tagsRequired[quantity.ResourceType] = quantity.NumResources;
tagsGot[quantity.ResourceType] = 0;
}
foreach (Stockpile stockpile in Stockpiles)
{
foreach (ResourceAmount resource in stockpile.Resources)
{
foreach (var requirement in tagsRequired)
{
int got = tagsGot[requirement.Key];
if (requirement.Value <= got)
{
continue;
}
if (!ResourceLibrary.GetResourceByName(resource.ResourceType).Tags.Contains(requirement.Key))
{
continue;
}
int amountToRemove = System.Math.Min(resource.NumResources, requirement.Value - got);
if (amountToRemove <= 0)
{
continue;
}
tagsGot[requirement.Key] += amountToRemove;
if (amounts.ContainsKey(resource.ResourceType))
{
amounts[resource.ResourceType].NumResources += amountToRemove;
}
else
{
amounts[resource.ResourceType] = new ResourceAmount(resource.ResourceType, amountToRemove);
}
}
}
}
return(amounts.Values.ToList());
}
protected static float GetHealth(ResourceLibrary.ResourceType type)
{
var resource = ResourceLibrary.GetResourceByName(type);
foreach (var tag in resource.Tags)
{
if (Healths.ContainsKey(tag))
{
return(Healths[tag]);
}
}
return(DefaultHealth);
}
public static IEnumerable <Act.Status> EatStockedFood(this Creature agent)
{
List <ResourceAmount> foods = agent.Faction.ListResourcesWithTag(Resource.ResourceTags.Edible);
if (foods.Count == 0)
{
if (agent.Allies == "Dwarf")
{
agent.Manager.World.MakeAnnouncement("We're out of food!", "Our stockpiles don't have any food. Our employees will starve!");
}
yield return(Act.Status.Fail);
yield break;
}
else
{
foreach (ResourceAmount resourceAmount in foods)
{
if (resourceAmount.NumResources > 0)
{
Resource resource = ResourceLibrary.GetResourceByName(resourceAmount.ResourceType);
bool removed = agent.Faction.RemoveResources(new List <ResourceAmount>()
{
new ResourceAmount(resourceAmount.ResourceType, 1)
}, agent.AI.Position);
agent.Status.Hunger.CurrentValue += resource.FoodContent;
agent.NoiseMaker.MakeNoise("Chew", agent.AI.Position);
if (!removed)
{
yield return(Act.Status.Fail);
}
else
{
agent.DrawIndicator(resource.Image, resource.Tint);
agent.AI.AddThought(Thought.ThoughtType.AteFood);
yield return(Act.Status.Success);
}
yield break;
}
}
if (agent.Allies == "Dwarf")
{
agent.Manager.World.MakeAnnouncement("We're out of food!", "Our stockpiles don't have any food. Our employees will starve!");
}
yield return(Act.Status.Fail);
yield break;
}
}
public Point GetSpritesheetFrame(ResourceType resourceType)
{
var resource = ResourceLibrary.GetResourceByName(resourceType);
foreach (var tag in resource.Tags)
{
if (Sprites.ContainsKey(tag))
{
return(Sprites[tag]);
}
}
return(DefaultSpriteFrame);
}
public int CountResourcesWithTags(Resource.ResourceTags tag)
{
int toReturn = 0;
foreach (ResourceAmount resource in Resources.Values)
{
if (ResourceLibrary.GetResourceByName(resource.ResourceType).Tags.Contains(tag))
{
toReturn += resource.NumResources;
}
}
return(toReturn);
}
public override IEnumerable <Status> Run()
{
bool validTargetFound = false;
List <Zone> sortedPiles;
if (ResourceLibrary.GetResourceByName(this.Item.ResourceType).Tags.Contains(Resource.ResourceTags.Money))
{
sortedPiles = new List <Zone>(Creature.Faction.Treasurys);
sortedPiles.Sort(CompareTreasurys);
}
else
{
sortedPiles =
new List <Zone>(Creature.Faction.Stockpiles.Where(pile => pile.IsAllowed(Item.ResourceType)));
sortedPiles.Sort(CompareStockpiles);
}
foreach (Zone s in sortedPiles)
{
if (s.IsFull())
{
continue;
}
var v = s.GetNearestVoxel(Creature.Physics.GlobalTransform.Translation);
if (!v.IsValid || v.IsEmpty)
{
continue;
}
Voxel = v;
Stockpile = s;
validTargetFound = true;
break;
}
if (validTargetFound)
{
yield return(Status.Success);
}
else
{
Creature.DrawIndicator(IndicatorManager.StandardIndicators.Question);
yield return(Status.Fail);
}
}
public Resource ToResource(WorldManager world, List <ResourceAmount> selectedResources, string prefix = "")
{
var objectName = String.IsNullOrEmpty(ObjectName) ? Name : ObjectName;
string resourceName = prefix + objectName + " (" + TextGenerator.GetListString(MergeResources(selectedResources).Select(r => (string)r.ResourceType)) + ")";
Resource toReturn = ResourceLibrary.GetResourceByName(resourceName);
if (toReturn == null)
{
var sheet = world.Gui.RenderData.SourceSheets[Icon.Sheet];
var tex = AssetManager.GetContentTexture(sheet.Texture);
var numTilesX = tex.Width / sheet.TileWidth;
var numTilesY = tex.Height / sheet.TileHeight;
var point = new Point(Icon.Tile % numTilesX, Icon.Tile / numTilesX);
toReturn = new Resource()
{
Name = resourceName,
Tags = new List <Resource.ResourceTags>()
{
Resource.ResourceTags.CraftItem,
Resource.ResourceTags.Craft
},
MoneyValue = selectedResources.Sum(r => ResourceLibrary.GetResourceByName(r.ResourceType).MoneyValue) * 2.0m,
CraftInfo = new Resource.CraftItemInfo
{
Resources = selectedResources,
CraftItemType = objectName
},
ShortName = Name,
Description = Description,
GuiLayers = new List <Gui.TileReference>()
{
Icon
},
CompositeLayers = new List <Resource.CompositeLayer>()
{
new Resource.CompositeLayer()
{
Asset = sheet.Texture, Frame = point, FrameSize = new Point(sheet.TileWidth, sheet.TileHeight)
}
},
Tint = Color.White,
};
ResourceLibrary.Add(toReturn);
}
return(toReturn);
}
public IEnumerable <GItem> GetResources(List <ResourceAmount> resources)
{
foreach (var amount in resources)
{
if (amount.NumResources == 0)
{
continue;
}
Resource r = ResourceLibrary.GetResourceByName(amount.ResourceType);
yield return(new GItem(r,
r.Image,
r.Tint, 0, 1000,
amount.NumResources, r.MoneyValue));
}
}
public static CraftItem ResourceToCraftItem(ResourceLibrary.ResourceType resource)
{
Resource res = ResourceLibrary.GetResourceByName(resource);
return(new CraftItem()
{
Name = resource,
BaseCraftTime = 30,
CraftLocation = "Forge",
Description = res.Description,
Icon = res.GuiLayers[0],
RequiredResources = res.CraftPrereqs,
ResourceCreated = resource,
Type = CraftItem.CraftType.Resource
});
}
public float GetPrice(ResourceLibrary.ResourceType type)
{
Resource item = ResourceLibrary.GetResourceByName(type);
float price = item.MoneyValue;
if (IsRare(type))
{
price *= 2;
}
else if (IsCommon(type))
{
price *= 0.5f;
}
return(price);
}
public void LayEgg()
{
NoiseMaker.MakeNoise("Lay Egg", AI.Position, true, 1.0f);
if (ResourceLibrary.GetResourceByName(Species + " Egg") == null ||
!EntityFactory.EnumerateEntityTypes().Contains(Species + " Egg Resource"))
{
Resource newEggResource =
new Resource(ResourceLibrary.GetResourceByName(ResourceType.Egg));
newEggResource.Name = Species + " Egg";
ResourceLibrary.Add(newEggResource);
}
var parent = EntityFactory.CreateEntity <Body>(this.Species + " Egg Resource", Physics.Position);
parent.AddChild(new Egg(parent, this.Species, Manager, Physics.Position, AI.PositionConstraint));
}
public int GetResourceCount(Resource.ResourceTags resourceType, bool allowHeterogenous = false)
{
if (allowHeterogenous)
{
return(Resources.Values.Where(resource => ResourceLibrary.GetResourceByName(resource.ResourceType).Tags.Contains(resourceType)).Sum(resource => resource.NumResources));
}
else
{
int count = 0;
foreach (var resource in Resources.Values.Where(resource => ResourceLibrary.GetResourceByName(resource.ResourceType).Tags.Contains(resourceType)))
{
count = Math.Max(count, resource.NumResources);
}
return(count);
}
}
public static void InitializeDefaultLibrary(GraphicsDevice graphics)
{
if (TypeList != null)
{
return;
}
var cubeTexture = AssetManager.GetContentTexture(ContentPaths.Terrain.terrain_tiles);
TypeList = FileUtils.LoadJsonListFromMultipleSources <VoxelType>(ContentPaths.voxel_types, null, v => v.Name);
emptyType = TypeList[0];
DesignationType = TypeList[1];
short ID = 0;
foreach (VoxelType type in TypeList)
{
type.ID = ID;
++ID;
Types[type.Name] = type;
PrimitiveMap[type] = type.ID == 0 ? null : CreatePrimitive(graphics, cubeTexture, 32, 32, type.Top, type.Bottom, type.Sides);
if (type.HasTransitionTextures)
{
type.TransitionTextures = CreateTransitionUVs(graphics, cubeTexture, 32, 32, type.TransitionTiles, type.Transitions);
}
type.ExplosionSound = SoundSource.Create(type.ExplosionSoundResource);
type.HitSound = SoundSource.Create(type.HitSoundResources);
if (type.ReleasesResource)
{
if (ResourceLibrary.GetResourceByName(type.Name) == null)
{
var resource = new Resource(ResourceLibrary.GetResourceByName(type.ResourceToRelease))
{
Name = type.Name,
ShortName = type.Name,
Tint = type.Tint,
Generated = false
};
ResourceLibrary.Add(resource);
type.ResourceToRelease = resource.Name;
}
}
}
}
public bool AddResources(ResourceAmount resources)
{
ResourceAmount amount = new ResourceAmount(resources.ResourceType, resources.NumResources);
var resource = ResourceLibrary.GetResourceByName(amount.ResourceType);
foreach (Stockpile stockpile in Stockpiles)
{
int space = stockpile.Resources.MaxResources - stockpile.Resources.CurrentResourceCount;
if (space >= amount.NumResources)
{
stockpile.Resources.AddResource(amount);
stockpile.HandleBoxes();
foreach (var tag in resource.Tags)
{
if (!CachedResourceTagCounts.ContainsKey(tag))
{
CachedResourceTagCounts[tag] = 0;
}
CachedResourceTagCounts[tag] += amount.NumResources;
}
RecomputeCachedVoxelstate();
return(true);
}
else
{
stockpile.Resources.AddResource(amount);
amount.NumResources -= space;
stockpile.HandleBoxes();
foreach (var tag in resource.Tags)
{
if (!CachedResourceTagCounts.ContainsKey(tag))
{
CachedResourceTagCounts[tag] = 0;
}
CachedResourceTagCounts[tag] += space;
}
RecomputeCachedVoxelstate();
if (amount.NumResources == 0)
{
return(true);
}
}
}
return(false);
}
public Egg(string adult, ComponentManager manager, Vector3 position) :
base(false, manager)
{
Adult = adult;
Birthday = Manager.World.Time.CurrentDate + new TimeSpan(0, 12, 0, 0);
if (ResourceLibrary.GetResourceByName(adult + " Egg") == null)
{
Resource newEggResource =
new Resource(ResourceLibrary.GetResourceByName(ResourceLibrary.ResourceType.Egg));
newEggResource.Type = adult + " Egg";
ResourceLibrary.Add(newEggResource);
}
ParentBody = EntityFactory.CreateEntity <Body>(adult + " Egg Resource", position);
ParentBody.AddChild(this);
manager.AddComponent(this);
}
public void OnVoxelDestroyed(VoxelHandle V)
{
if (!V.IsValid)
{
return;
}
RoomBuilder.OnVoxelDestroyed(V);
var toRemove = new List <Stockpile>();
foreach (var s in new List <Stockpile>(Stockpiles).Where(stockpile => stockpile.IsBuilt))
{
if (s.ContainsVoxel(V))
{
s.RemoveVoxel(V);
}
if (s.Voxels.Count == 0)
{
toRemove.Add(s);
}
}
foreach (Stockpile s in toRemove)
{
foreach (var resource in s.Resources)
{
var resourceType = ResourceLibrary.GetResourceByName(resource.ResourceType);
foreach (var tag in resourceType.Tags)
{
if (CachedResourceTagCounts.ContainsKey(tag))
{
CachedResourceTagCounts[tag] -= resource.NumResources;
Trace.Assert(CachedResourceTagCounts[tag] >= 0);
}
}
}
RecomputeCachedVoxelstate();
Stockpiles.Remove(s);
s.Destroy();
}
}