public void Start(ref Graphics R_g, int warBrz, int sasiedztwo, int promien)
        {
            /*
             * Von Neuman V
             * Moore V
             * Pentagonalne losowe V
             * Heksagonalne Lewe V
             * Heksagonalne Prawe V
             * Heksagonalne Losowe
             * Z promieniem
             */
            Random       random = new Random();
            MapaSasiadow mapa   = new MapaSasiadow();

            List <List <Cell> > R_grid_kopia = new List <List <Cell> >();

            for (int i = 0; i < x; i++)
            {
                R_grid_kopia.Add(new List <Cell>());
                for (int j = 0; j < y; j++)
                {
                    R_grid_kopia[i].Add(new Cell());
                }
            }

            int  pentagonalne_losowe;
            int  heksagonalne_losowe = 0;
            bool ischanged           = true;

            while (ischanged)
            {
                ischanged = false;

                for (int i = 0; i < x; i++)
                {
                    for (int j = 0; j < y; j++)
                    {
                        R_grid_kopia[i][j].Copy(grid[i][j]);
                    }
                }

                for (int j = 0; j < y; j++)
                {
                    for (int i = 0; i < x; i++)
                    {
                        pentagonalne_losowe = random.Next(0, 4);
                        if (sasiedztwo == 5)
                        {
                            heksagonalne_losowe = random.Next(1, 3);
                        }
                        if (!R_grid_kopia[i][j].Get_state_b())
                        {
                            // z promieniem
                            int X_od = -1, Y_od = -1, X_do = 1, Y_do = 1, srodekX = 0, srodekY = 0;
                            if (sasiedztwo == 6)
                            {
                                srodekX = i * size + 1 + size / 2 + R_grid_kopia[i][j].Get_przesuniecie_x() * size / 4;
                                srodekY = j * size + 1 + size / 2 + R_grid_kopia[i][j].Get_przesuniecie_y() * size / 4;
                                X_od    = -x;
                                X_do    = x;
                                Y_od    = -y;
                                Y_do    = y;
                            }


                            for (int ci = X_od; ci <= X_do; ci++)
                            {
                                for (int cj = Y_od; cj <= Y_do; cj++)
                                {
                                    if (cj == 0 && ci == 0)
                                    {
                                        continue;
                                    }
                                    //Von neuman
                                    else if (sasiedztwo == 0 && (ci == -1 && cj == -1 || ci == 1 && cj == -1 || ci == -1 && cj == 1 || ci == 1 && cj == 1))
                                    {
                                        continue;
                                    }
                                    //Pentagonalne ignorujemy prawe
                                    else if (sasiedztwo == 2 && pentagonalne_losowe == 0 && (ci == 1 && cj == -1 || ci == 1 && cj == 0 || ci == 1 && cj == 1))
                                    {
                                        continue;
                                    }
                                    //Pentagonalne ignorujemy lewe
                                    else if (sasiedztwo == 2 && pentagonalne_losowe == 1 && (ci == -1 && cj == -1 || ci == -1 && cj == 0 || ci == -1 && cj == 1))
                                    {
                                        continue;
                                    }
                                    //Pentagonalne ignorujemy gora
                                    else if (sasiedztwo == 2 && pentagonalne_losowe == 2 && (ci == -1 && cj == -1 || ci == 0 && cj == -1 || ci == 1 && cj == -1))
                                    {
                                        continue;
                                    }
                                    //Pentagonalne ignorujemy dol
                                    else if (sasiedztwo == 2 && pentagonalne_losowe == 3 && (ci == -1 && cj == 1 || ci == 0 && cj == 1 || ci == 1 && cj == 1))
                                    {
                                        continue;
                                    }
                                    //Heksagonalne lewe
                                    else if ((heksagonalne_losowe == 1 || sasiedztwo == 3) && (ci == -1 && cj == -1 || ci == 1 && cj == 1))
                                    {
                                        continue;
                                    }
                                    //Heksagonalne prawe
                                    else if ((heksagonalne_losowe == 2 || sasiedztwo == 4) && (ci == 1 && cj == -1 || ci == -1 && cj == 1))
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        double pkt_promien     = 0;
                                        double promien_kwadrat = 0;
                                        if (sasiedztwo == 6)
                                        {
                                            pkt_promien     = Math.Pow((srodekX - ((i + ci) * size + 1 + size / 2 + R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_x() * size / 4)), 2.0) + Math.Pow((srodekY - ((j + cj) * size + 1 + size / 2 + R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_y() * size / 4)), 2.0);
                                            promien_kwadrat = Math.Pow(promien, 2.0);
                                        }
                                        switch (warBrz)
                                        {
                                        case 0:     //periodyczne
                                            if (sasiedztwo != 6 && R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                            {
                                                int kolorek = R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id();
                                                mapa.Add(kolorek);
                                            }
                                            else if (pkt_promien <= promien_kwadrat && R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                            {
                                                int kolorek = R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id();
                                                mapa.Add(kolorek);
                                            }
                                            break;

                                        case 1:     // pochlaniajace
                                            if (sasiedztwo != 6 && (i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0 && R_grid_kopia[i + ci][j + cj].Get_state_b()))
                                            {
                                                mapa.Add((R_grid_kopia[i + ci][j + cj].Get_kolor_id()));
                                            }
                                            else if ((i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0) && pkt_promien <= promien_kwadrat && R_grid_kopia[i + ci][j + cj].Get_state_b())
                                            {
                                                mapa.Add((R_grid_kopia[i + ci][j + cj].Get_kolor_id()));
                                            }
                                            break;
                                        }
                                    }
                                }
                            }

                            if (mapa.WhetherAdd())
                            {
                                grid[i][j].Set_state(true);
                                grid[i][j].Set_color(mapa.GetMostFrequentColor());
                                grid[i][j].Draw(R_g, i * size + 1, j * size + 1, size - 1, border);
                                ischanged = true;
                            }

                            /*Pen blackPen = new Pen(Color.Black, 3);
                             * R_g.DrawEllipse(blackPen, (i * size + 1 + size / 2 + grid[i][j].get_przesuniecie_x() * size / 4), (j * size + +1 + size / 2 + grid[i][j].get_przesuniecie_y() * size / 4), 2, 2);*/
                        }
                        mapa.Clear();
                    }
                }
            }
        }
Exemple #2
0
        public void Monte_start(ref Graphics R_g, double kT, int warBrz, int sasiedztwo, int promien, int iter, int wyswietlanie)
        {
            int M_size   = x * y;
            int M_x      = 0;
            int M_y      = 0;
            int kolor_id = 0;

            double randomNumber;
            double delta_energy;
            double Prawd;
            int    random_color;

            MapaSasiadow        mapa_oryg    = new MapaSasiadow();
            MapaSasiadow        mapa_temp    = new MapaSasiadow();
            RandomGenerator     randomCords  = new RandomGenerator();
            List <List <Cell> > R_grid_kopia = new List <List <Cell> >();

            for (int k = 0; k < x; k++)
            {
                R_grid_kopia.Add(new List <Cell>());
                for (int j = 0; j < y; j++)
                {
                    R_grid_kopia[k].Add(new Cell());
                }
            }


            for (int iter_start = 0; iter_start < iter; iter_start++)
            {
                randomCords.Create(x, y);
                for (int k = 0; k < x; k++)
                {
                    for (int j = 0; j < y; j++)
                    {
                        R_grid_kopia[k][j].Copy(grid[k][j]);
                    }
                }
                for (int i = 0; i < M_size; i++)
                {
                    randomCords.Get_random(ref M_x, ref M_y);
                    kolor_id = grid[M_x][M_y].Get_kolor_id();

                    // z promieniem
                    Monte_cacl(ref R_grid_kopia, ref M_x, ref M_y, ref sasiedztwo, ref promien, ref warBrz, ref kolor_id, ref mapa_oryg);

                    random_color = mapa_oryg.GetRandomColor();
                    Monte_cacl(ref R_grid_kopia, ref M_x, ref M_y, ref sasiedztwo, ref promien, ref warBrz, ref random_color, ref mapa_temp);

                    randomNumber = random.NextDouble();
                    delta_energy = mapa_temp.GetEnergy() - mapa_oryg.GetEnergy();
                    Prawd        = Math.Exp(-delta_energy / kT);

                    if (delta_energy <= 0 || (delta_energy > 0 && Prawd <= randomNumber))
                    {
                        grid[M_x][M_y].Set_state(true);
                        grid[M_x][M_y].Set_color(random_color);
                        if (wyswietlanie == 0)
                        {
                            grid[M_x][M_y].Draw(R_g, M_x * size + 1, M_y * size + 1, size - 1, border);
                        }

                        energyGrid[M_x][M_y] = mapa_temp.GetEnergy();
                    }
                    else
                    {
                        energyGrid[M_x][M_y] = mapa_oryg.GetEnergy();
                    }


                    mapa_oryg.Clear();
                    mapa_temp.Clear();
                }
                randomCords.Clear();
                if (wyswietlanie == 1)
                {
                    Draw_energy(ref R_g);
                }
            }
        }
Exemple #3
0
        void NowaEnergia(int sasiedztwo, int promien, int warBrz)
        {
            MapaSasiadow mapa = new MapaSasiadow();

            int    pentagonalne_losowe;
            int    heksagonalne_losowe;
            int    X_od = -1, Y_od = -1, X_do = 1, Y_do = 1, srodekX = 0, srodekY = 0;
            double dyslok_komorki = 0;

            for (int i = 0; i < x; i++)
            {
                for (int j = 0; j < y; j++)
                {
                    dyslok_komorki      = grid[i][j].Get_dyslokacje();
                    pentagonalne_losowe = random.Next(0, 4);
                    heksagonalne_losowe = 0;
                    if (sasiedztwo == 5)
                    {
                        heksagonalne_losowe = random.Next(1, 3);
                    }

                    // z promieniem
                    X_od = -1; Y_od = -1; X_do = 1; Y_do = 1; srodekX = 0; srodekY = 0;
                    if (sasiedztwo == 6)
                    {
                        srodekX = i * size + 1 + size / 2 + grid[i][j].Get_przesuniecie_x() * size / 4;
                        srodekY = i * size + 1 + size / 2 + grid[i][j].Get_przesuniecie_y() * size / 4;
                        X_od    = -x;
                        X_do    = x;
                        Y_od    = -y;
                        Y_do    = y;
                    }


                    for (int ci = X_od; ci <= X_do; ci++)
                    {
                        for (int cj = Y_od; cj <= Y_do; cj++)
                        {
                            if (cj == 0 && ci == 0)
                            {
                                continue;
                            }
                            //Von neuman
                            else if (sasiedztwo == 0 && (ci == -1 && cj == -1 || ci == 1 && cj == -1 || ci == -1 && cj == 1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy prawe
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 0 && (ci == 1 && cj == -1 || ci == 1 && cj == 0 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy lewe
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 1 && (ci == -1 && cj == -1 || ci == -1 && cj == 0 || ci == -1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy gora
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 2 && (ci == -1 && cj == -1 || ci == 0 && cj == -1 || ci == 1 && cj == -1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy dol
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 3 && (ci == -1 && cj == 1 || ci == 0 && cj == 1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Heksagonalne lewe
                            else if ((heksagonalne_losowe == 1 || sasiedztwo == 3) && (ci == -1 && cj == -1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Heksagonalne prawe
                            else if ((heksagonalne_losowe == 2 || sasiedztwo == 4) && (ci == 1 && cj == -1 || ci == -1 && cj == 1))
                            {
                                continue;
                            }
                            else
                            {
                                double pkt_promien     = 0;
                                double promien_kwadrat = 0;
                                if (sasiedztwo == 6)
                                {
                                    pkt_promien     = Math.Pow((srodekX - ((i + ci) * size + 1 + size / 2 + grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_x() * size / 4)), 2.0) + Math.Pow((srodekY - ((j + cj) * size + 1 + size / 2 + grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_y() * size / 4)), 2.0);
                                    promien_kwadrat = Math.Pow(promien, 2.0);
                                }
                                switch (warBrz)
                                {
                                case 0:     //periodyczne
                                    if (sasiedztwo != 6 && grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                    {
                                        mapa.Add(grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    else if (pkt_promien <= promien_kwadrat && grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                    {
                                        mapa.Add(grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    break;

                                case 1:     // pochlaniajace
                                    if (sasiedztwo != 6 && (i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0 && grid[i + ci][j + cj].Get_state_b()))
                                    {
                                        mapa.Add(grid[i + ci][j + cj].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    else if ((i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0) && pkt_promien <= promien_kwadrat && grid[i + ci][j + cj].Get_state_b())
                                    {
                                        mapa.Add(grid[i + ci][j + cj].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    energyGrid[i][j] = mapa.GetEnergy();

                    mapa.Clear();
                }
            }
        }
Exemple #4
0
        protected void Monte_cacl(ref List <List <Cell> > R_grid_kopia, ref int M_x, ref int M_y, ref int sasiedztwo, ref int promien, ref int warBrz, ref int kolor_id, ref MapaSasiadow mapa)
        {
            int pentagonalne_losowe = random.Next(0, 4);
            int heksagonalne_losowe = 0;

            if (sasiedztwo == 5)
            {
                heksagonalne_losowe = random.Next(1, 3);
            }

            // z promieniem
            int X_od = -1, Y_od = -1, X_do = 1, Y_do = 1, srodekX = 0, srodekY = 0;

            if (sasiedztwo == 6)
            {
                srodekX = M_x * size + 1 + size / 2 + R_grid_kopia[M_x][M_y].Get_przesuniecie_x() * size / 4;
                srodekY = M_y * size + 1 + size / 2 + R_grid_kopia[M_x][M_y].Get_przesuniecie_y() * size / 4;
                X_od    = -x;
                X_do    = x;
                Y_od    = -y;
                Y_do    = y;
            }


            for (int ci = X_od; ci <= X_do; ci++)
            {
                for (int cj = Y_od; cj <= Y_do; cj++)
                {
                    if (cj == 0 && ci == 0)
                    {
                        continue;
                    }
                    //Von neuman
                    else if (sasiedztwo == 0 && (ci == -1 && cj == -1 || ci == 1 && cj == -1 || ci == -1 && cj == 1 || ci == 1 && cj == 1))
                    {
                        continue;
                    }
                    //Pentagonalne ignorujemy prawe
                    else if (sasiedztwo == 2 && pentagonalne_losowe == 0 && (ci == 1 && cj == -1 || ci == 1 && cj == 0 || ci == 1 && cj == 1))
                    {
                        continue;
                    }
                    //Pentagonalne ignorujemy lewe
                    else if (sasiedztwo == 2 && pentagonalne_losowe == 1 && (ci == -1 && cj == -1 || ci == -1 && cj == 0 || ci == -1 && cj == 1))
                    {
                        continue;
                    }
                    //Pentagonalne ignorujemy gora
                    else if (sasiedztwo == 2 && pentagonalne_losowe == 2 && (ci == -1 && cj == -1 || ci == 0 && cj == -1 || ci == 1 && cj == -1))
                    {
                        continue;
                    }
                    //Pentagonalne ignorujemy dol
                    else if (sasiedztwo == 2 && pentagonalne_losowe == 3 && (ci == -1 && cj == 1 || ci == 0 && cj == 1 || ci == 1 && cj == 1))
                    {
                        continue;
                    }
                    //Heksagonalne lewe
                    else if ((heksagonalne_losowe == 1 || sasiedztwo == 3) && (ci == -1 && cj == -1 || ci == 1 && cj == 1))
                    {
                        continue;
                    }
                    //Heksagonalne prawe
                    else if ((heksagonalne_losowe == 2 || sasiedztwo == 4) && (ci == 1 && cj == -1 || ci == -1 && cj == 1))
                    {
                        continue;
                    }
                    else
                    {
                        double pkt_promien     = 0;
                        double promien_kwadrat = 0;
                        if (sasiedztwo == 6)
                        {
                            pkt_promien     = Math.Pow((srodekX - ((M_x + ci) * size + 1 + size / 2 + R_grid_kopia[Modulo(M_x + ci, x)][Modulo(M_y + cj, y)].Get_przesuniecie_x() * size / 4)), 2.0) + Math.Pow((srodekY - ((M_y + cj) * size + 1 + size / 2 + R_grid_kopia[Modulo(M_x + ci, x)][Modulo(M_y + cj, y)].Get_przesuniecie_y() * size / 4)), 2.0);
                            promien_kwadrat = Math.Pow(promien, 2.0);
                        }
                        switch (warBrz)
                        {
                        case 0:     //periodyczne
                            if (sasiedztwo != 6 && R_grid_kopia[Modulo(M_x + ci, x)][Modulo(M_y + cj, y)].Get_state_b())
                            {
                                int kolorek = R_grid_kopia[Modulo(M_x + ci, x)][Modulo(M_y + cj, y)].Get_kolor_id();
                                mapa.Add(kolorek, kolor_id);
                            }
                            else if (pkt_promien <= promien_kwadrat && R_grid_kopia[Modulo(M_x + ci, x)][Modulo(M_y + cj, y)].Get_state_b())
                            {
                                int kolorek = R_grid_kopia[Modulo(M_x + ci, x)][Modulo(M_y + cj, y)].Get_kolor_id();
                                mapa.Add(kolorek, kolor_id);
                            }
                            break;

                        case 1:     // pochlaniajace
                            if (sasiedztwo != 6 && (M_x + ci < x && M_x + ci >= 0 && M_y + cj < y && M_y + cj >= 0 && R_grid_kopia[M_x + ci][M_y + cj].Get_state_b()))
                            {
                                mapa.Add((R_grid_kopia[M_x + ci][M_y + cj].Get_kolor_id()), kolor_id);
                            }
                            else if ((M_x + ci < x && M_x + ci >= 0 && M_y + cj < y && M_y + cj >= 0) && pkt_promien <= promien_kwadrat && R_grid_kopia[M_x + ci][M_y + cj].Get_state_b())
                            {
                                mapa.Add((R_grid_kopia[M_x + ci][M_y + cj].Get_kolor_id()), kolor_id);
                            }
                            break;
                        }
                    }
                }
            }
        }
Exemple #5
0
        void Rozrost(double timestepbefore, double timestep, int sasiedztwo, int promien, int warBrz)
        {
            MapaSasiadow mapa = new MapaSasiadow();

            int    pentagonalne_losowe;
            int    heksagonalne_losowe;
            int    X_od = -1, Y_od = -1, X_do = 1, Y_do = 1, srodekX = 0, srodekY = 0;
            double dyslok_komorki            = 0;
            List <List <Cell> > R_grid_kopia = new List <List <Cell> >();

            for (int k = 0; k < x; k++)
            {
                R_grid_kopia.Add(new List <Cell>());
                for (int j = 0; j < y; j++)
                {
                    R_grid_kopia[k].Add(new Cell());
                    R_grid_kopia[k][j].Copy(grid[k][j]);
                }
            }

            for (int i = 0; i < x; i++)
            {
                for (int j = 0; j < y; j++)
                {
                    dyslok_komorki      = grid[i][j].Get_dyslokacje();
                    pentagonalne_losowe = random.Next(0, 4);
                    heksagonalne_losowe = 0;
                    if (sasiedztwo == 5)
                    {
                        heksagonalne_losowe = random.Next(1, 3);
                    }

                    // z promieniem
                    X_od = -1; Y_od = -1; X_do = 1; Y_do = 1; srodekX = 0; srodekY = 0;
                    if (sasiedztwo == 6)
                    {
                        srodekX = i * size + 1 + size / 2 + R_grid_kopia[i][j].Get_przesuniecie_x() * size / 4;
                        srodekY = i * size + 1 + size / 2 + R_grid_kopia[i][j].Get_przesuniecie_y() * size / 4;
                        X_od    = -x;
                        X_do    = x;
                        Y_od    = -y;
                        Y_do    = y;
                    }


                    for (int ci = X_od; ci <= X_do; ci++)
                    {
                        for (int cj = Y_od; cj <= Y_do; cj++)
                        {
                            if (cj == 0 && ci == 0)
                            {
                                continue;
                            }
                            //Von neuman
                            else if (sasiedztwo == 0 && (ci == -1 && cj == -1 || ci == 1 && cj == -1 || ci == -1 && cj == 1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy prawe
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 0 && (ci == 1 && cj == -1 || ci == 1 && cj == 0 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy lewe
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 1 && (ci == -1 && cj == -1 || ci == -1 && cj == 0 || ci == -1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy gora
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 2 && (ci == -1 && cj == -1 || ci == 0 && cj == -1 || ci == 1 && cj == -1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy dol
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 3 && (ci == -1 && cj == 1 || ci == 0 && cj == 1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Heksagonalne lewe
                            else if ((heksagonalne_losowe == 1 || sasiedztwo == 3) && (ci == -1 && cj == -1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Heksagonalne prawe
                            else if ((heksagonalne_losowe == 2 || sasiedztwo == 4) && (ci == 1 && cj == -1 || ci == -1 && cj == 1))
                            {
                                continue;
                            }
                            else
                            {
                                double pkt_promien     = 0;
                                double promien_kwadrat = 0;
                                if (sasiedztwo == 6)
                                {
                                    pkt_promien     = Math.Pow((srodekX - ((i + ci) * size + 1 + size / 2 + R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_x() * size / 4)), 2.0) + Math.Pow((srodekY - ((j + cj) * size + 1 + size / 2 + R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_y() * size / 4)), 2.0);
                                    promien_kwadrat = Math.Pow(promien, 2.0);
                                }
                                switch (warBrz)
                                {
                                case 0:     //periodyczne
                                    if (sasiedztwo != 6 && R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                    {
                                        mapa.addDyslok(R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_dyslokacje(), dyslok_komorki);
                                        if (R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_rekrystalizowany_timestep() == timestepbefore)
                                        {
                                            mapa.Add(R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id());
                                        }
                                    }
                                    else if (pkt_promien <= promien_kwadrat && R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                    {
                                        mapa.addDyslok(R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_dyslokacje(), dyslok_komorki);
                                        if (R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_rekrystalizowany_timestep() == timestepbefore)
                                        {
                                            mapa.Add(R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id());
                                        }
                                    }
                                    break;

                                case 1:     // pochlaniajace
                                    if (sasiedztwo != 6 && (i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0 && R_grid_kopia[i + ci][j + cj].Get_state_b()))
                                    {
                                        mapa.addDyslok(R_grid_kopia[i + ci][j + cj].Get_dyslokacje(), dyslok_komorki);
                                        if (R_grid_kopia[i + ci][j + cj].Get_rekrystalizowany_timestep() == timestepbefore)
                                        {
                                            mapa.Add(R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id());
                                        }
                                    }
                                    else if ((i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0) && pkt_promien <= promien_kwadrat && R_grid_kopia[i + ci][j + cj].Get_state_b())
                                    {
                                        mapa.addDyslok(R_grid_kopia[i + ci][j + cj].Get_dyslokacje(), dyslok_komorki);
                                        if (R_grid_kopia[i + ci][j + cj].Get_rekrystalizowany_timestep() == timestepbefore)
                                        {
                                            mapa.Add(R_grid_kopia[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id());
                                        }
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    if (mapa.WhetherAdd() && mapa.WhetherDyslok())
                    {
                        grid[i][j].Zarodkuj(mapa.GetMostFrequentColor(), timestepbefore + timestep);
                    }

                    mapa.Clear();
                }
            }
        }