예제 #1
0
 public bool AddOcupante(Bitmon bitmon)
 {
     if (ocupantes.Count() < 2)
     {
         ocupantes.Add(bitmon);
         this.Controls.Add(bitmon);
         return(true);
     }
     return(false);
 }
예제 #2
0
        private void Odio(Casilla c, Bitmon bitmon1, Bitmon bitmon2)
        {
            int vida1   = bitmon1.getvida();
            int vida2   = bitmon2.getvida();
            int ataque1 = bitmon1.getataque();
            int ataque2 = bitmon2.getataque();

            if (bitmon1.Tipo == "Gofue" && bitmon2.Tipo == "Taplan")
            {
                ataque1 = (int)((double)ataque1 * 1.5); //los gofue tienen ventaja sobre los taplans
            }

            if (bitmon1.Tipo == "Taplan" && bitmon2.Tipo == "Gofue")
            {
                ataque2 = (int)((double)ataque1 * 1.5); //los gofue tienen ventaja sobre los taplans
            }

            if (bitmon1.Tipo == "Dorvalo" && bitmon2.Tipo == "Gofue")
            {
                ataque2 = (int)((double)ataque2 * 0.8);//los dorvalos son resistentes a los gofue
            }

            if (bitmon1.Tipo == "Gofue" && bitmon2.Tipo == "Dorvalo")
            {
                ataque1 = (int)((double)ataque1 * 0.8);//los dorvalos son resistentes a los gofue
            }


            while (vida1 >= 1 && vida2 >= 1)
            {
                vida1 -= ataque2;
                vida2 -= ataque1;
            }

            if (vida1 < 1)
            {
                bitmons_alive.Remove(bitmon1);
                bithalla.Add(bitmon1);
                c.BorrarOcupante(bitmon1);
                bitmons_muertos_mes++;
            }
            if (vida2 < 1)
            {
                bitmons_alive.Remove(bitmon2);
                bithalla.Add(bitmon2);
                c.BorrarOcupante(bitmon2);
                bitmons_muertos_mes++;
            }
        }
예제 #3
0
 private void Interactuar(Casilla c, Bitmon bitmon1, Bitmon bitmon2)
 {
     if ((bitmon1.Tipo == "Gofue" && bitmon2.Tipo == "Taplan") || (bitmon1.Tipo == "Taplan" && bitmon2.Tipo == "Gofue"))
     {
         this.Odio(c, bitmon1, bitmon2);
     }
     else if ((bitmon1.Tipo == "Wetar" && bitmon2.Tipo == "Dorvalo") || (bitmon1.Tipo == "Wetar" && bitmon2.Tipo == "Dorvalo"))
     {
         this.Odio(c, bitmon1, bitmon2);
     }
     else if ((bitmon1.Tipo == "Dorvalo" && bitmon2.Tipo == "Taplan") || (bitmon1.Tipo == "Taplan" && bitmon2.Tipo == "Dorvalo"))
     {
         this.Odio(c, bitmon1, bitmon2);
     }
     else if ((bitmon1.Tipo == "Dorvalo" && bitmon2.Tipo == "Gofue") || (bitmon1.Tipo == "Dorvalo" && bitmon2.Tipo == "Dorvalo"))
     {
         this.Odio(c, bitmon1, bitmon2);
     }
     else
     {
         this.Amor(c, bitmon1, bitmon2);
     }
 }
예제 #4
0
 // eliminar ocupante
 // la necesitaba para avanzar a si que la hize yo
 public void BorrarOcupante(Bitmon b)
 {
     ocupantes.Remove(b);
     this.Controls.Remove(b);
 }
예제 #5
0
        private void Amor(Casilla c, Bitmon bitmon1, Bitmon bitmon2)
        {
            // crear nuevo bitmon siguiendo las reglas
            string tipo;
            double prob1;
            Bitmon bitmon;

            //con que probabilidad tendra la raza del progenitor 1 o 2
            if (bitmon1.Tipo != "Ent" && bitmon2.Tipo != "Ent")
            {
                if (bitmon1.getCantHijos() > bitmon2.getCantHijos())
                {
                    prob1 = 0.7;
                }
                else if (bitmon1.getCantHijos() < bitmon2.getCantHijos())
                {
                    prob1 = 0.3;
                }
                else
                {
                    prob1 = 0.5;
                }
                bitmon1.tenerHijo();
                bitmon2.tenerHijo();
                // de quien hereda la raza
                if (random.NextDouble() < prob1)
                {
                    tipo = bitmon1.Tipo;
                }
                else
                {
                    tipo = bitmon2.Tipo;
                }

                if (tipo == "Gofue")
                {
                    bitmon = new Gofue();
                }
                else if (tipo == "Dorvalo")
                {
                    bitmon = new Dorvalo();
                }
                else if (tipo == "Taplan")
                {
                    bitmon = new Taplan();
                }
                else if (tipo == "Ent")
                {
                    bitmon = new Ent();
                }
                else if (tipo == "Wetar")
                {
                    bitmon = new Wetar();
                }
                else
                {
                    bitmon = new Doti();
                }

                if (bitmon1.Tipo == bitmon2.Tipo)//los purasangre son mas fuertes
                {
                    bitmon.boostataque(5); bitmon.boostvida(18);
                }
                // agregar bitmon al mapelse if (tipo == "Gofue")a si es posible
                // todo lo que al nacer aparece en un terreno ocupado (2 bitmons) muere al instante (el fuerte se aprovecha del debil!)
                bool pocisionado      = false;
                bool TerrenoValido    = true;
                int  potencialCasilla = random.Next((cols * rows));
                int  cont             = 0;
                foreach (Casilla casilla in MapLayout.Controls)
                {
                    if (cont == potencialCasilla)
                    {
                        if ((bitmon.Tipo == "Wetar" && casilla.Tipo != "agua"))
                        {
                            TerrenoValido = false;
                        }

                        else
                        {
                            pocisionado = casilla.AddOcupante(bitmon);
                        }

                        if (pocisionado && TerrenoValido)
                        {
                            bitmon.SizeMode = PictureBoxSizeMode.Zoom;
                            bitmon.Size     = new Size((int)(600 / cols / 3), (int)(600 / cols / 3));

                            bitmons_alive.Add(bitmon);
                            bitmon.setpocision(cont);
                            if (bitmon.Tipo == "Gofue")
                            {
                                gofue_nacidos_mes++;
                            }
                            if (bitmon.Tipo == "Taplan")
                            {
                                taplan_nacidos_mes++;
                            }
                            if (bitmon.Tipo == "Dorvalo")
                            {
                                dorvalo_nacidos_mes++;
                            }
                            if (bitmon.Tipo == "Wetar")
                            {
                                wetar_nacidos_mes++;
                            }
                            if (bitmon.Tipo == "Dorvalo")
                            {
                                dorvalo_nacidos_mes++;
                            }
                        }
                        else
                        {
                            bithalla.Add(bitmon);
                        }
                        break;
                    }

                    ++cont;
                }
            }
        }
예제 #6
0
        private void timer_mes_Tick(object sender, EventArgs e)
        {
            if (mes_actual <= meses_restantes)
            {
                label_mes_actual.Text      = $"Mes actual: {mes_actual}";
                label_bitmons_vivos.Text   = $"Bitmons vivos: {bitmons_alive.Count}";
                label_bitmons_muertos.Text = $"Bitmons muertos: {bithalla.Count}";

                // recorrer bitmons_alive para mover a los wns.
                // Si los bitmons no se mueven, puede ser porque se quedan en una casilla nueva, en vez de la de maplayout.
                foreach (Bitmon bitmon in bitmons_alive)
                {
                    int     antigua_posicion = bitmon.Posicion;
                    Casilla antigua_casilla  = (Casilla)MapLayout.Controls[antigua_posicion];
                    int     nueva_posicion   = bitmon.Moverse(cols, rows);
                    Casilla nueva_casilla    = (Casilla)MapLayout.Controls[nueva_posicion];
                    if (nueva_casilla.ContarOcupantes < 2)
                    {
                        if (bitmon.Tipo == "Wetar")
                        {
                            if (nueva_casilla.Tipo == "agua")
                            {
                                nueva_casilla.AddOcupante(bitmon);
                                antigua_casilla.Ocupantes.Remove(bitmon);
                                bitmon.Posicion = nueva_posicion;
                            }
                            else
                            {
                                bitmon.Posicion = antigua_posicion;
                            }
                        }
                        else
                        {
                            nueva_casilla.AddOcupante(bitmon);
                            antigua_casilla.Ocupantes.Remove(bitmon);
                            bitmon.Posicion = nueva_posicion;
                        }
                    }
                    else
                    {
                        bitmon.Posicion = antigua_posicion;
                    }
                }

                // recorrer casillas del mapa para que interactuen los wns
                foreach (Casilla casilla in MapLayout.Controls)
                {
                    if (casilla.ContarOcupantes == 2)
                    {
                        Interactuar(casilla, casilla.Ocupantes[0], casilla.Ocupantes[1]);
                    }
                    foreach (Bitmon bitmon in casilla.Ocupantes)
                    {
                        casilla.Tipo = bitmon.InteractuarTerreno(casilla.Tipo);
                    }
                }

                if ((mes_actual % 3) == 0)
                {
                    PlantarUnArbol();
                }

                // Hay que revisar el tipo de interaccion
                // revisada
                // hola, voy a agregar todo lo necesario para que los bitmons no tengan juventud eterna
                foreach (Casilla casilla in MapLayout.Controls)
                {
                    for (int i = casilla.Ocupantes.Count - 1; i >= 0; --i)
                    {
                        try
                        {
                            Bitmon bitmon = casilla.Ocupantes[i];
                            bitmon.envejecer();
                            if (bitmon.gettrestante() >= bitmon.getTvida())
                            {
                                casilla.BorrarOcupante(bitmon);
                                bitmons_alive.Remove(bitmon);
                                bithalla.Add(bitmon);
                                bitmons_muertos_mes++;
                            }
                        }
                        catch (Exception)
                        {
                        }
                    }
                }

                suma_nacido_mes_dorvalo += dorvalo_nacidos_mes;
                suma_nacido_mes_doti    += doti_nacidos_mes;
                suma_nacido_mes_ent     += ent_nacidos_mes;
                suma_nacido_mes_gofue   += gofue_nacidos_mes;
                suma_nacido_mes_taplan  += taplan_nacidos_mes;
                suma_nacido_mes_wetar   += wetar_nacidos_mes;
                suma_muertos_mes        += bitmons_muertos_mes;

                mes_actual++;

                gofue_nacidos_mes   = 0;
                taplan_nacidos_mes  = 0;
                wetar_nacidos_mes   = 0;
                ent_nacidos_mes     = 0;
                dorvalo_nacidos_mes = 0;
                doti_nacidos_mes    = 0;
                bitmons_muertos_mes = 0;
            }
            else
            {
                timer_mes.Stop();

                // calcular edad promedio de todos <<< Esto puede ser un OnCalcularPromedio, evento, lo que sea... que lo haga el modelo, todo este else
                int     doti_count          = 0;
                decimal edad_promedio_doti  = 0;
                decimal hijos_promedio_doti = 0;

                int     ent_count          = 0;
                decimal edad_promedio_ent  = 0;
                decimal hijos_promedio_ent = 0;

                int     dorvalo_count          = 0;
                decimal edad_promedio_dorvalo  = 0;
                decimal hijos_promedio_dorvalo = 0;

                int     taplan_count          = 0;
                decimal edad_promedio_taplan  = 0;
                decimal hijos_promedio_taplan = 0;

                int     gofue_count          = 0;
                decimal edad_promedio_gofue  = 0;
                decimal hijos_promedio_gofue = 0;

                int     wetar_count          = 0;
                decimal edad_promedio_wetar  = 0;
                decimal hijos_promedio_wetar = 0;

                foreach (Bitmon bitmon in bithalla)
                {
                    if (bitmon.Tipo == "Doti")
                    {
                        doti_count++;
                        edad_promedio_doti  += bitmon.getedad();
                        hijos_promedio_doti += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Ent")
                    {
                        ent_count++;
                        edad_promedio_ent  += bitmon.getedad();
                        hijos_promedio_ent += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Dorvalo")
                    {
                        dorvalo_count++;
                        edad_promedio_dorvalo  += bitmon.getedad();
                        hijos_promedio_dorvalo += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Taplan")
                    {
                        taplan_count++;
                        edad_promedio_taplan  += bitmon.getedad();
                        hijos_promedio_taplan += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Gofue")
                    {
                        gofue_count++;
                        edad_promedio_gofue  += bitmon.getedad();
                        hijos_promedio_gofue += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Wetar")
                    {
                        wetar_count++;
                        edad_promedio_wetar  += bitmon.getedad();
                        hijos_promedio_wetar += bitmon.getCantHijos();
                    }
                }

                // 7
                estadisticas.BithalaCantidadBitmonsEspecie = new Dictionary <string, int>()
                {
                    { "Gofue", gofue_count },
                    { "Taplan", taplan_count },
                    { "Doti", doti_count },
                    { "Ent", ent_count },
                    { "Dorvalo", dorvalo_count },
                    { "Wetar", wetar_count }
                };

                foreach (Bitmon bitmon in bitmons_alive)
                {
                    if (bitmon.Tipo == "Doti")
                    {
                        doti_count++;
                        edad_promedio_doti  += bitmon.getedad();
                        hijos_promedio_doti += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Ent")
                    {
                        ent_count++;
                        edad_promedio_ent  += bitmon.getedad();
                        hijos_promedio_ent += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Dorvalo")
                    {
                        dorvalo_count++;
                        edad_promedio_dorvalo  += bitmon.getedad();
                        hijos_promedio_dorvalo += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Taplan")
                    {
                        taplan_count++;
                        edad_promedio_taplan  += bitmon.getedad();
                        hijos_promedio_taplan += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Gofue")
                    {
                        gofue_count++;
                        edad_promedio_gofue  += bitmon.getedad();
                        hijos_promedio_gofue += bitmon.getCantHijos();
                    }
                    else if (bitmon.Tipo == "Wetar")
                    {
                        wetar_count++;
                        edad_promedio_wetar  += bitmon.getedad();
                        hijos_promedio_wetar += bitmon.getCantHijos();
                    }
                }

                if (doti_count > 0)
                {
                    edad_promedio_doti  = edad_promedio_doti / doti_count;
                    hijos_promedio_doti = hijos_promedio_doti / doti_count;
                }
                if (ent_count > 0)
                {
                    edad_promedio_ent  = edad_promedio_ent / ent_count;
                    hijos_promedio_ent = hijos_promedio_ent / ent_count;
                }
                if (gofue_count > 0)
                {
                    edad_promedio_gofue  = edad_promedio_gofue / gofue_count;
                    hijos_promedio_gofue = hijos_promedio_gofue / gofue_count;
                }
                if (taplan_count > 0)
                {
                    edad_promedio_taplan  = edad_promedio_taplan / taplan_count;
                    hijos_promedio_taplan = hijos_promedio_taplan / taplan_count;
                }
                if (wetar_count > 0)
                {
                    edad_promedio_wetar  = edad_promedio_wetar / wetar_count;
                    hijos_promedio_wetar = hijos_promedio_wetar / wetar_count;
                }
                if (dorvalo_count > 0)
                {
                    edad_promedio_dorvalo  = edad_promedio_dorvalo / dorvalo_count;
                    hijos_promedio_dorvalo = hijos_promedio_dorvalo / dorvalo_count;
                }

                // 1
                estadisticas.TiempoVidaPromedio = Math.Round(
                    (edad_promedio_dorvalo * dorvalo_count +
                     edad_promedio_doti * doti_count +
                     edad_promedio_ent * ent_count +
                     edad_promedio_gofue * gofue_count +
                     edad_promedio_taplan * taplan_count +
                     edad_promedio_wetar * wetar_count) /
                    (dorvalo_count + doti_count + ent_count + gofue_count + taplan_count + wetar_count), 2);

                int decimales_estadistica = 4;
                // 2
                estadisticas.TiempoVidaPromedioEspecie = new Dictionary <string, decimal>()
                {
                    { "Gofue", Math.Round(edad_promedio_gofue, decimales_estadistica) },
                    { "Taplan", Math.Round(edad_promedio_taplan, decimales_estadistica) },
                    { "Doti", Math.Round(edad_promedio_doti, decimales_estadistica) },
                    { "Ent", Math.Round(edad_promedio_ent, decimales_estadistica) },
                    { "Dorvalo", Math.Round(edad_promedio_dorvalo, decimales_estadistica) },
                    { "Wetar", Math.Round(edad_promedio_wetar, decimales_estadistica) }
                };

                // 3
                estadisticas.TasaBrutaNatalidadEspecie = new Dictionary <string, decimal>()
                {
                    { "Gofue", Math.Round(suma_nacido_mes_gofue / meses_restantes, decimales_estadistica) },
                    { "Taplan", Math.Round(suma_nacido_mes_taplan / meses_restantes, decimales_estadistica) },
                    { "Doti", Math.Round(suma_nacido_mes_doti / meses_restantes, decimales_estadistica) },
                    { "Ent", Math.Round(suma_nacido_mes_ent / meses_restantes, decimales_estadistica) },
                    { "Dorvalo", Math.Round(suma_nacido_mes_dorvalo / meses_restantes, decimales_estadistica) },
                    { "Wetar", Math.Round(suma_nacido_mes_wetar / meses_restantes, decimales_estadistica) }
                };

                // 4
                estadisticas.TasaBrutaMortalidad = Math.Round(suma_muertos_mes / meses_restantes, 2);

                // 5
                estadisticas.CantidadHijosPromedioEspecie = new Dictionary <string, decimal>()
                {
                    { "Gofue", Math.Round(hijos_promedio_gofue, decimales_estadistica) },
                    { "Taplan", Math.Round(hijos_promedio_taplan, decimales_estadistica) },
                    { "Doti", Math.Round(hijos_promedio_doti, decimales_estadistica) },
                    { "Ent", Math.Round(hijos_promedio_ent, decimales_estadistica) },
                    { "Dorvalo", Math.Round(hijos_promedio_dorvalo, decimales_estadistica) },
                    { "Wetar", Math.Round(hijos_promedio_wetar, decimales_estadistica) }
                };

                // 6
                List <string> especies_extintas = new List <string>()
                {
                    "Gofue", "Taplan", "Doti", "Ent", "Dorvalo", "Wetar"
                };
                foreach (Bitmon b in bitmons_alive)
                {
                    if (especies_extintas.Contains(b.Tipo))
                    {
                        especies_extintas.Remove(b.Tipo);
                    }
                }
                estadisticas.EspeciesExtintas = especies_extintas;


                button_ver_estadisticas.Visible = true;
            }
        }