コード例 #1
0
ファイル: Joueur.cs プロジェクト: RedYou1/Minecraft-Form
        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));
        }
コード例 #2
0
ファイル: Zombie.cs プロジェクト: RedYou1/Minecraft-Form
 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);
 }
コード例 #3
0
ファイル: Joueur.cs プロジェクト: RedYou1/Minecraft-Form
        public override bool Bouger(float nx, int ny, Monde monde)
        {
            bool a = base.Bouger(nx, ny, monde);

            if (!a)
            {
                Faim -= 0.05f;
            }
            return(a);
        }
コード例 #4
0
        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);
        }
コード例 #5
0
 /// <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);
     }
 }
コード例 #6
0
        /// <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);
        }
コード例 #7
0
        /// <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);
        }
コード例 #8
0
ファイル: Sauvegarde.cs プロジェクト: RedYou1/Minecraft-Form
        /// <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);
                        }
                    }
                }
            }
        }
コード例 #9
0
ファイル: Zombie.cs プロジェクト: RedYou1/Minecraft-Form
 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);
 }
コード例 #10
0
 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));
 }
コード例 #11
0
        /// <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);
        }
コード例 #12
0
 /// <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);
 }
コード例 #13
0
ファイル: Item.cs プロジェクト: RedYou1/Minecraft-Form
 /// <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));
 }
コード例 #14
0
ファイル: Sacados.cs プロジェクト: RedYou1/Minecraft-Form
 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 })));
 }
コード例 #15
0
ファイル: Item.cs プロジェクト: RedYou1/Minecraft-Form
 /// <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));
 }
コード例 #16
0
ファイル: Item_Block.cs プロジェクト: RedYou1/Minecraft-Form
        /// <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));
        }
コード例 #17
0
ファイル: Sauvegarde.cs プロジェクト: RedYou1/Minecraft-Form
        /// <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));
                    }
                }
            }
        }
コード例 #18
0
 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));
 }
コード例 #19
0
ファイル: Nourriture.cs プロジェクト: RedYou1/Minecraft-Form
 /// <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));
 }
コード例 #20
0
ファイル: Armure.cs プロジェクト: RedYou1/Minecraft-Form
        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));
        }
コード例 #21
0
 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));
 }