public override void OnSelect()
{
for (int i = 0; i < 10; i++)
{
UnitMap SpawnUnit = new UnitMap(Unit.FromType(ActiveFactory.ListSpawnUnit[0].UnitTypeName, ActiveFactory.ListSpawnUnit[0].UnitStat.Name, Map.Content, Map.DicUnitType,
Map.DicRequirement, Map.DicEffect, Map.DicAutomaticSkillTarget));
SpawnUnit.ActiveUnit.ArrayCharacterActive = new Core.Characters.Character[0];
Vector3 StartPosition;
//No waypoint found.
if (ActiveFactory.Waypoint.X == -1)
{
//Unit hidden in the Construction
StartPosition = ActiveFactory.Position;
}
else//Waypoint found
{
StartPosition = ActiveFactory.Waypoint;
}
Map.SpawnUnit(Map.ActivePlayerIndex, SpawnUnit, ActiveFactory.Position, StartPosition);
}
RemoveFromPanelList(this);
}
public void BindDictionary(IDictionary <string, string> dictionary)
{
if (dictionary == null)
{
return;
}
foreach (var pair in dictionary)
{
if (string.IsNullOrEmpty(pair.Key))
{
continue;
}
var key = pair.Key;
var values = pair.Value.Trim().Split('|');
foreach (var token in values)
{
if (string.IsNullOrWhiteSpace(token) || UnitMap.ContainsKey(token))
{
continue;
}
UnitMap.Add(token, key);
}
}
}
public ActiveUnits(UnitMap units)
{
activeUnitTypes = new HashSet <UnitType>();
activeUnitNumbers = new UnitMap(units);
startingUnits = new UnitMap(units);
InitialiseActiveUnitTypes();
}
/// <summary>
/// Sets the unit map for referencing later on. This is required because the map is created
/// after the director so it cannot be included in the constructor.
/// </summary>
internal void SetMap(ref Map.Map map)
{
mUnitMap = new UnitMap((int)map.GetMeasurements().X, (int)map.GetMeasurements().Y);
mMap = map;
mSelectedGroup = new FlockingGroup(ref mDirector, ref mMap);
mGroups.Add(mSelectedGroup);
}
public Army(PlayerType playerType)
{
this.playerType = playerType;
queue = new UnitTrainingQueue(playerType);
unitMap = new UnitMap();
currentSupply = 0;
maxSupply = 20;
}
public ArmyPlanner()
{
requiredWood = 0;
requiredMagicStone = 0;
remainingSupply = GetArmyController().army.maxSupply - GetArmyController().army.currentSupply;
startingUnits = new UnitMap(GetArmyController().army.unitMap);
}
public void SetUpCombatInstance()
{
// fetch units
UnitMap player1Units = GetArmyController(PlayerType.PLAYER).GetUnitsForCombat();
UnitMap player2Units = GetArmyController(PlayerType.AI).GetUnitsForCombat();
// set units
SetPlayer1Units(player1Units);
SetPlayer2Units(player2Units);
}
// Returns a unit map containing the units required to be equal to the other map (assuming the other map can be reached from the current state)
public UnitMap UnitsRequiredToBecome(UnitMap otherMap)
{
UnitMap comparisonResult = new UnitMap();
foreach (UnitType type in units.Keys)
{
int numUnits = otherMap.GetNumber(type) - GetNumber(type);
comparisonResult.AddMultiple(type, numUnits);
}
return(comparisonResult);
}
public void UpdateAIUnitViews(ActiveUnits aiUnits)
{
UnitMap ai_startingUnits = aiUnits.GetStartingUnits();
UnitMap ai_casualties = aiUnits.GetUnitLosses();
foreach (KeyValuePair <UnitType, UnitCombatResultView> entry in aiUnitViews)
{
int startingNum = ai_startingUnits.GetNumber(entry.Key);
int casualties = ai_casualties.GetNumber(entry.Key);
entry.Value.UpdateNumUnits(startingNum, casualties);
}
}
public GameState(GameState copy)
{
Terrain = copy.Terrain;
UnitMap = new UnitMap(Terrain.Width, Terrain.Height);
foreach (var unit in copy.Elves)
{
Elves.Add(new Unit(this, unit));
}
foreach (var unit in copy.Goblins)
{
Goblins.Add(new Unit(this, unit));
}
}
public void SpawnUnit(int PlayerIndex, UnitMap NewUnit, Vector3 SpawnPosition, Vector3 SpawnDestination)
{
NewUnit.Unit3D = new UnitMap3D(GameScreen.GraphicsDevice, Content.Load<Effect>("Shaders/Squad shader 3D"), NewUnit.ActiveUnit.SpriteMap, 1);
NewUnit.ActiveUnit.Init();
ListPlayer[PlayerIndex].ListUnit.Add(NewUnit);
NewUnit.SetPosition(SpawnPosition);
Vector3 FinalPosition;
GetEmptyPosition(SpawnDestination, out FinalPosition);
MovementAnimation.Add(NewUnit.X, NewUnit.Y, NewUnit);
NewUnit.SetPosition(FinalPosition);
}
public void UpdateArmy(UnitMap casualties)
{
foreach (UnitType type in Enum.GetValues(typeof(UnitType)).Cast <UnitType>())
{
int numDeaths = casualties.GetNumber(type);
for (int i = 0; i < numDeaths; i++)
{
army.RemoveUnit(type);
}
//update views
UpdateSupplyView();
UpdateUnitView(type);
}
}
protected internal virtual Result <Unit> Link(Unit self, Reference mod)
{
if (!UnitMap.TryGetValue(mod, out Unit unit))
{
if (mod.ModuleName == nameof(lang))
{
unit = lang;
}
else if (mod.DllName != null)
{
unit = LinkForeignModule(self, mod);
if (unit == null)
{
AddError(LinkerError.AssemblyNotFound, mod.SourceFileName, mod.SourceLocation, mod.DllName, mod.ModuleName);
}
}
else
{
var path = FindModule(self, mod.GetPath(), mod);
if (path != null && string.Equals(Path.GetExtension(path), EXT))
{
unit = ProcessSourceFile(path, mod);
}
else if (path != null)
{
unit = ProcessObjectFile(path, mod);
}
}
if (unit != null)
{
unit.Id = Units.Count;
Units.Add(unit);
UnitMap.Add(mod, unit);
}
}
if (unit != null && mod.Checksum != 0 && mod.Checksum != unit.Checksum && !BuilderOptions.LinkerSkipChecksum)
{
AddError(LinkerError.ChecksumValidationFailed, mod.SourceFileName, mod.SourceLocation, mod.ModuleName, unit.FileName);
}
return(Result.Create(unit, Messages));
}
public void ReloadSetMap(ref Map.Map map)
{
mMap = map;
mUnitMap = new UnitMap((int)map.GetMeasurements().X, (int)map.GetMeasurements().Y);
mSelectedGroup = new FlockingGroup(ref mDirector, ref mMap);
foreach (var funit in mFriendlyMilitary)
{
mUnitMap.AddUnit(funit);
}
//This list includes every platform
foreach (var platform in mReconstructionList)
{
mUnitMap.AddUnit(platform);
}
foreach (var hunit in mHostileMilitary)
{
mUnitMap.AddUnit(hunit);
}
}
public GameState(string raw)
{
Terrain = new Terrain(raw);
UnitMap = new UnitMap(Terrain.Width, Terrain.Height);
raw = raw.Replace("\r\n", "");
for (int i = raw.Length - 1; i >= 0; i--)
{
var position = new Coordinate(i % Terrain.Width, i / Terrain.Width);
switch (raw[i])
{
case 'E':
Elves.Add(new Unit(this, UnitType.Elf, position));
break;
case 'G':
Goblins.Add(new Unit(this, UnitType.Goblin, position));
break;
}
}
}
// generate target army for this combat phase
public UnitMap GenerateTargetArmy(UnitPriorities unitPriorities, BuildingType plannedBuilding)
{
UnitMap targetArmy = new UnitMap(startingUnits);
int remainingSupplyCopy = remainingSupply;
// while army not full (won't cause any issues as all units currently have 1 or 2 as their supplyCost, may need changes in future)
while (remainingSupplyCopy > 0)
{
UnitPurchaseModel model = null;
while (model == null)
{
model = RandomlySelectUnit(unitPriorities);
}
UnitType type = model.unitType;
if (IsUnitTrainable(type, remainingSupplyCopy, plannedBuilding))
{
requiredWood += model.buildCost.GetResourceAmount(ResourceType.WOOD);
requiredMagicStone += model.buildCost.GetResourceAmount(ResourceType.MAGIC_STONE);
remainingSupplyCopy -= model.armySize;
targetArmy.Add(type);
}
;
}
// check if supply has gone negative
if (remainingSupplyCopy != 0)
{
Debug.LogError("supply < 0? (=" + remainingSupplyCopy + ")");
}
Debug.Log(targetArmy.StatusString());
return(targetArmy);
}
// queue up target army creation
public Queue <AI_GameBehaviourCommand> GetArmyConstructionCommands(UnitMap targetMap, BuildingType plannedBuilding)
{
// calculate units that need to be trained
Queue <AI_GameBehaviourCommand> armyCommands = new Queue <AI_GameBehaviourCommand>();
UnitMap unitsToBeConstructed = startingUnits.UnitsRequiredToBecome(targetMap);
Debug.Log(unitsToBeConstructed.StatusString());
// iterate over required units and add the command to the queue
foreach (KeyValuePair <UnitType, int> unitMapEntry in unitsToBeConstructed.units)
{
UnitType type = unitMapEntry.Key;
UnitPurchaseModel model = UnitPurchaseModelFactory.Create(type);
int numUnits = unitMapEntry.Value;
while (numUnits > 0)
{
if (IsUnitTrainable(type, remainingSupply, plannedBuilding))
{
GameBehaviourCommand command = GetUnitToAddToQueue(type);
AI_GameBehaviourCommand aiCommand = new AI_GameBehaviourCommand(command, model.buildCost);
armyCommands.Enqueue(aiCommand);
numUnits--;
remainingSupply -= model.armySize;
}
else
{
Debug.LogError("Bad error -- cant create unit that was planned to be created");
break;
}
}
}
return(armyCommands);
}
private void initUnitMap()
{
unitMap = GameObject.Find("Units").GetComponent <UnitMap>();
}
// Generate Queue of planned commands to be executed by AI
public Queue <AI_GameBehaviourCommand> PlanCombatRound()
{
// Create empty queue
Queue <AI_GameBehaviourCommand> commands = new Queue <AI_GameBehaviourCommand>();
// Check Priorities
if (!unitPriorities.CheckSum())
{
Debug.LogError("Priority checksum problem");
}
;
// Are we building a building?
BuildingModel buildingModel = buildingPlanner.PlanBuilding(unitPriorities);
// Which units do we want?
UnitMap targetArmy = armyPlanner.GenerateTargetArmy(unitPriorities, buildingModel.type);
// Calculate total cost
int totalWood = CalculateTotalWoodCost();
int totalMagicStone = CalculateTotalMagicStoneCost();
// Set total cost
resourcePlanner.SetRequiredResources(totalWood, totalMagicStone);
// Worker Optimisation
Dictionary <ResourceType, int> idealWorkerDistribution = resourcePlanner.CalculateIdealWorkerDistribution();
// Resource Check -> Is it possible -> should always be yes -> future implementation to avoid queue spilling into next round
// Time check?
// Get WorkerCommand Queue
Queue <AI_GameBehaviourCommand> workerCommands = resourcePlanner.GetWorkerReassignmentCommands(idealWorkerDistribution);
// Queue up worker commands
int workerCommandCount = workerCommands.Count;
for (int i = 0; i < workerCommandCount; i++)
{
commands.Enqueue(workerCommands.Dequeue());
}
// Get Building Command
AI_GameBehaviourCommand buildingCommand = buildingPlanner.GetBuildingCommand(buildingModel);
// Queue up Building Command
if (buildingCommand != null)
{
commands.Enqueue(buildingCommand);
}
// Get Army Command Queue
Queue <AI_GameBehaviourCommand> armyCommands = armyPlanner.GetArmyConstructionCommands(targetArmy, buildingModel.type);
// Queue up army commands
int armyCommandCount = armyCommands.Count;
for (int i = 0; i < armyCommandCount; i++)
{
commands.Enqueue(armyCommands.Dequeue());
}
return(commands);
}
public void SetPlayer2Units(UnitMap armyUnitMap)
{
player2Units = new ActiveUnits(armyUnitMap);
}
public void UpdateArmy(PlayerType playerType)
{
UnitMap casualties = combatInstance.GetDefeatedUnits(playerType);
GetArmyController(playerType).UpdateArmy(casualties);
}
// copy constructor
public UnitMap(UnitMap map)
{
units = new Dictionary <UnitType, int>(map.units);
}
