/// <summary>
/// Gets a new unit from the save game unit xml node.
/// </summary>
/// <param name="reader"></param>
/// <param name="isAIUnit"></param>
/// <returns></returns>
internal static Unit FromSaveGameUnitNode(XmlReader reader, bool isAIUnit)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
UnitBase clone = null;
Unit reHydrated = null;
string unitName = reader.ReadElementString("Name");
GameRoot root = GameRoot.Instance;
clone = root.Ruleset.Units[unitName];
if (clone == null)
{
return(null);
}
if (isAIUnit && clone.CanSettle)
{
//ai settler
reHydrated = new AISettler();
}
else if (isAIUnit && clone.CanWork)
{
//ai worker
reHydrated = new AIWorker();
}
else if (clone.CanSettle)
{
//settler
reHydrated = new Settler();
}
else if (clone.CanWork)
{
//worker
reHydrated = new Worker();
}
else
{
//moveable unit
reHydrated = new Unit();
}
reHydrated.Load(reader);
return(reHydrated);
}
/// <summary>
/// Creates and returns units from cities and base units.
/// </summary>
/// <param name="city"></param>
/// <param name="baseUnit"></param>
/// <returns></returns>
internal static Unit CreateUnit(City city, Unit baseUnit)
{
if (city == null)
{
throw new ArgumentNullException("city");
}
if (baseUnit == null)
{
throw new ArgumentNullException("baseUnit");
}
Unit newUnit = null;
if (city.ParentCountry.GetType() == typeof(AICountry))
{
if (baseUnit.CanSettle)
{
newUnit = new AISettler(city.Coordinates, baseUnit);
}
else if (baseUnit.CanWork)
{
newUnit = new AIWorker(city.Coordinates, baseUnit);
}
else
{
newUnit = new AIUnit(city.Coordinates, baseUnit);
}
}
else
{
if (baseUnit.CanSettle)
{
newUnit = new Settler(city.Coordinates, baseUnit);
}
else if (baseUnit.CanWork)
{
newUnit = new Worker(city.Coordinates, baseUnit);
}
else
{
newUnit = new Unit(city.Coordinates, baseUnit);
}
}
return(newUnit);
}
/// <summary>
/// Creates a new <see cref="Worker"/> object.
/// </summary>
/// <param name="parentCity">The <see cref="City"/> creating the <see cref="Worker"/>.</param>
/// <returns></returns>
public static Worker CreateWorker(City parentCity)
{
Worker worker = null;
GameRoot root = GameRoot.Instance;
foreach (Unit unit in root.Ruleset.Units)
{
if (unit.CanWork)
{
if (parentCity is AICity)
{
worker = new AIWorker(unit);
}
else
{
worker = new Worker(unit);
}
break;
}
}
return(worker);
}
/// <summary>
/// Event handler for the <i>ImprovementBuilt</i> event of a city using this strategy.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void OnImprovementBuilt(object sender, ImprovementBuiltEventArgs e)
{
AICity city = e.City as AICity;
BuildableItem nextImprovement = null;
GameRoot root = GameRoot.Instance;
//what to do with what we just built?
if (e.Improvement.GetType() == typeof(AIUnit))
{
AIUnit unit = e.Improvement as AIUnit;
switch (city.PrimaryNeed)
{
case AICityNeed.Commerce:
break;
case AICityNeed.Culture:
break;
case AICityNeed.Food:
break;
case AICityNeed.UnitDefense:
unit.Fortified = true;
break;
}
}
else if (e.Improvement.GetType() == typeof(AISettler))
{
}
else if (e.Improvement.GetType() == typeof(AIWorker))
{
AIWorker worker = e.Improvement as AIWorker;
worker.ParentCity = e.City;
worker.Automated = true;
}
//next item to build
switch (city.PrimaryNeed)
{
case AICityNeed.Commerce:
if (!city.HasWorkerInFields())
{
nextImprovement = UnitFactory.CreateWorker(city);
}
else
{
nextImprovement =
city.GetBuildableItemForNeed(city.PrimaryNeed,
typeof(Improvement));
}
break;
case AICityNeed.Culture:
nextImprovement =
city.GetBuildableItemForNeed(city.PrimaryNeed, typeof(Improvement));
break;
case AICityNeed.Food:
if (!city.HasWorkerInFields())
{
nextImprovement = UnitFactory.CreateWorker(city);
}
else
{
nextImprovement =
city.GetBuildableItemForNeed(city.PrimaryNeed,
typeof(Improvement));
}
break;
case AICityNeed.UnitDefense:
nextImprovement =
city.GetBuildableItemForNeed(city.PrimaryNeed,
typeof(Unit));
break;
}
city.NextImprovement = nextImprovement;
}
