public FilterPlayerStrategyPattern(IOcuppy occupier)
{
this.occupier = occupier;
ContextPlayerFilter ctxPlayer = new ContextPlayerFilter(new FilterPlayer());
player = ctxPlayer.ExecuteStrategy(occupier);
}
public FilterUnitStrategyPattern(IOcuppy occupier)
{
this.occupier = occupier;
ContextUnitFilter ctxUnit = new ContextUnitFilter(new FilterUnit());
unit = ctxUnit.ExecuteStrategy(occupier);
}
public int damageAmountDeal; // CANTIDAD DE DANO A REALIZAR
public AttackAbilityEventInfo(IOcuppy attacker, IOcuppy damageTaker, DAMAGETYPE attackType, int damageAmountDeal)
{
this.attacker = attacker;
this.damageTaker = damageTaker;
this.attackType = attackType;
this.damageAmountDeal = damageAmountDeal;
}
public int damageAmountRecived; // CANTIDAD DE DANO A REALIZAR
public DamageAbilityEventInfo(IOcuppy attacker, IOcuppy damageTaker, DAMAGETYPE damageType, int damageAmountRecived)
{
this.attacker = attacker;
this.damageTaker = damageTaker;
this.damageType = damageType;
this.damageAmountRecived = damageAmountRecived;
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
if (base.CheckTarget(cardTarget) == null)
{
return(null);
}
IOcuppy ocuppier = cardTarget.GetOcuppy();
if (ocuppier == null)
{
return(null);
}
Kimboko kim = (Kimboko)ocuppier;
if (kim == null)
{
return(null);
}
if (kim.UnitType != unitType)
{
return(null);
}
return(cardTarget);
}
public FilterOcuppierStrategyPattern(Tile til2D)
{
this.til2D = til2D;
ContextOccupierFilter ctxOccupy = new ContextOccupierFilter(new FilterOccupier());
occupier = ctxOccupy.ExecuteStrategy(til2D);
}
public Ability(IOcuppy performerIOcuppy, int actionPointsRequired, ABILITYTYPE AbilityType)
{
abilityModifier = new List <AbilityModifier>();
this.performerIOcuppy = performerIOcuppy;
this.actionPointsRequired = actionPointsRequired;
this.AbilityType = AbilityType;
}
public void CreateOcuppierStatInformationPanel(IOcuppy ocuppier)
{
if (ocuppier == null)
{
actualSelectedOcuppier = null;
ClearStatInforPanel();
return;
}
if (actualSelectedOcuppier != null)
{
if (actualSelectedOcuppier == ocuppier)
{
return;
}
}
ClearStatInforPanel();
actualSelectedOcuppier = ocuppier;
foreach (var pair in ocuppier.Stats)
{
OcuppierStatsInformationUI statInfoUI = GetInformationStatInfo(ocuppier.OwnerPlayerID);
OcuppierStatInfo statInfo = new OcuppierStatInfo(pair.Value);
statInfoUI.SetOcuppierStatInformation(statInfo);
statInfoUICreated.Add(statInfoUI.gameObject);
}
if (ocuppier.OwnerPlayerID == 0)
{
playerOneInfoPanelParent.gameObject.SetActive(true);
}
else
{
playerTwoInfoPanelParent.gameObject.SetActive(true);
}
}
public Tile GetUnitPosition(IOcuppy ocuppier)
{
if (occupierPositions.ContainsKey(ocuppier))
{
return(GetGridObject(occupierPositions[ocuppier].posX, occupierPositions[ocuppier].posY));
}
return(null);
}
public TakeCardAbility(IOcuppy performerIOcuppy) : base(performerIOcuppy, ACTIONPOINTSREQUIRED, TYPEABILITY)
{
actionStatus = ABILITYEXECUTIONSTATUS.WAIT;
if (performerIOcuppy.OccupierType == OCUPPIERTYPE.PLAYER)
{
player = (Player)performerIOcuppy;
}
}
public StatIResultData(int statID, STATAMOUNTTYPE statAmountType, IOcuppy ocuppy)
{
this.statID = statID;
statType = (STATTYPE)statID;
this.statAmountType = statAmountType;
this.ocuppy = ocuppy;
resultDataType = RESULTDATATYPE.STAT;
}
Player IFilterPlayerStrategy.FilterPlayer(IOcuppy occupier)
{
if (occupier != null && occupier.OccupierType == OCUPPIERTYPE.PLAYER)
{
return((Player)occupier);
//Debug.Log("Estoy ocupada por un player " + selectedPlayer._ID);
}
return(null);
}
public void OnEnterMoveState(IOcuppy occupier)
{
// CREO LA LISTA/DICCTIONARY DE LAS POSIBLES TILES A MOVERSE CON SU HIGHLIGHT CORRESPONDIENTE
Dictionary <Tile, HIGHLIGHTUITYPE> tileHighlightTypesDictionary = CreateHighlightUIDictionary(occupier);
MoveAbilitySelectionUIContainer moveUIContainer = new MoveAbilitySelectionUIContainer(tileHighlightTypesDictionary);
MoveState moveState = new MoveState(game, game.baseStateMachine.currentState, moveUIContainer, occupier);
game.baseStateMachine.PopState(true);
game.baseStateMachine.PushState(moveState);
}
public Kimboko FilterUnitStrat(IOcuppy occupier)
{
if (occupier != null && occupier.OccupierType == OCUPPIERTYPE.UNIT)
{
return((Kimboko)occupier);
//Debug.Log("Estoy ocupada por un player " + selectedPlayer._ID);
}
return(null);
}
public void CreateButton(IOcuppy actualOccupier, ABILITYBUTTONTYPE abilityButtonType)
{
Button btnAbi = Instantiate(abilityButtonPrefab);
btnAbi.transform.SetParent(buttonParent, false);
switch (abilityButtonType)
{
case ABILITYBUTTONTYPE.MOVE:
MoveAbilityButtonExecution moveAbilityBtnExe = new MoveAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnMove = new AbilityButton(btnAbi, moveAbilityBtnExe, null);
btnMove.Suscribe();
actualAbilityButtons.Add(btnMove);
break;
case ABILITYBUTTONTYPE.ATTACK:
AttackAbilityButtonExecution attackAbilityBtnExe = new AttackAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnAttack = new AbilityButton(btnAbi, attackAbilityBtnExe, null);
btnAttack.Suscribe();
actualAbilityButtons.Add(btnAttack);
break;
case ABILITYBUTTONTYPE.DEFEND:
DefenseAbilityButtonExecution defenseAbilityBtnExe = new DefenseAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnDefense = new AbilityButton(btnAbi, defenseAbilityBtnExe, null);
btnDefense.Suscribe();
actualAbilityButtons.Add(btnDefense);
break;
case ABILITYBUTTONTYPE.COMBINE:
break;
case ABILITYBUTTONTYPE.TAKECARD:
TakeCardAbilityButtonExecution takeCardAbilityBtnExe = new TakeCardAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnTakeCard = new AbilityButton(btnAbi, takeCardAbilityBtnExe, null);
btnTakeCard.Suscribe();
actualAbilityButtons.Add(btnTakeCard);
break;
case ABILITYBUTTONTYPE.EVOLVE:
break;
case ABILITYBUTTONTYPE.FUSION:
break;
case ABILITYBUTTONTYPE.SPAWN:
SpawnAbilityButtonExecution spawnAbilityBtnExe = new SpawnAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnSpawn = new AbilityButton(btnAbi, spawnAbilityBtnExe, null);
btnSpawn.Suscribe();
actualAbilityButtons.Add(btnSpawn);
break;
default:
break;
}
}
public void SetTile(Tile selectedTile)
{
if (selectedTile == null)
{
ClearAbilityButtons();
return;
}
IOcuppy actualOccupier = selectedTile.GetOcuppy();
SetUnit(actualOccupier);
}
public override bool IsValidStat(IOcuppy ocuppy)
{
if (base.IsValidStat(ocuppy))
{
ABILITYTYPE abilityType = (ABILITYTYPE)abilityID;
if (ocuppy.Abilities[abilityType].IsModifierApply(modifierID))
{
return(true);
}
}
return(false);
}
public void RemoveOccupierPosition(IOcuppy ocuppier)
{
if (ocuppiersByTile[ocuppier.actualPosition.posX, ocuppier.actualPosition.posY] == ocuppier)
{
ocuppiersByTile[ocuppier.actualPosition.posX, ocuppier.actualPosition.posY] = null;
}
if (occupierPositions.ContainsKey(ocuppier))
{
occupierPositions.Remove(ocuppier);
}
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
IOcuppy occupier = cardTarget.GetOcuppy();
if (occupier == null) return null;
for (int i = 0; i < actionStatus.Count; i++)
{
if (occupier.Abilities[abilityType].actionStatus != actionStatus[i])
{
return null;
}
}
return base.CheckTarget(cardTarget);
}
public int distance; // DISTANCIA QUE SE MOVIO == Vector2.Distance(posInicial, posFinal);
public MoveAbilityEventInfo(IOcuppy moveOccupy, Tile fromTile, Tile endPosition)
{
Position startPosition = new Position(fromTile.position.posX, fromTile.position.posY);
Position finishPosition = new Position(endPosition.position.posX, endPosition.position.posY);
this.moveOccupy = moveOccupy;
this.fromTile = fromTile;
this.endPosition = endPosition;
Vector2 startPost = new Vector2(startPosition.posX, startPosition.posY);
Vector2 endPost = new Vector2(finishPosition.posX, finishPosition.posY);
distance = Mathf.FloorToInt(Vector2.Distance(startPost, endPost));
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
IOcuppy ocuppier = cardTarget.GetOcuppy();
if (ocuppier == null)
{
return(null);
}
if (abilityComparisonIDFiltter.IsValidStat(ocuppier) == false)
{
return(null);
}
return(base.CheckTarget(cardTarget));
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
IOcuppy ocuppier = cardTarget.GetOcuppy();
if (ocuppier == null)
{
return(null);
}
if (statModifierComparisonTypeFiltter.IsValidStatModifierType(ocuppier) == false)
{
return(null);
}
return(base.CheckTarget(cardTarget));
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
IOcuppy ocuppier = cardTarget.GetOcuppy();
if (ocuppier == null)
{
return(null);
}
if (ocuppier.OccupierType != ocuppierType)
{
return(null);
}
return(base.CheckTarget(cardTarget));
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
if (cardTarget.CardTargetType != CARDTARGETTYPE.UNIT || cardTarget.CardTargetType != CARDTARGETTYPE.BASENEXO || cardTarget.CardTargetType != CARDTARGETTYPE.BOARDOBJECT)
{
return null;
}
IOcuppy occupier = cardTarget.GetOcuppy();
if (occupier == null) return null;
rDToCheck.SetOcuppier(occupier);
rDToCheckAgainst.SetOcuppier(occupier);
ResultDataValidator validator = new ResultDataValidator(comparationType, rDToCheck, rDToCheckAgainst);
if (validator.IsValid() == false ) return null;
return base.CheckTarget(cardTarget);
}
public void ClearAbilityButtons()
{
buttonParent.gameObject.SetActive(false);
actualOccupier = null;
if (actualAbilityButtons != null && actualAbilityButtons.Count > 0)
{
for (int i = 0; i < actualAbilityButtons.Count; i++)
{
actualAbilityButtons[i].Unsuscribe();
Destroy(actualAbilityButtons[i].btnAbility.gameObject);
}
actualAbilityButtons.Clear();
}
isCreated = false;
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
//TODO: IsAlly no se setea desde ningun lado, asi que es una chotada
IOcuppy ocuppier = cardTarget.GetOcuppy();
if (ocuppier == null)
{
return(null);
}
if (ocuppier.IsAlly != isAlly)
{
return(null);
}
return(base.CheckTarget(cardTarget));
}
public void SetUnit(IOcuppy actualOccupier)
{
if (actualOccupier == null)
{
ClearAbilityButtons();
return;
}
if (this.actualOccupier == actualOccupier)
{
return;
}
ClearAbilityButtons();
this.actualOccupier = actualOccupier;
buttonParent.gameObject.SetActive(true);
StartCreationOfButtons(actualOccupier);
}
public StatModification(IOcuppy unitToModify, Stat statToModify, int amountToModify, STATMODIFIERTYPE statModifierType, bool notExcedMaxValue = false)
{
this.OcuppyToModify = unitToModify;
this.statToModify = statToModify;
this.statModifierType = statModifierType;
if (statModifierType == STATMODIFIERTYPE.CHANGE)
{
int valorDeseado = amountToModify; //
int valorDeStatActual = this.statToModify.ActualStatValue;
int valorDelStatAAplicar = valorDeseado - valorDeStatActual;
amountToModify = valorDelStatAAplicar;
}
this.amountToModify = amountToModify;
actualModificationID = ModificationID;
ModificationID++;
}
public bool IsValidStatModifierType(IOcuppy ocuppy)
{
foreach (KeyValuePair <STATTYPE, Stat> item in ocuppy.Stats)
{
var Value = item.Value;
if (Value.UnitsModifiersList.Count > 0)
{
for (int i = 0; i < Value.UnitsModifiersList.Count; i++)
{
if (Value.UnitsModifiersList[i].statModifierType == statModifierType)
{
return(true);
}
}
}
}
return(false);
}
public override ICardTarget CheckTarget(ICardTarget cardTarget)
{
if (cardTarget.CardTargetType != CARDTARGETTYPE.BASENEXO)
{
return(null);
}
IOcuppy occupier = cardTarget.GetOcuppy();
if (occupier == null)
{
return(null);
}
Player player = (Player)cardTarget;
if (player == null)
{
return(null);
}
return(base.CheckTarget(cardTarget));
}
