/**
* carteCibleCapacite : Carte vers laquelle la capacite va aller
* capaciteImmediate : capacite applicable immediatement
* carteOrigine : carte d'ou provient la capacite
* carteCibleAction : carte cibler lors de l'appel de l'event
* */
private static void traitementCapaciteImmediateCarte(CarteMetierAbstract carteCibleCapacite, CapaciteDTO capaciteReference, Joueur joueur, NetworkInstanceId netIdTaskEvent)
{
if (capaciteReference.Capacite == ConstanteIdObjet.ID_CAPACITE_MODIF_EMPLACEMENT_CARTE)
{
//TODO
}
else if (capaciteReference.Capacite == ConstanteIdObjet.ID_CAPACITE_VOLE_CARTE)
{
//TODO Definir le conteneur mains, deck, emplacement
carteCibleCapacite.deplacerCarte(joueur.Main, joueur.netId, netIdTaskEvent);
}
else if (capaciteReference.Capacite == ConstanteIdObjet.ID_CAPACITE_DESTRUCTION_CARTE)
{
//TODO que faire si pas IVulnerable?
if (carteCibleCapacite is IVulnerable)
{
((IVulnerable)carteCibleCapacite).destruction(netIdTaskEvent);
}
}
else if (capaciteReference.Capacite == ConstanteIdObjet.ID_CAPACITE_INVOQUE_CARTE && null != capaciteReference.CarteInvocation)
{
GameObject carteGO = CarteUtils.convertCarteDTOToGameobject(capaciteReference.CarteInvocation, true);
//TODO ne prends pas en compte l'emplacement cible ou l invocation chez l ennemie
CarteUtils.invoquerCarteServer(carteGO, capaciteReference.NiveauInvocation, joueur.Main, joueur);
}
else if (capaciteReference.Capacite == ConstanteIdObjet.ID_CAPACITE_REVELE_CARTE)
{
//TODO RPC carteCibleCapacite.generateVisualCard ();
}
}
private GameObject convertDataToGO(CarteConstructionAbstractData carteConstructionData, bool isServer)
{
CarteConstructionDTO carteDTO = ConvertDataAndDTOUtils.convertCarteConstructionDataToDTO(carteConstructionData);
GameObject carteConstructionGO = CarteUtils.convertCarteDTOToGameobject(carteDTO, isServer);
carteConstructionGO.SetActive(false);
return(carteConstructionGO);
}
public IConteneurCarte getConteneur()
{
if (CarteUtils.checkCarteActive(this))
{
return(transform.GetComponentInParent <IConteneurCarte> ());
}
else
{
return(null);
}
}
public void usePoseConstructionCapacity(NetworkInstanceId netIdJoueur, CarteMetierAbstract carteSourceAction, ISelectionnable cible, NetworkInstanceId netIdTaskEvent)
{
if (CarteUtils.checkCarteActive(this) &&
(this.getConteneur() is EmplacementMetierAbstract || carteSourceAction.netId == this.netId))
{
List <CapaciteDTO> capacitePoseConstruction = getListCapaciteToCall(netIdJoueur, carteSourceAction.netId, ConstanteIdObjet.ID_CONDITION_ACTION_POSE_CONSTRUCTION);
foreach (CapaciteDTO capacite in capacitePoseConstruction)
{
CapaciteUtils.callCapacite(this, carteSourceAction, cible, capacite, netIdJoueur, ConstanteIdObjet.ID_CONDITION_ACTION_POSE_CONSTRUCTION, netIdTaskEvent);
}
}
}
public void defenseSimultanee(CarteVaisseauMetier vaisseauAttaquant, NetworkInstanceId netIdTaskEvent)
{
bool attaqueEvite = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_EVITE_ATTAQUE);
if (!attaqueEvite)
{
bool attaqueReoriente = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_REORIENTE_ATTAQUE);
if (attaqueReoriente)
{
List <CarteMetierAbstract> listCartes = CarteUtils.getListCarteCibleReorientation(vaisseauAttaquant, this);
CarteMetierAbstract cible = listCartes [Random.Range(0, listCartes.Count)];
if (cible is CarteConstructionMetierAbstract)
{
vaisseauAttaquant.attaqueCarte((CarteConstructionMetierAbstract)cible, netIdTaskEvent);
}
else if (cible is CartePlaneteMetier)
{
vaisseauAttaquant.attaquePlanete((CartePlaneteMetier)cible, netIdTaskEvent);
}
}
else
{
bool attaquePriorite = 0 < CapaciteUtils.valeurAvecCapacite(0, listEffetCapacite, ConstanteIdObjet.ID_CAPACITE_ATTAQUE_OPPORTUNITE);
int degatInfliger = getPointDegat();
int degatRecu = vaisseauAttaquant.getPointDegat();
if (attaquePriorite)
{
this.recevoirAttaque(vaisseauAttaquant, netIdTaskEvent, false);
if (this.PV > 0)
{
vaisseauAttaquant.recevoirAttaque(this, netIdTaskEvent, false);
}
}
else
{
vaisseauAttaquant.recevoirAttaque(this, netIdTaskEvent, true);
this.recevoirAttaque(vaisseauAttaquant, netIdTaskEvent, true);
}
}
}
}
/***************************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 CmdChangeParent(NetworkInstanceId netIdParent, string pathParent)
{
NetworkBehaviour scriptParent = ConvertUtils.convertNetIdToScript <NetworkBehaviour> (netIdParent, false);
Transform trfParent;
if (null != scriptParent && null != pathParent)
{
trfParent = scriptParent.transform.Find(pathParent);
}
else
{
trfParent = null;
}
transform.parent = trfParent;
//transform.localScale = Vector3.one;
transform.localScale = Vector3.Scale(ConstanteInGame.tailleCarte, CarteUtils.inverseVector(CarteUtils.getParentScale(transform)));
RpcChangeParentOtherClient(netIdParent, pathParent);
}
public void progressStepServer(int actionPlayer)
{
if (isServer)
{
if (actionPlayer == PHASE_ATTAQUE)
{
phase = PHASE_ATTAQUE;
GameObject goBtnLastPlayer = NetworkServer.FindLocalObject(listJoueurs [indexPlayerPlaying].netIdBtnTour);
if (null != goBtnLastPlayer && null != goBtnLastPlayer.GetComponent <BoutonTour> ())
{
BoutonTour boutonTour = goBtnLastPlayer.GetComponent <BoutonTour> ();
boutonTour.setEtatBoutonServer(BoutonTour.enumEtatBouton.terminerTour);
}
List <CarteConstructionMetierAbstract> listAttaquant = CarteUtils.getListCarteCapableAttaque(listJoueurs [indexPlayerPlaying].netIdJoueur);
foreach (CarteConstructionMetierAbstract attaquant in listAttaquant)
{
attaquant.RpcSetEtatSelectionPlayer(listJoueurs [indexPlayerPlaying].netIdJoueur, SelectionnableUtils.ETAT_HIGH_LIGHT);
}
}
else if (actionPlayer == FIN_TOUR)
{
Joueur joueurTour = JoueurUtils.getJoueur(listJoueurs [indexPlayerPlaying].netIdJoueur);
int phasePrecedente = phase;
phase = FIN_TOUR;
if (phasePrecedente == PHASE_ATTAQUE)
{
ActionEventManager.EventActionManager.CreateTask(NetworkInstanceId.Invalid, joueurTour.netId, -1, ConstanteIdObjet.ID_CONDITION_ACTION_FIN_ATTAQUE, NetworkInstanceId.Invalid, false);
}
else
{
ActionEventManager.EventActionManager.CreateTask(NetworkInstanceId.Invalid, joueurTour.netId, -1, ConstanteIdObjet.ID_CONDITION_ACTION_FIN_TOUR, NetworkInstanceId.Invalid, false);
}
}
}
}
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);
}
}
}
}
}
}
public static void launchEventAction(int idActionEvent, NetworkInstanceId netIdSourceAction, NetworkInstanceId netIdJoueurSourceAction, int idSelectionCible, NetworkInstanceId netIdEventTask)
{
NetworkBehaviour scriptSource = ConvertUtils.convertNetIdToScript <NetworkBehaviour> (netIdSourceAction, false);
//TODO remplacer les -1
if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_PIOCHE_CONSTRUCTION)
{
if (scriptSource is CarteConstructionMetierAbstract)
{
((CarteConstructionMetierAbstract)scriptSource).CmdPiocheCard(netIdJoueurSourceAction);
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_PIOCHE_AMELIORATION)
{
//TODO
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_POSE_CONSTRUCTION ||
idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_POSE_AMELIORATION ||
idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_STANDART ||
idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_LIGNE_ATTAQUE)
{
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idSelectionCible);
if (null != cible && cible is IConteneurCarte && scriptSource is CarteConstructionMetierAbstract)
{
if (((CarteConstructionMetierAbstract)scriptSource).isDeplacable())
{
EmplacementUtils.putCardFromServer((IConteneurCarte)cible, (CarteConstructionMetierAbstract)scriptSource);
}
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_DEBUT_TOUR)
{
Joueur joueur = ConvertUtils.convertNetIdToScript <Joueur> (netIdJoueurSourceAction, false);
if (null != joueur)
{
TourJeuSystem.getTourSystem().debutTour(joueur);
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_FIN_TOUR)
{
Joueur joueur = ConvertUtils.convertNetIdToScript <Joueur> (netIdJoueurSourceAction, false);
if (null != joueur)
{
TourJeuSystem.getTourSystem().finTour(joueur);
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_ATTAQUE && scriptSource is IAttaquer)
{
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idSelectionCible);
if (null != cible && cible is CarteConstructionMetierAbstract)
{
((IAttaquer)scriptSource).attaqueCarte((CarteConstructionMetierAbstract)cible, netIdEventTask);
}
else if (null != cible && cible is CartePlaneteMetier)
{
((IAttaquer)scriptSource).attaquePlanete((CartePlaneteMetier)cible, netIdEventTask);
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_DEFEND && scriptSource is CarteMetierAbstract)
{
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idSelectionCible);
if (null != cible && cible is CarteVaisseauMetier && scriptSource is IDefendre)
{
((IDefendre)scriptSource).defenseSimultanee((CarteVaisseauMetier)cible, netIdEventTask);
}
else if (scriptSource is CartePlaneteMetier)
{
List <CarteConstructionMetierAbstract> listDefenseur = CarteUtils.getListCarteCapableDefendrePlanete(((CartePlaneteMetier)scriptSource).JoueurProprietaire);
if (null != listDefenseur && listDefenseur.Count > 0)
{
SelectionCiblesExecutionCapacite selectionCible = new SelectionCiblesExecutionCapacite(1, (CartePlaneteMetier)scriptSource, idActionEvent);
foreach (CarteConstructionMetierAbstract defenseur in listDefenseur)
{
selectionCible.ListIdCiblesProbables.Add(defenseur.IdISelectionnable);
}
ActionEventManager.EventActionManager.createTaskChooseTarget(selectionCible, scriptSource.netId, ((CartePlaneteMetier)scriptSource).JoueurProprietaire.netId, cible.IdISelectionnable, idActionEvent, netIdEventTask);
}
ActionEventManager.EventActionManager.CreateTask(scriptSource.netId, ((CartePlaneteMetier)scriptSource).JoueurProprietaire.netId, cible.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT, netIdEventTask, false);
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_UTILISE)
{
//TODO
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_DESTRUCTION_CARTE && scriptSource is IVulnerable)
{
((IVulnerable)scriptSource).destruction(netIdEventTask);
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_FIN_ATTAQUE)
{
ActionEventManager.EventActionManager.CreateTask(NetworkInstanceId.Invalid, netIdJoueurSourceAction, -1, ConstanteIdObjet.ID_CONDITION_ACTION_FIN_TOUR, NetworkInstanceId.Invalid, false);
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_GAIN_XP)
{
//TODO
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_INVOCATION)
{
//TODO
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT && scriptSource is IVulnerable)
{
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idSelectionCible);
if (null != cible && cible is CarteVaisseauMetier)
{
((IVulnerable)scriptSource).recevoirDegat(((CarteVaisseauMetier)cible).getPointDegat(), (CarteVaisseauMetier)cible, netIdEventTask);
}
else if (null != cible && cible is CarteDefenseMetier)
{
((IVulnerable)scriptSource).recevoirDegat(((CarteDefenseMetier)cible).getPointDegat(), (CarteDefenseMetier)cible, netIdEventTask);
}
else
{
aucuneActionEffectuer();
}
}
else if (idActionEvent == ConstanteIdObjet.ID_CONDITION_ACTION_EVOLUTION_CARTE)
{
//TODO
}
else
{
aucuneActionEffectuer();
}
}
