public void CreateBigUFOShip()
{
UnitFactory unitFactory = new UnitFactory();
Unit unit = unitFactory.makeUnit("B", false);
Assert.IsInstanceOf<BigUFOShip>(unit);
}
public void CreateRocketShip()
{
UnitFactory unitFactory = new UnitFactory();
Unit unit = unitFactory.makeUnit("R", false);
Assert.IsInstanceOf<RocketShip>(unit);
}
void Awake()
{
if (instance == null)
{
_instance = this;
}
else
Destroy(gameObject);
}
static void Main()
{
var buildingFactory = new BuildingFactory();
var unitFactory = new UnitFactory();
var resourceFactory = new ResourceFactory();
var reader = new ConsoleReader();
var writer = new ConsoleWriter();
var data = new EmpiresData();
var engine = new Engine(buildingFactory,resourceFactory,unitFactory,data,reader,writer);
engine.Run();
}
public static void Main(string[] args)
{
IBuildingFactory buildingFactory = new BuildingFactory();
IUnitFactory unitFactory = new UnitFactory();
IResourceFactory resourceFactory = new ResourceFactory();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter();
IEmpiresData database = new Database();
IEngine engine = new Engine(unitFactory, resourceFactory, buildingFactory, reader, writer, database);
engine.Run();
}
public UnitFactory() {
instance = this;
creationTable = new Dictionary<string, System.Func<GameObject>>();
creationTable.Add("commander", createCircleUnit);
creationTable.Add("construction", createConstructionGuy);
creationTable.Add("normandy",createNormandy);
creationTable.Add("lambo",createLambo);
creationTable.Add("centurion",createCenturion);
creationTable.Add("predator",createPredator);
creationTable.Add("healer",createHealer);
creationTable.Add("archer", createArcher);
creationTable.Add("wizard", createWizard);
}
public override void Execute(params string[] commandParams)
{
int numberOfUnits = int.Parse(commandParams[0]);
if (numberOfUnits < 0)
{
throw new ArgumentOutOfRangeException("Number of units should be non-negative");
}
string cityName = commandParams[2];
var city = this.Engine.Continent.GetCityByName(cityName);
if (city == null)
{
throw new ArgumentNullException();
}
string unitType = commandParams[1];
var factory = new UnitFactory();
var units = factory.CreateUnits(unitType, numberOfUnits);
if (city.AvailableUnitCapacity(units.First().Type) <
units.Sum(u => u.HousingSpacesRequired))
{
throw new InvalidOperationException(string.Format(
"City {0} does not have enough housing spaces to accommodate {1}" +
" units of {2}",
cityName,
numberOfUnits,
unitType));
}
if (city.ControllingHouse.TreasuryAmount < units.Sum(u => u.TrainingCost))
{
throw new InvalidOperationException(string.Format(
"House {0} does not have enough funds to train {1} units of {2}",
city.ControllingHouse.Name,
numberOfUnits,
unitType));
}
city.AddUnits(units);
city.ControllingHouse.TreasuryAmount -= units.Sum(u => u.TrainingCost);
this.Engine.Render(
"Successfully added {0} units of {1} to city {2}",
numberOfUnits,
unitType,
cityName);
}
public StrongholdCombatUnit(uint id,
uint battleId,
ushort type,
byte lvl,
ushort count,
IStronghold stronghold,
decimal leftOverHp,
UnitFactory unitFactory,
IBattleFormulas battleFormulas,
Formula formula,
IDbManager dbManager)
: base(id, battleId, battleFormulas, dbManager)
{
Stronghold = stronghold;
this.type = type;
this.count = count;
this.unitFactory = unitFactory;
this.lvl = lvl;
LeftOverHp = leftOverHp;
this.formula = formula;
stats = new BattleStats(unitFactory.GetUnitStats(type, lvl).Battle);
}
public void Init(WeaponMesh mesh)
{
if (current != null)
{
Destroy(current.AttachmentLeft);
Destroy(current.AttachmentRight);
Destroy(current.gameObject);
}
/*
* if(m_Animator != null)
* {
* caster.OnAbilityTrigger -= m_Animator.AbilityCallback;
* caster.OnWeaponHide -= m_Animator.WeaponHide;
* caster.OnWeaponShow -= m_Animator.WeaponShow;
* }*/
AnimationCallbackCaster caster = TargetUnit.GetComponent <AnimationCallbackCaster>();
current = UnitFactory.SpawnWeaponMeshToUnit(TargetUnit, mesh);
// UnitAnimation_IdleController idle = mesh.GetComponent<UnitAnimation_IdleController>();
m_Animator = UnitFactory.MakeUnitAnimations(TargetUnit, current, current.WeaponIndex, caster, () => { return(IsRaged); });
}
void SpawnTestUnits()
{
string[] recipes = new string[]
{
"Alaois",
"Hania",
"Kamau",
"Enemy Rogue",
"Enemy Warrior",
"Enemy Wizard"
};
GameObject unitContainer = new GameObject("Units");
unitContainer.transform.SetParent(owner.transform);
List <Tile> locations = new List <Tile>(board.tiles.Values);
for (int i = 0; i < recipes.Length; ++i)
{
int level = UnityEngine.Random.Range(9, 12);
GameObject instance = UnitFactory.Create(recipes[i], level);
instance.transform.SetParent(unitContainer.transform);
int random = UnityEngine.Random.Range(0, locations.Count);
Tile randomTile = locations[random];
locations.RemoveAt(random);
Unit unit = instance.GetComponent <Unit>();
unit.Place(randomTile);
unit.dir = (Directions)UnityEngine.Random.Range(0, 4);
unit.Match();
units.Add(unit);
}
//SelectTile(units[0].tile.pos);
}
public CityPassiveAction(IObjectTypeFactory objectTypeFactory,
ILocker locker,
Formula formula,
IActionFactory actionFactory,
Procedure procedure,
IGameObjectLocator locator,
IBattleFormulas battleFormulas,
IStructureCsvFactory structureFactory,
TechnologyFactory technologyFactory,
UnitFactory unitFactory)
{
this.objectTypeFactory = objectTypeFactory;
this.locker = locker;
this.formula = formula;
this.actionFactory = actionFactory;
this.procedure = procedure;
this.locator = locator;
this.battleFormulas = battleFormulas;
this.structureFactory = structureFactory;
this.technologyFactory = technologyFactory;
this.unitFactory = unitFactory;
CreateSubscriptions();
}
private static List <Unit> GenerateAndAddCompanies(int numberOfCompanies, PersonalLegacyContext context)
{
var companies = UnitFactory.GetCompanyFactory(_regionIdHardcoded)
.Generate(numberOfCompanies);
context.Units.AddRange(companies);
context.SaveChanges();
var unitContentBooks = companies.SelectMany(c => new List <UnitContentBook>
{
new UnitContentBook {
UnitId = c.Id, ContentBookId = 1
},
new UnitContentBook {
UnitId = c.Id, ContentBookId = 2
},
new UnitContentBook {
UnitId = c.Id, ContentBookId = 8
},
});
context.UnitContentBooks.AddRange(unitContentBooks);
context.SaveChanges();
return(companies);
}
public void CreateFarmerTest()
{
Assert.Throws <Exception>(() => UnitFactory.CreateUnit(typeof(Farmer)));
FarmerUnitRegister visitor = new FarmerUnitRegister();
UnitFactory.AddFactory(visitor);
var unit = UnitFactory.CreateUnit(typeof(Farmer));
Assert.IsType <Farmer>(unit);
var farmer = unit as Farmer;
Assert.Equal(1, farmer.FoodNeeded);
Assert.Equal(Satisfaction.Ok, farmer.Satisfaction);
Assert.Equal(5, farmer.MaxInput);
Assert.Equal(3, farmer.InputOutputMapping.Count);
Assert.Equal(2, farmer.InputOutputMapping["cow"].Count);
Assert.Single(farmer.InputOutputMapping["cow"].Where(r => r.Type == "meat" && r.Amount == 2));
Assert.Single(farmer.InputOutputMapping["cow"].Where(r => r.Type == "milk" && r.Amount == 2));
Assert.Single(farmer.InputOutputMapping["pig"]);
Assert.Single(farmer.InputOutputMapping["pig"].Where(r => r.Type == "meat" && r.Amount == 4));
Assert.Equal(2, farmer.InputOutputMapping["chicken"].Count);
Assert.Single(farmer.InputOutputMapping["chicken"].Where(r => r.Type == "meat" && r.Amount == 2));
Assert.Single(farmer.InputOutputMapping["chicken"].Where(r => r.Type == "egg" && r.Amount == 2));
}
public PlayerCommandLineModule(IPlayersRemoverFactory playerRemoverFactory,
IPlayerSelectorFactory playerSelectorFactory,
ICityRemoverFactory cityRemoverFactory,
Chat chat,
IDbManager dbManager,
ITribeManager tribeManager,
IWorld world,
ILocker locker,
IStructureCsvFactory structureFactory,
UnitFactory unitFactory,
TechnologyFactory technologyFactory)
{
this.playerRemoverFactory = playerRemoverFactory;
this.playerSelectorFactory = playerSelectorFactory;
this.cityRemoverFactory = cityRemoverFactory;
this.chat = chat;
this.dbManager = dbManager;
this.tribeManager = tribeManager;
this.world = world;
this.locker = locker;
this.structureFactory = structureFactory;
this.unitFactory = unitFactory;
this.technologyFactory = technologyFactory;
}
public static void CreatePlayer(this UnitFactory factory, GameObject gameObject)
{
var moduleMgr = WorldManager.Instance.Module;
var requiredModuleGroup = moduleMgr.TagToModuleGroupType(Constant.OBJECT_MODULE_GROUP_NAME)
| moduleMgr.TagToModuleGroupType(Constant.CONTROL_MODULE_GROUP_NAME)
| moduleMgr.TagToModuleGroupType(Constant.STATE_MODULE_GROUP_NAME)
| moduleMgr.TagToModuleGroupType(Constant.SYNC_MODULE_GROUP_NAME);
var unit = factory.CreateAsset(requiredModuleGroup, gameObject);
unit.AddData <ObjectSyncData>();
factory.InitBuffModuleList();
AttachStateData(unit);
AttachAttributeData(unit);
AttachControlData(unit);
AttachKeyboardControlData(unit);
AttachBuffData(unit);
var unitData = unit.GetData <UnitData>();
unitData.stateTypeProperty.Value = UnitStateType.Init;
}
public SystemRepository()
{
_UnitFactory = new UnitFactory();
}
private void SpawnUnit()
{
UnitFactory.Create("mech");
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
GraphicsDevice t = GraphicsDevice;
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(GraphicsDevice);
// Load the camera class
_camera = new Camera(new Vector2(400, 300), 800, 600);
// Check required resources exist
var txPixel = new Texture2D(GraphicsDevice, 1, 1);
txPixel.SetData(new[] { Color.White });
//Content.RootDirectory = "Content";
// load the map, get the map elements and load them
Textures.Add(UnitsEnum.ADELAIDE, Content.Load <Texture2D>("Adelaide"));
Textures.Add(UnitsEnum.TURRET, Content.Load <Texture2D>("Turret"));
Textures.Add(UnitsEnum.RAPTOR, Content.Load <Texture2D>("Raptor"));
Textures.Add(UnitsEnum.MISSILE, Content.Load <Texture2D>("Missile"));
Textures.Add(UnitsEnum.CLOUD1, Content.Load <Texture2D>("Cloud11"));
Textures.Add(UnitsEnum.CLOUD2, Content.Load <Texture2D>("Cloud15"));
Textures.Add(UnitsEnum.CLOUD3, Content.Load <Texture2D>("Cloud3"));
Textures.Add(UnitsEnum.WATER1, Content.Load <Texture2D>("Water1"));
Textures.Add(UnitsEnum.WATERBUMP1, Content.Load <Texture2D>("WaterBump1"));
// Load the map class
_map = new Map(2, 2);
_map.Wind = new Vector2(0.3f, 0.2f);
_map.Tiles[0, 0] = new Tile(Textures[UnitsEnum.WATER1])
{
Bumpmap = Textures[UnitsEnum.WATERBUMP1]
};
_map.Tiles[1, 0] = new Tile(Textures[UnitsEnum.WATER1])
{
Bumpmap = Textures[UnitsEnum.WATERBUMP1]
};
_map.Tiles[0, 1] = new Tile(Textures[UnitsEnum.WATER1])
{
Bumpmap = Textures[UnitsEnum.WATERBUMP1]
};
_map.Tiles[1, 1] = new Tile(Textures[UnitsEnum.WATER1])
{
Bumpmap = Textures[UnitsEnum.WATERBUMP1]
};
_map.Tiles[0, 0].UpdateBumpmap();
//Load units data
var ud = new UnitData
{
Position = new Vector2(0, 0),
//Destination = new List<UnitData> {new Vector2(150, 200)};
Destination = new List <UnitData> {
new UnitData {
Position = new Vector2(10, 10)
}
}
};
var ud2 = new UnitData
{
Position = new Vector2(400, 250),
//Destination = new List<Vector2> {new Vector2(200, 550)}
//Destination = new List<UnitData> { new UnitData { Position = new Vector2(100, 55) } }
MovementMode = MovementMode.PATROL,
};
//var ud3 = new UnitData
//{
// Position = new Vector2(1000, 1000),
// MovementMode = MovementMode.INTERCEPT,
// Timeout = 2000,
// Timer = new System.Diagnostics.Stopwatch(),
//};
//ud3.Timer.Start();
//Load each unit into memory
//_units.Add(UnitFactory.New(UnitsEnum.ADELAIDE, ud));
_units.Add(UnitFactory.New(UnitsEnum.RAPTOR, ud));
_units.Add(UnitFactory.New(UnitsEnum.ADELAIDE, ud2));
//_units.Add(UnitFactory.New(UnitsEnum.MISSILE, ud3));
}
public void SetTestingFactory(UnitFactory factory)
{
//_dataContext = new FactoryDataContext();
_dataContext.Builder = factory;
_dataContext.Builder.FactoryStatus += Builder_FactoryProgress;
}
public void FixedUpdate()
{
if (factory == null)
factory = GameObject.Find("GameManager").GetComponent<UnitFactory>();
if (!isLocalPlayer)
return;
if (!gameOver) {
string endText = "";
if (health <= 0) { health = 0;
endText = "Game Over! \n You Lose.";
} else if (opponent != null && opponent.GetComponent<Player>().health <= 0) {
opponent.GetComponent<Player>().health = 0;
endText = "Game Over! \n You Win.";
}
if (endText.Length > 0) {
GameObject.Find("WaitingPanel").transform.position = new Vector3();
GameObject.Find("WaitingPanel").transform.FindChild("Text").GetComponent<Text>().text = endText;
gameOver = true;
foreach (GameObject go in GameObject.FindGameObjectsWithTag("Tile")) {
Destroy(go);
}
}
updateUI();
}
}
public void FarmTest()
{
Farm farm = new Farm(1, 2);
Builder builder = (Builder)UnitFactory.CreateUnit(typeof(Builder));
Farmer farmer = (Farmer)UnitFactory.CreateUnit(typeof(Farmer));
Assert.False(farm.AbleToFunction);
Assert.Equal(2, farm.BuildingTime);
Assert.Equal(0, farm.BuildProgress);
Assert.Equal(0, farm.CurrentCapacity);
Assert.Equal(1, farm.MaxCapacity);
Assert.Equal(0, farm.CurrentConstructionUnitCount);
Assert.Single(farm.UnitTypes);
Assert.Single(farm.UnitTypes.Where(u => u == typeof(Farmer)));
farm.DoBuildProcess();
Assert.Equal(0, farm.BuildProgress);
farm.AddConstructionUnit(builder);
Assert.Equal(1, farm.CurrentConstructionUnitCount);
farm.DoBuildProcess();
Assert.Equal(1, farm.BuildProgress);
Assert.False(farm.AbleToFunction);
farm.DoBuildProcess();
Assert.Equal(2, farm.BuildProgress);
Assert.True(farm.AbleToFunction);
farm.AssignUnit(farmer);
Assert.Equal(1, farm.CurrentCapacity);
var resources = farm.DoWork();
Assert.NotNull(resources);
Assert.Empty(resources);
farm.AddInput(new ResourceAmount("cow", 3));
resources = farm.DoWork();
Assert.Equal(2, resources.Count);
Assert.Single(resources.Where(r => r.Type == "meat"));
Assert.Single(resources.Where(r => r.Type == "meat" && r.Amount == 6)); //3 cow -> 2*3
Assert.Single(resources.Where(r => r.Type == "milk"));
Assert.Single(resources.Where(r => r.Type == "milk" && r.Amount == 6));
resources = farm.DoWork();
Assert.NotNull(resources);
Assert.Empty(resources);
farm.AddInput(new ResourceAmount("cow", 2));
farm.RemoveInput(new ResourceAmount("cow", 2));
Assert.NotNull(resources);
Assert.Empty(resources);
farm.AddInput(new ResourceAmount("cow", 2));
farm.RemoveInput(new ResourceAmount("cow", 1));
resources = farm.DoWork();
Assert.Equal(2, resources.Count);
Assert.Single(resources.Where(r => r.Type == "meat"));
Assert.Single(resources.Where(r => r.Type == "meat" && r.Amount == 2));
Assert.Single(resources.Where(r => r.Type == "milk"));
Assert.Single(resources.Where(r => r.Type == "milk" && r.Amount == 2));
}
public void SetTestingFactory(UnitFactory factory)
{
_dataContext.Builder = factory; /***** casting *****/
//_dataContext.Builder.FactoryProgress += Builder_FactoryProgress;
_dataContext.Builder.FactoryProgress += Builder_FactoryProgress;
}
void Awake()
{
unitFactory = new UnitFactory();
}
public void LoadContent(int levelValue)
{
_levelValue = levelValue;
_currentWave = -1;
_waveTimer = 5000;
// Load the enemies into the unit list
List <Tuple <string, int> > list = LoadFromFile();
foreach (Tuple <string, int> val in list)
{
string type = val.Item1;
int num = val.Item2;
switch (type)
{
case "---":
_waves.Add(new Wave(++_currentWave, _numLanes, FIELD_SIZE, FIELD_ORIGIN));
break;
case "WeakMelee":
for (int i = 0; i < num; i++)
{
_waves[_currentWave].AddUnit(UnitFactory.CreateWeakMelee());
}
break;
case "MediumMelee":
for (int i = 0; i < num; i++)
{
_waves[_currentWave].AddUnit(UnitFactory.CreateMediumMelee());
}
break;
case "StrongMelee":
for (int i = 0; i < num; i++)
{
_waves[_currentWave].AddUnit(UnitFactory.CreateStrongMelee());
}
break;
case "WeakRanged":
for (int i = 0; i < num; i++)
{
_waves[_currentWave].AddUnit(UnitFactory.CreateWeakRanged());
}
break;
case "MediumRanged":
for (int i = 0; i < num; i++)
{
_waves[_currentWave].AddUnit(UnitFactory.CreateMediumRanged());
}
break;
case "StrongRanged":
for (int i = 0; i < num; i++)
{
_waves[_currentWave].AddUnit(UnitFactory.CreateStrongRanged());
}
break;
default:
throw new ArgumentException("you cant spell for shit");
}
}
_currentWave = -1;
foreach (Wave w in _waves)
{
w.LoadContent();
}
}
IEnumerator Start()
{
#region Config
log.Info("\n\nStart");
var units = new UnitInfoLoader().Load();
var saveDataLoader = new SaveInfoLoader();
var saves = saveDataLoader.Load();
var decisionTreeLoader = new DecisionTreeLoader();
var decisionTreeComponent = decisionTreeLoader.Load();
#endregion
#region Infrastructure
var tickController = new TickController();
var inputController = new InputController(tickController);
//TODO: implement event bus that won't allocate(no delegates)
var eventBus = new EventBus(); //TODO: stop using eventbus Ievent interface to remove reference on that library from model
EventBus.Log = m => log.Info($"{m}"); //TODO: remove that lmao
EventBus.IsLogOn = () => DebugController.Info.IsDebugOn;
#endregion
#region View
var mainCamera = Camera.main;
var tileSpawner = new TilePresenter(TileStartPoints, new TileViewFactory(TileViewPrefab));
var coordFinder = new CoordFinder(TileStartPoints);
var unitViewFactory = new UnitViewFactory(units, UnitViewPrefab, coordFinder, mainCamera);
var unitViewCoordChangedHandler = new UnitViewCoordChangedHandler(coordFinder);
var boardPresenter = new BoardPresenter(unitViewCoordChangedHandler);
var playerPresenterContext = new PlayerPresenterContext(
new PlayerPresenter(unitViewFactory, unitViewCoordChangedHandler),
new PlayerPresenter(unitViewFactory, unitViewCoordChangedHandler));
#endregion
#region Model
var decisionTreeLookup = new DecisionTreeLookup();
var decisionTreeCreatorVisitor = new DecisionTreeCreatorVisitor(eventBus,
d => new LoggingDecorator(d, DebugController.Info), decisionTreeLookup);
var unitFactory = new UnitFactory(units, new DecisionFactory(
decisionTreeCreatorVisitor, decisionTreeComponent));
//TODO: replace board/bench dictionaries with array?
var playerContext = new PlayerContext(new Player(unitFactory), new Player(unitFactory));
var board = new Board();
var aiHeap = new AiHeap();
var aiContext = new AiContext(board, aiHeap);
#endregion
#region Shared
var worldContext = new PlayerSharedContext(playerContext, playerPresenterContext, BattleSetupUI);
#endregion
#region Controller
var raycastController = new RaycastController(mainCamera,
LayerMask.GetMask("Terrain", "GlobalCollider"), LayerMask.GetMask("Unit"));
var unitSelectionController = new UnitSelectionController(inputController,
raycastController, coordFinder);
var unitTooltipController = new UnitTooltipController(UnitTooltipUI,
unitSelectionController);
#endregion
#region Unit drag
var battleStateController = new BattleStateController(BattleSimulationUI);
var unitDragController = new UnitDragController(raycastController,
new CoordFinderBySelectedPlayer(coordFinder, BattleSetupUI),
inputController, unitSelectionController,
new CanStartDrag(battleStateController, BattleSetupUI));
var tileHighlightController = new TileHighlighterController(tileSpawner,
unitDragController);
var unitMoveController = new UnitMoveController(worldContext, unitDragController);
#endregion
#region Battle simulation
var movementController = new MovementController(boardPresenter, coordFinder);
var attackController = new AttackController(boardPresenter, unitTooltipController);
var animationController = new AnimationController(boardPresenter);
eventBus.Register <StartMoveEvent>(movementController, animationController); //TODO: register implicitly?
eventBus.Register <FinishMoveEvent>(movementController);
eventBus.Register <RotateEvent>(movementController);
eventBus.Register <UpdateHealthEvent>(attackController);
eventBus.Register <DeathEvent>(attackController);
eventBus.Register <IdleEvent>(animationController);
eventBus.Register <StartAttackEvent>(animationController);
var battleSimulationPresenter = new BattleSimulationPresenter(coordFinder,
boardPresenter, movementController, movementController);
var battleSimulation = new BattleSimulation(aiContext, board, aiHeap);
var realtimeBattleSimulationController = new RealtimeBattleSimulationController(
movementController, battleSimulation);
#endregion
#region Debug
var battleSimulationDebugController = new BattleSimulationDebugController(
battleSimulation, BattleSimulationUI,
aiContext, playerContext, playerPresenterContext, realtimeBattleSimulationController,
battleSimulationPresenter);
var battleSaveController = new BattleSaveController(playerContext,
playerPresenterContext, BattleSaveUI, saveDataLoader, saves,
battleSimulationDebugController);
var battleSetupController = new BattleSetupController(playerContext,
playerPresenterContext, BattleSetupUI);
var unitModelDebugController = new UnitModelDebugController(playerContext, board, ModelUI,
DebugController.Info, unitSelectionController);
var takenCoordDebugController = new TakenCoordDebugController(board, DebugController,
tileSpawner);
var targetDebugController = new TargetDebugController(
board, coordFinder, DebugController.Info);
var uiDebugController = new UIDebugController(
BattleSetupUI, BattleSaveUI, BattleSimulationUI,
unitModelDebugController);
#endregion
yield return(null);
#region Infrastructure
tickController.InitObservable(takenCoordDebugController, targetDebugController,
uiDebugController, unitModelDebugController, realtimeBattleSimulationController,
DebugController); //TODO: register implicitly?
inputController.InitObservables();
#endregion
#region View
BattleSetupUI.SetDropdownOptions(units.Keys.ToList());
BattleSaveUI.SubToUI(saves.Keys.ToList());
tileSpawner.SpawnTiles();
#endregion
decisionTreeCreatorVisitor.Init();
#region Controller
unitSelectionController.SubToInput(disposable);
battleStateController.SubToUI();
unitDragController.SubToUnitSelection(disposable);
tileHighlightController.SubToDrag(disposable);
unitMoveController.SubToDrag(disposable);
unitTooltipController.SubToUnitSelection(disposable);
#endregion
#region Debug
battleSaveController.SubToUI();
battleSetupController.SubToUI();
unitModelDebugController.SubToUnitSelection(disposable);
battleSimulationDebugController.SubToUI();
DebugController.Init(UnitTooltipUI);
#endregion
MonoBehaviourCallBackController.StartUpdating(tickController);
}
void Start()
{
if (isServer) {
unitFactory = gameObject.GetComponent<UnitFactory>();
gruntPoolInitialised = false;
numberOfHeros = 0;
}
}
public override void Given()
{
subject = new UnitFactory();
}
protected Command(string[] data, UnitFactory unitFactory, IRepository unitRepository)
{
this.data = data;
this.unitFactory = unitFactory;
this.unitRepository = unitRepository;
}
public LogRepository()
{
_UnitFactory = new UnitFactory();
}
public void UpdateUnits()
{
Dictionary <double, double> clickedLocations = MouseCapture.getClicks();
foreach (MovingUnit unit in _movingUnits)
{
foreach (KeyValuePair <double, double> coords in clickedLocations)
{
unit.SetIsShot(coords);
}
unit.IsOutOfBounds(_yMaxBounds, _xMaxBounds);
bool wasCollide = false;
unit.MoveX();
foreach (Unit nonMovingUnit in _nonMovingUnits)
{
wasCollide = unit.CheckCollisionX(nonMovingUnit);
}
unit.MoveY();
if (!wasCollide)
{
foreach (Unit nonMovingUnit in _nonMovingUnits)
{
unit.CheckCollisionY(nonMovingUnit);
}
}
}
MovingUnit newMovingUnit = null;
// Add MovingUnit
int randomNum = _random.Next(35);
if (randomNum % 2 == 0 && _movingUnits.Count < this.MovingUnitAmount)
{
bool collides = true;
while (collides)
{
// set location
var xPos = _random.Next(_xMinBounds, _xMaxBounds);
var yPos = _random.Next(_yMinBounds, _yMaxBounds);
var unitType = (UnitEnum)_random.Next(2, 4);
newMovingUnit = (MovingUnit)UnitFactory.CreateUnit(unitType, xPos, yPos);
if (
!_nonMovingUnits.Any(
unit1 =>
xPos >= unit1.LeftPosition && xPos <= (unit1.LeftPosition + 50) &&
yPos >= unit1.TopPosition &&
yPos <= (unit1.TopPosition + 50)))
{
collides = false;
}
}
newMovingUnit.SetSteps(this.MinSpeed, this.MaxSpeed);
_movingUnits.Add(newMovingUnit);
}
}
public void ForestCampTest2()
{
ForestCamp forestCamp = new ForestCamp(5, 1);
Builder builder = (Builder)UnitFactory.CreateUnit(typeof(Builder));
Gatherer gatherer = (Gatherer)UnitFactory.CreateUnit(typeof(Gatherer));
Gatherer gatherer2 = (Gatherer)UnitFactory.CreateUnit(typeof(Gatherer));
Gatherer gatherer3 = (Gatherer)UnitFactory.CreateUnit(typeof(Gatherer));
Assert.False(forestCamp.AbleToFunction);
Assert.Equal(1, forestCamp.BuildingTime);
Assert.Equal(0, forestCamp.BuildProgress);
Assert.Equal(0, forestCamp.CurrentCapacity);
Assert.Equal(5, forestCamp.MaxCapacity);
Assert.Equal(0, forestCamp.CurrentConstructionUnitCount);
Assert.Single(forestCamp.UnitTypes);
Assert.Single(forestCamp.UnitTypes.Where(u => u == typeof(Gatherer)));
forestCamp.AddConstructionUnit(builder);
Assert.Equal(1, forestCamp.CurrentConstructionUnitCount);
var removed = forestCamp.RemoveLastConstructionUnit();
Assert.Equal(builder, removed);
Assert.Equal(0, forestCamp.CurrentConstructionUnitCount);
forestCamp.AddConstructionUnit(builder);
Assert.Equal(1, forestCamp.CurrentConstructionUnitCount);
forestCamp.DoBuildProcess();
Assert.Equal(1, forestCamp.BuildProgress);
Assert.True(forestCamp.AbleToFunction);
forestCamp.AssignUnit(gatherer);
Assert.Equal(1, forestCamp.CurrentCapacity);
var resources = forestCamp.DoWork();
Assert.NotNull(resources);
Assert.NotEmpty(resources);
Assert.Single(resources);
Assert.Single(resources.Where(r => r.Type == "wood"));
Assert.Single(resources.Where(r => r.Type == "wood" && r.Amount == 1));
forestCamp.AssignUnit(gatherer2);
Assert.Equal(2, forestCamp.CurrentCapacity);
resources = forestCamp.DoWork();
Assert.NotNull(resources);
Assert.NotEmpty(resources);
Assert.Single(resources);
Assert.Single(resources.Where(r => r.Type == "wood"));
Assert.Single(resources.Where(r => r.Type == "wood" && r.Amount == 2));
forestCamp.AssignUnit(gatherer3);
Assert.Equal(3, forestCamp.CurrentCapacity);
resources = forestCamp.DoWork();
Assert.NotNull(resources);
Assert.NotEmpty(resources);
Assert.Single(resources);
Assert.Single(resources.Where(r => r.Type == "wood"));
Assert.Single(resources.Where(r => r.Type == "wood" && r.Amount == 3));
var unit = forestCamp.RemoveLastUnit();
Assert.Equal(gatherer3, unit);
Assert.Equal(2, forestCamp.CurrentCapacity);
resources = forestCamp.DoWork();
Assert.NotNull(resources);
Assert.NotEmpty(resources);
Assert.Single(resources);
Assert.Single(resources.Where(r => r.Type == "wood"));
Assert.Single(resources.Where(r => r.Type == "wood" && r.Amount == 2));
}
public override void InitLevel()
{
_mouseCapture = new MouseCapture(_playGrid);
_xMaxBounds = (int)_playGrid.ActualWidth - 60;
_xMinBounds = 10;
_yMaxBounds = (int)_playGrid.ActualHeight - 60;
_yMinBounds = 10;
_unitsHit = 0;
_nonMovingUnits = new List <Unit>();
_movingUnits = new List <MovingUnit>();
// set trees
for (int t = 0; t < this.NonMovingUnitAmount; t++)
{
Application.Current.Dispatcher.Invoke(() =>
{
// set location
// random based on x and y bounds
var xPos = (double)_random.Next(_xMinBounds, _xMaxBounds);
var yPos = (double)_random.Next(_yMinBounds, _yMaxBounds);
// Set tree on screen
Unit unit = UnitFactory.CreateUnit(UnitEnum.Tree, xPos, yPos);
_nonMovingUnits.Add(unit);
});
}
// random amount MovingUnits
int startAmountUnits = _random.Next(5);
for (int x = 0; x < startAmountUnits; x++)
{
Application.Current.Dispatcher.Invoke(() =>
{
MovingUnit unit = null;
bool collides = true;
while (collides)
{
// set location
var xPos = _random.Next(_xMinBounds, _xMaxBounds);
var yPos = _random.Next(_yMinBounds, _yMaxBounds);
var unitType = (UnitEnum)_random.Next(2, 4);
unit = (MovingUnit)UnitFactory.CreateUnit(unitType, xPos, yPos);
if (
!_nonMovingUnits.Any(
unit1 =>
xPos >= unit1.LeftPosition && xPos <= (unit1.LeftPosition + 50) &&
yPos >= unit1.TopPosition &&
yPos <= (unit1.TopPosition + 50)))
{
collides = false;
}
}
unit.SetSteps(this.MinSpeed, this.MaxSpeed);
_movingUnits.Add(unit);
});
}
}
public void LabTest()
{
Lab lab = new Lab(5, 2);
Builder builder = (Builder)UnitFactory.CreateUnit(typeof(Builder));
Researcher researcher = (Researcher)UnitFactory.CreateUnit(typeof(Researcher));
Assert.False(lab.AbleToFunction);
Assert.Equal(2, lab.BuildingTime);
Assert.Equal(0, lab.BuildProgress);
Assert.Equal(0, lab.CurrentCapacity);
Assert.Equal(5, lab.MaxCapacity);
Assert.Equal(0, lab.CurrentConstructionUnitCount);
Assert.Single(lab.UnitTypes);
Assert.Single(lab.UnitTypes.Where(u => u == typeof(Researcher)));
lab.DoBuildProcess();
Assert.Equal(0, lab.BuildProgress);
lab.AddConstructionUnit(builder);
Assert.Equal(1, lab.CurrentConstructionUnitCount);
lab.DoBuildProcess();
Assert.Equal(1, lab.BuildProgress);
Assert.False(lab.AbleToFunction);
lab.DoBuildProcess();
Assert.Equal(2, lab.BuildProgress);
Assert.True(lab.AbleToFunction);
var resources = lab.DoWork();
Assert.NotNull(resources);
Assert.Empty(resources);
lab.AssignUnit(researcher);
Assert.Equal(1, lab.CurrentCapacity);
resources = lab.DoWork();
Assert.NotNull(resources);
Assert.Single(resources);
Assert.Single(resources.Where(r => r.Type == "researchpoint"));
Assert.Single(resources.Where(r => r.Type == "researchpoint" && r.Amount == 1));
//unlock
researcher.UpgradeConverterOutputResource("ore");
researcher.UpgradeConverterInputMapping("ore", new List <ResourceAmount>()
{
new ResourceAmount("ironore", 1)
});
resources = lab.DoWork();
Assert.NotNull(resources);
Assert.Single(resources);
Assert.Single(resources.Where(r => r.Type == "researchpoint"));
Assert.Single(resources.Where(r => r.Type == "researchpoint" && r.Amount == 1));
//add input
lab.AddInput(new ResourceAmount("ore", 2));
resources = lab.DoWork();
Assert.NotNull(resources);
Assert.Equal(2, resources.Count);
Assert.Single(resources.Where(r => r.Type == "researchpoint"));
Assert.Single(resources.Where(r => r.Type == "researchpoint" && r.Amount == 1));
Assert.Single(resources.Where(r => r.Type == "ironore"));
Assert.Single(resources.Where(r => r.Type == "ironore" && r.Amount == 2));
//unlock x2
researcher.UpgradeConverterInputMapping("ore", new List <ResourceAmount>()
{
new ResourceAmount("goldore", 1)
});
lab.AddInput(new ResourceAmount("ore", 1));
resources = lab.DoWork();
Assert.NotNull(resources);
Assert.Equal(3, resources.Count);
Assert.Single(resources.Where(r => r.Type == "researchpoint"));
Assert.Single(resources.Where(r => r.Type == "researchpoint" && r.Amount == 1));
Assert.Single(resources.Where(r => r.Type == "ironore"));
Assert.Single(resources.Where(r => r.Type == "ironore" && r.Amount == 1));
Assert.Single(resources.Where(r => r.Type == "goldore"));
Assert.Single(resources.Where(r => r.Type == "goldore" && r.Amount == 1));
lab.AddInput(new ResourceAmount("ore", 3));
lab.RemoveInput(new ResourceAmount("ore", 2));
resources = lab.DoWork();
Assert.NotNull(resources);
Assert.Equal(3, resources.Count);
Assert.Single(resources.Where(r => r.Type == "researchpoint"));
Assert.Single(resources.Where(r => r.Type == "researchpoint" && r.Amount == 1));
Assert.Single(resources.Where(r => r.Type == "ironore"));
Assert.Single(resources.Where(r => r.Type == "ironore" && r.Amount == 1));
Assert.Single(resources.Where(r => r.Type == "goldore"));
Assert.Single(resources.Where(r => r.Type == "goldore" && r.Amount == 1));
}
private void InitializeValuesAndReferences() {
_gameMgr = GameManager.Instance;
_factory = UnitFactory.Instance;
}
public AddCommand(string[] data, UnitFactory unitFactory, IRepository unitRepository)
: base(data, unitFactory, unitRepository)
{
}
public UnitTemplate(UnitFactory unitFactory, uint cityId)
{
this.unitFactory = unitFactory;
this.cityId = cityId;
}
public EntityCreator(UnitFactory uFact, BuildingFactory bFact)
{
this.uFact = uFact;
this.bFact = bFact;
}
public Dependencies(UnitRepository repository, UnitFactory unitFactory)
{
this.repository = repository;
this.unitFactory = unitFactory;
}
public SimpleStubGenerator(double[][] ratio, ushort[] type, UnitFactory unitFactory)
{
this.unitFactory = unitFactory;
this.ratio = ratio;
this.type = type;
}
public void ExitSpawnMode()
{
factory = null;
isBuilding = false;
}
public BattleFormulas(UnitModFactory unitModFactory, UnitFactory unitFactory, IObjectTypeFactory objectTypeFactory)
{
this.unitModFactory = unitModFactory;
this.unitFactory = unitFactory;
this.objectTypeFactory = objectTypeFactory;
}
public void EnterSpawnMode(UnitFactory factory)
{
this.factory = factory;
isBuilding = true;
}
