public CombineAbilityEventInfo(Kimboko combiner, Kimboko kimbokoToCombine, Player player, int IndexID)
{
this.combiner = combiner;
this.kimbokoToCombine = kimbokoToCombine;
this.player = player;
this.IndexID = IndexID;
}
public static bool CanICombineAndEvolve(Kimboko combinerCharacter, Kimboko toCombineCharacter)
{
if (combinerCharacter.UnitType == UNITTYPE.FUSION || toCombineCharacter.UnitType == UNITTYPE.FUSION)
{
return(false);
}
if (combinerCharacter.UnitType != UNITTYPE.X && toCombineCharacter.UnitType != UNITTYPE.X)
{
return(false);
}
int totalPoints;
int combinerPoints = PuntuateKimboko(combinerCharacter);
int toCombinePoints = PuntuateKimboko(toCombineCharacter);
totalPoints = combinerPoints + toCombinePoints;
switch (totalPoints)
{
case 22:
case 41:
case 121:
return(true);
default:
return(false);
}
}
public bool CanIEnterCombineState(Kimboko kimboko)
{
// 6- SI ESTOY ONLINE TENGO QUE PREGUNTARLE AL SERVER SI ES UN MOVIMIENTO VALIDO
// SINO CHEQUEO TODO NORMALMENTE
// QUIEN QUIERE SPAWNEAR, Y EN DONDE QUIERE SPAWNEAR
// SI EL PLAYER ES VALIDO Y ES SU TURNO
// Y SI EL LUGAR PARA SPAWNEAR ES UN LUGAR VALIDO
// ENTONCES EL SERVER TE DICE SI, PODES SPAWNEAR MANDA EL CMD SPAWN A LOS DOS JUGADORES
// SI EL PLAYER ESTA EN SU TURNO
//if (player != game.turnController.CurrentPlayerTurn)
//{
// if (debugOn) Debug.Log("NO ES EL TURNO DEL PLAYER");
// return false;
//}
//if (player.Abilities.ContainsKey(ABILITYTYPE.SPAWN) == false)
//{
// if (debugOn) Debug.Log("ERROR HABILIDAD SPAWN NO ENCONTRADA EN PLAYER");
// return false;
//}
//SpawnAbility spw = (SpawnAbility)player.Abilities[ABILITYTYPE.SPAWN];
//if (spw == null)
//{
// if (debugOn) Debug.Log("ERROR HABILIDAD SPAWN NO ENCONTRADA EN PLAYER");
// return false;
//}
return(false);
}
public static bool CanIEvolve(Kimboko combinerCharacter, Kimboko toCombineCharacter)
{
if (combinerCharacter.UnitType == UNITTYPE.FUSION || toCombineCharacter.UnitType == UNITTYPE.FUSION)
{
return(false);
}
int totalPoints;
int combinerPoints = PuntuateKimboko(combinerCharacter);
int toCombinePoints = PuntuateKimboko(toCombineCharacter);
totalPoints = combinerPoints + toCombinePoints;
switch (totalPoints)
{
case 4:
case 6:
case 8:
case 38:
case 40:
case 57:
return(true);
default:
return(false);
}
}
public bool IsThereAPosibleSpawneableTile(int playerID)
{
int columnIndex = 2;
if (playerID == 1)
{
columnIndex = 8;
}
for (int i = 0; i < rowsHeight; i++)
{
if (GridArray[columnIndex, i].IsOccupied() == false)
{
return(true);
}
if (GridArray[columnIndex, i].GetOcuppy() == null)
{
return(false);
}
if (GridArray[columnIndex, i].GetOcuppy().OccupierType != OCUPPIERTYPE.UNIT)
{
return(false);
}
Kimboko auxKimb = (Kimboko)GridArray[columnIndex, i].GetOcuppy();
if (auxKimb.OwnerPlayerID == playerID)
{
if (CombineKimbokoRules.CanICombineAndEvolveWithUnitType(auxKimb, UNITTYPE.X))
{
return(true);
}
}
}
return(false);
}
private Kimboko GetNewKimboko(SpawnAbilityEventInfo spawnInfo)
{
Debug.Log("PLAYER ID FROM SPAWN INFO " + spawnInfo.spawnerPlayer);
Kimboko kimboko = null;
switch (spawnInfo.spawnUnitType)
{
case UNITTYPE.X:
KimbokoXFactory kimbokoXFac = new KimbokoXFactory();
kimboko = kimbokoXFac.CreateKimboko(spawnInfo.spawnIndexID, spawnInfo.spawnerPlayer);
break;
case UNITTYPE.Y:
KimbokoYFactory kimbokoYFac = new KimbokoYFactory();
kimboko = kimbokoYFac.CreateKimboko(spawnInfo.spawnIndexID, spawnInfo.spawnerPlayer);
break;
case UNITTYPE.Z:
KimbokoZFactory kimbokoZFac = new KimbokoZFactory();
kimboko = kimbokoZFac.CreateKimboko(spawnInfo.spawnIndexID, spawnInfo.spawnerPlayer);
break;
default:
break;
}
return(kimboko);
}
public static bool CanICombineWithUnitType(Kimboko combiner, UNITTYPE toCombine)
{
if (combiner.UnitType == UNITTYPE.FUSION || toCombine == UNITTYPE.FUSION || toCombine == UNITTYPE.COMBINE)
{
return(false);
}
int totalPoints;
int combinerPoints = PuntuateKimboko(combiner);
int toCombinePoints = PuntuateUnitType(toCombine);
totalPoints = combinerPoints + toCombinePoints;
switch (totalPoints)
{
case 2:
case 5:
case 7:
case 8:
case 18:
case 34:
case 39:
case 55:
case 116:
case 132:
case 136:
case 138:
return(true);
default:
return(false);
}
}
private void ExecuteSpecialSpawn(SpawnAbility spawnAbility, SpawnAbilityEventInfo spwInf)
{
Kimboko unit = (Kimboko)spwInf.spawnTile.GetOcuppy();
if (unit == null)
{
return;
}
if (unit.OwnerPlayerID != spwInf.spawnerPlayer.OwnerPlayerID)
{
return;
}
bool canCombine = CombineKimbokoRules.CanICombineWithUnitType(unit, spwInf.spawnUnitType);
bool canCombineAndEvolve = CombineKimbokoRules.CanICombineAndEvolveWithUnitType(unit, spwInf.spawnUnitType);
if (canCombineAndEvolve)
{
ExecuteSpawnCombineAndEvolve(unit, spwInf);
}
else if (canCombine)
{
ExecuteSpawnCombine(unit, spawnAbility, spwInf);
}
else
{
// Y ACA NO SE PUDO COMBINAR NI EVOLUCIONAR
// ESTO PUEDE PASAR POR INVOCAR UNA UNIDAD Y QUE SE LE CAMBIE DE CLASE
// AL HACER ESTO NO PODEMOS INVOCARLA POR QUE SON INCOMPATIBLES
// SE EJECUTA IGUAL EL END PERFORM?????
// PODRIAMOS TENER UN ESTADO EN EL EVENT INFO PARA PONER CANCEL EXECUTION
// ENTONCES DE ESTA MANERA SABEMOS QUE SE CANCELO Y NO HACEMOS EL END PERFORM...
}
}
public static int PuntuateKimboko(Kimboko characterToPuntuate)
{
int totalPoints = 0;
switch (characterToPuntuate.UnitType)
{
case UNITTYPE.X:
totalPoints += Xpoints;
break;
case UNITTYPE.Y:
totalPoints += Ypoints;
break;
case UNITTYPE.Z:
totalPoints += Zpoints;
break;
case UNITTYPE.COMBINE:
for (int i = 0; i < (characterToPuntuate as KimbokoCombine).kimbokos.Count; i++)
{
switch ((characterToPuntuate as KimbokoCombine).kimbokos[i].UnitType)
{
case UNITTYPE.X:
totalPoints += Xpoints + XCombPoints;
break;
case UNITTYPE.Y:
totalPoints += Ypoints + YCombPoints;
break;
case UNITTYPE.Z:
totalPoints += Zpoints + ZCombPoints;
break;
case UNITTYPE.COMBINE:
return(0);
case UNITTYPE.FUSION:
return(0);
default:
return(0);
}
}
break;
case UNITTYPE.FUSION:
return(0);
default:
return(0);
}
return(totalPoints);
}
private void ExecuteSpawnCombineAndEvolve(Kimboko unit, SpawnAbilityEventInfo spwInf)
{
// ACA DEBERIA TENER UNA REFERENCIA AL COMBINE MANAGER
// ACA DEBERIA TENER UNA REFERENCIA AL EVOLVE MANAGER
// CREAMOS UNA COMBINE MOTION
// A - Motion normalSpawnMotion = spawnManagerUI.NormalSpawn(spawnPosition, goKimboko);
// B - GENERAMOS UN DESTELLO O ALGO SIMILAR EN LA POSICION DE SPAWNEO
// C - DESTRUIMOS LOS OBJETOS ACTUALES DE LOS KIMBOKOS
// D - CREAMOS EL NUEVO KIMBOKO EVOLUCIONADO
}
public static Dictionary <ABILITYTYPE, IAbility> CreateKimbokoAbilities(Kimboko kimboko)
{
Dictionary <ABILITYTYPE, IAbility> Abilities = new Dictionary <ABILITYTYPE, IAbility>();
MoveAbility moveAbility = new MoveAbility(kimboko);
Abilities.Add(moveAbility.AbilityType, moveAbility);
CombineAbility combineAbility = new CombineAbility(kimboko);
Abilities.Add(combineAbility.AbilityType, combineAbility);
return(Abilities);
}
private void Move(MoveAbilityEventInfo movInfo)
{
Kimboko kimb = (Kimboko)movInfo.moveOccupy;
if (kimb != null && kimb.UnitType == UNITTYPE.COMBINE)
{
KimbokoCombine combien = (KimbokoCombine)kimb;
if (combien != null)
{
CombineMove(combien, movInfo);
return;
}
}
NormalMove(movInfo);
}
public List <SpawnTile> GetPlayerSpawnTiles(int playerID)
{
List <SpawnTile> spawnTile = new List <SpawnTile>();
int columnIndex = 2;
if (playerID == 1)
{
columnIndex = 8;
}
for (int i = 0; i < rowsHeight; i++)
{
if (GridArray[columnIndex, i].IsOccupied() == false)
{
SpawnTile aux = (SpawnTile)GridArray[columnIndex, i];
spawnTile.Add(aux);
continue;
}
if (GridArray[columnIndex, i].GetOcuppy() == null)
{
continue;
}
if (GridArray[columnIndex, i].GetOcuppy().OccupierType != OCUPPIERTYPE.UNIT)
{
continue;
}
Kimboko auxKimb = (Kimboko)GridArray[columnIndex, i].GetOcuppy();
if (auxKimb.OwnerPlayerID == playerID)
{
if (CombineKimbokoRules.CanICombineWithUnitType(auxKimb, UNITTYPE.X))
{
SpawnTile aux = (SpawnTile)GridArray[columnIndex, i];
spawnTile.Add(aux);
continue;
}
if (CombineKimbokoRules.CanICombineAndEvolveWithUnitType(auxKimb, UNITTYPE.X))
{
SpawnTile aux = (SpawnTile)GridArray[columnIndex, i];
spawnTile.Add(aux);
continue;
}
}
}
return(spawnTile);
}
public static Kimboko WhoIsTheStrong(Kimboko kimbokoOne, Kimboko kimbokoTwo)
{
Kimboko theStongest;
int CharacterOnePoints = PuntuateKimboko(kimbokoOne);
int CharacterTwoPoints = PuntuateKimboko(kimbokoTwo);
if (CharacterOnePoints == CharacterTwoPoints || CharacterOnePoints > CharacterTwoPoints)
{
theStongest = kimbokoOne;
}
else
{
theStongest = kimbokoTwo;
}
return(theStongest);
}
public static bool CanIFusion(Kimboko toFusionCharacter)
{
if (toFusionCharacter.UnitType == UNITTYPE.FUSION)
{
return(false);
}
int fusionPoints = PuntuateKimboko(toFusionCharacter);
switch (fusionPoints)
{
case 4:
case 6:
case 8:
case 38:
case 57:
return(true);
default:
return(false);
}
}
public static bool CanIEvolve(Kimboko toEvolveCharacter)
{
if (toEvolveCharacter.UnitType == UNITTYPE.FUSION)
{
return(false);
}
int evolverPoints = PuntuateKimboko(toEvolveCharacter);
switch (evolverPoints)
{
case 4:
case 6:
case 8:
case 38:
case 40:
case 57:
return(true);
default:
return(false);
}
}
public static bool CanIDecombine(Kimboko characterToDecombine, Tile from)
{
//// ESTO TIENE QUE SER GLOBAL YA QUE VA A SER UN CONTADOR
//int CharactersLeftToDecombine = 0;
//if (characterToDecombine.UnitType != UNITTYPE.COMBINE) return false;
//// Primero tengo que ver cuantos characters hay combinados
//// Despues tengo que buscar en forma de cruz si tengo esta cantidad de lugares libres
//int amountOfCharacters = 0;
//for (int i = 0; i < (characterToDecombine as KimbokoCombine).kimbokos.Count; i++)
//{
// amountOfCharacters++;
//}
//// Lista de posibles lugares para moverse
////CrossCombineDirectionCommand crossCombineDirectionCommand = new CrossCombineDirectionCommand(from, characterToDecombine, BoardManager.Instance.GetAllBoardTileList());
////List<Tile2D> posibleDecombinableTiles = crossCombineDirectionCommand.crossTiles;
//int amountOfFreePosibleTiles = 0;
////for (int i = 0; i < posibleDecombinableTiles.Count; i++)
////{
//// if (!posibleDecombinableTiles[i].IsOcuppied)
//// {
//// amountOfFreePosibleTiles++;
//// }
////}
////// le pongo menos uno ya que siempre el que descombina se queda en el lugar
////if (amountOfFreePosibleTiles >= amountOfCharacters - 1)
////{
//// CharactersLeftToDecombine = amountOfCharacters - 1;
//// return true;
////}
return(false);
}
public void RemoveUnit(Kimboko kimbokoUnit)
{
kimbokoUnits.Remove(kimbokoUnit);
}
public void AddUnit(Kimboko kimbokoUnit)
{
kimbokoUnits.Add(kimbokoUnit);
}
Dictionary <Kimboko, Vector2> kimbokoToDecombineAndPositions; // QUIENES Y EN DONDE VAN A DESCOMBINAR
public DecombineAbilityEventInfo(Kimboko decombiner, Dictionary <Kimboko, Vector2> kimbokoToDecombineAndPositions)
{
this.decombiner = decombiner;
this.kimbokoToDecombineAndPositions = kimbokoToDecombineAndPositions;
}
private void ExecuteSpawnCombine(Kimboko actualCombiner, SpawnAbility spawnAbility, SpawnAbilityEventInfo spwInf)
{
CombineAbility combineAbility = (CombineAbility)actualCombiner.Abilities[ABILITYTYPE.COMBINE];
if (combineAbility == null)
{
if (debugOn)
{
Debug.Log("ERROR HABILIDAD COMBINE NULL");
}
return;
}
Kimboko spawnedKimboko = GetNewKimboko(spwInf);
CombineAbilityEventInfo cmbInfo = new CombineAbilityEventInfo(actualCombiner, spawnedKimboko, spwInf.spawnerPlayer, spwInf.spawnIndexID);
spawnAbility.SetRequireGameData(spwInf);
combineAbility.SetRequireGameData(cmbInfo);
StartPerform(spawnAbility);
if (spawnAbility.CanIExecute() == false)
{
if (debugOn)
{
Debug.Log("SPAWN ABILITY NO SE PUEDE EJECUTAR");
}
return;
}
game.combineManager.StartPerform(combineAbility);
// NO VOY A GENERAR ESTE CHEQUEO, YA QUE EL SPAWN GENERA AUTOMATICAMENTE LA COMBINACION
//if (combineAbility.CanIExecute() == false)
//{
// if (debugOn) Debug.Log("COMBINE ABILITY NO SE PUEDE EJECUTAR");
// return;
//}
// C - CombineSpawn(Kimboko actualCombiner, SpawnAbilityEventInfo spwInf)
GameObject goKimboko = spawnManagerUI.GetKimbokoPrefab();
spawnedKimboko.SetGoAnimContainer(new GameObjectAnimatorContainer(goKimboko, goKimboko.GetComponent <Animator>()));
ISpawnCombineCommand spawnCombineCmd = new ISpawnCombineCommand(spawnedKimboko, spwInf, actualCombiner, game);
Invoker.AddNewCommand(spawnCombineCmd);
Invoker.ExecuteCommands();
Vector3 spawnPosition = spwInf.spawnTile.GetRealWorldLocation();
List <GameObject> combinersGO = new List <GameObject>();
if (actualCombiner.UnitType == UNITTYPE.COMBINE)
{
KimbokoCombine kimbComb = (KimbokoCombine)actualCombiner;
for (int i = 0; i < kimbComb.kimbokos.Count; i++)
{
combinersGO.Add(kimbComb.kimbokos[i].goAnimContainer.GetGameObject());
}
}
else
{
combinersGO.Add(actualCombiner.goAnimContainer.GetGameObject());
}
//Motion combineSpawnMotion = spawnManagerUI.CombineSpawn(spawnPosition, goKimboko, combinersGO, game);
//InvokerMotion.AddNewMotion(combineSpawnMotion);
//InvokerMotion.StartExecution(spawnManagerUI);
Animotion combineSpawnMotion = spawnManagerUI.CombineSpawnAnimotion(spawnPosition, goKimboko, combinersGO, game);
InvokerAnimotion.AddNewMotion(combineSpawnMotion);
InvokerAnimotion.StartExecution(spawnManagerUI);
// D - Perform(spawnAbility);
// Perform(combineAbility);
Perform(spawnAbility);
game.combineManager.Perform(combineAbility);
// E - EndPerform(spawnAbility);
// EndPerform(combineAbility);
EndPerform(spawnAbility);
game.combineManager.EndPerform(combineAbility);
// F - spawnIndexID++;
spawnIndexID++;
}