public TileRuleSet(SerializationInputStream Stream)
: this(
Stream.ReadString(),
Stream.ReadEnumerable(PARSER).ToArray(),
Stream.ReadEnumerable(PARSER).ToArray(),
Stream.ReadEnumerable(PARSER).ToArray())
{
}
public MatchLobby(SerializationInputStream Stream)
{
_Scenario = new Scenario(Stream);
_Players = Stream.ReadEnumerable(i => new Player(Stream)).ToList();
_PlayerArmies = Stream.ReadEnumerable(
i => new KeyValuePair <Player, ArmyConfiguration>(
_Players[Stream.ReadByte()], ReadArmyConfiguration(Stream)))
.ToDictionary(i => i.Key, i => i.Value);
_PlayerReady = Stream.ReadEnumerable(
i => new KeyValuePair <Player, bool>(
_Players[Stream.ReadByte()], Stream.ReadBoolean())).ToDictionary(i => i.Key, i => i.Value);
}
public IndirectFireAttackOrder(SerializationInputStream Stream, List <GameObject> Objects)
: base(Stream, Objects)
{
_Attackers = Stream.ReadEnumerable(i => new IndirectFireSingleAttackOrder(Stream, Objects)).ToList();
_ScatterRoll = Stream.ReadByte();
_ScatterDirectionRoll = Stream.ReadByte();
}
public Environment(SerializationInputStream Stream)
{
UniqueKey = Stream.ReadString();
TileRuleSet = new TileRuleSet(Stream);
MovementMultiplier = Stream.ReadFloat();
_RestrictRoadMovement = Stream.ReadEnumerable(i => i.ReadBoolean()).ToArray();
}
public UnitConfigurationLock(SerializationInputStream Stream)
: this(
Stream.ReadString(),
Stream.ReadFloat(),
Stream.ReadEnumerable(i => GameData.UnitConfigurationLinks[i.ReadString()]))
{
}
public ArmyConfiguration(SerializationInputStream Stream)
{
UniqueKey = Stream.ReadString();
Faction = GameData.Factions[Stream.ReadString()];
Team = Stream.ReadByte();
DeploymentConfigurations = Stream.ReadEnumerable(DeploymentConfigurationSerializer.Deserialize).ToList();
VictoryCondition = new VictoryCondition(Stream);
}
public UnitConfigurationPack(SerializationInputStream Stream)
: this(
Stream.ReadInt32(),
Stream.ReadString(),
Stream.ReadInt32(),
Stream.ReadEnumerable(i => new UnitConfigurationLock(i)))
{
}
public UnitConstraints(SerializationInputStream Stream)
{
IntroduceYear = Stream.ReadInt32();
ObsoleteYear = Stream.ReadInt32();
Front = (Front)Stream.ReadByte();
Environments = Stream.ReadEnumerable(
i => Stream.ReadObject(j => new Environment(j), false, true)).ToList();
}
public Faction(SerializationInputStream Stream)
: this(
Stream.ReadString(),
Stream.ReadString(),
Stream.ReadEnumerable(FileUtils.DeserializeColor).ToArray(),
Stream.ReadByte(),
Stream.ReadBoolean())
{
}
public MatchRecord(SerializationInputStream Stream)
{
var scenario = new Scenario(Stream);
scenario.Rules &= new ScenarioRules(false, true);
Match = new Match(scenario, null);
OrderSerializer = new OrderSerializer(Match);
Orders = Stream.ReadEnumerable(() => OrderSerializer.Deserialize(Stream)).ToList();
}
public Scenario(SerializationInputStream Stream)
: this(
Stream.ReadString(),
Stream.ReadEnumerable(i => new ArmyConfiguration(Stream)).ToList(),
new TurnConfiguration(Stream),
GameData.Environments[Stream.ReadString()],
(MapConfiguration)MapConfigurationSerializer.Instance.Deserialize(Stream),
new ScenarioRules(Stream))
{
}
public UnitMovementRules(SerializationInputStream Stream)
{
UniqueKey = Stream.ReadString();
BaseCost = Stream.ReadInt32();
IgnoresEnvironmentMovement = Stream.ReadBoolean();
CannotUseRoadMovement = Stream.ReadBoolean();
MovementRules = Stream.ReadEnumerable(i => new MovementRule(i)).ToArray();
}
public Map(SerializationInputStream Stream, TileRuleSet RuleSet, IdGenerator IdGenerator)
{
var width = Stream.ReadInt32();
var height = Stream.ReadInt32();
Tiles = new Tile[width, height];
var tiles = Stream.ReadEnumerable(i => new Tile(i, this, RuleSet, IdGenerator)).GetEnumerator();
for (int i = 0; i < width; ++i)
{
for (int j = 0; j < height; ++j)
{
tiles.MoveNext();
Tiles[i, j] = tiles.Current;
}
}
Regions = Stream.ReadEnumerable(i => new MapRegion(Stream, Tiles)).ToList();
Ready();
}
protected AttackOrderBase(SerializationInputStream Stream, List <GameObject> Objects)
: this(
(Army)Objects[Stream.ReadInt32()],
(Tile)Objects[Stream.ReadInt32()])
{
Target = (AttackTarget)Stream.ReadByte();
_Results =
Stream.ReadEnumerable(
i => new Tuple <Unit, CombatResult>(
(Unit)Objects[Stream.ReadInt32()], (CombatResult)Stream.ReadByte()))
.ToList();
}
public TileRenderer(SerializationInputStream Stream)
: this(
Stream.ReadString(),
Stream.ReadString(),
FileUtils.DeserializeColor(Stream),
FileUtils.DeserializeColor(Stream),
Stream.ReadEnumerable(i => FileUtils.DeserializeColor(i)).ToArray(),
Stream.ReadEnumerable(i => FileUtils.DeserializeColor(i)).ToArray(),
Stream.ReadEnumerable(i => FileUtils.DeserializeColor(i)).ToArray(),
Stream.ReadEnumerable(i => FileUtils.DeserializeColor(i)).ToArray(),
Stream.ReadEnumerable(i => FileUtils.DeserializeColor(i)).ToArray(),
Stream.ReadEnumerable(i => FileUtils.DeserializeColor(i)).ToArray(),
Stream.ReadEnumerable(i => i.ReadFloat()).ToArray(),
Stream.ReadEnumerable(i => i.ReadFloat()).ToArray())
{
}
public TileComponentRules(SerializationInputStream Stream)
: this(
Stream.ReadString(),
Stream.ReadBoolean(),
Stream.ReadInt32(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Stream.ReadBoolean(),
Enumerable.Empty <TerrainAttribute>())
{
_TerrainAttributes = Stream.ReadEnumerable(Stream.ReadBoolean).ToArray();
}
public AirAttackOrder(SerializationInputStream Stream, List <GameObject> Objects)
: base(Stream, Objects)
{
_Attackers = Stream.ReadEnumerable(i => new AirSingleAttackOrder(Stream, Objects)).ToList();
}
public SumObjective(SerializationInputStream Stream)
{
Objectives = Stream.ReadEnumerable(
i => (Objective)ObjectiveSerializer.Instance.Deserialize(Stream)).ToList();
}
public RandomSequence(SerializationInputStream Stream)
: this(Stream.ReadEnumerable(i => i.ReadByte()).ToArray())
{
}
public UnitGroup(SerializationInputStream Stream)
{
Name = Stream.ReadString();
_UnitCounts = Stream.ReadEnumerable(i => new UnitCount(i)).ToList();
}
public BoardCompositeMapConfiguration(SerializationInputStream Stream)
: this(Stream.ReadEnumerable(
i => Stream.ReadEnumerable(
j => new BoardConfiguration(Stream.ReadString(), Stream.ReadBoolean()))))
{
}
public ConvoyOrderDeployOrder(SerializationInputStream Stream, List <GameObject> Objects)
: this(
(ConvoyDeployment)Objects[Stream.ReadInt32()],
Stream.ReadEnumerable(i => (Unit)Objects[Stream.ReadInt32()]).ToList())
{
}
public CompositeObjective(SerializationInputStream Stream)
: this(
Stream.ReadEnumerable(i => (Objective)ObjectiveSerializer.Instance.Deserialize(Stream)).ToList(),
Aggregators.AGGREGATORS[Stream.ReadByte()])
{
}
public StaticSequence(SerializationInputStream Stream)
: this(Stream.ReadInt32(), Stream.ReadEnumerable(i => i.ReadByte()).ToArray())
{
}
public GetUnitConfigurationPacksResponse(SerializationInputStream Stream)
: base(Stream)
{
UnitConfigurationPacks = Stream.ReadEnumerable(i => new UnitConfigurationPack(i)).ToList();
}
public VictoryCondition(SerializationInputStream Stream)
{
Scorers = Stream.ReadEnumerable(
i => (Objective)ObjectiveSerializer.Instance.Deserialize(Stream, false, true)).ToList();
Triggers = Stream.ReadEnumerable(i => new ObjectiveSuccessTrigger(Stream)).ToList();
}
public Polygon(SerializationInputStream Stream)
: this(Stream.ReadEnumerable(i => new Vector2f(Stream.ReadFloat(), Stream.ReadFloat())).ToArray())
{
}
public MapRegion(SerializationInputStream Stream, Tile[,] Tiles)
: this(Stream.ReadString(), Stream.ReadEnumerable(i => Tiles[Stream.ReadInt32(), Stream.ReadInt32()]))
{
}
public CompositeMatcher(SerializationInputStream Stream)
: this(
Stream.ReadEnumerable(i => (Matcher <T>)MatcherSerializer.Instance.Deserialize(Stream)).ToList(),
Aggregators.AGGREGATORS[Stream.ReadByte()])
{
}
public static void Load(string Module, SerializationInputStream Stream)
{
LoadedModule = Module;
string Path = "./Modules/" + Module;
ClassLibrary.Instance.ReadBlock(new ParseBlock(new ParseBlock[]
{
ParseBlock.FromFile(Path + "/Theme/Fonts.blk"),
new ParseBlock(
"class<>",
"classes",
Enumerable.Repeat(Path + "/Theme/Base.blk", 1)
.Concat(Directory.EnumerateFiles(
Path + "/Theme/Components", "*", SearchOption.AllDirectories))
.SelectMany(i => ParseBlock.FromFile(i).Break()))
}));
UnitMovementRules = Stream.ReadEnumerable(
i => i.ReadObject(j => new UnitMovementRules(j), false, true)).ToDictionary(i => i.UniqueKey);
TileComponentRules = Stream.ReadEnumerable(
i => i.ReadObject(j => new TileComponentRules(j), false, true)).ToDictionary(i => i.UniqueKey);
Environments = Stream.ReadEnumerable(
i => i.ReadObject(j => new Environment(j), false, true)).ToDictionary(i => i.UniqueKey);
Factions = Stream.ReadEnumerable(
i => i.ReadObject(j => new Faction(j), false, true)).ToDictionary(i => i.UniqueKey);
FactionRenderDetails = Stream.ReadEnumerable(
i => new KeyValuePair <string, FactionRenderDetails>(
i.ReadString(),
new FactionRenderDetails(i, Path + "/FactionSymbols/"))).ToDictionary(i => i.Key, i => i.Value);
UnitConfigurations = Stream.ReadEnumerable(
i => i.ReadObject(j => new UnitConfiguration(j), false, true)).ToDictionary(i => i.UniqueKey);
UnitRenderDetails = Stream.ReadEnumerable(
i => new KeyValuePair <string, UnitRenderDetails>(
i.ReadString(),
new UnitRenderDetails(i, Path + "/UnitSprites/"))).ToDictionary(i => i.Key, i => i.Value);
UnitConfigurationLinks =
Stream.ReadEnumerable(i => new UnitConfigurationLink(i)).ToDictionary(i => i.UniqueKey);
UnitConfigurationLocks =
Stream.ReadEnumerable(i => new UnitConfigurationLock(i)).ToDictionary(i => i.UniqueKey);
Scenarios = Stream.ReadEnumerable(i => new Scenario(i)).ToList();
TileRenderers = Stream.ReadEnumerable(i => new TileRenderer(i)).ToDictionary(i => i.UniqueKey);
NameGenerators = Stream.ReadEnumerable(
i => new KeyValuePair <string, MarkovGenerator <char> >(
Stream.ReadString(), Stream.ReadObject(j => new MarkovGenerator <char>(j))))
.ToDictionary(i => i.Key, i => i.Value);
TerrainGenerators = Stream.ReadEnumerable(
i => new KeyValuePair <string, TerrainGeneratorConfiguration>(
Stream.ReadString(), Stream.ReadObject(j => new TerrainGeneratorConfiguration(j))))
.ToDictionary(i => i.Key, i => i.Value);
MatchSettings = Stream.ReadEnumerable(i => new MatchSetting(i)).ToDictionary(i => i.UniqueKey);
}
