/*****************ISelectionnable*****************/
public override void onClick()
{
Joueur joueurLocal = JoueurUtils.getJoueurLocal();
if (null != joueurLocal)
{
TourJeuSystem systemTour = TourJeuSystem.getTourSystem();
//Si un joueur clique sur une carte capable d'attaquer puis sur une carte ennemie cela lance une attaque
EventTask eventTask = EventTaskUtils.getEventTaskEnCours();
if (systemTour.getPhase(joueurLocal.netId) == TourJeuSystem.PHASE_ATTAQUE &&
null != joueurLocal.CarteSelectionne && joueurLocal.CarteSelectionne.JoueurProprietaire != JoueurProprietaire &&
joueurLocal.CarteSelectionne is IAttaquer && ((IAttaquer)joueurLocal.CarteSelectionne).isCapableAttaquer() &&
!(null != eventTask && eventTask is EventTaskChoixCible)) //On ne peut attaquer si choix de defense en cours
//TODO vérifier l'emplacement sol
{
JoueurUtils.getJoueurLocal().CmdCreateTask(joueurLocal.CarteSelectionne.netId, joueurLocal.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_ATTAQUE, NetworkInstanceId.Invalid, false);
}
else
{
base.onClick();
}
}
else
{
base.onClick();
}
}
public void deplacerCarte(IConteneurCarte nouveauEmplacement, NetworkInstanceId netIdNouveauPossesseur, NetworkInstanceId netIdTaskEvent)
{
//TODO que faire pour deplacement vers la mains
if (isDeplacable())
{
if (nouveauEmplacement is EmplacementMetierAbstract)
{
((EmplacementMetierAbstract)nouveauEmplacement).putCard(this, this.getConteneur() is Mains, netIdTaskEvent);
}
else if (nouveauEmplacement is ISelectionnable)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(this.netId, this.idJoueurProprietaire, ((ISelectionnable)nouveauEmplacement).IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_STANDART, NetworkInstanceId.Invalid, false);
}
else if (!isServer)
{
//TODO bon comportement si emplacement pa sselectionnable?
nouveauEmplacement.putCard(this);
}
if (netIdNouveauPossesseur != NetworkInstanceId.Invalid && netIdNouveauPossesseur != idJoueurProprietaire)
{
this.idJoueurProprietaire = netIdNouveauPossesseur;
}
}
}
public override void onClick()
{
Joueur joueurLocal = JoueurUtils.getJoueurLocal();
//Selection de la defense lors de la phase attaque adverse
if (SelectionnableDefense && null != joueurLocal)
{
TourJeuSystem systemTour = TourJeuSystem.getTourSystem();
if (systemTour.getPhase() == TourJeuSystem.PHASE_ATTAQUE &&
systemTour.getPhase(joueurLocal.netId) == TourJeuSystem.EN_ATTENTE)
{
defenseSelectionne = true;
defenduCeTour = true;
}
else
{
base.onClick();
}
}
else
{
base.onClick();
}
}
public void RpcSetEtatSelectionPlayer(NetworkInstanceId netIdPlayer, int etat)
{
if (netIdPlayer == NetworkInstanceId.Invalid || JoueurUtils.getJoueurLocal().netId == netIdPlayer)
{
EtatSelectionnable = etat;
}
}
public void sacrificeCarte()
{
CartePlaneteMetier cartePlanete = CartePlaneteMetier.getPlaneteEnnemie(idJoueurProprietaire);
//TODO point de degat ou cout carte?
cartePlanete.recevoirDegat(getPointDegat(), this, NetworkInstanceId.Invalid);
JoueurUtils.getJoueurLocal().CmdCreateTask(this.netId, this.idJoueurProprietaire, cartePlanete.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DESTRUCTION_CARTE, NetworkInstanceId.Invalid, false); //TODO idEventTask provenance?
}
/***********************IVulnerable*****************/
//Retourne PV restant
public void recevoirAttaque(CarteMetierAbstract sourceDegat, NetworkInstanceId netdTaskEvent, bool attaqueSimultane)
{
bool invulnerable = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_ETAT_INVULNERABLE);
if (!invulnerable) //TODO calcul degat
{
JoueurUtils.getJoueurLocal().CmdCreateTask(this.netId, this.idJoueurProprietaire, sourceDegat.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT, netdTaskEvent, attaqueSimultane);
}
}
/*************************Methode IDefendre********************/
public void preDefense(CarteVaisseauMetier vaisseauAttaquant, NetworkInstanceId netIdTaskEvent)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(vaisseauAttaquant.netId, vaisseauAttaquant.idJoueurProprietaire, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT, netIdTaskEvent, false);
defenduCeTour = true;
if (!isCapableDefendre())
{
this.JoueurProprietaire.CarteSelectionne = null;
this.EtatSelectionnable = SelectionnableUtils.ETAT_NON_SELECTION;
}
}
public void Start()
{
if (isServer)
{
idSelectionnable = ++SelectionnableUtils.sequenceSelectionnable;
RpcInitIdSelectionnable(idSelectionnable);
}
else if (null == idSelectionnable || idSelectionnable <= 0)
{
JoueurUtils.getJoueurLocal().CmdSyncIdSelectionnableCarte(netId);
}
}
public int recevoirDegat(int nbDegat, CarteMetierAbstract sourceDegat, NetworkInstanceId netIdEventTask)
{
if (null != sourceDegat && (!(sourceDegat is CarteConstructionMetierAbstract) || ((CarteConstructionMetierAbstract)sourceDegat).OnBoard))
{
pointVie -= nbDegat;
if (pointVie <= 0)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(this.netId, this.idJoueurProprietaire, sourceDegat.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DESTRUCTION_CARTE, netIdEventTask, false);
}
}
return(pointVie);
}
//Retourne PV restant
public int recevoirDegat(int nbDegat, CarteMetierAbstract sourceDegat, NetworkInstanceId netdTaskEvent)
{
bool invulnerable = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_ETAT_INVULNERABLE);
if (!invulnerable && nbDegat > 0)
{
PV -= nbDegat;
if (PV <= 0)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(this.netId, this.idJoueurProprietaire, sourceDegat.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DESTRUCTION_CARTE, netdTaskEvent, false);
}
}
return(PV);
}
public void putCard(CarteMetierAbstract cartePoser, bool isNewCard, NetworkInstanceId netIdTaskEvent)
{
//Si c'est une nouvelle carte, on lance les capacités pour les cartes posées
if (isNewCard)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(cartePoser.netId, cartePoser.JoueurProprietaire.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_POSE_CONSTRUCTION, netIdTaskEvent, false);
}
else if (this is EmplacementAttaque)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(cartePoser.netId, cartePoser.JoueurProprietaire.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_LIGNE_ATTAQUE, netIdTaskEvent, false);
}
else
{
JoueurUtils.getJoueurLocal().CmdCreateTask(cartePoser.netId, cartePoser.JoueurProprietaire.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_STANDART, netIdTaskEvent, false);
}
}
/***************************Methode IAttaquer*************************/
public void attaqueCarte(CarteConstructionMetierAbstract cible, NetworkInstanceId netIdEventTask)
{
bool attaqueReoriente = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_REORIENTE_ATTAQUE);
bool attaqueEvite = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_EVITE_ATTAQUE);
if (!attaqueEvite)
{
if (attaqueReoriente && netIdEventTask == NetworkInstanceId.Invalid) //Si netIdEventTask est invalid alors ce n'est pas une action appeler diretement mais une action rappelé par
{
List <CarteMetierAbstract> listCartes = CarteUtils.getListCarteCibleReorientation(this, cible);
CarteMetierAbstract cibleReoriente = listCartes [Random.Range(0, listCartes.Count)];
if (cibleReoriente is CartePlaneteMetier)
{
attaquePlanete((CartePlaneteMetier)cibleReoriente, netIdEventTask);
}
else if (cibleReoriente is CarteConstructionMetierAbstract)
{
cible = (CarteConstructionMetierAbstract)cibleReoriente;
}
}
if (cible is IDefendre)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(cible.netId, JoueurProprietaire.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DEFEND, netIdEventTask, false);
AttaqueCeTour = true;
}
else if (cible is IVulnerable)
{
((IVulnerable)cible).recevoirAttaque(this, netIdEventTask, false);
AttaqueCeTour = true;
}
}
else
{
//TODO anim evite
}
if (!isCapableAttaquer())
{
this.JoueurProprietaire.CarteSelectionne = null;
}
}
public void attaquePlanete(CartePlaneteMetier cible, NetworkInstanceId netIdTaskEvent)
{
//TODO
bool modeFurtif = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_ETAT_FURTIF);
//Mode furtif permet d'attaquer sans déclancher de réponse
if (modeFurtif)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(cible.netId, JoueurProprietaire.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT, netIdTaskEvent, false);
}
else
{
JoueurUtils.getJoueurLocal().CmdCreateTask(cible.netId, JoueurProprietaire.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_DEFEND, netIdTaskEvent, false);
}
AttaqueCeTour = true;
if (!isCapableAttaquer())
{
this.JoueurProprietaire.CarteSelectionne = null;
}
}
private void RpcDisplayCapacityChoice()
{
if (null != JoueurUtils.getJoueurLocal() && JoueurUtils.getJoueurLocal().netId == joueur)
{
List <ISelectionnable> listCibleSelectionnable = new List <ISelectionnable> ();
foreach (int idCible in selectionCibles.ListIdCiblesProbables)
{
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idCible);
if (null != cible)
{
cible.EtatSelectionnable = SelectionnableUtils.ETAT_SELECTIONNABLE;
listCibleSelectionnable.Add(cible);
}
}
StartCoroutine(phaseChoixCible(listCibleSelectionnable));
}
else
{
StartCoroutine(waitOtherPlayer());
}
}
/****************** IVulnerable **********************/
public void recevoirAttaque(CarteMetierAbstract sourceDegat, NetworkInstanceId netIdEventTask, bool attaqueSimultane)
{
JoueurUtils.getJoueurLocal().CmdCreateTask(this.netId, this.idJoueurProprietaire, sourceDegat.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT, netIdEventTask, attaqueSimultane);
}
public void RpcRemiseEnPlaceCarte(NetworkInstanceId netIdJoueur)
{
if (JoueurUtils.getJoueurLocal().netId == netIdJoueur)
{
List <CarteMetierAbstract> listCarteJoueur = CarteUtils.getListCarteJoueur(netIdJoueur);
foreach (CarteMetierAbstract carteJoueur in listCarteJoueur)
{
if (carteJoueur is IAttaquer)
{
((IAttaquer)carteJoueur).AttaqueCeTour = false;
}
if (carteJoueur is IDefendre)
{
((IDefendre)carteJoueur).reinitDefenseSelectTour();
}
}
List <EmplacementAttaque> listEmplacementAttaqueOccuper = EmplacementUtils.getListEmplacementOccuperJoueur <EmplacementAttaque> (netIdJoueur);
if (listEmplacementAttaqueOccuper.Count > 0)
{
List <EmplacementAtomsphereMetier> listEmplacementAtmosJoueurLibre = EmplacementUtils.getListEmplacementLibreJoueur <EmplacementAtomsphereMetier> (netIdJoueur);
//On essaye d'abord de replacer les vaisseaux au bonne endroit
if (listEmplacementAtmosJoueurLibre.Count > 0)
{
List <EmplacementAttaque> listEmplacementAttaqueToujoursOccuper = new List <EmplacementAttaque> (listEmplacementAttaqueOccuper);
List <EmplacementAtomsphereMetier> listEmplacementAtmosToujoursLibre = new List <EmplacementAtomsphereMetier> (listEmplacementAtmosJoueurLibre);
foreach (EmplacementAttaque emplacementAttaqueJoueur in listEmplacementAttaqueOccuper)
{
foreach (EmplacementAtomsphereMetier emplacementAtmosJoueur in listEmplacementAtmosJoueurLibre)
{
if (emplacementAttaqueJoueur.NumColonne == emplacementAtmosJoueur.NumColonne)
{
CarteConstructionMetierAbstract carteADeplacer = emplacementAttaqueJoueur.gameObject.GetComponentInChildren <CarteConstructionMetierAbstract> ();
emplacementAtmosJoueur.putCard(carteADeplacer);
listEmplacementAttaqueToujoursOccuper.Remove(emplacementAttaqueJoueur);
listEmplacementAtmosToujoursLibre.Remove(emplacementAtmosJoueur);
break;
}
}
}
listEmplacementAttaqueToujoursOccuper.Sort((p1, p2) => p1.NumColonne.CompareTo(p2.NumColonne));
listEmplacementAtmosToujoursLibre.Sort((p1, p2) => p1.NumColonne.CompareTo(p2.NumColonne));
while (0 < listEmplacementAttaqueToujoursOccuper.Count && 0 < listEmplacementAtmosToujoursLibre.Count)
{
CarteConstructionMetierAbstract carteADeplacer = listEmplacementAttaqueToujoursOccuper [0].gameObject.GetComponentInChildren <CarteConstructionMetierAbstract> ();
listEmplacementAtmosToujoursLibre [0].putCard(carteADeplacer);
listEmplacementAttaqueToujoursOccuper.RemoveAt(0);
listEmplacementAtmosToujoursLibre.RemoveAt(0);
}
if (listEmplacementAttaqueToujoursOccuper.Count > 0)
{
foreach (EmplacementAttaque emplacementAVider in listEmplacementAttaqueToujoursOccuper)
{
CarteConstructionMetierAbstract carteADeplacer = emplacementAVider.gameObject.GetComponentInChildren <CarteConstructionMetierAbstract> ();
if (carteADeplacer is CarteVaisseauMetier)
{
((CarteVaisseauMetier)carteADeplacer).sacrificeCarte();
}
else
{
//TODO
}
}
}
//On fait de même avec les emplacement de sol
if (listEmplacementAtmosToujoursLibre.Count > 0)
{
List <EmplacementSolMetier> listEmplacementSolJoueur = EmplacementUtils.getListEmplacementOccuperJoueur <EmplacementSolMetier> (netIdJoueur);
List <EmplacementSolMetier> listEmplacementSolAvecCarteVaisseau = new List <EmplacementSolMetier> (listEmplacementSolJoueur);
List <EmplacementAtomsphereMetier> listEmplacementAtmosToujoursLibre2 = new List <EmplacementAtomsphereMetier> (listEmplacementAtmosJoueurLibre);
foreach (EmplacementSolMetier emplacementSolJoueur in listEmplacementSolJoueur)
{
foreach (EmplacementAtomsphereMetier emplacementAtmosJoueur in listEmplacementAtmosJoueurLibre)
{
if (emplacementSolJoueur.NumColonne == emplacementAtmosJoueur.NumColonne)
{
CarteConstructionMetierAbstract carteADeplacer = emplacementSolJoueur.gameObject.GetComponentInChildren <CarteConstructionMetierAbstract> ();
if (null != carteADeplacer && carteADeplacer is CarteVaisseauMetier)
{
emplacementAtmosJoueur.putCard(carteADeplacer);
listEmplacementSolAvecCarteVaisseau.Remove(emplacementSolJoueur);
listEmplacementAtmosToujoursLibre2.Remove(emplacementAtmosJoueur);
}
else
{
listEmplacementSolAvecCarteVaisseau.Remove(emplacementSolJoueur);
}
break;
}
}
}
listEmplacementSolAvecCarteVaisseau.Sort((p1, p2) => p1.NumColonne.CompareTo(p2.NumColonne));
listEmplacementAtmosToujoursLibre.Sort((p1, p2) => p1.NumColonne.CompareTo(p2.NumColonne));
while (0 < listEmplacementSolAvecCarteVaisseau.Count && 0 < listEmplacementAtmosToujoursLibre.Count)
{
CarteConstructionMetierAbstract carteADeplacer = listEmplacementSolAvecCarteVaisseau [0].gameObject.GetComponentInChildren <CarteConstructionMetierAbstract> ();
listEmplacementAtmosToujoursLibre [0].putCard(carteADeplacer);
listEmplacementSolAvecCarteVaisseau.RemoveAt(0);
listEmplacementAtmosToujoursLibre.RemoveAt(0);
}
}
}
}
}
}
