private void Ajouter_Click(object sender, RoutedEventArgs e)
{
Personnage personnage;
string nom = textBoxNom.Text;
string surnom = textBoxSurnom.Text;
switch (faction)
{
case 1: Allie allie = new Allie(nom, image, surnom);
personnage = allie;
break;
case 2:
Avenger avenger = new Avenger(nom, image, surnom);
personnage = avenger;
break;
case 3:
Ennemi ennemi = new Ennemi(nom, image, surnom);
personnage = ennemi;
break;
default: personnage = new Allie("nom par défaut", "img", "surnom");
break;
}
personnage.AjouterInterprete(interprete);
foreach (Film f in filmographie)
{
personnage.AjouterFilm(f);
}
manager.MonEnsemble.AjouterElement((Element)personnage);
manager.SauvegardeDonnees();
this.Close();
}
public void debutTour()
{
Personnage p = personnages[indexJoueur];
p.debutTour();
effectControlleur.applyEffectDebut(p);
Case c = boardManager.getCase(p.transform.position);
foreach (Effet e in c.GetEffets())
{
Debug.Log("lanceur dans la case " + e.Lanceur);
e.applyEffect(p);
}
if (p.getStatusPersonnage() == 0)
{
joueurc = (Joueur)p;
sortPanelControlleur.GetComponent <SortPanelControlleur>().afficheSort(joueurc);
/*gestionAffichageSort.j = joueurc;
* gestionAffichageSort.afficheSort();*/
choisiSort = false;
sortSelectionne = null;
boardManager.reinitColor(positionAttaquable);
boardManager.reinitDistanceSort();
reinitialiseAffichageDeplacement();
gereDeplacementPossible();
}
else
{
ennemic = (Ennemi)p;
ennemic.joue(boardManager.grid, boardManager.tailleX, boardManager.tailleY);
ennemic = null;
}
}
// Start is called before the first frame update
protected override void Start()
{
Destroy(random_object);
base.Start();
ennemi = null;
agent.isStopped = false;
}
public ActionResult DeleteConfirmed(int id)
{
Ennemi ennemi = db.Ennemi.Find(id);
db.Ennemi.Remove(ennemi);
db.SaveChanges();
return(RedirectToAction("Index"));
}
static void UpdateSpawn()
{
if (nbEnnemiAfficher < tabEnnemis.Length)
{
tabEnnemis[nbEnnemiAfficher] = new Ennemi(76, 4);
nbEnnemiAfficher++;
}
}
float vieMax; //Vie maximale
/**
* Fonction d'initialisation des variables
* @param void
* @return void
*/
void Start()
{
vieUi = barreVie.transform.GetChild(1).GetComponent <Image>();
scriptEnnemi = GetComponent <Ennemi>();
//Conversion (Cast) nécessaire pour que l'affichage d'update
tmpVie = (float)scriptEnnemi.pointsVie;
vieMax = (float)scriptEnnemi.pointsVieMax;
}
static void ClearEnnemi(Ennemi ennemi)
{
Console.SetCursorPosition(ennemi.oldPosX, ennemi.oldPosY);
Console.Write(" ");
Console.SetCursorPosition(ennemi.oldPosX, ennemi.oldPosY + 1);
Console.Write(" ");
Console.SetCursorPosition(ennemi.oldPosX, ennemi.oldPosY + 2);
Console.Write(@" ");
}
/**************************************************************************/
static void AfficherEnnemi(Ennemi ennemi)
{
Console.SetCursorPosition(ennemi.posX, ennemi.posY);
Console.Write(" __");
Console.SetCursorPosition(ennemi.posX, ennemi.posY + 1);
Console.Write("|__|");
Console.SetCursorPosition(ennemi.posX, ennemi.posY + 2);
Console.Write(@"/ \");
}
public Noeud(string intitule, Ennemi ennemi, Personnage ennemiP, bool mortOuRandom,
Dictionary <int, string> choixReponses)
{
MortOuRandom = mortOuRandom;
Intitule = intitule;
Ennemi = ennemi;
EnnemiP = ennemiP;
ChoixReponses = choixReponses;
}
private void GérerÉtatJeu()
{
if (ÉtatJoueur != ÉtatsJoueur.SOLO)
{
Ennemi.AjusterPosition(NetworkManager.MatriceMondeEnnemi);
}
GérerCollisions();
GérerCheckPoints();
}
private void fireOnClosest()
{
// We have a closest target, we fire on it
if (closest)
{
distanceClosest = Vector3.Distance(closest.transform.position, transform.position);
// We fire on the current closest target
if (distanceClosest < attackRange && !closest.isDead)
{
line.enabled = true;
lightTourelle.enabled = true;
tourellesManager.hackersManager.damageEnnemi(closest, dps * Time.deltaTime, targetSpeedMultiplier);
var heading = closest.transform.position - lightTourelle.transform.position;
Ray ray = new Ray(lightTourelle.transform.position, heading);
line.SetPosition(0, ray.origin);
line.SetPosition(1, ray.GetPoint(distanceClosest));
}
// Closest target is out of range, unsetting closest
else
{
line.enabled = false;
lightTourelle.enabled = false;
closest = null;
}
}
// We don't have a closest target, we find one to fire on it
if (!closest)
{
closest = tourellesManager.hackersManager.closestEnnemi(transform.position, this);
// We fire on the new closest target
if (closest)
{
distanceClosest = Vector3.Distance(closest.transform.position, transform.position);
if (distanceClosest < attackRange)
{
line.enabled = true;
lightTourelle.enabled = true;
tourellesManager.hackersManager.damageEnnemi(closest, dps * Time.deltaTime, targetSpeedMultiplier);
var heading = closest.transform.position - lightTourelle.transform.position;
Ray ray = new Ray(lightTourelle.transform.position, heading);
line.SetPosition(0, ray.origin);
line.SetPosition(1, ray.GetPoint(distanceClosest));
}
// New closest target is still too far
else
{
line.enabled = false;
lightTourelle.enabled = false;
}
}
}
}
public ActionResult Edit([Bind(Include = "IdEnnemi,NomEnemi,AtkEnnemi,SpeedEnnemi,PvEnnemi,Isboss")] Ennemi ennemi)
{
if (ModelState.IsValid)
{
db.Entry(ennemi).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(ennemi));
}
public static void Main(string[] args)
{
/***************************************************************************************/
IntPtr hConsole = DllImports.GetStdHandle(-11); // get console handle
DllImports.COORD xy = new DllImports.COORD(100, 100);
DllImports.SetConsoleDisplayMode(hConsole, 1, out xy); // set the console to fullscreen
//SetConsoleDisplayMode(hConsole, 2); // set the console to windowed
/***************************************************************************************/
player = new Player(136, 64);
tabEnnemis = new Ennemi[15];
tabEnnemis[nbEnnemiAfficher] = new Ennemi(76, 4);
nbEnnemiAfficher++;
bool finJeu = false;
InitialiseGame(player);
Timer timer = new Timer(UpdateTime, null, 0, 100);
isEnnemiMoving = false;
isPlayerMoving = false;
Console.CursorVisible = false;
while (!finJeu)
{
player.oldPosX = player.posX;
player.oldPosY = player.posY;
for (int i = 0; i < nbEnnemiAfficher; i++)
{
tabEnnemis[i].oldPosX = tabEnnemis[i].posX;
tabEnnemis[i].oldPosY = tabEnnemis[i].posY;
}
UpdateVaisseau();
Update();
UpTire();
if (isPlayerMoving || isEnnemiMoving)
{
ClearVaisseau(player);
AfficherVaisseau(player);
//AfficherTireVaisseau(tire);
//ClearTireVaisseau(tire);
for (int i = 0; i < nbEnnemiAfficher; i++)
{
ClearEnnemi(tabEnnemis[i]);
AfficherEnnemi(tabEnnemis[i]);
}
isPlayerMoving = false;
isEnnemiMoving = false;
//isTireMoving = false;
}
}
}
public ActionResult Create([Bind(Include = "IdEnnemi,NomEnemi,AtkEnnemi,SpeedEnnemi,PvEnnemi,Isboss")] Ennemi ennemi)
{
if (ModelState.IsValid)
{
db.Ennemi.Add(ennemi);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(ennemi));
}
private Transform _enfant; //contient le gameObject ayant le renderer. Utiliser pour la rotation.
//Assignation de quelques références.
void Start()
{
Teddy = GameObject.Find("Teddy");
_ennemi = gameObject.GetComponent <Ennemi>();
_enfant = transform.GetChild(0);
//si l'avion est NAGAZAKI, alors on le désactive de base
if (gameObject.name == "NAGAZAKI")
{
gameObject.SetActive(false);
}
}
private void GérerTransitionGagné()
{
if (NetworkManager.EnnemiEstArrivé || ÉtatJoueur == ÉtatsJoueur.SOLO)
{
État = ÉtatsJeu.FIN_DE_PARTIE;
MenuFinDePartie.Enabled = true;
Joueur.Enabled = false;
}
else
{
Ennemi.AjusterPosition(NetworkManager.MatriceMondeEnnemi);
}
}
public void CreerEnnemi()
{
int randomEnnemi = Random.Range(0, 3);
switch (randomEnnemi)
{
case 0: ennemi = new RatGeant(); break;
case 1: ennemi = new VerDesEntrailles(); break;
case 2: ennemi = new Gargouille(); break;
}
}
public void doConvert(Ennemi ennemi)
{
for (int i = 0; i < ennemi.nbAfterConvertion; i++)
{
GameObject essaimAI = GameObject.Instantiate(prefabEssaim, essaimParent);
essaimAI.transform.position = new Vector3(ennemi.transform.position.x, essaimMaitre.transform.position.y, ennemi.transform.position.z) + ennemi.radius * new Vector3(Random.Range(-1f, 1f), 0, Random.Range(-1f, 1f));
EssaimAI essaimAiScript = essaimAI.GetComponent <EssaimAI>();
essaimAiScript.isMaster = false;
essaimAiScript.master = essaimMaitre;
listEssaim.Add(essaimAiScript);
}
listEnnemis.Remove(ennemi);
}
// GET: Ennemis/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ennemi ennemi = db.Ennemi.Find(id);
if (ennemi == null)
{
return(HttpNotFound());
}
return(View(ennemi));
}
private void OnCollisionStay(Collision collision)
{
if (collision.transform.CompareTag("Ennemi"))
{
ennemi = collision.transform.GetComponent <Ennemi>();
if (currentTime == 0)
{
GetComponent <Animator>().SetBool("isWalking", false);
currentTime = allowedTime;
GetComponent <Animator>().SetBool("isFighting", true);
StartCoroutine("Combattre", ennemi);
}
}
}
IEnumerator Combattre(Ennemi other)
{
agent.isStopped = true;
transform.forward = other.transform.position - transform.position;
yield return(new WaitForSeconds(1));
currentTime--;
GetComponent <Animator>().SetBool("isFighting", false);
if (other != null)
{
other.pointsVie -= pointsAttaque;
}
agent.isStopped = false;
}
private void GérerTransitionPerdu()
{
if (NbTours == NB_TOURS || ÉtatJoueur == ÉtatsJoueur.SOLO)
{
État = ÉtatsJeu.FIN_DE_PARTIE;
MenuFinDePartie.Enabled = true;
NetworkManager.TempsDeCourseJ.EstActif = false;
Joueur.EstActif = false;
NetworkManager.SendTerminé(true, NetworkManager.TempsDeCourseJ.ValeurTimer, NetworkManager.PseudonymeJ);
}
else
{
Ennemi.AjusterPosition(NetworkManager.MatriceMondeEnnemi);
}
}
public EssaimAI GetTarget(Ennemi ennemi)
{
EssaimAI target = null;
float shortestDistance = ennemi.range * ennemi.range;
foreach (EssaimAI essaim in listEssaim)
{
float distance = Vector3.SqrMagnitude(essaim.transform.position - ennemi.transform.position);
if (distance < shortestDistance)
{
target = essaim;
shortestDistance = distance;
}
}
return(target);
}
public void lanceSort(Case c, Personnage p, Sort sort)
{
if (boardManager.contient(positionAttaquable, c.getX(), c.getY()))
{
if (p.lanceSort(sort))
{
foreach (Case ca in boardManager.getAllCase(rayonAction))
{
if (sort.effet.styleEffect == StyleEffect.Case)
{
effectControlleur.ajouteEffetCase(sort.effet, ca, personnages[indexJoueur]);
}
if (ca.perso != null)
{
if (sort.effet.styleEffect == StyleEffect.Personnage)
{
effectControlleur.ajouteEffetJoueur(sort.effet, ca, personnages[indexJoueur]);
}
int degatPresume = AlgoCalculDegat.degatPresume(p, sort);
ca.perso.recoitAttaque(AlgoCalculDegat.calculDegat(ca.perso, sort.typeSort, degatPresume));
if (ca.perso.pdv <= 0)
{
foreach (GameObject e in ennemisInstanciate)
{
Debug.Log(e.GetComponent <Ennemi>().pdv);
if (e.GetComponent <Ennemi>() == ca.perso)
{
ennemic = null;
Destroy(e);
}
}
ca.perso = null;
}
}
}
}
sortPanelControlleur.GetComponent <SortPanelControlleur>().UpdateAffichage();
// gestionAffichageSort.UpdateAffichage();
desSelectionneSort();
}
else
{
desSelectionneSort();
}
}
public Ennemi closestEnnemi(Vector3 _v3, Tourelle _t)
{
Ennemi closest = null;
float bestDistance = 10000f;
float candidateDistance;
foreach (Ennemi ennemi in ennemiList)
{
candidateDistance = Vector3.Distance(_t.transform.position, ennemi.transform.position);
if (bestDistance > candidateDistance)
{
bestDistance = candidateDistance;
closest = ennemi;
}
}
return(closest);
}
private void OnTriggerEnter2D(Collider2D collision)
{
Ennemi bwate = collision.gameObject.GetComponent <Ennemi>();
Coeur coeur = collision.gameObject.GetComponent <Coeur>();
if (bwate != null)
{
Debug.Log("Aïe");
GameManager.Instance.DamageToBilly(1);
}
if (coeur != null)
{
Debug.Log("Yes");
GameManager.Instance.HealToBilly(1);
Destroy(coeur.gameObject);
}
}
public void initEnnemies()
{
GameObject nobj = (GameObject)GameObject.Instantiate(ennemies[0]);
nobj.transform.position = new Vector2((1 * 10), -(1 * 10));
nobj.transform.localScale = new Vector3(1f, 1f, 1f);
Ennemi e = nobj.GetComponent <Ennemi>();
ennemic = e;
foreach (Joueur j in joueursCIntanciate)
{
ennemic.joueurs.Add(j);
}
ennemisInstanciate.Add(nobj);
boardManager.ajoutePerso(e.transform.position, e);
nobj.SetActive(true);
personnages.Add(e);
}
public void TestCasterSortDegats()
{
Sort leSort = new Sort("test", "test", 1, 30);
Personnage p = new Personnage("Karjo", "Fail", 0, new Arme("", 0, "", 0), new Armure("", 0, "", 1));
p.AjouterStat(new Stat("Mana", 100));
p.AjouterSort(leSort);
Ennemi e = new Ennemi("Evil karjo", new Arme("a", 5, "rien", 1));
e.AjouterStat(new Stat("PV", 100));
p.CasterSort(leSort, e);
Assert.AreEqual(99, e.FindStat("PV").Valeur);
}
public bool isGettingConversion(Ennemi ennemi)
{
int nbClose = 0;
for (int i = 0; i < listEssaim.Count; i++)
{
EssaimAI toCompare = listEssaim[i];
Vector3 vectorToVoisin = (toCompare.transform.position - ennemi.transform.position);
float distanceToVoisin = vectorToVoisin.sqrMagnitude;
if (distanceToVoisin < ennemi.radius + distanceToConversion)
{
nbClose++;
if (nbClose >= ennemi.nbToConvert)
{
return(true);
}
}
}
return(false);
}
/*private void OnTriggerStay(Collider other)
* {
* if (other.CompareTag("Ennemi"))
* {
* ennemi = other.GetComponent<Ennemi>();
* if (currentTime == 0)
* {
* GetComponent<Animator>().SetBool("isWalking", false);
* Vec = new Vector3(Vec.x, Vec.y, Vec.z);
* V = new Vector3(0, 0, 0);
* IsActif = true;
* currentTime = allowedTime;
* GetComponent<Animator>().SetBool("isFighting", true);
* StartCoroutine("Timer", ennemi);
* }
* }
* }*/
public bool searchEnnemi()
{
float closestEnnemi = 1000f;
foreach (Ennemi e in FindObjectsOfType <Ennemi>())
{
float val = Vector3.Distance(transform.position, e.transform.position);
if (val < closestEnnemi)
{
closestEnnemi = val;
ennemi = e;
}
}
if (closestEnnemi == 1000f)
{
ennemi = null;
return(false);
}
return(true);
}
public override string UtiliserCompetenceA(Ennemi.Ennemi cible)
{
int chanceAttaque = 5;
int degatAttaque = 0;
string strAction = "";
chanceAttaque += this.Precisionactuel + this.Arme.Precision - cible.Esquive;
chanceAttaque = chanceAttaque > 9 ? 9 : chanceAttaque;
chanceAttaque = chanceAttaque < 1 ? 1 : chanceAttaque;
Random rnd = new Random();
int chiffreAleatoire = rnd.Next(0, 10);
strAction = this.NomAventurier + " tente une frappe puissante sur " + cible.Nom;
if (chiffreAleatoire < chanceAttaque)
{
double defenseCible = cible.Defense / 2;
degatAttaque = this.Forceactuel + this.Arme.Force - (int)Math.Ceiling(defenseCible);
degatAttaque = degatAttaque < 1 ? 1 : degatAttaque;
cible.PvActuel -= degatAttaque;
strAction += "\r\n" + this.NomAventurier + " à touché la cible et infligé : " + degatAttaque + " points de dégats!";
if (cible.PvActuel <= 0)
{
cible.Etat = Etat.Mort;
strAction += "\r\n" + cible.Nom + " est mort!";
}
}
else
{
strAction += "\r\n" + this.NomAventurier + " à manqué la cible!";
//MessageBox.Show(strAction);
}
this.Energieactuel -= this.CoutCompetenceA;
return strAction;
}
public override string UtiliserCompetenceA(Ennemi.Ennemi cible)
{
int degatAttaque = 0;
string strAction = "";
Random rnd = new Random();
int chiffreAleatoire = rnd.Next(0, 10);
strAction = this.NomAventurier + " lance un éclair vers " + cible.Nom;
if (chiffreAleatoire > 1)
{
degatAttaque = 10 + (this.Niveau * 5);
cible.PvActuel -= degatAttaque;
strAction += "\r\n" + this.NomAventurier + " à touché la cible et infligé : " + degatAttaque + " points de dégats!";
if (cible.PvActuel <= 0)
{
cible.Etat = Etat.Mort;
strAction += "\r\n" + cible.Nom + " est mort!";
}
//MessageBox.Show(strAction);
}
else
{
strAction += "\r\n" + this.NomAventurier + " à manqué la cible!";
//MessageBox.Show(strAction);
}
this.Manaactuel -= this.CoutCompetenceA;
return strAction;
}
