public async Task <IMoveModel> TryMove(IPieceModel piece)
{
if (AllowMove)
{
var meepleId = piece.Meeple != null ? piece.Meeple.MeepleId : -1;
var curr = ActivePlayer;
var result = curr.TryMove(piece, GameField.ResetChangedPieces);
if (meepleId < 0)
{
meepleId = piece.Meeple != null ? piece.Meeple.MeepleId : meepleId;
}
_currentMoveInfo.MeepleId = meepleId;
_currentMoveInfo.Finished = true;
await _networkHelper.SendMoveToServer(_currentMoveInfo);
AllowMove = false;
if (LastDice == 6)
{
AllowDice = true;
}
else
{
AllowDice = false;
SelectNextPlayer();
}
return(result);
}
return(null);
}
private IResponse AddPiece(Coord coord, IPieceModel piece)
{
Assert.IsNotNull(piece);
Assert.IsTrue(IsValidCoord(coord));
piece.Coord.Value = coord;
_pieces.Add(piece);
return(Response.Ok);
}
public Battle(IPlayerModel player, IPieceModel attacker, IPieceModel defender)
: base(player, EActionType.Battle)
{
Assert.IsNotNull(player);
Assert.IsNotNull(attacker);
Assert.IsNotNull(defender);
Attacker = attacker;
Defender = defender;
}
public MoveResults GetMovements(IPieceModel piece)
{
if (piece == null)
{
Warn($"Attempt to get movements for empty piece");
return(null);
}
var coord = piece.Coord.Value;
return(GetMovements(coord, piece.PieceType));
}
public bool CanMoveOrAttack(IPieceModel pieceModel)
{
Assert.IsNotNull(pieceModel);
// movements and attacks can be different for different pieces so be ba careful
var moves = GetMovements(pieceModel);
var attacks = GetAttacks(pieceModel);
// we have an empty square to
if (moves.Coords.Count > 0)
{
return(true);
}
// we have no empty squares, but check for interference squares on movement
foreach (var other in moves.Interferernce)
{
Assert.IsNotNull(other);
Assert.IsFalse(other.SameOwner(pieceModel));
// we should not have an interference square in our movements list that
// contains a piece that does not belong to same owner
if (!other.SameOwner(pieceModel))
{
Error($"{pieceModel} can 'move' to opposing piece {other}");
continue;
}
// TODO: Mounting
// for now, if this is only option to move to, and has same
// owner, then we can't move. check for attacks next.
if (moves.Coords.Count == 0)
{
break;
}
}
// now we can only attack
if (attacks.Coords.Count > 0)
{
return(true);
}
// we can attack a defender of a square we could otherwise attack directly
if (attacks.Interferernce.Count > 0)
{
return(true);
}
// we can't move anywhere, mount anything, or attack directly or attack a defender
return(false);
}
public IResponse Move(IPieceModel pieceModel, Coord coord)
{
Assert.IsNotNull(pieceModel);
Assert.IsNotNull(coord);
Assert.IsTrue(IsValidCoord(coord));
var found = Get(coord);
if (found == null)
{
return(Response.Fail);
}
found.Coord.Value = coord;
return(Response.Ok);
}
public IResponse Move([NotNull] IPieceModel pieceModel, Coord coord)
{
var found = Get(coord);
if (found == null)
{
return(Response.Ok);
}
if (found.Dead.Value)
{
return(Response.Ok);
}
found.Coord.Value = coord;
return(Response.Ok);
}
private IResponse MovePieceTo(Coord coord, IPieceModel piece)
{
Assert.IsNotNull(piece);
Assert.IsNotNull(coord);
Assert.IsTrue(IsValidCoord(coord));
var found = _pieces.FirstOrDefault(p => p == piece);
Assert.IsNotNull(found);
if (found == null)
{
return(Response.Fail);
}
found.Coord.Value = coord;
return(Response.Ok);
}
public async Task <IMoveModel> TryMove(IPieceModel piece)
{
var curr = ActivePlayer;
var move = curr.TryMove(piece, GameField.ResetChangedPieces);
if (move != null)
{
AllowMove = false;
if (LastDice != 6)
{
SelectNextPlayer();
}
return(move);
}
return(null);
}
public IResponse Attack(IPieceModel defender)
{
var attack = defender.TakeDamage(this);
if (attack.Failed)
{
return(attack);
}
var defend = TakeDamage(defender);
if (defend.Failed)
{
return(defend);
}
if (defender.Dead.Value && !Dead.Value)
{
return(Board.Move(this, defender.Coord.Value));
}
return(Response.Ok);
}
public MovePiece(IPlayerModel player, IPieceModel piece, Coord coord)
: base(player, EActionType.MovePiece)
{
Piece = piece;
Coord = coord;
}
public Response TryUnequip(IPieceModel piece)
{
throw new System.NotImplementedException();
}
public MountPiece(IPlayerModel player, IPieceModel mount, IPieceModel rider)
: base(player, EActionType.Mount)
{
Mount = mount;
Rider = rider;
}
public MoveResults GetAttacks(IPieceModel piece)
{
return(piece == null ? null : GetAttacks(piece.Coord.Value, piece.PieceType));
}
public IResponse Add(IPieceModel piece)
{
Assert.IsNull(At(piece.Coord.Value));
AddPiece(piece.Coord.Value, piece);
return(Response.Ok);
}
public IResponse Remove(IPieceModel pieceModel)
{
Assert.IsNotNull(pieceModel);
return(_pieces.Remove(pieceModel) ? Response.Ok : Response.Fail);
}
public IResponse TakeDamage(IPieceModel attacker)
{
return(Card.TakeDamage(attacker.Card));
}
public IEnumerable <IPieceModel> AllAttackingPieces(IEnumerable <IPieceModel> pieces, IPieceModel defender) => AllAttackingPieces(pieces, defender.Coord.Value);
