public KimbokoCombine(List <Kimboko> kimbokos, int ID, Player ownerPlayer, MOVEDIRECTIONTYPE moveDirectionerType)
: base(ID, ownerPlayer, unitType, moveDirectionerType)
{
this.kimbokos = OccupierStatDatabase.GetCombineKimbokoOrder(kimbokos);
Stats = OccupierStatDatabase.CreateKimbokoCombineStat(kimbokos);
Abilities = OccupierAbilityDatabase.CreateKimbokoAbilities(this);
}
public FilterMoveableWithBoardStrategyPattern(Tile from, MOVEDIRECTIONTYPE moveDirectionType, Tile[,] boardTiles, int movementAmount)
{
IFiltterMoveableTileWithBoardStrategy moveStratToUse = null;
switch (moveDirectionType)
{
case MOVEDIRECTIONTYPE.CROSSLEFT:
case MOVEDIRECTIONTYPE.CROSSRIGHT:
moveStratToUse = new FilterMoveableCrossFrontWithBoard();
break;
case MOVEDIRECTIONTYPE.DIAGONAL:
moveStratToUse = new FilterMoveableDiagonalWithBoard();
break;
case MOVEDIRECTIONTYPE.MULTI:
moveStratToUse = new FilterMoveableAllDirectionWithBoard();
break;
}
if (moveStratToUse == null)
{
moveableTiles = null;
return;
}
ContextMoveableWithBoardFilter ctxMoveable = new ContextMoveableWithBoardFilter(moveStratToUse);
moveableTiles = ctxMoveable.ExecuteStrategy(from, moveDirectionType, boardTiles, movementAmount);
}
public List <Tile> GetPosibleMoveableTiles(Tile fromTile, MOVEDIRECTIONTYPE moveDirection, int movementAmount)
{
List <Tile> posibleMoveableTiles = new List <Tile>();
// Filtramos esas tiles y las ponemos en la lista
FilterMoveableWithBoardStrategyPattern filterMoveable = new FilterMoveableWithBoardStrategyPattern(fromTile, moveDirection, game.board2DManager.GridArray, movementAmount);
posibleMoveableTiles = filterMoveable.moveableTiles;
return(posibleMoveableTiles);
}
public Kimboko(int ID, Player ownerPlayer, UNITTYPE UnitType, MOVEDIRECTIONTYPE MoveDirectionerType)
{
this.ID = ID;
OwnerPlayerID = ownerPlayer.OwnerPlayerID;
CardTargetType = CARDTARGETTYPE.UNIT;
OccupierType = OCUPPIERTYPE.UNIT;
this.UnitType = UnitType;
this.MoveDirectionerType = MoveDirectionerType;
}
private Dictionary <Tile, HIGHLIGHTUITYPE> CreateHighlightUIDictionary(IOcuppy occupier)
{
Dictionary <Tile, HIGHLIGHTUITYPE> tileHighlightTypesDictionary = new Dictionary <Tile, HIGHLIGHTUITYPE>();
int moveAmount = occupier.Stats[STATTYPE.MOVERANGE].ActualStatValue;
MOVEDIRECTIONTYPE movementType = occupier.MoveDirectionerType;
Tile fromTile = game.board2DManager.GetGridObject(occupier.actualPosition.posX, occupier.actualPosition.posY);
List <Tile> moveTiles = GetPosibleMoveableTiles(fromTile, movementType, moveAmount);
if (moveTiles.Count <= 0)
{
return(tileHighlightTypesDictionary);
}
for (int i = 0; i < moveTiles.Count; i++)
{
tileHighlightTypesDictionary.Add(moveTiles[i], HIGHLIGHTUITYPE.MOVE);
}
return(tileHighlightTypesDictionary);
}
public List <Tile> ExecuteStrategy(Tile from, MOVEDIRECTIONTYPE moveDirectionType, Tile[,] boardTiles, int movementAmount)
{
return(strategy.FiltterMoveables(from, moveDirectionType, boardTiles, movementAmount));
}
public List <Tile> FiltterMoveables(Tile from, MOVEDIRECTIONTYPE moveDirectionType, Tile[,] boardTiles, int movementAmount)
{
if (from == null)
{
return(null);
}
if (movementAmount == 0)
{
return(null);
}
List <Tile> moveableTiles = new List <Tile>();
PositionerDemo.Position fromPosition = new PositionerDemo.Position(from.position.posX, from.position.posY);
int maxX = boardTiles.GetLength(0);
int maxY = boardTiles.GetLength(1);
for (int i = 1; i <= movementAmount; i++)
{
// UP RIGHT
if (blockDirection)
{
if (!blockUpRight)
{
if (fromPosition.posY + i < maxY && fromPosition.posX + i < maxX)
{
if (!boardTiles[fromPosition.posX + i, fromPosition.posY + i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX + i, fromPosition.posY + i]);
}
else
{
blockUpRight = true;
}
}
}
}
else
{
if (fromPosition.posY + i < maxY && fromPosition.posX + i < maxX)
{
if (!boardTiles[fromPosition.posX + i, fromPosition.posY + i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX + i, fromPosition.posY + i]);
}
}
}
// UP LEFT
if (blockDirection)
{
if (!blockUpLeft)
{
if (fromPosition.posY + i < maxY && fromPosition.posX - i >= 0)
{
if (!boardTiles[fromPosition.posX - i, fromPosition.posY + i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX - i, fromPosition.posY + i]);
}
else
{
blockUpLeft = true;
}
}
}
}
else
{
if (fromPosition.posY + i < maxY && fromPosition.posX - i >= 0)
{
if (!boardTiles[fromPosition.posX - i, fromPosition.posY + i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX - i, fromPosition.posY + i]);
}
}
}
// DOWN RIGHT
if (blockDirection)
{
if (!blockDownRight)
{
if (fromPosition.posY - i >= 0 && fromPosition.posX + i < maxX)
{
if (!boardTiles[fromPosition.posX + i, fromPosition.posY - i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX + i, fromPosition.posY - i]);
}
else
{
blockDownRight = true;
}
}
}
}
else
{
if (fromPosition.posY - i >= 0 && fromPosition.posX + i < maxX)
{
if (!boardTiles[fromPosition.posX + i, fromPosition.posY - i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX + i, fromPosition.posY - i]);
}
}
}
// DOWN LEFT
if (blockDirection)
{
if (!blockDownLeft)
{
if (fromPosition.posY - i >= 0 && fromPosition.posX - i >= 0)
{
if (!boardTiles[fromPosition.posX - i, fromPosition.posY - i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX - i, fromPosition.posY - i]);
}
else
{
blockDownLeft = true;
}
}
}
}
else
{
if (fromPosition.posY - i >= 0 && fromPosition.posX - i >= 0)
{
if (!boardTiles[fromPosition.posX - i, fromPosition.posY - i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX - i, fromPosition.posY - i]);
}
}
}
}
return(moveableTiles);
}
public void OnTryMove(IOcuppy occupier, Tile endPosition)
{
if (CanIEnterMoveState(occupier) == false)
{
return;
}
if (occupier == null || endPosition == null)
{
if (debugOn)
{
Debug.Log("No Tile Object or Ocuppier");
}
return;
}
/////////////////////////////////////////////////////////////////
// CREAMOS POSIBLE MOVEABLE TILES, SOLO LA LISTA SIN PINTARLAS NI NADA
// TILE EN DONDE ESTAMOS PARADOS
Tile fromTile = game.board2DManager.GetUnitPosition(occupier);
if (fromTile == null)
{
if (debugOn)
{
Debug.Log("You are walking on the sky my men");
}
return;
}
// TIPO DE MOVIMIENTO DE NUESTRA UNIDAD
MOVEDIRECTIONTYPE moveDirection = occupier.MoveDirectionerType;
if (moveDirection == MOVEDIRECTIONTYPE.NONE)
{
return;
}
// CANTIDA DE CASILLA QUE PUEDO MOVERME
int movementAmount = occupier.Stats[STATTYPE.MOVERANGE].ActualStatValue;
if (movementAmount == 0)
{
return;
}
// 3 - QUE SEA UNA DISTANCIA VALIDA SEGUN MI RANGO DE MOVIMIENTO
// CANTIDA DE CASILLA QUE PUEDO MOVERME DEBERIA RESTAR A LA POS INICIAL LA POS FINAL Y VER LA DIFERENCIA EN DISTANCIA
// Filtramos esas tiles y las ponemos en la lista
FilterMoveableWithBoardStrategyPattern filterMoveable =
new FilterMoveableWithBoardStrategyPattern(fromTile, moveDirection, game.board2DManager.GridArray, movementAmount);
posibleMoveableTiles = filterMoveable.moveableTiles;
// 2- SI NO HAY TILES LIBRES PARA MOVERSE
if (posibleMoveableTiles.Count == 0)
{
return;
}
/////////////////////////////////////
if (!IsLegalMovement(occupier, endPosition))
{
if (debugOn)
{
Debug.Log("Ilegal MOVE");
}
return;
}
if (occupier.Abilities.ContainsKey(ABILITYTYPE.MOVE) == false)
{
if (debugOn)
{
Debug.Log("ERROR HABILIDAD MOVE NO ENCONTRADA EN OCUPPIER");
}
return;
}
MoveAbility moveAb = (MoveAbility)occupier.Abilities[ABILITYTYPE.MOVE];
if (moveAb == null)
{
if (debugOn)
{
Debug.Log("ERROR HABILIDAD MOVE NO ENCONTRADA EN EL OCCUPIER");
}
return;
}
MoveAbilityEventInfo movInfo = new MoveAbilityEventInfo(occupier, fromTile, endPosition);
moveAb.SetRequireGameData(movInfo);
StartPerform(moveAb);
if (moveAb.CanIExecute() == false)
{
if (debugOn)
{
Debug.Log("SPAWN ABILITY NO SE PUEDE EJECUTAR");
}
return;
}
Move(movInfo);
Perform(moveAb);
EndPerform(moveAb);
}
public List <Tile> FiltterMoveables(Tile from, MOVEDIRECTIONTYPE moveDirectionType, Tile[,] boardTiles, int movementAmount)
{
if (from == null)
{
return(null);
}
if (movementAmount == 0)
{
return(null);
}
List <Tile> moveableTiles = new List <Tile>();
PositionerDemo.Position fromPosition = new PositionerDemo.Position(from.position.posX, from.position.posY);
int maxX = boardTiles.GetLength(0);
int maxY = boardTiles.GetLength(1);
// GridArray = new Tile[this.columnsWidht, this.rowsHeight];
// this.columnsWidht = columnsWidht + 4; 11 columnas
// this.rowsHeight = rowsHeight; 5 filas
//
// maxX = 11; x + 1 == right x - 1 == left
// maxY = 5; y + 1 == up y - 1 == down
for (int i = 1; i <= movementAmount; i++)
{
if (moveDirectionType == MOVEDIRECTIONTYPE.CROSSRIGHT)
{
if (blockDirection)
{
if (!blockRight)
{
if (fromPosition.posX + i < maxX)
{
if (!boardTiles[fromPosition.posX + i, fromPosition.posY].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX + i, fromPosition.posY]);
}
else
{
blockRight = true;
}
}
}
}
else
{
if (fromPosition.posX + i < maxX)
{
if (!boardTiles[fromPosition.posX + i, fromPosition.posY].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX + i, fromPosition.posY]);
}
}
}
}
else if (moveDirectionType == MOVEDIRECTIONTYPE.CROSSLEFT)
{
if (blockDirection)
{
if (!blockLeft)
{
if (fromPosition.posX - i >= 0)
{
if (!boardTiles[fromPosition.posX - i, fromPosition.posY].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX - i, fromPosition.posY]);
}
else
{
blockLeft = true;
}
}
}
}
else
{
if (fromPosition.posX - i >= 0)
{
if (!boardTiles[fromPosition.posX - i, fromPosition.posY].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX - i, fromPosition.posY]);
}
}
}
}
// UP
if (blockDirection)
{
if (!blockUp)
{
if (fromPosition.posY + i < maxY)
{
if (!boardTiles[fromPosition.posX, fromPosition.posY + i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX, fromPosition.posY + i]);
}
else
{
blockUp = true;
}
}
}
}
else
{
if (fromPosition.posY + i < maxY)
{
if (!boardTiles[fromPosition.posX, fromPosition.posY + i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX, fromPosition.posY + i]);
}
}
}
// DOWN
if (blockDirection)
{
if (!blockDown)
{
if (fromPosition.posY - i >= 0)
{
if (!boardTiles[fromPosition.posX, fromPosition.posY - i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX, fromPosition.posY - i]);
}
else
{
blockDown = true;
}
}
}
}
else
{
if (fromPosition.posY - i >= 0)
{
if (!boardTiles[fromPosition.posX, fromPosition.posY - i].IsOccupied())
{
moveableTiles.Add(boardTiles[fromPosition.posX, fromPosition.posY - i]);
}
}
}
}
return(moveableTiles);
}
public KimbokoCombineFactory(List <Kimboko> kimbokos)
{
this.kimbokos = kimbokos;
this.directionType = OccupierStatDatabase.GetMovementDirectionTypeCombineStat(kimbokos);
}
