public override void Execute(float d)
{
if (Input.GetMouseButtonDown(0))
{
List <RaycastResult> results = Settings.GetUIObjs();
foreach (RaycastResult r in results)
{
CardInstance inst = r.gameObject.GetComponentInParent <CardInstance>();
PlayerHolder p = Settings.gameManager.currentPlayer;
if (!p.downCards.Contains(inst))
{
return;
}
MultiplayerManager.singleton.PlayerWantsToUseCard(inst.viz.card.instID, p.photonId, MultiplayerManager.CardOpertation.setCardForBattle);
//if ( inst.CanAttack())
//{
// p.attackingCards.Add(inst);
// p.currentHolder.SetCardsOnBatlleLine(inst);
//}
}
}
}
public void PlayerPicksCardFromDeck(PlayerHolder playerHolder)
{
NetworkPrint p = GetPlayer(playerHolder.photonId);
Card c = p.deckCards[0];
p.deckCards.RemoveAt(0);
PlayerWantsToUseCard(c.instID, p.photonID, CardOpertation.pickCardFromDeck);
}
public void LoadPlayerOnActive(PlayerHolder p)
{
PlayerHolder prevPlayer = playerOneHolder.playerHolder;
if (prevPlayer != p)
{
LoadPlayerOnHolder(prevPlayer, otherPlayersHolder, statsUIs[1]);
}
LoadPlayerOnHolder(p, playerOneHolder, statsUIs[0]);
}
public PlayerHolder GetEnemyOf(PlayerHolder p)
{
for (int i = 0; i < all_Players.Length; i++)
{
if (all_Players[i] != p)
{
return(all_Players[i]);
}
}
return(null);
}
public override bool IsValid()
{
GameManager gm = GameManager.singleton;
PlayerHolder p = gm.currentPlayer;
int count = p.downCards.Count;
for (int i = 0; i < p.downCards.Count; i++)
{
if (p.downCards[i].isFlatfooted)
{
count--;
}
}
return(count > 0);
}
public override void OnStartPhase()
{
forceExit = true;
return;
GameManager gm = Settings.gameManager;
gm.SetState(playerControlState);
gm.onPhaseCompleted.Raise();
PlayerHolder e = gm.GetEnemyOf(gm.currentPlayer);
if (e.attackingCards.Count == 0)
{
forceExit = true;
return;
}
}
public void LoadPlayer(PlayerHolder p, PlayerStatsUI statsUI)
{
if (p == null)
{
return;
}
playerHolder = p;
p.currentHolder = this;
foreach (CardInstance c in p.downCards)
{
if (!p.attackingCards.Contains(c))
{
Settings.SetParentForCard(c.viz.gameObject.transform, downGrid.value.transform);
}
}
foreach (CardInstance c in p.handCards)
{
if (c.viz != null)
{
Settings.SetParentForCard(c.viz.gameObject.transform, handGrid.value.transform);
}
}
foreach (ResourceHolder c in p.resourcesList)
{
Settings.SetParentForCard(c.cardObj.transform, resourcesGrid.value.transform);
}
foreach (CardInstance c in p.attackingCards)
{
SetCardsOnBatlleLine(c);
}
p.statsUI = statsUI;
p.LoadPlayerOnStatsUI();
}
public override void Execute(PlayerHolder player)
{
MultiplayerManager.singleton.PlayerWantsToResetResourcesCards(player.photonId);
MultiplayerManager.singleton.PlayerWantsToResetFlatfootedCards(player.photonId);
}
public override void Execute(PlayerHolder player)
{
GameManager.singleton.PickNewCardFromDeck(player);
}
void BattleResolveForPlayers()
{
PlayerHolder player = Settings.gameManager.currentPlayer;
PlayerHolder enemy = Settings.gameManager.GetEnemyOf(player);
if (enemy.attackingCards.Count == 0)
{
photonView.RPC("RPC_BattleResolveCallback", PhotonTargets.All, enemy.photonId);
// photonView.RPC("RPC_PlayerEndsPhase", PhotonTargets.All, player.photonId);
return;
}
Dictionary <CardInstance, BlockInstance> blockDict = Settings.gameManager.GetBlockInstances();
for (int i = 0; i < enemy.attackingCards.Count; i++)
{
CardInstance inst = enemy.attackingCards[i];
Card c = inst.viz.card;
CardProperties attack = c.GetProperty(dataHolder.attackElement);
if (attack == null)
{
Debug.LogError("You are attacking with a card that can't attack");
continue;
}
int damageValue = attack.intValue;
BlockInstance bi = GetBlockInstanceOfAttacker(inst, gm.GetBlockInstances());
if (bi != null)
{
for (int b = 0; b < bi.blocker.Count; b++)
{
CardProperties def = c.GetProperty(gm.defenceProperty);
if (def == null)
{
Debug.LogWarning("You are trying to block with a card with no defense element!");
continue;
}
damageValue -= def.intValue;
if (def.intValue <= damageValue)
{
bi.blocker[b].CardInstanceToGraveyard();
}
}
}
if (damageValue <= 0)
{
damageValue = 0;
PlayerWantsToUseCard(inst.viz.card.instID, enemy.photonId, CardOpertation.cardToGraveyard);
}
enemy.DropCard(inst, false);
player.DoDamage(damageValue);
photonView.RPC("RPC_SyncPlayerHealth", PhotonTargets.All, player.photonId, player.health);
}
photonView.RPC("RPC_BattleResolveCallback", PhotonTargets.All, enemy.photonId);
//photonView.RPC("RPC_PlayerEndsPhase", PhotonTargets.All, player.photonId);
return;
}
public override void Execute(PlayerHolder player)
{
GameManager.singleton.LoadPlayerOnActive(player);
}
public abstract void Execute(PlayerHolder player);
public void LoadPlayerOnHolder(PlayerHolder p, CardHolders h, PlayerStatsUI ui)
{
h.LoadPlayer(p, ui);
}
public void PickNewCardFromDeck(PlayerHolder p)
{
MultiplayerManager.singleton.PlayerPicksCardFromDeck(p);
}
