CutterWrapper(SequentialPluginDataReader reader, AggressivePlayer player, ILevelManager level)
{
reader.GetNext(out int id);
this.cutter = (TreeCutter)level.GetBuilding(id).Plugin;
this.player = player;
reader.GetNext(out position);
}
static ITile GetTileRelativeToKeepCenter(IntVector2 relativeDiff, AggressivePlayer player)
{
Vector3 worldPosition = player.Keep.Building.Center +
player.Keep.Building.Forward * relativeDiff.X +
player.Keep.Building.Right * relativeDiff.Y;
return(player.Player.Level.Map.GetContainingTile(worldPosition));
}
public static void SaveCutters(AggressivePlayer player, SequentialPluginDataWriter writer, IEnumerable <CutterWrapper> cutters)
{
writer.StoreNext(player.takenPositions.Count);
foreach (var cutter in cutters)
{
cutter.Save(writer);
}
}
public static State Load(SequentialPluginDataReader reader, AggressivePlayer player)
{
reader.GetNext(out int intState);
switch ((States)intState)
{
case States.BuildCutters:
return(new BuildCutters(reader, player));
case States.BuildUnits:
return(new BuildUnits(reader, player));
case States.AttackEnemy:
return(new AttackEnemy(reader, player));
default:
throw new ArgumentOutOfRangeException();
}
}
public AttackEnemy(State previousState, AggressivePlayer player)
: base(CutterTimeout, DefenseTimeout, player)
{
previousState?.Dispose();
var targetPlayer = player.Player
.GetEnemyPlayers()
.MinBy(enemy => {
var keep = (enemy.Plugin as PlayerWithKeep)?.Keep;
return(keep == null
? double.MaxValue
: Vector3.Distance(player.Keep.Building.Center, keep.Building.Center));
}).FirstOrDefault();
target = targetPlayer?.Plugin as PlayerWithKeep;
if (target != null)
{
target.Player.OnRemoval += TargetDied;
}
}
public static CutterWrapper CreateNewCutter(ILevelManager level, AggressivePlayer player)
{
foreach (var position in PossiblePositions)
{
ITile tile = GetTileRelativeToKeepCenter(position, player);
if (player.takenPositions.Contains(position) ||
!player.type.TreeCutter.CanBuild(tile.MapLocation, player.Player, level))
{
continue;
}
IBuilding newBuilding = level.BuildBuilding(player.type.TreeCutter.MyTypeInstance,
tile.MapLocation,
Quaternion.Identity,
player.Player);
if (newBuilding != null)
{
player.takenPositions.Add(position);
return(new CutterWrapper(newBuilding, player, position));
}
}
return(null);
}
public override PlayerAIInstancePlugin CreateNewInstance(ILevelManager level, IPlayer player)
{
return(AggressivePlayer.CreateNew(level, player, this));
}
public AttackEnemy(SequentialPluginDataReader reader, AggressivePlayer player)
: base(CutterTimeout, DefenseTimeout, player)
{
}
public BuildUnits(State previousState, AggressivePlayer player)
: base(CutterTimeout, DefenseTimeout, player)
{
previousState?.Dispose();
}
public BuildUnits(SequentialPluginDataReader reader, AggressivePlayer player)
: base(CutterTimeout, DefenseTimeout, player)
{
}
protected Defend(double cutterCheckTimeout, double defendCheckTimeout, AggressivePlayer player)
: base(player)
{
this.CutterCheckTimeout = new Timeout(cutterCheckTimeout);
this.DefendCheckTimeout = new Timeout(defendCheckTimeout);
}
public static Dictionary <IBuilding, CutterWrapper> LoadCutters(SequentialPluginDataReader reader, AggressivePlayer player, ILevelManager level)
{
Dictionary <IBuilding, CutterWrapper> cutters = new Dictionary <IBuilding, CutterWrapper>();
reader.GetNext(out int numberOfCutters);
for (int i = 0; i < numberOfCutters; i++)
{
CutterWrapper newWrapper = new CutterWrapper(reader, player, level);
cutters.Add(newWrapper.cutter.Building, newWrapper);
player.takenPositions.Add(newWrapper.position);
}
return(cutters);
}
public BuildCutters(SequentialPluginDataReader reader, AggressivePlayer player)
: base(player)
{
}
protected State(AggressivePlayer player)
{
this.Player = player;
}
CutterWrapper(IBuilding building, AggressivePlayer player, IntVector2 position)
{
this.cutter = (TreeCutter)building.BuildingPlugin;
this.player = player;
this.position = position;
}
public override PlayerAIInstancePlugin GetInstanceForLoading(ILevelManager level, IPlayer player)
{
return(AggressivePlayer.GetInstanceForLoading(level, player, this));
}
public static AggressivePlayer CreateNew(ILevelManager level, IPlayer player, AggressivePlayerType type)
{
var instance = new AggressivePlayer(level, player, type);
return(instance);
}
public BuildCutters(State previousState, AggressivePlayer player)
: base(player)
{
previousState?.Dispose();
this.cutterBuildTimeout = new Timeout(BuildTimeout);
}
