/*****************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 putCard(CarteMetierAbstract carteAdded)
{
//CarteMetierAbstract carteAdded = ConvertUtils.convertNetIdToScript<CarteMetierAbstract> (netIdcarteAdded, true);
if (null != carteAdded && null != carteAdded.JoueurProprietaire && carteAdded.JoueurProprietaire.isLocalPlayer)
{
carteEnMains.Add(carteAdded);
carteAdded.transform.parent = transform;
carteAdded.CmdChangeParent(netIdJoueurPossesseur, JoueurUtils.getPathJoueur(this));
int nbCarteEnMains = transform.childCount;
Vector3 position = Vector3.zero;
if (carteAdded is CarteConstructionMetierAbstract)
{
//On ajoute a gauche
position.x = (nbCarteEnMains - .5f) /* * carteAdded.transform.localScale.x*/;
}
else if (carteAdded is CarteMetierAbstract)
{
//TODO nbCarte ne doit compter separement les ameliration et les construction
position.x = -(nbCarteEnMains - .5f) /* * carteAdded.transform.localScale.x*/;
}
carteAdded.transform.localPosition = position;
carteAdded.transform.Rotate(new Vector3(-60, 0) + transform.rotation.eulerAngles);
}
}
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 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 void RpcSetEtatSelectionPlayer(NetworkInstanceId netIdPlayer, int etat)
{
if (netIdPlayer == NetworkInstanceId.Invalid || JoueurUtils.getJoueurLocal().netId == netIdPlayer)
{
EtatSelectionnable = etat;
}
}
/**
* Appeler sur server
* */
private void addJoueur(JoueurMinimalDTO joueurToAdd)
{
if (isServer)
{
if (null == listJoueurs)
{
listJoueurs = new List <JoueurMinimalDTO> ();
}
listJoueurs.Add(joueurToAdd);
//TODO chercher mode pour nb joueur
if ((listJoueurs.Count >= 2 || tester) && !gameBegin)
{
gameBegin = true;
//Remplissage de la main initial
foreach (JoueurMinimalDTO joueurDTO in listJoueurs)
{
Joueur joueur = JoueurUtils.getJoueur(joueurDTO.netIdJoueur);
if (null != joueur)
{
joueur.DeckConstruction.piocheDeckConstructionByServer();
joueur.DeckConstruction.piocheDeckConstructionByServer();
}
}
chooseFirstPlayer();
}
}
}
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?
}
public static void executeCapacity(SelectionCiblesExecutionCapacite selectionCiblesResult, NetworkInstanceId netIdTaskEvent)
{
Joueur joueurSource = JoueurUtils.getJoueur(selectionCiblesResult.IdJoueurCarteSource);
CapaciteDTO capacite;
if (ActionEventManager.capacityInUse.TryGetValue(selectionCiblesResult.IdCapaciteSource, out capacite))
{
foreach (int idCible in selectionCiblesResult.ListIdCiblesProbables)
{
ISelectionnable cibleSelectionne = SelectionnableUtils.getSelectiobleById(idCible);
if (listIdCapaciteEffetImmediat.Contains(selectionCiblesResult.IdTypeCapacite))
{
if (cibleSelectionne is CarteMetierAbstract)
{
traitementCapaciteImmediateCarte((CarteMetierAbstract)cibleSelectionne, capacite, joueurSource, netIdTaskEvent);
}
else
{
//TODO traitement capacite immediate autre
}
}
else if (null != selectionCiblesResult.ListIdRessouceCible && cibleSelectionne is IAvecCapacite)
{
List <RessourceMetier> listRessouceCible = new List <RessourceMetier> ();
foreach (int idRessourceCible in selectionCiblesResult.ListIdRessouceCible)
{
ISelectionnable ressourceCible = SelectionnableUtils.getSelectiobleById(idRessourceCible);
if (null != ressourceCible && ressourceCible is RessourceMetier)
{
listRessouceCible.Add((RessourceMetier)ressourceCible);
}
}
//TODO faire le trie ressource ou non
traitementCapaciteRessource(capacite, listRessouceCible, (IAvecCapacite)cibleSelectionne, joueurSource, selectionCiblesResult.IdCarteSource);
foreach (RessourceMetier ressourceCible in listRessouceCible)
{
ressourceCible.synchroniseListCapacite();
}
}
else if (cibleSelectionne is IAvecCapacite)
{
//TODO faire le trie ressource ou non
traitementAutreCible((IAvecCapacite)cibleSelectionne, capacite, selectionCiblesResult.IdCarteSource);
((IAvecCapacite)cibleSelectionne).synchroniseListCapacite();
}
}
//Fin d'utilisation de la capacite
ActionEventManager.capacityInUse.Remove(selectionCiblesResult.IdCapaciteSource);
}
else
{
//TODO capacite not found
}
}
/***********************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);
}
public void putCard(CarteMetierAbstract carte)
{
if (null != carte && null != carte.JoueurProprietaire && carte.JoueurProprietaire.isLocalPlayer)
{
//TODO ungenerated card on client
Transform trfmCard = carte.transform;
trfmCard.parent = transform;
//TODO délpacer à un index au hasard
carte.CmdChangeParent(this.NetIdJoueurPossesseur, JoueurUtils.getPathJoueur(this));
carte.JoueurProprietaire.CarteSelectionne = null;
}
}
//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;
}
}
private static HashSet <Joueur> getJoueursCible(string conditionCible, NetworkInstanceId netIdJoueurSource, NetworkInstanceId netIdJoueurCible, CarteMetierAbstract carteSource)
{
HashSet <Joueur> joueursCible = new HashSet <Joueur>();
if (netIdJoueurCible != netIdJoueurSource && conditionCible.Contains(ConstanteIdObjet.STR_CONDITION_POUR_ENNEMIE))
{
joueursCible.Add(JoueurUtils.getJoueur(netIdJoueurCible));
}
if (netIdJoueurCible == netIdJoueurSource && conditionCible.Contains(ConstanteIdObjet.STR_CONDITION_POUR_ALLIER))
{
joueursCible.Add(JoueurUtils.getJoueur(netIdJoueurSource));
}
if (null != carteSource && null != carteSource.JoueurProprietaire && conditionCible.Contains(ConstanteIdObjet.STR_CONDITION_POUR_PROVENANCE))
{
joueursCible.Add(carteSource.JoueurProprietaire);
}
return(joueursCible);
}
public static void putCardFromServer(IConteneurCarte emplacementCible, CarteMetierAbstract carteDeplacer)
{
if (emplacementCible is EmplacementMetierAbstract)
{
((EmplacementMetierAbstract)emplacementCible).RpcPutCard(carteDeplacer.netId);
}
else if (emplacementCible is Mains)
{
Joueur joueur = JoueurUtils.getJoueur(((Mains)emplacementCible).NetIdJoueur);
joueur.RpcPutCardInHand(carteDeplacer.netId);
}
else if (emplacementCible is DeckMetierAbstract)
{
((DeckMetierAbstract)emplacementCible).RpcPutCard(carteDeplacer.netId);
}
else if (emplacementCible is CartePlaneteMetier)
{
((CartePlaneteMetier)emplacementCible).RpcPutCard(carteDeplacer.netId);
}
}
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;
}
}
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 finTour(Joueur joueurTour)
{
GameObject goBtnLastPlayer = NetworkServer.FindLocalObject(listJoueurs [indexPlayerPlaying].netIdBtnTour);
if (null != goBtnLastPlayer && null != goBtnLastPlayer.GetComponent <BoutonTour> ())
{
BoutonTour boutonTour = goBtnLastPlayer.GetComponent <BoutonTour> ();
if (boutonTour.getEtatBouton() == BoutonTour.enumEtatBouton.terminerTour)
{
boutonTour.setEtatBoutonServer(BoutonTour.enumEtatBouton.enAttente);
CapaciteUtils.endOfTurnOfCapacityPlayer(listJoueurs [indexPlayerPlaying].netIdJoueur);
bool tourSupJoueur = 0 < CapaciteUtils.valeurAvecCapacite(0, joueurTour.CartePlaneteJoueur.containCapacityOfType(ConstanteIdObjet.ID_CAPACITE_PERTE_TOUR_JEU), ConstanteIdObjet.ID_CAPACITE_PERTE_TOUR_JEU);
if (!tourSupJoueur) //Pas de tour supplementaire
{
if (indexPlayerPlaying < listJoueurs.Count - 1)
{
indexPlayerPlaying++;
}
else
{
indexPlayerPlaying = 0;
nbTurn++;
}
this.idJoueurTour = listJoueurs [indexPlayerPlaying].netIdJoueur;
joueurTour = JoueurUtils.getJoueur(listJoueurs [indexPlayerPlaying].netIdJoueur);
}
RpcAffichagePseudo(listJoueurs [indexPlayerPlaying].Pseudo);
ActionEventManager.EventActionManager.CreateTask(NetworkInstanceId.Invalid, joueurTour.netId, -1, ConstanteIdObjet.ID_CONDITION_ACTION_DEBUT_TOUR, NetworkInstanceId.Invalid, false);
}
}
}
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());
}
}
void Start()
{
JoueurUtils.initAllJoueurDictionnary();
if (isServer)
{
//TODO rechercher autrement
pseudo = "Pseudo" + GameObject.FindObjectsOfType <Joueur> ().Length;
}
else
{
CmdReInitAllJoueurDict();
}
main.init(this);
deckConstruction.intiDeck(this, isServer);
cimetiereConstruction.intiDeck(this, isServer);
ressourceXP.init(this);
ressourceMetal.init(this);
ressourceCarburant.init(this);
if (isLocalPlayer)
{
CmdGenerateCardAlreadyLaid(this.netId);
initPlateau();
CmdInitSystemeTour();
}
else
{
string nomPlateau = transform.localPosition.z < 0 ? "Plateau1" : "Plateau2"; //TODO mettre en constante
goPlateau = GameObject.Find(nomPlateau);
transform.Find("VueJoueur").gameObject.SetActive(false); //TODO créer en constante
}
}
/****************** 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);
}
}
}
}
}
}
private void RpcReInitAllJoueurDict()
{
JoueurUtils.initAllJoueurDictionnary();
}
private static void traitementCapaciteRessource(CapaciteDTO capacite, List <RessourceMetier> ressourcesCible, IAvecCapacite cibleSelectionne, Joueur joueurCarteSource, NetworkInstanceId netIdCarteSource /*, NetworkInstanceId netIdJoueurAction, NetworkInstanceId netIdJoueurCible, int actionAppelante*/)
{
if (capacite.Capacite == ConstanteIdObjet.ID_CAPACITE_MODIF_PRODUCTION_RESSOURCE ||
capacite.Capacite == ConstanteIdObjet.ID_CAPACITE_MODIF_STOCK_RESSOURCE)
{
//Cas ou l on rajoute une capaciteMetier
foreach (RessourceMetier ressource in ressourcesCible)
{
if (cibleSelectionne is CarteBatimentMetier || cibleSelectionne is CarteDefenseMetier || cibleSelectionne is CarteVaisseauMetier)
{
CapaciteDTO capaciteRessource = getRessourceFromCarte(capacite, cibleSelectionne, ressource.TypeRessource);
CapaciteMetier capaciteMetier = convertCapaciteDTOToMetier(capaciteRessource, netIdCarteSource);
ressource.addCapacity(capaciteMetier);
}
else
{
CapaciteMetier capaciteMetier = convertCapaciteDTOToMetier(capacite, netIdCarteSource);
ressource.addCapacity(capaciteMetier);
}
}
}
else if (capacite.Capacite == ConstanteIdObjet.ID_CAPACITE_VOL_RESSOURCE && null != joueurCarteSource)
{
foreach (RessourceMetier ressource in ressourcesCible)
{
CapaciteDTO capaciteUtile = null;
if (ressource.NetIdJoueur != joueurCarteSource.netId) //on ne peut se voler soit même
{
if (cibleSelectionne is CarteBatimentMetier || cibleSelectionne is CarteDefenseMetier || cibleSelectionne is CarteVaisseauMetier)
{
capaciteUtile = getRessourceFromCarte(capacite, cibleSelectionne, ressource.TypeRessource);
}
else
{
capaciteUtile = capacite;
}
int stockActuel = ressource.Stock;
int newStock = getNewValue(stockActuel, capaciteUtile.Quantite, capaciteUtile.ModeCalcul);
int montantVoler = newStock - stockActuel;
if (ressource.Stock < montantVoler)
{
montantVoler = ressource.Stock;
}
ressource.Stock -= montantVoler;
int montantReelVole = joueurCarteSource.addRessourceServer(ressource.TypeRessource, montantVoler);
if (montantReelVole != montantVoler)
{
ressource.Stock += montantVoler - montantReelVole;
}
}
}
}
else if (capacite.Capacite == ConstanteIdObjet.ID_CAPACITE_MODIF_TYPE_RESSOURCE)
{
foreach (RessourceMetier ressource in ressourcesCible)
{
CapaciteDTO capaciteUtile;
if (cibleSelectionne is CarteBatimentMetier || cibleSelectionne is CarteDefenseMetier || cibleSelectionne is CarteVaisseauMetier)
{
capaciteUtile = getRessourceFromCarte(capacite, cibleSelectionne, ressource.TypeRessource);
}
else
{
capaciteUtile = capacite;
}
int stockActuel = ressource.Stock;
int newStock = getNewValue(stockActuel, capaciteUtile.Quantite, capaciteUtile.ModeCalcul);
int montantEchange = newStock - stockActuel;
if (ressource.Stock < montantEchange)
{
montantEchange = ressource.Stock;
}
ressource.Stock -= montantEchange;
string ressourceOppose = "";
if (ressource.TypeRessource == "Metal")
{
ressourceOppose = "Carburant";
}
else if (ressource.TypeRessource == "Carburant")
{
ressourceOppose = "Metal";
}
Joueur joueurRessource = JoueurUtils.getJoueur(ressource.NetIdJoueur);
int montantReelEchange = joueurRessource.addRessourceServer(ressourceOppose, montantEchange);
if (montantReelEchange != montantEchange)
{
ressource.Stock += montantEchange - montantReelEchange;
}
}
}
}