• API
• FAQ
• Tools
• Archive
daily pastebin goal
46%
SHARE
TWEET

# Untitled

a guest Jan 18th, 2019 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1. #include <iostream>
2. #define CIMGGIP_MAIN
3. #include "CImgGIP05.h"
4. using namespace std;
5. using namespace cimg_library;
6.
7. const int grid_size = 10; // Anzahl an Kaestchen in x- und y-Richtung
8. const int box_size = 30;  // size der einzelnen Kaestchen (in Pixel)
9. const int border = 20;    // Rand links und oben bis zu den ersten Kaestchen (in Pixel)
10.
11. // Prototyp der Funktionen zum Vorbelegen des Grids ...
12. void grid_init(bool grid[][grid_size]);
13.
14. int main()
15. {
16.     bool grid[grid_size][grid_size] = { 0 };
17.     bool next_grid[grid_size][grid_size] = { 0 };
18.
19.     // Erstes Grid vorbelegen
20.     grid_init(grid);
21.
22.     while (gip_window_not_closed())
23.     {
24.         // Spielfeld anzeigen
26.         // TO DO
28.         gip_draw_rectangle(border, border, border + grid_size * box_size, border + grid_size * box_size, white);
29.         for (int y = 0; y < grid_size; y++)
30.         {
31.             for (int x = 0; x < grid_size; x++)
32.             {
33.
34.                 if (grid[x][y] == true)
35.                 {
36.                     gip_draw_rectangle(border + x * box_size, border + y * box_size, border + (x + 1) * box_size, border + (y + 1) * box_size, green);
37.                 }
38.             }
39.         }
41.         gip_sleep(3);
42.
43.         // Berechne das naechste Spielfeld ...
44.         // Achtung; Fьr die Zelle (x,y) darf die Position (x,y) selbst *nicht*
45.         // mit in die Betrachtungen einbezogen werden.
46.         // Ausserdem darf bei zellen am rand nicht ьber den Rand hinausgegriffen
47.         // werden (diese Zellen haben entsprechend weniger Nachbarn) ...
48.
49.         // TO DO
50.         for (int y = 0; y < grid_size; y++)
51.         {
52.             for (int x = 0; x < grid_size; x++)
53.             {
54.                 int living_neighbors = 0;
55.                 for (int y1 = 0; y1 < 3; y1++)
56.                 {
57.                     for (int x1 = 0; x1 < 3; x1++)
58.                     {
59.                         if (x - 1 + x1 < 0 || x - 1 + x1 >= grid_size || y - 1 + y1 < 0 || y - 1 + y1 >= grid_size) //Abfangen der Werte, die ueber dem Rand des arrays sind
60.                         {
61.                             //Falls man den Rand von Tot auf lebendig aendern will
62.                             //living_neighbors++;
63.                         }
64.                         else if (x1 == 1 && y1 == 1)
65.                         {
66.                             //sich selber ausser betracht zeihen
67.                         }
68.                         else if (grid[x - 1 + x1][y - 1 + y1] == true) //zaehlen der Lebenden Nachbarn
69.                         {
70.                             living_neighbors++;
71.                         }
72.                     }
73.                 }
74.                 if (grid[x][y] == false && living_neighbors == 3)
75.                     next_grid[x][y] = true;
76.                 else if (living_neighbors < 2 || living_neighbors > 3)
77.                 {
78.                     next_grid[x][y] = false;
79.                 }
80.                 else
81.                     next_grid[x][y] = grid[x][y];
82.             }
83.         }
84.
85.         // Kopiere das naechste Spielfeld in das aktuelle Spielfeld ...
86.
87.         // TO DO
88.         for (int y = 0; y < grid_size; y++)
89.         {
90.             for (int x = 0; x < grid_size; x++)
91.             {
92.                 grid[x][y] = next_grid[x][y];
93.             }
94.         }
95.
96.     }
97.     return 0;
98. }
99.
100. void grid_init(bool grid[][grid_size])
101. {
102.     int eingabe = -1;
103.     do {
104.         cout << "Bitte waehlen Sie die Vorbelegung des Grids aus:" << endl
105.             << "0 - Zufall" << endl
106.             << "1 - Statisch" << endl
107.             << "2 - Blinker" << endl
108.             << "3 - Oktagon" << endl
109.             << "4 - Gleiter" << endl
110.             << "5 - Segler 1 (Light-Weight Spaceship)" << endl
111.             << "6 - Segler 2 (Middle-Weight Spaceship)" << endl
112.             << "? ";
113.         cin >> eingabe;
114.         cin.clear();
115.         cin.ignore(1000, '\n');
116.     } while (eingabe < 0 || eingabe > 6);
117.
118.     if (eingabe == 0)
119.     {
120.         // Erstes Grid vorbelegen (per Zufallszahlen) ...
121.
122.         // TO DO
123.         for (int y = 0; y < grid_size; y++)
124.             for (int x = 0; x < grid_size; x++)
125.                 grid[x][y] = gip_random(0, 1);
126.     }
127.     else if (eingabe == 1)
128.     {
129.         const int pattern_size = 3;
130.         char pattern[pattern_size][pattern_size] =
131.         {
132.             { '.', '*', '.' },
133.             { '*', '.', '*' },
134.             { '.', '*', '.' },
135.         };
136.         for (int y = 0; y < pattern_size; y++)
137.             for (int x = 0; x < pattern_size; x++)
138.                 if (pattern[y][x] == '*')
139.                     grid[x][y + 3] = true;
140.     }
141.     else if (eingabe == 2)
142.     {
143.         const int pattern_size = 3;
144.         char pattern[pattern_size][pattern_size] =
145.         {
146.             { '.', '*', '.' },
147.             { '.', '*', '.' },
148.             { '.', '*', '.' },
149.         };
150.         for (int y = 0; y < pattern_size; y++)
151.             for (int x = 0; x < pattern_size; x++)
152.                 if (pattern[y][x] == '*')
153.                     grid[x][y + 3] = true;
154.     }
155.     else if (eingabe == 3)
156.     {
157.         const int pattern_size = 8;
158.         char pattern[pattern_size][pattern_size] =
159.         {
160.             { '.', '.', '.', '*', '*', '.', '.', '.' },
161.             { '.', '.', '*', '.', '.', '*', '.', '.' },
162.             { '.', '*', '.', '.', '.', '.', '*', '.' },
163.             { '*', '.', '.', '.', '.', '.', '.', '*' },
164.             { '*', '.', '.', '.', '.', '.', '.', '*' },
165.             { '.', '*', '.', '.', '.', '.', '*', '.' },
166.             { '.', '.', '*', '.', '.', '*', '.', '.' },
167.             { '.', '.', '.', '*', '*', '.', '.', '.' },
168.         };
169.         for (int y = 0; y < pattern_size; y++)
170.             for (int x = 0; x < pattern_size; x++)
171.                 if (pattern[y][x] == '*')
172.                     grid[x][y + 1] = true;
173.     }
174.     else if (eingabe == 4)
175.     {
176.         const int pattern_size = 3;
177.         char pattern[pattern_size][pattern_size] =
178.         {
179.             { '.', '*', '.' },
180.             { '.', '.', '*' },
181.             { '*', '*', '*' },
182.         };
183.         for (int y = 0; y < pattern_size; y++)
184.             for (int x = 0; x < pattern_size; x++)
185.                 if (pattern[y][x] == '*')
186.                     grid[x][y + 3] = true;
187.     }
188.     else if (eingabe == 5)
189.     {
190.         const int pattern_size = 5;
191.         char pattern[pattern_size][pattern_size] =
192.         {
193.             { '*', '.', '.', '*', '.' },
194.             { '.', '.', '.', '.', '*' },
195.             { '*', '.', '.', '.', '*' },
196.             { '.', '*', '*', '*', '*' },
197.             { '.', '.', '.', '.', '.' },
198.         };
199.         for (int y = 0; y < pattern_size; y++)
200.             for (int x = 0; x < pattern_size; x++)
201.                 if (pattern[y][x] == '*')
202.                     grid[x][y + 3] = true;
203.     }
204.     else if (eingabe == 6)
205.     {
206.         const int pattern_size = 6;
207.         char pattern[pattern_size][pattern_size] =
208.         {
209.             { '.', '*', '*', '*', '*', '*' },
210.             { '*', '.', '.', '.', '.', '*' },
211.             { '.', '.', '.', '.', '.', '*' },
212.             { '*', '.', '.', '.', '*', '.' },
213.             { '.', '.', '*', '.', '.', '.' },
214.             { '.', '.', '.', '.', '.', '.' },
215.         };
216.         for (int y = 0; y < pattern_size; y++)
217.             for (int x = 0; x < pattern_size; x++)
218.                 if (pattern[y][x] == '*')
219.                     grid[x][y + 3] = true;
220.     }
221. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.

Top