/// <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>
/// 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 virtual bool Equals(Entite ent)
{
return(ent != null && GetType() == ent.GetType() && x == ent.x && y == ent.y && vie == ent.vie);
}
/// <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));
}
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));
}
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>
/// 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 bool CanPassThrough(Entite entite, bool byGravity)
{
return(generateur);
}
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>
///
/// </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>
///
/// </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>
/// si l'entite peut le traverser
/// </summary>
/// <param name="ent"></param>
/// <param name="byGravity"></param>
/// <returns></returns>
public virtual bool CanPassThrough(Entite ent, bool byGravity)
{
return(false);
}
public override bool CanPassThrough(Entite ent, bool byGravity)
{
return(!byGravity);
}
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));
}
/// <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));
}
