public override bool CliqueGauche(Entite ent, int dommage, Monde monde)
{
if (casque != null)
{
casque.Durabiliter--;
dommage -= casque.Resistance;
if (casque.Durabiliter <= 0)
{
casque = null;
}
}
if (dommage <= 0)
{
return(false);
}
if (plastron != null)
{
plastron.Durabiliter--;
dommage -= plastron.Resistance;
if (plastron.Durabiliter <= 0)
{
plastron = null;
}
}
if (dommage <= 0)
{
return(false);
}
if (jambiere != null)
{
jambiere.Durabiliter--;
dommage -= jambiere.Resistance;
if (jambiere.Durabiliter <= 0)
{
jambiere = null;
}
}
if (dommage <= 0)
{
return(false);
}
if (botte != null)
{
botte.Durabiliter--;
dommage -= botte.Resistance;
if (botte.Durabiliter <= 0)
{
botte = null;
}
}
if (dommage <= 0)
{
return(false);
}
return(base.CliqueGauche(ent, dommage, monde));
}
public override bool CliqueGauche(Entite ent, int dommage, Monde monde)
{
base.CliqueGauche(ent, dommage, monde);
if (ent != null && ent is Joueur joueur)
{
joueur.CliqueGauche(this, 1, monde);
}
return(true);
}
public override bool Bouger(float nx, int ny, Monde monde)
{
bool a = base.Bouger(nx, ny, monde);
if (!a)
{
Faim -= 0.05f;
}
return(a);
}
public bool Equals(Monde monde)
{
if (monde == null)
{
return(false);
}
if (chunks.Count != monde.chunks.Count)
{
return(false);
}
if (entites.Count != monde.entites.Count)
{
return(false);
}
if (generateur.Nom != monde.generateur.Nom || generateur.Noise.Seed != monde.generateur.Noise.Seed)
{
return(false);
}
foreach (string i in chunks.Keys)
{
if (!monde.chunks.ContainsKey(i))
{
return(false);
}
if (!chunks[i].Equals(monde.chunks[i]))
{
return(false);
}
}
for (int i = 0; i < entites.Count; i++)
{
if ((entites[i] == null) != (monde.entites[i] == null))
{
return(false);
}
if (entites[i] == null && monde.entites[i] == null)
{
continue;
}
if (!entites[i].Equals(monde.entites[i]))
{
return(false);
}
}
return(true);
}
/// <summary>
/// met le schema dans le monde</br>
/// cree accessoirement les chunk non cree en mode non generer
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="monde"></param>
public void AppliquerSchema(int x, int y, Monde monde)
{
foreach (string block in blocks.Keys)
{
string[] s = block.Split('/');
monde.SetBlock(x + int.Parse(s[0]), y + int.Parse(s[1]), blocks[block]);
}
foreach (Entite ent in entites)
{
Entite t = ent.Clone();
t.Tp(t.X + x, t.Y + y);
monde.Entites.Add(t);
}
}
/// <summary>
/// clone le monde
/// </summary>
/// <returns></returns>
public Monde Clone()
{
Monde monde = new Monde(generateur);
foreach (KeyValuePair <string, Chunk> c in chunks)
{
monde.chunks.Add(c.Key, c.Value.Clone());
}
foreach (Entite ent in entites)
{
monde.entites.Add(ent.Clone());
}
return(monde);
}
/// <summary>
/// attaque
/// </summary>
/// <param name="joueur"></param>
/// <returns>return true si tu dois rafraichir l'image</returns>
public virtual bool CliqueGauche(Entite ent, int dommage, Monde monde)
{
int dommageAFaire = dommage;
if (ent != null && ent is Joueur joueur)
{
Item item = joueur.Barre.GetItem(joueur.Maindroite);
if (item is Arme arme)
{
dommageAFaire = arme.Degat;
}
}
vie -= dommageAFaire;
if (vie <= 0)
{
monde.Entites.Remove(this);
return(true);
}
return(false);
}
/// <summary>
/// Permet de Sauvegarder un monde à l'endroit que tu veux</br>
/// System.IO.Directory.GetCurrentDirectory() pour recuperer le dossier de l'application
/// </summary>
/// <param name="monde"></param>
/// <param name="path"></param>
public static void SauvegarderMonde(Monde monde, string path)
{
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
File.WriteAllLines(path + "\\info.txt", new string[] { "Generateur:" + monde.Generateur.Nom, "Seed:" + monde.Generateur.Noise.Seed });
Directory.CreateDirectory(path + "\\Entities");
for (int i = 0; i < monde.Entites.Count; i++)
{
Entite ent = monde.Entites[i];
Directory.CreateDirectory(path + "\\Entities\\" + i + "." + ent.id());
ent.Sauvegarder(path + "\\Entities\\" + i + "." + ent.id());
}
foreach (KeyValuePair <string, Chunk> chunks in monde.Chunks)
{
string[] s = chunks.Key.Split('/');
string c = s[0] + "." + s[1] + "." + chunks.Value.Generer;
Directory.CreateDirectory(path + "\\Chunks\\" + c);
for (int bx = 0; bx < 16; bx++)
{
for (int by = 0; by < 16; by++)
{
Block block = chunks.Value.Blocks[bx, by];
if (block != null)
{
Directory.CreateDirectory(path + "\\Chunks\\" + c + "\\" + bx + "." + by + "." + block.Name);
block.Sauvegarder(path + "\\Chunks\\" + c + "\\" + bx + "." + by + "." + block.Name);
}
}
}
}
}
public override bool Comportement(Monde monde)
{
foreach (Entite ent in monde.Entites)
{
if (ent is Joueur j)
{
if (X != j.X && X != j.X - 1 && X != j.X + 1)
{
float tx = x > j.X ? -1 : 1;
Block b = monde.GetBlock((int)(x + tx), (int)y, false);
Block b2 = monde.GetBlock((int)(x + tx), (int)y + 1, false);
if (b == null || b.CanPassThrough(this, false) ||
b2 == null || b2.CanPassThrough(this, false))
{
Bouger(tx / 2, 0, monde);
return(true);
}
}
return(false);
}
}
return(false);
}
public override Tuple <bool, Tuple <Ecrans, object> > CliqueDroite(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
//TODO : systeme de paré(se proteger)
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}
/// <summary>
/// Faire bouger le personnage(déplacement) (maximum 1 block de distance)
/// </summary>
/// <returns>s'il est bloquer</returns>
public virtual bool Bouger(float nx, int ny, Monde monde)
{
if (nx > 1)
{
nx = 1;
}
if (nx < -1)
{
nx = -1;
}
if (ny > 1)
{
ny = 1;
}
if (ny < -1)
{
ny = -1;
}
if (nx != 0 && ny != 0)
{
ny = 0;
}
Func <Block, bool, bool> pass = (iblock, byGrav) =>
{
return(iblock == null || iblock.CanPassThrough(this, byGrav));
};
Block block = monde.GetBlock((int)(x + nx), (int)y + ny, true);
if (pass(block, false))
{
int tomber = -3;
x += nx;
y += ny;
while (pass(monde.GetBlock((int)x, (int)y - 1, true), true))
{
y--;
tomber++;
}
if (tomber > 0)
{
Vie -= tomber;
}
}
else if (ny == 0)
{
block = monde.GetBlock((int)(x + nx), (int)y + 1, true);
Block dessus = monde.GetBlock((int)x, (int)y + 1, true);
if (pass(block, false) && pass(dessus, false))
{
x += nx;
y++;
}
else
{
return(true);
}
}
return(false);
}
/// <summary>
/// fait des chose selon un timer de 20 tick par seconde
/// </summary>
/// <param name="monde"></param>
/// <returns>si besion d'actualiser l'ecran</returns>
public virtual bool Comportement(Monde monde)
{
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="joueur"></param>
/// <param name="bx"></param>
/// <param name="by"></param>
/// <param name="block"></param>
/// <param name="monde"></param>
/// <returns>true si effectue le clique droit sur block / entite</returns>
public virtual Tuple <bool, Tuple <Ecrans, object> > CliqueDroite(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}
public override Tuple <bool, Tuple <Ecrans, object> > CliqueDroite(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
//ouvre inventaire
return(new Tuple <bool, Tuple <Ecrans, object> >(false, new Tuple <Ecrans, object>(Ecrans.Inventaire, new Inventaire[] { inventaire, joueur.Inventaire, joueur.Barre })));
}
/// <summary>
///
/// </summary>
/// <param name="joueur"></param>
/// <param name="bx"></param>
/// <param name="by"></param>
/// <param name="block"></param>
/// <param name="monde"></param>
/// <returns>
/// true si effectue le clique droit sur block / entite</br>
/// null pour rester dans l'ecran</br>
/// </returns>
public virtual Tuple <bool, Tuple <Ecrans, object> > CliqueGauche(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
//Attaquer et creuser
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}
/// <summary>
/// place un block si ni a rien
/// </summary>
/// <param name="joueur"></param>
/// <param name="bx"></param>
/// <param name="by"></param>
/// <param name="block"></param>
/// <param name="entite"></param>
/// <param name="monde"></param>
/// <returns></returns>
public override Tuple <bool, Tuple <Ecrans, object> > CliqueDroite(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
if (block == null && entite == null)
{
monde.SetBlock(bx, by, this.block.Clone());
Item it = Clone();
it.Quantite = 1;
joueur.EnleverItem(it);
return(new Tuple <bool, Tuple <Ecrans, object> >(false, null));
}
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}
/// <summary>
/// Permet de Charger un monde</br>
/// System.IO.Directory.GetCurrentDirectory() pour recuperer le dossier de l'application</br>
/// le monde recuperer (si le dossier du monde exists) il sera dans Sauvegarde.monde</br>
/// le joueur sera initer avec le monde
/// </summary>
/// <param name="path"></param>
public static void ChargerMonde(string path)
{
if (Directory.Exists(path))
{
string[] mondeOptions = File.ReadAllLines(path + "\\info.txt");
long seed = long.Parse(mondeOptions[1].Split(':')[1]);
Generateur generateur = null;
switch (mondeOptions[0].Split(':')[1])
{
case "GenerateurParDefault":
generateur = new GenerateurParDefault(new Noise(seed));
break;
case "VoidGenerateur":
generateur = new VoidGenerateur(new Noise(seed));
break;
case "FlatGenerateur":
generateur = new FlatGenerateur(new Noise(seed));
break;
}
if (generateur != null)
{
string[] ents = Directory.GetDirectories(path + "\\Entities");
int max = -1;
List <KeyValuePair <int, Entite> > entities = new List <KeyValuePair <int, Entite> >();
foreach (string entpath in ents)
{
string[] n = entpath.Split('\\');
string[] a = n[n.Length - 1].Split('.');
Entite ent = Entite.Entites()[a[1]].Charger(entpath);
int i = int.Parse(a[0]);
if (i > max)
{
max = i;
}
entities.Add(new KeyValuePair <int, Entite>(i, ent));
if (ent is Joueur j)
{
joueur = j;
}
}
Entite[] entites = new Entite[max + 1];
foreach (KeyValuePair <int, Entite> ent in entities)
{
entites[ent.Key] = ent.Value;
}
monde = new Monde(generateur, entites.ToList());
string[] chunks = Directory.GetDirectories(path + "\\Chunks");
foreach (string cpath in chunks)
{
string[] blocksFile = Directory.GetDirectories(cpath);
Block[,] blocks = new Block[16, 16];
foreach (string blockfile in blocksFile)
{
string[] bnom = blockfile.Split('\\');
string[] bcoord = bnom[bnom.Length - 1].Split('.');
int bx = int.Parse(bcoord[0]);
int by = int.Parse(bcoord[1]);
Block block = Block.Blocks()[bcoord[2]].Charger(blockfile);
blocks[bx, by] = block;
}
string[] cnom = cpath.Split('\\');
string[] coord = cnom[cnom.Length - 1].Split('.');
int cx = int.Parse(coord[0]);
int cy = int.Parse(coord[1]);
bool generer = bool.Parse(coord[2]);
monde.SetChunk(cx, cy, new Chunk(blocks, generer));
}
}
}
}
public override Tuple <bool, Tuple <Ecrans, object> > CliqueGauche(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
if (block != null)
{
durabiliter--;
if (durabiliter == 0)
{
joueur.EnleverItem(this);
}
}
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}
/// <summary>
/// mange</br>
/// N'ENLEVE PAS L'ITEM DE L'INVENTAIRE
/// </summary>
/// <param name="joueur"></param>
/// <param name="bx"></param>
/// <param name="by"></param>
/// <param name="block"></param>
/// <param name="entite"></param>
/// <param name="monde"></param>
/// <returns>true si effectue le clique droit sur block / entite</returns>
public override Tuple <bool, Tuple <Ecrans, object> > CliqueDroite(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
if (entite == null)
{
joueur.Faim += faimRestoree;
quantite--;
return(new Tuple <bool, Tuple <Ecrans, object> >(false, null));
}
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}
public override Tuple <bool, Tuple <Ecrans, object> > CliqueDroite(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
Item it = joueur.MainDroit();
if (it is Casque casque)
{
joueur.Barre.SetItem(joueur.Maindroite, joueur.Casque);
joueur.Casque = casque;
}
if (it is Plastron plastron)
{
joueur.Barre.SetItem(joueur.Maindroite, joueur.Plastron);
joueur.Plastron = plastron;
}
if (it is Jambiere jambiere)
{
joueur.Barre.SetItem(joueur.Maindroite, joueur.Jambiere);
joueur.Jambiere = jambiere;
}
if (it is Botte Botte)
{
joueur.Barre.SetItem(joueur.Maindroite, joueur.Botte);
joueur.Botte = Botte;
}
return(new Tuple <bool, Tuple <Ecrans, object> >(false, null));
}
public override Tuple <bool, Tuple <Ecrans, object> > CliqueGauche(Joueur joueur, int bx, int by, Block block, Entite entite, Monde monde)
{
//dans le system de degat. les degats de larme son deja pris en compte
if (entite != null)
{
durabiliter--;
if (durabiliter == 0)
{
joueur.EnleverItem(this);
}
}
return(new Tuple <bool, Tuple <Ecrans, object> >(true, null));
}