public void CmdPoseCarte(NetworkInstanceId netIdJoueur, NetworkInstanceId netIdCarteSource, int idSelectionnableCible, NetworkInstanceId netIdTaskEvent)
{
CarteMetierAbstract carteOrigineAction = ConvertUtils.convertNetIdToScript <CarteMetierAbstract> (netIdCarteSource, false);
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idSelectionnableCible);
if (null != carteOrigineAction)
{
if (carteOrigineAction is CarteConstructionMetierAbstract)
{
if (null != onPoseConstruction)
{
onPoseConstruction(netIdJoueur, carteOrigineAction, cible, netIdTaskEvent);
}
}
//TODO carteAmeliration
/*if (carteOrigineAction is CarteAmeliorationMetier && null != onPoseConstruction) {
* onPoseConstruction (netIdJoueur);
* }*/
/*
* if (null != onInvocation) {
* //TODO carteInvoque?
* onInvocation (netIdJoueur, carteOrigineAction, cible);
* }*/
}
}
public void CmdGenerateCardAlreadyLaid(NetworkInstanceId networkIdJoueur)
{
Debug.Log("Begin CmdGenerateCardAlreadyLaid");
CarteMetierAbstract[] listeCarteDejaPose = GameObject.FindObjectsOfType <CarteMetierAbstract> ();
if (null != listeCarteDejaPose)
{
for (int index = 0; index < listeCarteDejaPose.Length; index++)
{
CarteMetierAbstract carteDejaPosee = listeCarteDejaPose [index];
if (null != carteDejaPosee)
{
//carteDejaPosee.generateGOCard ();
if (carteDejaPosee is CartePlaneteMetier) //pas besoin de serialisation pour les planete
{
RpcGeneratePlanete(carteDejaPosee.gameObject, networkIdJoueur);
}
else if (carteDejaPosee is CarteConstructionMetierAbstract)
{
byte[] carteRefData = SerializeUtils.SerializeToByteArray(carteDejaPosee.getCarteDTORef());
((CarteConstructionMetierAbstract)carteDejaPosee).RpcGenerate(carteRefData, networkIdJoueur);
}
else
{
//TODO carteAmeliration
}
}
}
}
Debug.Log("End CmdGenerateCardAlreadyLaid");
}
public void putCard(CarteMetierAbstract carte)
{
if (null != carte && null != carte.JoueurProprietaire && carte.JoueurProprietaire.isLocalPlayer)
{
//TODO ajout de module ou changer héros?
}
}
/**
* 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 ();
}
}
public static void callCapacite(CarteMetierAbstract carteSourceCapacite, CarteMetierAbstract carteSourceAction, ISelectionnable cible, CapaciteDTO capaciteSource, NetworkInstanceId netIdJoueur, int actionAppelante, NetworkInstanceId netIdEventTaskAction)
{
SelectionCiblesExecutionCapacite selectionCiblesResult = getCiblesOfCapacity(carteSourceCapacite, carteSourceAction, cible, capaciteSource, netIdJoueur, actionAppelante);
int idSelection = null != cible ? cible.IdISelectionnable : -1;
ActionEventManager.EventActionManager.createTaskChooseTarget(selectionCiblesResult, carteSourceAction.netId, netIdJoueur, idSelection, actionAppelante, netIdEventTaskAction);
}
private static SelectionCiblesExecutionCapacite getCiblesOfCapacity(CarteMetierAbstract carteSourceCapacite, CarteMetierAbstract carteSourceAction, ISelectionnable cible, CapaciteDTO capaciteSource, NetworkInstanceId netIdJoueur, int actionAppelante)
{
SelectionCiblesExecutionCapacite selectionCiblesResult;
CapaciteDTO capacite = capaciteSource.Clone();
if (capacite.Capacite == ConstanteIdObjet.ID_CAPACITE_ACTION_HASARD)
{
capacite.Capacite = Random.Range(1, 40);
}
if (ConditionCarteUtils.listIdCapacitePourCarte.Contains(capacite.Capacite) && (null == cible || cible is CarteMetierAbstract))
{
List <CarteMetierAbstract> cartesCible = getCartesCible(carteSourceCapacite, (CarteMetierAbstract)cible, capacite, netIdJoueur);
//TODO use ConstanteIdObjet.ID_CAPACITE_CONDITION
selectionCiblesResult = new SelectionCiblesExecutionCapacite(capacite, carteSourceCapacite, actionAppelante);
foreach (CarteMetierAbstract cibleProbable in cartesCible)
{
selectionCiblesResult.ListIdCiblesProbables.Add(cibleProbable.IdISelectionnable);
}
}
else
{
selectionCiblesResult = findCiblesHorsCarte(capacite, carteSourceCapacite, carteSourceAction, netIdJoueur, NetworkInstanceId.Invalid /*TODO cible.netIdJoueurCible*/, actionAppelante);
}
return(selectionCiblesResult);
}
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 static void invoquerCarteServer(GameObject carteAInvoquer, int niveauInvocation, IConteneurCarte emplacementCible, Joueur joueurPossesseur)
{
NetworkServer.Spawn(carteAInvoquer);
CarteMetierAbstract carteScript = carteAInvoquer.GetComponent <CarteMetierAbstract> ();
if (carteScript is CarteConstructionMetierAbstract)
{
((CarteConstructionMetierAbstract)carteScript).NiveauActuel = niveauInvocation;
}
if (joueurPossesseur.isServer)
{
EmplacementUtils.putCardFromServer(emplacementCible, carteScript);
}
else
{
emplacementCible.putCard(carteScript);
}
NetworkUtils.assignObjectToPlayer(carteScript.GetComponent <NetworkIdentity> (), joueurPossesseur.GetComponent <NetworkIdentity> (), .2f);
byte[] carteRefData = SerializeUtils.SerializeToByteArray(carteScript.getCarteDTORef());
if (carteScript is CarteConstructionMetierAbstract)
{
((CarteConstructionMetierAbstract)carteScript).RpcGenerate(carteRefData, NetworkInstanceId.Invalid);
} //TODO carte amelioration
}
/***********************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);
}
}
public void RpcPutCardInHand(NetworkInstanceId netIdCarte)
{
CarteMetierAbstract carte = ConvertUtils.convertNetIdToScript <CarteMetierAbstract> (netIdCarte, true);
if (null != main)
{
main.putCard(carte);
}
}
public void CmdPiocheAmelioration(NetworkInstanceId netIdJoueur, NetworkInstanceId netIdCarteSource, int idSelectionnableCible, NetworkInstanceId netIdTaskEvent)
{
CarteMetierAbstract carteOrigineAction = ConvertUtils.convertNetIdToScript <CarteMetierAbstract> (netIdCarteSource, false);
ISelectionnable cible = SelectionnableUtils.getSelectiobleById(idSelectionnableCible);
if (null != onPiocheAmelioration)
{
onPiocheAmelioration(netIdJoueur, carteOrigineAction, cible, netIdTaskEvent);
}
}
public bool isCardCostPayable(RessourceMetier ressourceMetal, CarteMetierAbstract carteSelectionne)
{
bool costPayable = false;
if (null != ressourceMetal && carteSelectionne is CarteConstructionMetierAbstract && ressourceMetal.StockWithCapacity >= ((CarteConstructionMetierAbstract)carteSelectionne).getCoutMetal())
{
costPayable = true;
}
return(costPayable);
}
public void useRecoitDegatCapacity(NetworkInstanceId netIdJoueur, CarteMetierAbstract carteSourceAction, ISelectionnable cible, NetworkInstanceId netIdTaskEvent)
{
if (this.getConteneur() is EmplacementMetierAbstract)
{
List <CapaciteDTO> capaciteDegatRecu = getListCapaciteToCall(netIdJoueur, carteSourceAction.netId, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT);
foreach (CapaciteDTO capacite in capaciteDegatRecu)
{
CapaciteUtils.callCapacite(this, carteSourceAction, cible, capacite, netIdJoueur, ConstanteIdObjet.ID_CONDITION_ACTION_RECOIT_DEGAT, netIdTaskEvent);
}
}
}
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 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 CmdSyncIdSelectionnableCarte(NetworkInstanceId netIdCarte)
{
CarteMetierAbstract carte = ConvertUtils.convertNetIdToScript <CarteMetierAbstract> (netIdCarte, false);
if (null != carte)
{
if (null == carte.IdISelectionnable || carte.IdISelectionnable <= 0)
{
carte.initIdSelection();
}
carte.RpcInitIdSelectionnable(carte.IdISelectionnable);
}
}
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);
}
//Constructeur pour le choix de cible sans capacite
public SelectionCiblesExecutionCapacite(int nbCibleMax, CarteMetierAbstract carteSource, int idActionAppelante)
{
this.idTypeCapacite = -1;
this.idCapaciteSource = -1;
this.libelleCapacite = "Action type" + idActionAppelante; // TODO rajouter fonction descriptive de action
this.choixManuelle = true;
this.nbChoixCible = nbCibleMax;
this.idActionAppelante = idActionAppelante;
this.idCarteSource = carteSource.netId;
this.idJoueurCarteSource = carteSource.JoueurProprietaire.netId;
this.listIdCiblesProbables = new List <int> ();
this.listIdRessouceCible = null;
}
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);
}
}
private static List <CarteMetierAbstract> getCartesCible(CarteMetierAbstract carteOrigin, CarteMetierAbstract carteCible, CapaciteDTO capacite, NetworkInstanceId netIdJoueur)
{
List <CarteMetierAbstract> listCartesCible = new List <CarteMetierAbstract> ();
List <IConteneurCarte> listEmplacementsCible = new List <IConteneurCarte> ();
foreach (string conditionEmplacement in capacite.ConditionsEmplacement)
{
string[] tabConditionEmplacement = conditionEmplacement.Split(char.Parse("-"));
if (tabConditionEmplacement.Length >= 2)
{
int idEmplacement = int.Parse(tabConditionEmplacement [0]);
listEmplacementsCible.AddRange(ConditionEmplacementUtils.getMethodeEmplacement(idEmplacement, tabConditionEmplacement[1], carteOrigin.getConteneur(), carteCible, netIdJoueur));
}
}
//TODO si capacite a cible pas besoin de faire la suite
foreach (string conditionCible in capacite.ConditionsCible)
{
string[] tabConditionCible = conditionCible.Split(char.Parse("-"));
if (tabConditionCible.Length >= 2)
{
int idCible = int.Parse(tabConditionCible [0]);
List <CarteMetierAbstract> listCartesCibleProbable = ConditionCarteUtils.getMethodeCarteCible(idCible, tabConditionCible[1], listEmplacementsCible, carteOrigin, netIdJoueur);
if (capacite.AppelUnique)
{
foreach (CarteMetierAbstract carteProbable in listCartesCibleProbable)
{
//On vérifie que la carte ne possède pas déjà l'effet
if (!carteProbable.containCapacityWithId(capacite.Id))
{
listCartesCible.Add(carteProbable);
}
}
}
else
{
listCartesCible.AddRange(listCartesCibleProbable);
}
}
}
return(listCartesCible);
}
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;
}
}
private static string getTypeCard(CarteMetierAbstract carteTest)
{
string result = "";
if (carteTest is CarteBatimentMetier)
{
result = ConstanteInGame.strBatiment;
}
else if (carteTest is CarteDefenseMetier)
{
result = ConstanteInGame.strDefense;
}
else if (carteTest is CarteVaisseauMetier)
{
result = ConstanteInGame.strVaisseau;
}
return(result);
}
public void removeCarte(CarteMetierAbstract carteToRemove)
{
carteEnMains.Remove(carteToRemove);
float position = carteToRemove.transform.position.x;
foreach (CarteMetierAbstract carte in carteEnMains)
{
float positionxCarte = carte.transform.position.x;
if (position > 0 && positionxCarte > position)
{
carte.transform.position = new Vector3(positionxCarte - 1f, carte.transform.position.y, carte.transform.position.z);
}
else if (position < 0 && positionxCarte < position)
{
carte.transform.position = new Vector3(positionxCarte + 1f, carte.transform.position.y, carte.transform.position.z);
}
}
}
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);
}
}
//CARTE INVOQUER
//Niv CARTE INVOQUER
public SelectionCiblesExecutionCapacite(CapaciteDTO capacite, CarteMetierAbstract carteSource, int idActionAppelante)
{
this.idTypeCapacite = capacite.Capacite;
this.libelleCapacite = capacite.Nom; // TODO rajouter fonction descriptive de action
this.choixManuelle = capacite.ChoixCible;
this.nbChoixCible = capacite.NbCible;
int newIdCapacityInUse = ActionEventManager.sequenceCapacityInUse++;
this.idCapaciteSource = newIdCapacityInUse;
ActionEventManager.capacityInUse.Add(newIdCapacityInUse, capacite.Clone());
//this.capaciteBase = capacite.Clone ();
this.idActionAppelante = idActionAppelante;
this.idCarteSource = carteSource.netId;
this.idJoueurCarteSource = carteSource.JoueurProprietaire.netId;
this.listIdCiblesProbables = new List <int> ();
this.listIdRessouceCible = null;
}
public void useDeplacementCapacity(NetworkInstanceId netIdJoueur, CarteMetierAbstract carteSourceAction, ISelectionnable cible, NetworkInstanceId netIdTaskEvent)
{
if (cible is EmplacementAttaque && this.getConteneur() is EmplacementMetierAbstract)
{
List <CapaciteDTO> capaciteDeplacementAttaque = getListCapaciteToCall(netIdJoueur, carteSourceAction.netId, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_LIGNE_ATTAQUE);
foreach (CapaciteDTO capacite in capaciteDeplacementAttaque)
{
CapaciteUtils.callCapacite(this, carteSourceAction, cible, capacite, netIdJoueur, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_LIGNE_ATTAQUE, netIdTaskEvent);
}
}
else if (cible is EmplacementMetierAbstract)
{
List <CapaciteDTO> capaciteDeplacementAttaque = getListCapaciteToCall(netIdJoueur, carteSourceAction.netId, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_STANDART);
foreach (CapaciteDTO capacite in capaciteDeplacementAttaque)
{
CapaciteUtils.callCapacite(this, carteSourceAction, cible, capacite, netIdJoueur, ConstanteIdObjet.ID_CONDITION_ACTION_DEPLACEMENT_STANDART, netIdTaskEvent);
}
}
}
public static List <CarteConstructionMetierAbstract> getListCarteCapableDefendrePlanete(Joueur joueurPlanete)
{
List <CarteConstructionMetierAbstract> listeDefenseur = new List <CarteConstructionMetierAbstract> ();
List <EmplacementSolMetier> listEmplacementSolJoueur = EmplacementUtils.getListEmplacementOccuperJoueur <EmplacementSolMetier> (joueurPlanete.netId);
foreach (EmplacementSolMetier emplacementSolJoueur in listEmplacementSolJoueur)
{
List <CarteMetierAbstract> listCarteContenu = emplacementSolJoueur.getCartesContenu();
if (null != listCarteContenu && listCarteContenu.Count > 0)
{
CarteMetierAbstract carteContenue = listCarteContenu [0];
if (null != carteContenue && carteContenue is IDefendre && ((IDefendre)carteContenue).isCapableDefendre() && carteContenue is CarteConstructionMetierAbstract)
{
listeDefenseur.Add((CarteConstructionMetierAbstract)carteContenue);
}
}
}
return(listeDefenseur);
}
public static List <CarteConstructionMetierAbstract> getListCarteCapableAttaque(NetworkInstanceId netIdJoueurAttaque)
{
List <CarteConstructionMetierAbstract> listeAttaque = new List <CarteConstructionMetierAbstract> ();
List <EmplacementAttaque> listEmplacementAttaqueJoueur = EmplacementUtils.getListEmplacementOccuperJoueur <EmplacementAttaque> (netIdJoueurAttaque);
foreach (EmplacementAttaque emplacementAttaqueJoueur in listEmplacementAttaqueJoueur)
{
List <CarteMetierAbstract> listCarteContenu = emplacementAttaqueJoueur.getCartesContenu();
if (null != listCarteContenu && listCarteContenu.Count > 0)
{
CarteMetierAbstract carteContenue = listCarteContenu [0];
if (null != carteContenue && carteContenue is IAttaquer && ((IAttaquer)carteContenue).isCapableAttaquer() && carteContenue is CarteConstructionMetierAbstract)
{
listeAttaque.Add((CarteConstructionMetierAbstract)carteContenue);
}
}
}
return(listeAttaque);
}
