private void BuildResource_OnClicked()
{
List <Task> assignments = new List <Task>();
SelectedResource.SelectedResources = new List <ResourceAmount>();
for (int i = 0; i < BuildResourceTab.SelectedResourceBoxes.Count; i++)
{
ComboBox box = BuildResourceTab.SelectedResourceBoxes[i];
if (box.CurrentValue == "<Not enough!>")
{
return;
}
Quantitiy <Resource.ResourceTags> tags = SelectedResource.RequiredResources[i];
SelectedResource.SelectedResources.Add(new ResourceAmount(box.CurrentValue, tags.NumResources));
}
assignments.Add(new CraftResourceTask(SelectedResource));
if (assignments.Count > 0)
{
TaskManager.AssignTasks(assignments, Faction.FilterMinionsWithCapability(Master.SelectedMinions, GameMaster.ToolMode.Craft));
}
}
public void VoxelsSelected(List <Voxel> refs, InputManager.MouseButton button)
{
if (CurrentRoomData == null)
{
return;
}
if (displayObjects != null)
{
foreach (var thing in displayObjects)
{
thing.Delete();
}
}
if (button == InputManager.MouseButton.Left)
{
if (Faction.FilterMinionsWithCapability(Faction.SelectedMinions, GameMaster.ToolMode.Build).Count == 0)
{
World.ShowToolPopup("None of the selected units can build rooms.");
}
else if (CurrentRoomData.Verify(refs, Faction, World))
{
BuildNewVoxels(refs);
}
}
else
{
DeleteVoxels(refs);
}
}
public override void OnBodiesSelected(List <Body> bodies, InputManager.MouseButton button)
{
List <Body> resourcesPickedByMouse = ComponentManager.FilterComponentsWithTag("Resource", bodies);
List <Task> assignments = new List <Task>();
foreach (Body resource in resourcesPickedByMouse.Where(resource => resource.IsActive && resource.IsVisible && resource.Parent == PlayState.ComponentManager.RootComponent))
{
if (!resource.IsVisible || resource.IsAboveCullPlane)
{
continue;
}
Drawer3D.DrawBox(resource.BoundingBox, Color.LightGoldenrodYellow, 0.05f, true);
if (button == InputManager.MouseButton.Left)
{
Player.Faction.AddGatherDesignation(resource);
assignments.Add(new GatherItemTask(resource));
}
else
{
if (!Player.Faction.GatherDesignations.Contains(resource))
{
continue;
}
Player.Faction.GatherDesignations.Remove(resource);
}
}
TaskManager.AssignTasks(assignments, Faction.FilterMinionsWithCapability(PlayState.Master.SelectedMinions, GameMaster.ToolMode.Gather));
}
public override void OnBodiesSelected(List <GameComponent> bodies, InputManager.MouseButton button)
{
List <Task> assignments = new List <Task>();
foreach (var resource in bodies.Where(body => CanGather(World, body)))
{
if (World.ChunkManager.IsAboveCullPlane(resource.BoundingBox))
{
continue;
}
if (button == InputManager.MouseButton.Left)
{
assignments.Add(new GatherItemTask(resource));
}
else if (World.PersistentData.Designations.GetEntityDesignation(resource, DesignationType.Gather).HasValue(out var designation))
{
World.TaskManager.CancelTask(designation.Task);
}
}
World.TaskManager.AddTasks(assignments);
OnConfirm(Faction.FilterMinionsWithCapability(World.PersistentData.SelectedMinions, TaskCategory.Gather));
}
public override void OnBodiesSelected(List <Body> bodies, InputManager.MouseButton button)
{
List <Task> assignments = new List <Task>();
foreach (var resource in bodies.Where(body => CanGather(body)))
{
if (Player.World.ChunkManager.IsAboveCullPlane(resource.BoundingBox))
{
continue;
}
if (button == InputManager.MouseButton.Left)
{
assignments.Add(new GatherItemTask(resource));
}
else
{
var designation = Player.Faction.Designations.GetEntityDesignation(resource, DesignationType.Gather);
if (designation != null)
{
Player.TaskManager.CancelTask(designation.Task);
}
}
}
Player.TaskManager.AddTasks(assignments);
OnConfirm(Faction.FilterMinionsWithCapability(Player.World.Master.SelectedMinions, Task.TaskCategory.Gather));
}
private void BuildNewVoxels(IEnumerable <Voxel> refs)
{
BuildRoomOrder order = null;
IEnumerable <Voxel> designations = refs as IList <Voxel> ?? refs.ToList();
IEnumerable <Voxel> nonEmpty = designations.Select(r => r).Where(v => !v.IsEmpty);
foreach (Voxel v in nonEmpty)
{
if (IsBuildDesignation(v) || IsInRoom(v))
{
continue;
}
if (!v.GetVoxelAbove().IsEmpty)
{
continue;
}
if (order == null)
{
order = GetMostLikelyDesignation(v);
}
if (order != null)
{
order.VoxelOrders.Add(new BuildVoxelOrder(order, order.ToBuild, v));
}
else
{
if (CurrentRoomData != RoomLibrary.GetData("Stockpile"))
{
Room toBuild = RoomLibrary.CreateRoom(Faction, CurrentRoomData.Name, designations.ToList(), true, World);
DesignatedRooms.Add(toBuild);
order = new BuildRoomOrder(toBuild, Faction, Faction.World);
order.VoxelOrders.Add(new BuildVoxelOrder(order, toBuild, v));
BuildDesignations.Add(order);
}
else
{
Stockpile toBuild = new Stockpile(Faction, World);
DesignatedRooms.Add(toBuild);
order = new BuildStockpileOrder(toBuild, this.Faction);
order.VoxelOrders.Add(new BuildVoxelOrder(order, toBuild, v));
BuildDesignations.Add(order);
}
}
}
if (order != null)
{
order.CreateFences(World.ComponentManager);
TaskManager.AssignTasks(new List <Task>()
{
new BuildRoomTask(order)
}, Faction.FilterMinionsWithCapability(World.Master.SelectedMinions, GameMaster.ToolMode.Build));
}
}
public void VoxelsSelected(List <Voxel> refs, InputManager.MouseButton button)
{
if (Faction == null)
{
Faction = World.PlayerFaction;
}
if (CurrentVoxelType == null)
{
return;
}
Selected.Clear();
switch (button)
{
case (InputManager.MouseButton.Left):
{
if (Faction.FilterMinionsWithCapability(Faction.SelectedMinions, GameMaster.ToolMode.Build).Count == 0)
{
World.ShowToolPopup("None of the selected units can build walls.");
return;
}
List <Task> assignments = new List <Task>();
List <Voxel> validRefs = refs.Where(r => !IsDesignation(r) && r.IsEmpty).ToList();
if (!Verify(validRefs, CurrentVoxelType.ResourceToRelease))
{
World.ShowToolPopup("Can't build this! Need at least " + validRefs.Count + " " + ResourceLibrary.Resources[CurrentVoxelType.ResourceToRelease].ResourceName + ".");
return;
}
foreach (Voxel r in validRefs)
{
AddDesignation(new WallBuilder(r, CurrentVoxelType, World));
assignments.Add(new BuildVoxelTask(r, CurrentVoxelType));
}
TaskManager.AssignTasks(assignments, Faction.FilterMinionsWithCapability(World.Master.SelectedMinions, GameMaster.ToolMode.Build));
break;
}
case (InputManager.MouseButton.Right):
{
foreach (Voxel r in refs)
{
if (!IsDesignation(r) || r.TypeName != "empty")
{
continue;
}
else
{
RemoveDesignation(r);
}
}
break;
}
}
}
public override void OnVoxelsSelected(List <Voxel> refs, InputManager.MouseButton button)
{
if (button == InputManager.MouseButton.Left)
{
List <Task> assignments = new List <Task>();
foreach (Voxel r in refs)
{
if (r == null)
{
continue;
}
Voxel v = r;
if (v.IsEmpty)
{
continue;
}
if (!Player.Faction.IsDigDesignation(v) && !Player.Faction.RoomBuilder.IsInRoom(v))
{
BuildOrder d = new BuildOrder
{
Vox = r
};
Player.Faction.DigDesignations.Add(d);
}
assignments.Add(new KillVoxelTask(r));
}
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(Player.SelectedMinions, GameMaster.ToolMode.Dig);
TaskManager.AssignTasksGreedy(assignments, minions, 5);
OnConfirm(minions);
}
else
{
foreach (Voxel r in refs)
{
if (r == null)
{
continue;
}
Voxel v = r;
if (v.IsEmpty)
{
continue;
}
if (Player.Faction.IsDigDesignation(v))
{
Player.Faction.DigDesignations.Remove(Player.Faction.GetDigDesignation(v));
}
}
}
}
public override void OnBodiesSelected(List <Body> bodies, InputManager.MouseButton button)
{
var plantsPicked = bodies.Where(c => c.Tags.Contains("Vegetation"));
if (button == InputManager.MouseButton.Left)
{
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(Player.Faction.SelectedMinions, Task.TaskCategory.Chop);
List <Task> tasks = new List <Task>();
foreach (var plant in plantsPicked)
{
if (!plant.IsVisible)
{
continue;
}
if (Player.World.ChunkManager.IsAboveCullPlane(plant.BoundingBox))
{
continue;
}
var task = ChopPlant(plant, Player.Faction);
if (task != null)
{
tasks.Add(task);
}
}
Player.TaskManager.AddTasks(tasks);
if (tasks.Count > 0 && minions.Count > 0)
{
OnConfirm(minions);
}
}
else if (button == InputManager.MouseButton.Right)
{
foreach (var plant in plantsPicked)
{
if (!plant.IsVisible)
{
continue;
}
if (Player.World.ChunkManager.IsAboveCullPlane(plant.BoundingBox))
{
continue;
}
Player.Faction.Designations.RemoveEntityDesignation(plant, DesignationType.Chop);
}
}
}
public override void OnBodiesSelected(List <GameComponent> bodies, InputManager.MouseButton button)
{
var plantsPicked = bodies.Where(c => c.Tags.Contains("Vegetation"));
if (button == InputManager.MouseButton.Left)
{
var minions = Faction.FilterMinionsWithCapability(World.PersistentData.SelectedMinions, TaskCategory.Chop);
var tasks = new List <Task>();
foreach (var plant in plantsPicked)
{
if (!plant.IsVisible)
{
continue;
}
if (World.ChunkManager.IsAboveCullPlane(plant.BoundingBox))
{
continue;
}
tasks.Add(new ChopEntityTask(plant));
}
World.TaskManager.AddTasks(tasks);
if (tasks.Count > 0 && minions.Count > 0)
{
OnConfirm(minions);
}
}
else if (button == InputManager.MouseButton.Right)
{
foreach (var plant in plantsPicked)
{
if (!plant.IsVisible)
{
continue;
}
if (World.ChunkManager.IsAboveCullPlane(plant.BoundingBox))
{
continue;
}
var designation = World.PersistentData.Designations.GetEntityDesignation(plant, DesignationType.Chop);
if (designation != null)
{
World.TaskManager.CancelTask(designation.Task);
}
}
}
}
public override void OnVoxelsSelected(List <VoxelHandle> refs, InputManager.MouseButton button)
{
if (button == InputManager.MouseButton.Left)
{
Player.World.Tutorial("slice");
List <Task> assignments = new List <Task>();
foreach (var v in refs)
{
if (!v.IsValid || (v.IsEmpty && v.IsExplored) || v.Type.IsInvincible)
{
continue;
}
var boundingBox = v.GetBoundingBox().Expand(-0.1f);
var entities = Player.World.EnumerateIntersectingObjects(boundingBox, CollisionType.Static);
if (entities.OfType <IVoxelListener>().Any())
{
continue;
}
if (!Player.Faction.Designations.IsVoxelDesignation(v, DesignationType.Dig) && !(Player.Faction.RoomBuilder.IsInRoom(v) || Player.Faction.RoomBuilder.IsBuildDesignation(v)))
{
var task = new KillVoxelTask(v);
assignments.Add(task);
}
}
Player.TaskManager.AddTasks(assignments);
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(Player.SelectedMinions, Task.TaskCategory.Dig);
OnConfirm(minions);
}
else
{
foreach (var r in refs)
{
if (r.IsValid)
{
var designation = Player.Faction.Designations.GetVoxelDesignation(r, DesignationType.Dig);
if (designation != null && designation.Task != null)
{
Player.TaskManager.CancelTask(designation.Task);
}
}
}
}
}
private void ImageButton_OnClicked(SpellTree.Node spell)
{
if (spell.IsResearched || (spell.Parent != null && !spell.Parent.IsResearched))
{
return;
}
else
{
List <CreatureAI> wizards = Faction.FilterMinionsWithCapability(PlayState.Master.SelectedMinions, GameMaster.ToolMode.Magic);
foreach (CreatureAI wizard in wizards)
{
wizard.Tasks.Add(new ActWrapperTask(new GoResearchSpellAct(wizard, spell))
{
Priority = Task.PriorityType.Low
});
}
}
}
public override void OnVoxelsSelected(List <VoxelHandle> refs, InputManager.MouseButton button)
{
if (button == InputManager.MouseButton.Left)
{
Player.World.Tutorial("slice");
List <Task> assignments = new List <Task>();
foreach (var v in refs)
{
if (!v.IsValid || (v.IsEmpty && v.IsExplored))
{
continue;
}
if (!Player.Faction.Designations.IsVoxelDesignation(v, DesignationType.Dig) && !Player.Faction.RoomBuilder.IsInRoom(v))
{
BuildOrder d = new BuildOrder
{
Vox = v
};
Player.Faction.Designations.AddVoxelDesignation(v, DesignationType.Dig, d);
}
assignments.Add(new KillVoxelTask(v));
}
Player.TaskManager.AddTasks(assignments);
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(Player.SelectedMinions, Task.TaskCategory.Dig);
//TaskManager.AssignTasksGreedy(assignments, minions, 5);
OnConfirm(minions);
}
else
{
foreach (var r in refs)
{
if (!r.IsValid || (r.IsEmpty && r.IsExplored))
{
continue;
}
Player.Faction.Designations.RemoveVoxelDesignation(r, DesignationType.Dig);
}
}
}
public override void OnBodiesSelected(List <Body> bodies, InputManager.MouseButton button)
{
List <Body> treesPickedByMouse = ComponentManager.FilterComponentsWithTag("Vegetation", bodies);
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(Player.Faction.SelectedMinions,
GameMaster.ToolMode.Chop);
List <Task> tasks = new List <Task>();
foreach (Body tree in treesPickedByMouse)
{
if (!tree.IsVisible || tree.IsAboveCullPlane)
{
continue;
}
Drawer3D.DrawBox(tree.BoundingBox, Color.LightGreen, 0.1f, false);
if (button == InputManager.MouseButton.Left)
{
if (!Player.Faction.ChopDesignations.Contains(tree))
{
Player.Faction.ChopDesignations.Add(tree);
tasks.Add(new KillEntityTask(tree, KillEntityTask.KillType.Chop)
{
Priority = Task.PriorityType.Low
});
}
}
else if (button == InputManager.MouseButton.Right)
{
if (Player.Faction.ChopDesignations.Contains(tree))
{
Player.Faction.ChopDesignations.Remove(tree);
}
}
}
if (tasks.Count > 0 && minions.Count > 0)
{
TaskManager.AssignTasks(tasks, minions);
OnConfirm(minions);
}
}
public void Research(SpellTree.Node spell)
{
List <CreatureAI> wizards = Faction.FilterMinionsWithCapability(Player.Faction.Minions, Task.TaskCategory.Research);
var body = Player.Faction.FindNearestItemWithTags("Research", Vector3.Zero, false);
if (body != null)
{
Player.World.ShowToolPopup(string.Format("{0} wizard{2} sent to research {1}", wizards.Count, spell.Spell.Name, wizards.Count > 1 ? "s" : ""));
Player.TaskManager.AddTask(new ResearchSpellTask(spell.Spell.Name)
{
Priority = Task.PriorityType.Low
});
}
else
{
Player.World.ShowToolPopup(string.Format("Can't research {0}, no magical research object has been built.",
spell.Spell.Name));
}
}
public override void OnVoxelsSelected(List <VoxelHandle> voxels, InputManager.MouseButton button)
{
if (button == InputManager.MouseButton.Left)
{
List <Task> assignedTasks = new List <Task>();
foreach (var v in voxels.Where(v => v.IsValid))
{
if (v.IsEmpty || Player.Faction.Designations.IsVoxelDesignation(v, DesignationType.Guard))
{
continue;
}
BuildOrder d = new BuildOrder
{
Vox = v
};
Player.Faction.Designations.AddVoxelDesignation(v, DesignationType.Guard, d);
assignedTasks.Add(new GuardZoneTask());
}
List <CreatureAI> minions =
Faction.FilterMinionsWithCapability(Player.World.Master.SelectedMinions, Task.TaskCategory.Gather);
Player.TaskManager.AddTasks(assignedTasks);
//TaskManager.AssignTasks(assignedTasks, minions);
OnConfirm(minions);
}
else
{
foreach (var v in voxels.Where(v => v.IsValid))
{
if (v.IsEmpty || !Player.Faction.Designations.IsVoxelDesignation(v, DesignationType.Guard))
{
continue;
}
Player.Faction.Designations.RemoveVoxelDesignation(v, DesignationType.Guard);
}
}
}
public override void OnVoxelsSelected(List <Voxel> voxels, InputManager.MouseButton button)
{
List <Task> assignedTasks = new List <Task>();
foreach (Voxel v in from r in voxels
where r != null
select r)
{
if (button == InputManager.MouseButton.Left)
{
if (v.IsEmpty || Player.Faction.IsGuardDesignation(v))
{
continue;
}
BuildOrder d = new BuildOrder
{
Vox = v
};
Player.Faction.GuardDesignations.Add(d);
assignedTasks.Add(new GuardVoxelTask(v));
}
else
{
if (v.IsEmpty || !Player.Faction.IsGuardDesignation(v))
{
continue;
}
Player.Faction.GuardDesignations.Remove(Player.Faction.GetGuardDesignation(v));
}
}
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(PlayState.Master.SelectedMinions, GameMaster.ToolMode.Gather);
TaskManager.AssignTasks(assignedTasks, minions);
OnConfirm(minions);
}
public override void OnVoxelsSelected(List <VoxelHandle> voxels, InputManager.MouseButton button)
{
var parentTask = Player.TaskManager.EnumerateTasks().OfType <GuardZoneTask>().FirstOrDefault();
if (parentTask == null)
{
parentTask = new GuardZoneTask();
Player.TaskManager.AddTask(parentTask);
}
if (button == InputManager.MouseButton.Left)
{
foreach (var v in voxels.Where(v => v.IsValid && !v.IsEmpty))
{
var key = VoxelHelpers.GetVoxelQuickCompare(v);
if (Player.Faction.GuardedVoxels.ContainsKey(key))
{
return;
}
Player.Faction.Designations.AddVoxelDesignation(v, DesignationType.Guard, null, new GuardZoneTask.DesignationProxyTask(parentTask, v));
Player.Faction.GuardedVoxels.Add(key, v);
}
OnConfirm(Faction.FilterMinionsWithCapability(Player.World.Master.SelectedMinions, Task.TaskCategory.Gather));
}
else
{
foreach (var v in voxels.Where(v => v.IsValid && !v.IsEmpty))
{
var des = Player.Faction.Designations.GetVoxelDesignation(v, DesignationType.Guard);
if (des != null)
{
Player.TaskManager.CancelTask(des.Task);
}
}
}
}
public override void OnBodiesSelected(List <Body> bodies, InputManager.MouseButton button)
{
List <Task> assignments = new List <Task>();
foreach (Body resource in bodies.Where(c =>
c.Tags.Contains("Resource") &&
c.Active &&
c.IsVisible &&
c.Parent == Player.World.ComponentManager.RootComponent))
{
if (!resource.IsVisible)
{
continue;
}
if (Player.World.ChunkManager.IsAboveCullPlane(resource.BoundingBox))
{
continue;
}
if (button == InputManager.MouseButton.Left)
{
Player.Faction.Designations.AddEntityDesignation(resource, DesignationType.Gather);
assignments.Add(new GatherItemTask(resource));
}
else
{
Player.Faction.Designations.RemoveEntityDesignation(resource, DesignationType.Gather);
}
}
List <CreatureAI> minions = Faction.FilterMinionsWithCapability(Player.World.Master.SelectedMinions,
Task.TaskCategory.Gather);
Player.TaskManager.AddTasks(assignments);
//TaskManager.AssignTasks(assignments, minions);
OnConfirm(minions);
}
public void Research(SpellTree.Node spell)
{
List <CreatureAI> wizards = Faction.FilterMinionsWithCapability(Player.SelectedMinions, GameMaster.ToolMode.Magic);
var body = Player.Faction.FindNearestItemWithTags("Research", Vector3.Zero, false);
if (body != null)
{
Player.World.ShowToolPopup(string.Format("{0} wizard{2} sent to research {1}", wizards.Count, spell.Spell.Name, wizards.Count > 1 ? "s" : ""));
foreach (CreatureAI wizard in wizards)
{
wizard.Tasks.Add(new ActWrapperTask(new GoResearchSpellAct(wizard, spell))
{
Priority = Task.PriorityType.Low
});
}
}
else
{
Player.World.ShowToolPopup(string.Format("Can't research {0}, no library has been built.",
spell.Spell.Name));
}
}
public void VoxelsSelected(List <Voxel> refs, InputManager.MouseButton button)
{
if (!IsEnabled)
{
return;
}
switch (button)
{
case (InputManager.MouseButton.Left):
{
if (Faction.FilterMinionsWithCapability(Faction.SelectedMinions, GameMaster.ToolMode.Craft).Count == 0)
{
World.ShowToolPopup("None of the selected units can craft items.");
return;
}
List <Task> assignments = new List <Task>();
foreach (Voxel r in refs)
{
if (IsDesignation(r) || r == null || !r.IsEmpty)
{
continue;
}
else
{
Vector3 pos = r.Position + Vector3.One * 0.5f;
Vector3 startPos = pos + new Vector3(0.0f, -0.1f, 0.0f);
Vector3 endPos = pos;
CraftDesignation newDesignation = new CraftDesignation()
{
ItemType = CurrentCraftType,
Location = r,
WorkPile = new WorkPile(World.ComponentManager, startPos)
};
newDesignation.WorkPile.AnimationQueue.Add(new EaseMotion(1.1f, Matrix.CreateTranslation(startPos), endPos));
World.ParticleManager.Trigger("puff", pos, Color.White, 10);
if (IsValid(newDesignation))
{
AddDesignation(newDesignation);
assignments.Add(new CraftItemTask(new Voxel(new Point3(r.GridPosition), r.Chunk),
CurrentCraftType));
}
else
{
newDesignation.WorkPile.Die();
}
}
}
if (assignments.Count > 0)
{
TaskManager.AssignTasks(assignments, Faction.FilterMinionsWithCapability(World.Master.SelectedMinions, GameMaster.ToolMode.Craft));
}
break;
}
case (InputManager.MouseButton.Right):
{
foreach (Voxel r in refs)
{
if (!IsDesignation(r))
{
continue;
}
RemoveDesignation(r);
}
break;
}
}
}
public override void OnVoxelsSelected(List <VoxelHandle> refs, InputManager.MouseButton button)
{
if (button == InputManager.MouseButton.Left)
{
int count = World.PersistentData.Designations.EnumerateDesignations(DesignationType.Dig).Count();
World.Tutorial("slice");
List <Task> assignments = new List <Task>();
foreach (var v in refs)
{
if (!v.IsValid || (v.IsEmpty && v.IsExplored) || v.Type.IsInvincible)
{
continue;
}
var boundingBox = v.GetBoundingBox().Expand(-0.1f);
var entities = World.EnumerateIntersectingObjects(boundingBox, CollisionType.Static);
if (entities.OfType <IVoxelListener>().Any())
{
continue;
}
if (count >= GameSettings.Current.MaxVoxelDesignations)
{
World.UserInterface.ShowToolPopup("Too many dig designations!");
break;
}
// Todo: Should this be removed from the existing compound task and put in the new one?
if (!World.PersistentData.Designations.IsVoxelDesignation(v, DesignationType.Dig) && !(World.IsInZone(v) || World.IsBuildDesignation(v)))
{
var task = new KillVoxelTask(v);
task.Hidden = true;
assignments.Add(task);
count++;
}
}
if (assignments.Count > 0)
{
World.TaskManager.AddTasks(assignments);
var compoundTask = new CompoundTask("DIG A HOLE", TaskCategory.Dig, TaskPriority.Medium);
compoundTask.AddSubTasks(assignments);
World.TaskManager.AddTask(compoundTask);
var minions = Faction.FilterMinionsWithCapability(World.PersistentData.SelectedMinions, TaskCategory.Dig);
OnConfirm(minions);
}
}
else
{
foreach (var r in refs)
{
if (r.IsValid)
{
if (World.PersistentData.Designations.GetVoxelDesignation(r, DesignationType.Dig).HasValue(out var designation) && designation.Task != null) // Todo: Is this necessary?
{
World.TaskManager.CancelTask(designation.Task);
}
}
}
}
}
public override void OnVoxelsSelected(List <VoxelHandle> voxels, InputManager.MouseButton button)
{
if (Arguments == null)
{
return;
}
if (Selected == null)
{
Selected = new List <VoxelHandle>();
}
Selected.Clear();
switch (button)
{
case (InputManager.MouseButton.Left):
{
if (Library.GetVoxelType(Arguments.VoxelType).HasValue(out VoxelType vType))
{
List <Task> assignments = new List <Task>();
foreach (var r in voxels)
{
if (r.Type == vType)
{
continue;
}
var above = VoxelHelpers.GetVoxelAbove(r);
if (above.IsValid && above.LiquidType != LiquidType.None)
{
continue;
}
if (World.PersistentData.Designations.GetVoxelDesignation(r, DesignationType.Put).HasValue(out var existingDesignation))
{
World.TaskManager.CancelTask(existingDesignation.Task);
}
if (World.PersistentData.Designations.GetVoxelDesignation(r, DesignationType.Dig).HasValue(out var digDes))
{
World.TaskManager.CancelTask(digDes.Task);
}
if (r.IsEmpty)
{
assignments.Add(new BuildVoxelTask(r, vType.Name)
{
Hidden = true
});
}
else
{
var sequentialTask = new SequentialTask("Put voxel", TaskCategory.Dig, TaskPriority.Medium)
{
Hidden = true
};
sequentialTask.AddSubTask(new KillVoxelTask(r)
{
Hidden = true
});
sequentialTask.AddSubTask(new BuildVoxelTask(r, vType.Name)
{
Hidden = true
});
assignments.Add(sequentialTask);
}
}
if (assignments.Count > 0)
{
World.TaskManager.AddTasks(assignments);
var compoundTask = new CompoundTask("Build Voxels", TaskCategory.BuildBlock, TaskPriority.Medium);
compoundTask.AddSubTasks(assignments);
World.TaskManager.AddTask(compoundTask);
var minions = Faction.FilterMinionsWithCapability(World.PersistentData.SelectedMinions, TaskCategory.BuildBlock);
OnConfirm(minions);
}
}
break;
}
case (InputManager.MouseButton.Right):
{
foreach (var r in voxels)
{
if (World.PersistentData.Designations.GetVoxelDesignation(r, DesignationType.Put).HasValue(out var designation))
{
World.TaskManager.CancelTask(designation.Task);
}
if (World.PersistentData.Designations.GetVoxelDesignation(r, DesignationType.Dig).HasValue(out var digDesignation))
{
World.TaskManager.CancelTask(digDesignation.Task);
}
}
break;
}
}
}
public void OnVoxelsDragged(List <Voxel> refs, InputManager.MouseButton button)
{
if (Faction == null)
{
Faction = World.PlayerFaction;
}
if (displayObjects != null)
{
foreach (var thing in displayObjects)
{
thing.Delete();
}
}
if (CurrentRoomData == null)
{
return;
}
if (button == InputManager.MouseButton.Left)
{
if (Faction.FilterMinionsWithCapability(Faction.SelectedMinions, GameMaster.ToolMode.Build).Count == 0)
{
World.ShowToolPopup("None of the selected units can build rooms.");
}
else if (CurrentRoomData.Verify(refs, Faction, World))
{
List <Quantitiy <Resource.ResourceTags> > requirements =
CurrentRoomData.GetRequiredResources(refs.Count, Faction);
string tip = "Needs ";
if (requirements.Count == 0)
{
tip = "";
}
int i = 0;
foreach (var requirement in requirements)
{
i++;
tip += requirement.NumResources.ToString();
tip += " ";
tip += requirement.ResourceType;
tip += "\n";
}
World.ShowToolPopup("Release to build here.");
displayObjects = RoomLibrary.GenerateRoomComponentsTemplate(CurrentRoomData, refs, Faction.Components,
World.ChunkManager.Content, World.ChunkManager.Graphics);
foreach (Body thing in displayObjects)
{
thing.SetActiveRecursive(false);
SetDisplayColor(thing, Color.Green);
}
}
}
}
