/// <summary>
/// Constructor
/// </summary>
/// <param name="name">The name of the player.</param>
/// <param name="factory">The factory for this player (represent the nation).</param>
public Player(string name, IUnitFactory factory)
{
this.name = name;
this.factory = factory;
count++;
this.number = count;
}
/// <summary>
/// Build the game.
/// Creates the game manager with the right players, units and map.
/// </summary>
/// <remarks>
/// The map is created in the C++ library as for the unit positions.
/// </remarks>
/// <param name="name1">The first player's name.</param>
/// <param name="factory1">The factory for the first player.</param>
/// <param name="name2">The second player's name.</param>
/// <param name="factory2">The factory for the second player.</param>
/// <returns>The game manager.</returns>
public IGame BuildGame(string name1, IUnitFactory factory1, string name2, IUnitFactory factory2)
{
// Builds the map using the MapBuilder:
IMap map = MapBuilder.Instance.BuildMap(this.mapSize);
ITile[,] tiles = map.Tiles;
int[][] mapAsIntegers = TileFactory.GetNumbers(tiles);
IPlayer player1 = new Player(name1, factory1);
IPlayer player2 = new Player(name2, factory2);
// Retrieves the starting points from the wrapper:
int[][] starts = Wrapper.getStartsPlayers(mapAsIntegers, this.mapSize);
IPoint startPlayer1 = new Point(starts[0][0], starts[0][1]);
IPoint startPlayer2 = new Point(starts[1][0], starts[1][1]);
// Creates and places the units for each player:
List<IUnit> units1 = player1.CreateUnits(this.nbUnits);
for(int i = 0; i < this.nbUnits; i++) {
map.PlaceUnit(units1[i], startPlayer1);
}
List<IUnit> units2 = player2.CreateUnits(this.nbUnits);
for(int i = 0; i < this.nbUnits; i++) {
map.PlaceUnit(units2[i], startPlayer2);
}
return new Game(player1, player2, map, this.maxRounds);
}
public Engine(IUserInterface userInterface,IDatabase db)
{
this.buildingFactory = new BuildingFactory();
this.resourceFactory = new ResourceFactory();
this.unitFactory = new UnitFactory();
this.io = userInterface;
this.db = db;
}
public Engine(IUnitFactory unitFactory, IResourceFactory resourceFactory,IBuildingFactory buildingFactory, IInputReader reader, IOutputWriter writer, IEmpiresData data)
{
this.unitFactory = unitFactory;
this.resourceFactory = resourceFactory;
this.buildingFactory = buildingFactory;
this.reader = reader;
this.writer = writer;
this.data = data;
}
public Engine(IBuildingFactory buildingFactory, IResourceFactory resourceFactory, IUnitFactory unitFactory, IData data, IInputReader reader, IOuptupWriter writer)
{
this.buildingFactory = buildingFactory;
this.resourceFactory = resourceFactory;
this.unitFactory = unitFactory;
this.data = data;
this.reader = reader;
this.writer = writer;
}
public Engine(IBuildingFactory buildingFactory, IResourseFactory resourseFactory, IUnitFactory unitFactory, IData empireData, IInputReader reader, IOutputWriter writer)
{
this.buildingFactory = buildingFactory;
this.resourseFactory = resourseFactory;
this.unitFactory = unitFactory;
this.empireData = empireData;
this.reader = reader;
this.writer = writer;
}
public Barracks(IUnitFactory unitFactory, IResourceFactory resourceFactory)
: base(BarracksUnitType,
BarracksUnitCycleLength,
BarracksResourceType,
BarracksResourceCycleLength,
BarracksResourceQuantity,
unitFactory,
resourceFactory)
{
}
public Barracks(IUnitFactory unitFactory, IResourceFactory resourceFactory)
: base(UnitType,
UnitCicleLenth,
BarracsResourceType,
ResourceCicleLength,
ResourceQuantity,
unitFactory,
resourceFactory)
{
}
public Archery( IUnitFactory unitFactory, IResourceFactory resourseFactory)
: base(ArcheryUnitType,
ArcheryUnitCycleLength,
ArcheryResourseType,
ArcheryResourceCycleLength,
unitFactory,
ArcheryResourceQuantity,
resourseFactory)
{
}
protected Building(string unitType, int unitCycleLength, ResourceType resourceType, int resourceCycleLength, int resourceQuantity, IUnitFactory unitFactory, IResourceFactory resourceFactory)
{
this.unitType = unitType;
this.unitCycleLength = unitCycleLength;
this.resourceType = resourceType;
this.resourceCycleLength = resourceCycleLength;
this.resourceQuantity = resourceQuantity;
this.unitFactory = unitFactory;
this.resourceFactory = resourceFactory;
}
public Archery(IUnitFactory unitFactory, IResourceFactory resourceFactory)
: base(UnitType,
UnitCicleLenth,
ArcheryResourceType,
ResourceCicleLength,
ResourceQuantity,
unitFactory,
resourceFactory)
{
}
public IBuilding CreateBuilding(string buildingType, IResourceFactory resourceFactory, IUnitFactory unitFactory)
{
var type = Assembly.GetExecutingAssembly()
.GetTypes()
.FirstOrDefault(t => t.Name.ToLowerInvariant() == buildingType);
var building = (IBuilding)Activator.CreateInstance(type, unitFactory, resourceFactory);
return building;
}
public SimpleFixedUnitLayer(ISet<IUnit> units,
IUnitFactory<Archer> archerFactory,
IUnitFactory<Legion> legionFactory,
IUnitFactory<Settler> settlerFactory)
{
Units = units;
Units.Add(archerFactory.Create(RedArcherTile, Red));
Units.Add(legionFactory.Create(BlueLegionTile, Blue));
Units.Add(settlerFactory.Create(RedSettlerTile, Red));
}
public IBuilding CreateBuilding(string buildingType, IUnitFactory unitFactory, IResourceFactory resourceFactory)
{
switch (buildingType)
{
case "archery":
return new Archery(unitFactory, resourceFactory);
case "barracks":
return new Barracks(unitFactory, resourceFactory);
default:
throw new ArgumentException("Unknow building type.");
}
}
public IBuilding CreateBuilding(string buildingType, IUnitFactory unitFactory, IResourceFactory resourceFactory)
{
// Reflection
var type = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(t => t.Name.ToLowerInvariant() == buildingType);
if (type == null)
{
throw new AggregateException("Unknow building type");
}
var building = (IBuilding)Activator.CreateInstance(type, unitFactory, resourceFactory);
return building;
}
public IBuilding CreateBuilding(string buildingType,IResourceFactory rf, IUnitFactory bf)
{
var type = Assembly.GetExecutingAssembly().GetTypes()
.FirstOrDefault(t => t.Name.ToLowerInvariant() == buildingType);
if (type == null)
{
throw new ArgumentException("Unknown building type.");
}
var building = (IBuilding)Activator.CreateInstance(type, rf, bf);
return building;
}
public IBuilding CreateBuilding(string buildingType, IUnitFactory unitFactory, IResourceFactory resourceFacotory)
{
var type = Assembly.GetExecutingAssembly().GetTypes()
.FirstOrDefault(t => t.Name.ToLowerInvariant() == buildingType);
if (type == null)
{
throw new InvalidOperationException("Invalid building type.");
}
var building = Activator.CreateInstance(type, unitFactory, resourceFacotory) as IBuilding;
return building;
}
public Engine(
IBuildingFactory buildingFactory,
IResourceFactory resourceFactory,
IUnitFactory unitFactory,
IDatabase db,
IInputReader reader,
IOutputWriter writer)
{
this.buildingFactory = buildingFactory;
this.resourceFactory = resourceFactory;
this.unitFactory = unitFactory;
this.db = db;
this.reader = reader;
this.writer = writer;
}
protected Building(string unitType, int unitCycleLenght,
ResourseType resourseType,
int resoursesCycleLenght,
int resourceQuantity,
IUnitFactory unitFactory,
IResourseFactory resourseFactory)
{
this.unitType = unitType;
this.unitCycleLenght = unitCycleLenght;
this.resourseType = resourseType;
this.resourcseCycleLenght = resoursesCycleLenght;
this.resourceQuantity = resourceQuantity;
this.unitFactory = unitFactory;
this.resourseFactory = resourseFactory;
}
public UpgradedWarEngine(
IRenderer renderer,
IInputController inputController,
IUnitFactory unitFactory,
IArmyStructureFactory armyStructureFactory,
ICommandFactory commandFactory,
IContinent continent)
: base(renderer,
inputController,
unitFactory,
armyStructureFactory,
commandFactory,
continent)
{
}
internal UnitSystem(string name, IUnitFactory unitFactory, IUnitDialect dialect)
{
Check.Argument(name, nameof(name)).IsNotNull();
Check.Argument(unitFactory, nameof(unitFactory)).IsNotNull();
Check.Argument(dialect, nameof(dialect)).IsNotNull();
this.unitFactory = unitFactory;
this.dialect = dialect;
this.Name = name;
this.baseUnits = new Dictionary<Dimension, KnownUnit>();
this.coherentUnits = new Dictionary<Dimension, Unit>();
this.units = new Dictionary<Tuple<double, Dimension>, KnownUnit>();
this.unitsBySymbol = new Dictionary<string, KnownUnit>();
this.NoUnit = new DerivedUnit(this, 1, Dimension.DimensionLess);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitSystemDependencies"/> class.
/// </summary>
/// <param name="unitRegistry">The unit registry.</param>
/// <param name="lexicalAnalyzer">The lexical analyzer.</param>
/// <param name="expressionParser">The expression parser.</param>
/// <param name="quantityParser">The quantity parser.</param>
/// <param name="unitFactory">The unit factory.</param>
/// <param name="quantityOperations">The quantity operations.</param>
public UnitSystemDependencies(
UnitRegistry unitRegistry,
ILexicalAnalyzer lexicalAnalyzer,
IExpressionParser expressionParser,
IQuantityParser quantityParser,
IUnitFactory unitFactory,
IQuantityOperations quantityOperations)
{
this.UnitRegistry = unitRegistry;
this.LexicalAnalyzer = lexicalAnalyzer;
this.ExpressionParser = expressionParser;
this.QuantityParser = quantityParser;
this.UnitFactory = unitFactory;
this.QuantityOperations = quantityOperations;
}
public WarEngine(
IRenderer renderer,
IInputController inputController,
IUnitFactory unitFactory,
IArmyStructureFactory armyStructureFactory,
ICommandFactory commandFactory,
IContinent continent)
{
this.renderer = renderer;
this.inputController = inputController;
this.UnitFactory = unitFactory;
this.ArmyStructureFactory = armyStructureFactory;
this.CommandFactory = commandFactory;
this.Continent = continent;
}
protected Building(ResourceType resourceType,
int resourceProduceTime,
int resourceQuantity,
string unitType,
int unitProduceTime,
IUnitFactory unitFactory,
IResourceFactory resourceFactory)
{
this.resourceType = resourceType;
this.resourceProduceTime = resourceProduceTime;
this.Quantity = resourceQuantity;
this.unitType = unitType;
this.unitProduceTime = unitProduceTime;
this.unitFactory = unitFactory;
this.resourceFactory = resourceFactory;
}
public Building(
string unitType,
int unitCicleLength,
ResourceType resourceType,
int resourceCicleLength,
int quantity,
IUnitFactory unitFactory,
IResourceFactory resourceFactory)
{
this.unitType = unitType;
this.unitCicleLength = unitCicleLength;
this.resourceType = resourceType;
this.resourceCicleLength = resourceCicleLength;
this.quantity = quantity;
this.unitFactory = unitFactory;
this.resourceFactory = resourceFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="QuantityOperations"/> class.
/// </summary>
/// <param name="unitFactory">The unit factory.</param>
/// <param name="expressionReducer">The expression reducer.</param>
/// <param name="valueFromBaseVisitor">From base visitor.</param>
/// <param name="valueToBaseVisitor">To base visitor.</param>
public QuantityOperations(
IUnitFactory unitFactory,
IExpressionReducer expressionReducer,
ValueFromBaseVisitor valueFromBaseVisitor,
ValueToBaseVisitor valueToBaseVisitor)
{
this.Addition = new AdditionOperation(valueFromBaseVisitor, valueToBaseVisitor);
this.Subtraction = new SubtractionOperation(valueFromBaseVisitor, valueToBaseVisitor);
this.Multiplication = new ReducingOperation(
unitFactory,
new UnitMultiplicationOperation(expressionReducer),
new MultiplicationOperation());
this.Division = new ReducingOperation(
unitFactory,
new UnitDivisionOperation(expressionReducer),
new DivisionOperation());
this.Exponentiation = new ExponentiationOperation(unitFactory, expressionReducer);
this.NthRoot = new NthRootOperation(unitFactory, expressionReducer);
this.ConvertToUnit = new ConvertToUnitOperation();
}
/// <summary>
/// Constructor for the deserialization.
/// </summary>
/// <param name="info">Information for the serialization.</param>
/// <param name="context">The context for the serialization.</param>
public Player(SerializationInfo info, StreamingContext context)
{
this.name = (string)info.GetValue("Name", typeof(string));
this.points = (int)info.GetValue("Points", typeof(int));
IUnitFactory vikingFactory = new VikingFactory();
IUnitFactory gauloisFactory = new GauloisFactory();
IUnitFactory dwarfFactory = new DwarfFactory();
// Deserialises the factory by its unique number:
int factoryNumber = (int)info.GetValue("Factory", typeof(int));
if(factoryNumber == vikingFactory.Number) {
this.factory = vikingFactory;
} else if(factoryNumber == gauloisFactory.Number) {
this.factory = gauloisFactory;
} else if(factoryNumber == dwarfFactory.Number) {
this.factory = dwarfFactory;
} else {
throw new IncorrectFactoryNumberException(factoryNumber);
}
this.number = (int)info.GetValue("Number", typeof(int));
count++;
}
public Engine(IRepository repository, IUnitFactory unitFactory)
{
this.repository = repository;
this.unitFactory = unitFactory;
this.commandInterpreter = new CommandInterpreter(unitFactory, repository);
}
public Command(string[] data, IRepository repository, IUnitFactory unitFactory)
{
Data = data;
Repository = repository;
UnitFactory = unitFactory;
}
public Engine(IOutputWriter writer, IInputReader reader, IResourceFactory resourceFactory, IUnitFactory unitFactory, IBuildingFactory buildingFactory, IDatabase database)
{
}
public void SetFactory(IUnitFactory factory)
{
_unitFactory = factory;
}
public ReportCommand(string[] data, IRepository repository, IUnitFactory unitFactory) : base(data)
{
this.Repository = repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="ExponentiationOperation" /> class.
/// </summary>
/// <param name="unitFactory">The unit factory.</param>
/// <param name="expressionReducer">The expression reducer.</param>
public ExponentiationOperation(IUnitFactory unitFactory, IExpressionReducer expressionReducer)
{
this.unitFactory = unitFactory;
this.expressionReducer = expressionReducer;
}
protected Command(string[] data, IRepository repository, IUnitFactory unitFactory)
{
this.Data = data;
this.Repository = repository;
this.UnitFactory = unitFactory;
}
public RetireCommand(string[] data, IUnitFactory unitFactory, IRepository unitRepository)
: base(data, unitFactory, unitRepository)
{
}
public Engine(IBuildingFactory buildingFactory, IResourceFactory resourceFactory, IUnitFactory unitFactory, IEmpiresData data, IInputReader reader, IOutputWriter writer)
{
this.buildingFactory = buildingFactory;
this.resourceFactory = resourceFactory;
this.unitFactory = unitFactory;
this.data = data;
this.reader = reader;
this.writer = writer;
}
public Add(string[] data, IUnitFactory factory, IRepository repository)
: base(data)
{
this.UnitFactory = factory;
this.Repository = repository;
}
public AddCommand(string[] data, IRepository repo, IUnitFactory fatory) : base(data, repo, fatory)
{
}
public Retire(string[] data, IRepository repository, IUnitFactory unitFactory)
: base(data, repository, unitFactory)
{
}
public Building(string unitType, ResourceTypes resourceType, int unitCycle, int resourceCycle, int resourceQuantity, IResourceFactory resourceFactory, IUnitFactory unitFactory)
{
this.UnitType = unitType;
this.ResourceType = resourceType;
this.UnitCycle = unitCycle;
this.ResourceCycle = resourceCycle;
this.ResourceQuantity = resourceQuantity;
this.ResourceFactory = resourceFactory;
this.UnitFactory = unitFactory;
}
public LocalEnemyUnitCommander(IUnitFactory factory) : base(factory)
{
}
public Engine(IRepository repository, IUnitFactory unitFactory, ContainerBuilder container)
{
this.repository = repository;
this.unitFactory = unitFactory;
this.ioc = container;
}
public FightCommand(IRepository repository, IUnitFactory unitFactory, string[] data)
: base(repository, unitFactory, data)
{
}
/// <summary>
/// Creates the parser.
/// </summary>
/// <param name="expressionParser">The expression parser.</param>
/// <param name="unitFactory">The unit factory.</param>
/// <returns>
/// A <see cref="QuantityParser" />.
/// </returns>
public IQuantityParser CreateParser(IExpressionParser expressionParser, IUnitFactory unitFactory)
{
return(new QuantityParser(expressionParser, unitFactory));
}
public CommandInterpreter(IRepository repository, IUnitFactory unitFactory, string[] data)
: base(repository, unitFactory, data)
{
}
public CommandInterpreter(IRepository repository, IUnitFactory unitFactory)
{
this.repository = repository;
this.unitFactory = unitFactory;
}
public CommandInterpreter(IRepository repository, IUnitFactory unitFactory)
{
iocc = new DependencyContainer();
iocc.AddDependency <IRepository, UnitRepository>(repository as UnitRepository);
iocc.AddDependency <IUnitFactory, UnitFactory>(unitFactory as UnitFactory);
}
public Engine(IRepository repository, IUnitFactory unitFactory)
{
this.commandInterpreter = new CommandInterpreter(repository, unitFactory);
}
public Retire(string[] data, IRepository repository, IUnitFactory unitFactory)
: base(data)
{
this.Repository = repository;
this.UnitFactory = unitFactory;
}
/// <summary>
/// Initializes the unit system.
/// </summary>
/// <param name="unitSystemDependencyFactory">The unit system dependency factory.</param>
/// <param name="registerUnitAction">The register unit action.</param>
public UnitSystemDependencies InitializeUnitSystem(
IUnitSystemDependencyFactory unitSystemDependencyFactory,
Action<IUnitRegistrar> registerUnitAction)
{
this.LockedAction(
() =>
{
if (!this.isInitialized)
{
unitSystemDependencyFactory = unitSystemDependencyFactory
?? new UnitSystemDependencyFactory(
new ExpressionToFlatRepresentationConverter());
this.unitRegistry = unitSystemDependencyFactory.CreateUnitRegistry();
registerUnitAction?.Invoke(this.unitRegistry);
this.expressionParser = unitSystemDependencyFactory.CreateParser(this.unitRegistry);
this.lexicalAnalyzer =
unitSystemDependencyFactory.CreateLexicalAnalyzer(TokenMatching.CompositeUnit);
this.unitFactory = unitSystemDependencyFactory.CreateUnitFactory(this.unitRegistry);
this.quantityParser = unitSystemDependencyFactory.CreateParser(
this.expressionParser,
this.unitFactory);
this.quantityOperations =
unitSystemDependencyFactory.CreateQuantityOperations(this.unitFactory);
this.Dependencies = new UnitSystemDependencies(
this.unitRegistry,
this.lexicalAnalyzer,
this.expressionParser,
this.quantityParser,
this.unitFactory,
this.quantityOperations);
this.isInitialized = true;
}
});
return this.Dependencies;
}
public Report(string[] data, IRepository repository, IUnitFactory factory)
: base(data, repository, factory)
{
}
public Barracks(IUnitFactory unitFactory, IResourceFactory resourceFactory)
: base(ResourceType, ResourceProduceTime, resourceQuantity, UnitType, UnitProduceTime, unitFactory, resourceFactory)
{
}
public Fight(string[] data, IRepository repository, IUnitFactory unitFactory)
: base(data, repository, unitFactory)
{
}
public Engine(IRepository repository, IUnitFactory unitFactory, ICommandInterpreter commandInterpreter)
{
this.repository = repository;
this.unitFactory = unitFactory;
this.commandInterpreter = commandInterpreter;
}
public Barrack(IResourceFactory resourceFactory, IUnitFactory unitFactory)
: base(resourceFactory, unitFactory)
{
}
public Engine(IRepository repository, IUnitFactory unitFactory)
{
this.repository = repository;
this.unitFactory = unitFactory;
}
public ReportCommand(string[] data, IRepository repository, IUnitFactory unitFactory)
: base(data, repository, unitFactory)
{
}
public AddCommand(string[] data, IRepository repository, IUnitFactory unitFactory)
: base(data)
{
this.repository = repository;
this.unitFactory = unitFactory;
}
public IExecutable CreateCommand(string commandType, string[] data, IRepository repository, IUnitFactory unitFactory)
{
//var types = Assembly.GetExecutingAssembly().GetTypes();
var type = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(x => x.Name.ToLower() == commandType.ToLower());
if (type == null)
{
throw new NotSupportedException($"Not supported Command type: {commandType}");
}
var instance = Activator.CreateInstance(type, new object[] { data });
if (!(instance is IExecutable currentInstance))
{
throw new NotSupportedException($"Incorrect Command type: {commandType}");
}
var injectFields = instance
.GetType()
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
.Where(x => x.IsDefined(typeof(InjectAttribute), false))
.ToArray();
foreach (var field in injectFields)
{
var fieldType = field.FieldType;
if (fieldType == typeof(IRepository))
{
field.SetValue(instance, repository);
continue;
}
if (fieldType == typeof(IUnitFactory))
{
field.SetValue(instance, unitFactory);
continue;
}
}
return(currentInstance);
}
public FightCommand(string[] data, IRepository r, IUnitFactory uF) : base(data)
{
}
