private static IEnumerable <string> GetTechnologyRequirements(uint type, byte level, IStructureBaseStats trainer)
{
ActionRequirementFactory.ActionRecord record =
kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(trainer.WorkerId);
ActionRequirement foundAction =
record.List.FirstOrDefault(
action =>
action.Type == ActionType.TechnologyUpgradeActive &&
ushort.Parse(action.Parms[0]) == type &&
ushort.Parse(action.Parms[1]) >= level);
if (foundAction != null)
{
var requirements =
kernel.Get <EffectRequirementFactory>()
.GetEffectRequirementContainer(foundAction.EffectReqId);
foreach (var requirement in requirements)
{
if (requirement.WebsiteDescription != string.Empty)
{
yield return(requirement.WebsiteDescription);
}
}
}
}
private static void FindTechnologyTrainer(uint type, byte level, out IStructureBaseStats trainer)
{
foreach (var builderType in structureTypes)
{
byte structureLevel = 1;
IStructureBaseStats stats;
while ((stats = kernel.Get <IStructureCsvFactory>().GetBaseStats(builderType, structureLevel)) != null)
{
structureLevel++;
ActionRequirementFactory.ActionRecord record =
kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(stats.WorkerId);
if (record == null)
{
continue;
}
if (
record.List.Any(
action =>
action.Type == ActionType.TechnologyUpgradeActive &&
ushort.Parse(action.Parms[0]) == type &&
byte.Parse(action.Parms[1]) >= level))
{
trainer = stats;
return;
}
}
}
trainer = null;
}
private static void FindStructureBuilder(ushort type,
byte level,
out IStructureBaseStats builder,
out bool convert)
{
if (level > 1)
{
builder = kernel.Get <IStructureCsvFactory>().GetBaseStats(type, (byte)(level - 1));
convert = false;
return;
}
foreach (var builderType in structureTypes)
{
if (builderType == type)
{
continue;
}
byte structureLevel = 1;
IStructureBaseStats stats;
while ((stats = kernel.Get <IStructureCsvFactory>().GetBaseStats(builderType, structureLevel)) != null)
{
structureLevel++;
ActionRequirementFactory.ActionRecord record =
kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(stats.WorkerId);
if (record == null)
{
continue;
}
foreach (var action in record.List)
{
if (level == 1)
{
if (action.Type == ActionType.StructureBuildActive && ushort.Parse(action.Parms[0]) == type)
{
builder = stats;
convert = false;
return;
}
if (action.Type == ActionType.StructureChangeActive && ushort.Parse(action.Parms[0]) == type)
{
builder = stats;
convert = true;
return;
}
}
}
}
}
builder = null;
convert = false;
}
private static IEnumerable <string> GetStructureRequirements(ushort type, byte level, IStructureBaseStats builder)
{
ActionRequirementFactory.ActionRecord record =
kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(builder.WorkerId);
ActionRequirement foundAction = null;
foreach (var action in record.List)
{
if (level == 1 && action.Type == ActionType.StructureBuildActive &&
ushort.Parse(action.Parms[0]) == type)
{
foundAction = action;
break;
}
if (level == 1 && action.Type == ActionType.StructureChangeActive &&
ushort.Parse(action.Parms[0]) == type)
{
foundAction = action;
break;
}
if (action.Type == ActionType.StructureUpgradeActive && byte.Parse(action.Parms[0]) >= level)
{
foundAction = action;
break;
}
}
if (foundAction != null)
{
var requirements =
kernel.Get <EffectRequirementFactory>()
.GetEffectRequirementContainer(foundAction.EffectReqId);
foreach (var requirement in requirements)
{
if (requirement.WebsiteDescription != string.Empty)
{
yield return(requirement.WebsiteDescription);
}
}
}
}
private static IEnumerable <string> GetUnitRequirements(ushort type, byte level, IStructureBaseStats trainer)
{
ActionRequirementFactory.ActionRecord record =
kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(trainer.WorkerId);
ActionRequirement foundAction;
if (level == 1)
{
foundAction =
record.List.FirstOrDefault(
action =>
action.Type == ActionType.UnitTrainActive &&
ushort.Parse(action.Parms[0]) == type);
}
else
{
foundAction =
record.List.FirstOrDefault(
action =>
action.Type == ActionType.UnitUpgradeActive &&
ushort.Parse(action.Parms[0]) == type &&
byte.Parse(action.Parms[1]) >= level);
}
if (foundAction == null)
{
yield break;
}
var requirements =
kernel.Get <EffectRequirementFactory>().GetEffectRequirementContainer(foundAction.EffectReqId);
foreach (
var requirement in requirements.Where(requirement => requirement.WebsiteDescription != string.Empty)
)
{
yield return(requirement.WebsiteDescription);
}
}
public Error DoActive(int workerType, IGameObject workerObject, ActiveAction action, IHasEffect effects)
{
if (workerObject.IsBlocked > 0)
{
return(Error.ObjectNotFound);
}
uint actionId = actionIdGen.GetNext();
ActionRequirementFactory.ActionRecord record =
Ioc.Kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(workerType);
if (record == null)
{
return(Error.ActionNotFound);
}
foreach (var actionReq in record.List.Where(x => x.Type == action.Type))
{
var error = action.Validate(actionReq.Parms);
if (error != Error.Ok)
{
if (error != Error.ActionInvalid)
{
return(error);
}
continue;
}
if (!CanDoActiveAction(action, actionReq, workerObject))
{
return(Error.ActionTotalMaxReached);
}
error =
Ioc.Kernel.Get <EffectRequirementFactory>()
.GetEffectRequirementContainer(actionReq.EffectReqId)
.Validate(workerObject, effects.GetAllEffects(actionReq.EffectReqInherit), requirementFormula);
if (error != Error.Ok)
{
return(error);
}
SetActiveActionParams(action);
action.ActionId = actionId;
action.WorkerIndex = actionReq.Index;
action.WorkerType = workerType;
action.WorkerObject = workerObject;
active.Add(action.ActionId, action);
Error ret = action.Execute();
if (ret != Error.Ok)
{
action.StateChange(ActionState.Failed);
active.Remove(action.ActionId);
actionIdGen.Release(action.ActionId);
}
else
{
action.StateChange(ActionState.Started);
}
return(ret);
}
return(Error.ActionInvalid);
}
private static Result ProcessStructure(IStructureBaseStats structureBaseStats, bool skipUpgrades)
{
int hash = structureBaseStats.Type * 100 + structureBaseStats.Lvl;
if (processedStructures.Contains(hash))
{
return(Result.AlreadyProcessed);
}
Console.Out.WriteLine("Parsing " + structureBaseStats.Name + " " + structureBaseStats.Lvl);
ActionRequirementFactory.ActionRecord record =
kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(structureBaseStats.WorkerId);
processedStructures.Add(hash);
bool hadConnection = false;
if (structureBaseStats.Lvl == 1)
{
CreateDefinition(structureBaseStats);
}
if (record == null)
{
return(Result.Empty);
}
// First pass
foreach (var action in record.List)
{
switch (action.Type)
{
case ActionType.StructureBuildActive:
case ActionType.StructureChangeActive:
IStructureBaseStats building = kernel.Get <IStructureCsvFactory>().GetBaseStats(ushort.Parse(action.Parms[0]), 1);
Result result = ProcessStructure(building, false);
if (result != Result.AlreadyProcessed)
{
if (action.Type == ActionType.StructureBuildActive)
{
WriteNode(structureBaseStats, building);
}
else if (action.Type == ActionType.StructureChangeActive)
{
WriteNode(structureBaseStats, building, "dashed", "Converts To");
}
hadConnection = true;
}
break;
case ActionType.UnitTrainActive:
IBaseUnitStats training =
kernel.Get <UnitFactory>().GetUnitStats(ushort.Parse(action.Parms[0]), 1);
if (!processedUnits.Contains(training.UnitHash))
{
WriteNode(structureBaseStats, training);
CreateDefinition(training);
hadConnection = true;
processedUnits.Add(training.UnitHash);
}
break;
case ActionType.TechnologyUpgradeActive:
TechnologyBase tech =
kernel.Get <TechnologyFactory>().GetTechnologyBase(ushort.Parse(action.Parms[0]), 1);
if (!processedTechnologies.Contains(tech.TechnologyHash))
{
WriteNode(structureBaseStats, tech);
CreateDefinition(tech);
hadConnection = true;
processedTechnologies.Add(tech.TechnologyHash);
}
break;
}
}
// Second pass
foreach (var action in record.List)
{
switch (action.Type)
{
case ActionType.StructureUpgradeActive:
if (!skipUpgrades)
{
byte maxLvl = byte.Parse(action.Parms[0]);
IStructureBaseStats from = structureBaseStats;
var newRank = new List <String> {
GetKey(from)
};
for (int i = from.Lvl; i < maxLvl; i++)
{
IStructureBaseStats to = kernel.Get <IStructureCsvFactory>()
.GetBaseStats(from.Type, (byte)(i + 1));
Result result = ProcessStructure(to, true);
if (result == Result.Ok || i == maxLvl - 1)
{
WriteNode(from, to);
CreateDefinition(to);
hadConnection = true;
newRank.Add(GetKey(to));
from = to;
}
}
if (newRank.Count > 1)
{
ranks.Add(newRank);
}
}
break;
}
}
return(hadConnection ? Result.Ok : Result.Empty);
}
