public UnitModel RetriveTarget(BattlefieldVision vision, MyHexPosition activatingPosition)
{
var grabbedUnit = ShootingTarget(vision);
Assert.IsNotNull(grabbedUnit, "There is no target");
return(grabbedUnit);
}
public BattleResults PerformProjectileHitAtPlace(MyHexPosition projectileHitPosition)
{
Assert.IsTrue(_units.IsPawnAt(projectileHitPosition), "There is no unit at " + projectileHitPosition);
Assert.IsTrue(_projectiles.IsPawnAt(projectileHitPosition), "There is no projectile at " + projectileHitPosition);
var unit = _units.GetPawnAt(projectileHitPosition);
var projectile = _projectiles.GetPawnAt(projectileHitPosition);
var projectileOrientation = projectile.Orientation;
var projectileEffect = projectile.HitEffect;
BattleEngagementResult engagementResult = new BattleEngagementResult();
var engagement = new BattleEngagement(engagementResult);
AddEngagementElement(projectile, unit, engagement, projectileEffect);
projectileEffect.Execute(new BattlefieldVision(projectile, projectileOrientation, _units, _mapModel, BattleCircumstances.ProjectileHit), projectileHitPosition, engagementResult);
var defenderSymbolOrientation = unit.Orientation.CalculateLocalDirection(projectileOrientation.Opposite());
if (unit.Symbols.ContainsKey(defenderSymbolOrientation))
{
var reactEffect = unit.Symbols[defenderSymbolOrientation].ReactEffect;
AddEngagementElement(unit, projectile, engagement, reactEffect);
BattlefieldVision vision = new BattlefieldVision(unit, projectileOrientation, _units, _mapModel, BattleCircumstances.ProjectileHit);
reactEffect.Execute(vision, projectileHitPosition, engagementResult);
}
var results = new BattleResults();
results.Add(engagement);
return(results);
}
public void Execute(BattlefieldVision vision, MyHexPosition activatingPosition, BattleEngagementResult reciever)
{
var unitInFront = vision.GetUnitAt(new MyHexPosition(1, 0));
Assert.IsTrue(unitInFront != null && unitInFront.Owner != vision.PossesedPawn.Owner, "There is no enemy unit in front of me");
reciever.AddStruckUnit(unitInFront);
}
public void Execute(BattlefieldVision vision, MyHexPosition activatingPosition, BattleEngagementResult reciever)
{
var targetUnit = ShootingTarget(vision);
Assert.IsNotNull(targetUnit, "There is no target");
reciever.AddProjectile(vision.PossesedPawn.Position, vision.PossesedPawn.Orientation, targetUnit.Position, _projectileType);
}
public UnitModel RetriveTarget(BattlefieldVision vision, MyHexPosition activatingPosition)
{
var target = vision.GetUnitAt(new MyHexPosition(1, 0));
Assert.IsNotNull(target, "There is no target");
return(target);
}
public void OrientPawn(MyHexPosition unitPosition, Orientation orientation)
{
Assert.IsTrue(IsPawnAt(unitPosition));
var unit = _pawns[unitPosition];
unit.Orientation = orientation;
}
public void Execute(BattlefieldVision vision, MyHexPosition activatingPosition, BattleEngagementResult reciever)
{
var grabbedUnit = RetriveGrabbedUnit(vision);
Assert.IsNotNull(grabbedUnit, "There is no target");
reciever.DisplaceUnit(grabbedUnit, vision.ToGlobalPosition(new MyHexPosition(DistanceAfterGrab, 0)));
}
public void Execute(BattlefieldVision vision, MyHexPosition activatingPosition, BattleEngagementResult reciever)
{
Assert.IsTrue(vision.PossesedPawn is UnitModel); // TODO !!! UGLY !!
if (reciever.UnitWasStruck((UnitModel)vision.PossesedPawn))
{
reciever.UnStrike((UnitModel)vision.PossesedPawn);
}
}
public UnitModel GetUnitAt(MyHexPosition localPosition)
{
if (!_units.IsPawnAt(ToGlobalPosition(localPosition)))
{
return(null);
}
return(_units.GetPawnAt(ToGlobalPosition(localPosition)));
}
public void AddResidentMagic(MyHexPosition position, MagicType magic)
{
Assert.IsFalse(_residentMagicMap.ContainsKey(position), $"There is arleady magic at ${position}");
Assert.IsTrue(HasTileAt(position));
_residentMagicMap[position] = magic;
GetTileAt(position).ApplyWindMagic(); //todo TL1
}
public void GenerateMap()
{
foreach (Transform child in MapParentGameObject.transform.GetEnumerator().ToEnumerable().ToList()) // kill all children
{
if (Application.isEditor)
{
DestroyImmediate(child.gameObject);
}
else
{
GameObject.Destroy(child.gameObject);
}
}
var positionToTiles = new List <TileModel>();
for (int y = 0; y < Height; y++)
{
for (int x = y % 2; x < Width; x++)
{
var tile = Instantiate(TilePrefab);
var hexPosition = new MyHexPosition(x + y / 2, y);
tile.GetComponent <TileModel>().Position = hexPosition;
if (x == y % 2)
{
tile.GetComponent <TileModel>().Role = TileRole.StartTeam1;
}
else if (x == Width - 1)
{
tile.GetComponent <TileModel>().Role = TileRole.StartTeam2;
}
else
{
tile.GetComponent <TileModel>().Role = TileRole.Normal;
}
positionToTiles.Add(tile.GetComponent <TileModel>());
tile.transform.SetParent(MapParentGameObject.transform);
if (Application.isEditor)
{
tile.GetComponent <TileView>().MyStart();
}
}
}
MapParentGameObject.GetComponent <MapModel>().Tiles = positionToTiles;
var mouseColliderObject = new GameObject("MapMouseCollider");
var newCollider = mouseColliderObject.AddComponent <BoxCollider>();
mouseColliderObject.transform.SetParent(MapParentGameObject.transform);
mouseColliderObject.transform.localPosition = Vector3.zero;
newCollider.center = new Vector3(Width * 1.5f / 2 - 1, -0.5f, Height * 1.5f / 2); // todo, calculate it using mathematics, this is approximation
newCollider.size = new Vector3(Width * 1.5f + 2, 1, Height * 1.5f + 4);
mouseColliderObject.layer = UserLayer.TileCollisionLayer.LayerIndex;
}
public void MovePawn(MyHexPosition oldPosition, MyHexPosition newPosition)
{
Assert.IsTrue(IsPawnAt(oldPosition), "Pawn is not at old position");
var unit = _pawns[oldPosition];
_pawns.Remove(oldPosition);
_pawns[newPosition] = unit;
unit.Position = newPosition;
}
public void DisplaceUnit(UnitModel unit, MyHexPosition newPosition)
{
_displacements.Add(new UnitDisplacements()
{
Unit = unit,
DisplacementStart = unit.Position,
DisplacementEnd = newPosition
});
}
public MyHexPosition ToGlobalPosition(MyHexPosition position)
{
var localPositionCube = PositionUtils.AxialToCube(position);
for (int i = 0; i < _globalCenterOrientation.ClockwiseIndex(); i++)
{
localPositionCube = RotateRightByOneStep(localPositionCube);
}
return(PositionUtils.CubeToAxial(localPositionCube) + _globalCenterPosition);
}
public void Move(UnitModel unit, MyHexPosition targetPosition)
{
var possibleTargets = GameCourseController.GetPossibleMoveTargets(unit, null);
if (!possibleTargets.Contains(targetPosition))
{
throw new ImpossibleMovePredictionException(unit, targetPosition, possibleTargets);
}
GameCourseController.MoveTo(targetPosition, unit, null);
}
public bool IsActivated(BattlefieldVision vision, MyHexPosition activatingPosition)
{
if (!_activationCircumstances.IsActivated(vision.BattleCircumstances))
{
return(false);
}
var toReturn = ShootingTarget(vision) != null;
return(toReturn);
}
public void AddProjectile(MyHexPosition startPosition, Orientation orientation, MyHexPosition endPosition, ProjectileType type)
{
_projectiles.Add(new ProjectileCreations()
{
StartPosition = startPosition,
EndPosition = endPosition,
Orientation = orientation,
Type = type
});
}
public MyHexPosition ToLocalPosition(MyHexPosition globalPosition)
{
var localPositionBeforeOrientation = globalPosition - _globalCenterPosition;
var localPositionCube = PositionUtils.AxialToCube(localPositionBeforeOrientation);
for (int i = 0; i < _globalCenterOrientation.ClockwiseIndex(); i++)
{
localPositionCube = RotateLeftByOneStep(localPositionCube);
}
return(PositionUtils.CubeToAxial(localPositionCube));
}
public UnitModel GetUnitAt(MyHexPosition position)
{
if (Units.IsPawnAt(position))
{
return(Units.GetPawnAt(position));
}
else
{
return(null);
}
}
public UnitModelComponent AddUnit(MyHexPosition startPosition, MyPlayer player, Orientation startOrientation, GameObject prefab) // public for test reasons
{
var unitModel = _courseModel.AddUnit(startPosition, player, startOrientation);
var unitObject = GameObject.Instantiate(prefab, UnitsParent.transform);
var unitModelComponent = unitObject.GetComponent <UnitModelComponent>();
unitModelComponent.Model = unitModel;
_unitModelToGameObjectMap[unitModel] = unitModelComponent;
unitModelComponent.Model.OnUnitKilled += () => { _unitModelToGameObjectMap.Remove(unitModel); }; // quite hacky
return(unitModelComponent);
}
public ProjectileModel AddProjectile(MyHexPosition position, Orientation orientation)
{
var projectile = new ProjectileModel
{
Orientation = orientation,
Position = position
};
base.AddPawn(position, projectile);
return(projectile);
}
public UnitModel AddUnit(MyHexPosition position, MyPlayer player, Orientation orientation)
{
var unit = new UnitModel
{
Orientation = orientation,
Position = position,
Owner = player
};
base.AddPawn(position, unit);
return(unit);
}
public bool IsActivated(BattlefieldVision vision, MyHexPosition activatingPosition)
{
var unitInFront = vision.GetUnitAt(new MyHexPosition(1, 0));
if (unitInFront != null && unitInFront.Owner != vision.PossesedPawn.Owner)
{
return(true);
}
else
{
return(false);
}
}
public List <MyHexPosition> GetPossibleMoveTargets(UnitModel unit, MyHexPosition magicSelector)
{
var key = new PossibleMoveTargetsQueryKey(unit, magicSelector);
if (_possibleMoveTargetsCache.ContainsKey(key))
{
return(_possibleMoveTargetsCache[key]);
}
var toReturn = unit.PossibleMoveTargets.Where(c => _courseModel.CanMoveTo(unit, c, magicSelector, CurrentPlayer)).ToList();
_possibleMoveTargetsCache[key] = toReturn;
return(toReturn);
}
public void MoveTo(MyHexPosition selectorPosition, UnitModel selectedUnit, MyHexPosition magicUsePosition)
{
var magicType = _courseModel.GetPlayerMagicType(CurrentPlayer);
if (magicUsePosition != null)
{
Assert.IsNull(_magicUsage);
_magicUsage = new MagicUsage(magicType, magicUsePosition, _courseModel, CurrentPlayer, CameraShake, MasterSound);
}
_unitLocomotions.Push(LocomotionUtils.CreateMovementJourney(_courseModel, _unitModelToGameObjectMap[selectedUnit], selectorPosition));
_courseModel.NextTurn();
_possibleMoveTargetsCache = new Dictionary <PossibleMoveTargetsQueryKey, List <MyHexPosition> >();
}
public void UseMagic(MagicType type, MyHexPosition position, MyPlayer player)
{
Assert.IsTrue(PlayerCanUseMagic(player));
_magicLeft[player]--;
if (type == MagicType.Earth) //todo polymorphism
{
MapModel.DisableAt(position);
}
else
{
MapModel.AddResidentMagic(position, type);
}
}
public BattleResults PerformPassiveBattleAtPlace(MyHexPosition battleActivatorPosition, BattleCircumstances battleCircumstances)
{
var battleResults = new BattleResults();
var intruderUnit = _units.GetPawnAt(battleActivatorPosition);
// First - Passive effects of all neighbours
foreach (var pair in battleActivatorPosition.NeighboursWithDirections)
{
if (_mapModel.HasTileAt(pair.NeighbourPosition)) // is valid position
{
if (_units.IsPawnAt(pair.NeighbourPosition))
{
var neighbourUnit = _units.GetPawnAt(pair.NeighbourPosition);
if (!battleResults.UnitIncapaciated(neighbourUnit))
{
battleResults.Add(PerformSingleFight(intruderUnit, neighbourUnit, pair.NeighbourDirection, symbol => symbol.PassiveEffect,
battleCircumstances));
if (battleResults.UnitIncapaciated(intruderUnit))
{
return(battleResults);
}
}
}
}
}
foreach (var pair in battleActivatorPosition.NeighboursWithDirections)
{
if (_mapModel.HasTileAt(pair.NeighbourPosition)) // is valid position
{
if (_units.IsPawnAt(pair.NeighbourPosition))
{
var neighbourUnit = _units.GetPawnAt(pair.NeighbourPosition);
if (!battleResults.UnitIncapaciated(neighbourUnit))
{
battleResults.Add(PerformSingleFight(neighbourUnit, intruderUnit, pair.NeighbourDirection.Opposite(), symbol => symbol.PassiveEffect,
battleCircumstances));
if (battleResults.UnitIncapaciated(intruderUnit))
{
return(battleResults);
}
}
}
}
}
return(battleResults);
}
public MagicUsage(MagicType type, MyHexPosition position, GameCourseModel model, MyPlayer player, CameraShake cameraShake, MasterSound masterSound)
{
_type = type;
_position = position;
_player = player;
_model = model;
_magicUsageEnded = false;
if (type == MagicType.Earth) //todo ugly, should not be if, rather should be polymorphism
{
_animation = new EarthMagicUsageAnimation(model.GetTileAt(position).gameObject, cameraShake, masterSound);
}
else
{
_animation = new WindMagicUsageAnimation(model.GetTileAt(position).gameObject, cameraShake, masterSound);
}
_animation.StartAnimation();
}
public bool CanMoveTo(PawnModel unitMoved, MyHexPosition target, MyHexPosition magicSelector, MyPlayer player)
{
if (!unitMoved.PossibleMoveTargets.Contains(target))
{
return(false);
}
else if (IsTileMovable(target)) //empty!
{
if (magicSelector == null)
{
return(true);
}
if (GetPlayerMagicType(player) != MagicType.Wind)
{
return(!magicSelector.Equals(target));
}
return(true);
}
else
{
if (Units.IsPawnAt(target))
{
var tempUnitsContainer = Units.Clone();
var tempProjectilesContainer = Projectiles.Clone();
var tempMapModel = MapModel.Clone();
var newOrientation = unitMoved.Position.NeighboursWithDirections.Where(c => c.NeighbourPosition.Equals(target))
.Select(c => c.NeighbourDirection).First();
var tempUnitModel = tempUnitsContainer.GetPawnAt(unitMoved.Position);
tempUnitsContainer.OrientPawn(tempUnitModel.Position, newOrientation);
var arbiter = new BattleArbiter(tempUnitsContainer, tempProjectilesContainer, tempMapModel);
var battleResults = arbiter.PerformBattleAtPlace(unitMoved.Position, BattleCircumstances.Director);
return(battleResults.PositionWasFreed(target));
}
}
return(false);
}
private UnitModel ShootingTarget(BattlefieldVision vision)
{
for (int i = 1; i <= _maxShootingDistance; i++)
{
var pos = new MyHexPosition(i, 0);
if (!vision.HasTileAt(pos))
{
return(null);
}
var otherUnitAtFront = vision.GetUnitAt(pos);
if (otherUnitAtFront != null)
{
if (otherUnitAtFront.Owner != vision.PossesedPawn.Owner)
{
return(otherUnitAtFront);
}
else
{
return(null);
}
}
}
return(null);
}
