white space changes
[rocksndiamonds.git] / src / game_bd / bd_caveobject.c
1 /*
2  * Copyright (c) 2007, 2008, 2009, Czirkos Zoltan <cirix@fw.hu>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 #include "main_bd.h"
18
19
20 GdObjectLevels gd_levels_mask[] =
21 {
22   GD_OBJECT_LEVEL1,
23   GD_OBJECT_LEVEL2,
24   GD_OBJECT_LEVEL3,
25   GD_OBJECT_LEVEL4,
26   GD_OBJECT_LEVEL5
27 };
28
29 // bdcff text description of object. caller should free string.
30 char *gd_object_get_bdcff(const GdObject *object)
31 {
32   char *str = NULL;
33   int j;
34   const char *type;
35
36   switch (object->type)
37   {
38     case GD_POINT:
39       return getStringPrint("Point=%d %d %s", object->x1, object->y1, gd_elements[object->element].filename);
40
41     case GD_LINE:
42       return getStringPrint("Line=%d %d %d %d %s", object->x1, object->y1, object->x2, object->y2, gd_elements[object->element].filename);
43
44     case GD_RECTANGLE:
45       return getStringPrint("Rectangle=%d %d %d %d %s", object->x1, object->y1, object->x2, object->y2, gd_elements[object->element].filename);
46
47     case GD_FILLED_RECTANGLE:
48       // if elements are not the same
49       if (object->fill_element!=object->element)
50         return getStringPrint("FillRect=%d %d %d %d %s %s", object->x1, object->y1, object->x2, object->y2, gd_elements[object->element].filename, gd_elements[object->fill_element].filename);
51       // they are the same
52       return getStringPrint("FillRect=%d %d %d %d %s", object->x1, object->y1, object->x2, object->y2, gd_elements[object->element].filename);
53
54     case GD_RASTER:
55       return getStringPrint("Raster=%d %d %d %d %d %d %s", object->x1, object->y1, (object->x2-object->x1)/object->dx+1, (object->y2-object->y1)/object->dy+1, object->dx, object->dy, gd_elements[object->element].filename);
56
57     case GD_JOIN:
58       return getStringPrint("Add=%d %d %s %s", object->dx, object->dy, gd_elements[object->element].filename, gd_elements[object->fill_element].filename);
59
60     case GD_FLOODFILL_BORDER:
61       return getStringPrint("BoundaryFill=%d %d %s %s", object->x1, object->y1, gd_elements[object->fill_element].filename, gd_elements[object->element].filename);
62
63     case GD_FLOODFILL_REPLACE:
64       return getStringPrint("FloodFill=%d %d %s %s", object->x1, object->y1, gd_elements[object->fill_element].filename, gd_elements[object->element].filename);
65
66     case GD_MAZE:
67     case GD_MAZE_UNICURSAL:
68     case GD_MAZE_BRAID:
69       switch(object->type)
70       {
71         case GD_MAZE:
72           type = "perfect";
73           break;
74
75         case GD_MAZE_UNICURSAL:
76           type = "unicursal";
77           break;
78
79         case GD_MAZE_BRAID:
80           type = "braid";
81           break;
82
83         default:
84           // never reached
85           break;
86       }
87
88       return getStringPrint("Maze=%d %d %d %d %d %d %d %d %d %d %d %d %s %s %s", object->x1, object->y1, object->x2, object->y2, object->dx, object->dy, object->horiz, object->seed[0], object->seed[1], object->seed[2], object->seed[3], object->seed[4], gd_elements[object->element].filename, gd_elements[object->fill_element].filename, type);
89
90     case GD_RANDOM_FILL:
91       appendStringPrint(&str, "%s=%d %d %d %d %d %d %d %d %d %s", object->c64_random?"RandomFillC64":"RandomFill", object->x1, object->y1, object->x2, object->y2, object->seed[0], object->seed[1], object->seed[2], object->seed[3], object->seed[4], gd_elements[object->fill_element].filename);
92
93       // seed and initial fill
94       for (j = 0; j < 4; j++)
95         if (object->random_fill_probability[j] != 0)
96           appendStringPrint(&str, " %s %d", gd_elements[object->random_fill[j]].filename, object->random_fill_probability[j]);
97
98       if (object->element != O_NONE)
99         appendStringPrint(&str, " %s", gd_elements[object->element].filename);
100
101       return str;
102
103     case GD_COPY_PASTE:
104       return getStringPrint("CopyPaste=%d %d %d %d %d %d %s %s", object->x1, object->y1, object->x2, object->y2, object->dx, object->dy, object->mirror?"mirror":"nomirror", object->flip?"flip":"noflip");
105
106     case NONE:
107       // never reached
108       break;
109   }
110
111   return NULL;
112 }
113
114 // create an INDIVIDUAL POINT CAVE OBJECT
115 GdObject *gd_object_new_point(GdObjectLevels levels, int x, int y, GdElement elem)
116 {
117   GdObject *newobj = checked_calloc(sizeof(GdObject));
118
119   newobj->levels = levels;
120   newobj->type = GD_POINT;
121   newobj->x1 = x;
122   newobj->y1 = y;
123   newobj->element = elem;
124
125   return newobj;
126 }
127
128 // create a LINE OBJECT
129 GdObject *gd_object_new_line(GdObjectLevels levels, int x1, int y1, int x2, int y2,
130                              GdElement elem)
131 {
132   GdObject *newobj = checked_calloc(sizeof(GdObject));
133
134   newobj->levels = levels;
135   newobj->type = GD_LINE;
136   newobj->x1 = x1;
137   newobj->y1 = y1;
138   newobj->x2 = x2;
139   newobj->y2 = y2;
140   newobj->element = elem;
141
142   return newobj;
143 }
144
145 // create a RECTANGLE OBJECT
146 GdObject *gd_object_new_rectangle(GdObjectLevels levels, int x1, int y1, int x2, int y2,
147                                   GdElement elem)
148 {
149   GdObject *newobj = checked_calloc(sizeof(GdObject));
150
151   newobj->levels = levels;
152   newobj->type = GD_RECTANGLE;
153   newobj->x1 = x1;
154   newobj->y1 = y1;
155   newobj->x2 = x2;
156   newobj->y2 = y2;
157   newobj->element = elem;
158
159   return newobj;
160 }
161
162 // create a RECTANGLE OBJECT
163 GdObject *gd_object_new_filled_rectangle(GdObjectLevels levels, int x1, int y1, int x2, int y2,
164                                          GdElement elem, GdElement fill_elem)
165 {
166   GdObject *newobj = checked_calloc(sizeof(GdObject));
167
168   newobj->levels = levels;
169   newobj->type = GD_FILLED_RECTANGLE;
170   newobj->x1 = x1;
171   newobj->y1 = y1;
172   newobj->x2 = x2;
173   newobj->y2 = y2;
174   newobj->element = elem;
175   newobj->fill_element = fill_elem;
176
177   return newobj;
178 }
179
180 // create a raster object
181 GdObject *gd_object_new_raster(GdObjectLevels levels, int x1, int y1, int x2, int y2,
182                                int dx, int dy, GdElement elem)
183 {
184   GdObject *newobj = checked_calloc(sizeof(GdObject));
185
186   newobj->levels = levels;
187   newobj->type = GD_RASTER;
188   newobj->x1 = x1;
189   newobj->y1 = y1;
190   newobj->x2 = x2;
191   newobj->y2 = y2;
192   newobj->dx = dx;
193   newobj->dy = dy;
194   newobj->element = elem;
195
196   return newobj;
197 }
198
199 // create a raster object
200 GdObject *gd_object_new_join(GdObjectLevels levels, int dx, int dy,
201                              GdElement search, GdElement replace)
202 {
203   GdObject *newobj = checked_calloc(sizeof(GdObject));
204
205   newobj->levels = levels;
206   newobj->type = GD_JOIN;
207   newobj->dx = dx;
208   newobj->dy = dy;
209   newobj->element = search;
210   newobj->fill_element = replace;
211
212   return newobj;
213 }
214
215 // create a new boundary fill object
216 GdObject *gd_object_new_floodfill_border(GdObjectLevels levels, int x1, int y1,
217                                          GdElement fill, GdElement border)
218 {
219   GdObject *newobj = checked_calloc(sizeof(GdObject));
220
221   newobj->levels = levels;
222   newobj->type = GD_FLOODFILL_BORDER;
223   newobj->x1 = x1;
224   newobj->y1 = y1;
225   newobj->element = border;
226   newobj->fill_element = fill;
227
228   return newobj;
229 }
230
231 GdObject *gd_object_new_floodfill_replace(GdObjectLevels levels, int x1, int y1,
232                                           GdElement fill, GdElement to_replace)
233 {
234   GdObject *newobj = checked_calloc(sizeof(GdObject));
235
236   newobj->levels = levels;
237   newobj->type = GD_FLOODFILL_REPLACE;
238   newobj->x1 = x1;
239   newobj->y1 = y1;
240   newobj->element = to_replace;
241   newobj->fill_element = fill;
242
243   return newobj;
244 }
245
246 GdObject *gd_object_new_maze(GdObjectLevels levels, int x1, int y1, int x2, int y2,
247                              int wall_w, int path_w, GdElement wall_e, GdElement path_e,
248                              int horiz_percent, const int seed[5])
249 {
250   int i;
251   GdObject *newobj = checked_calloc(sizeof(GdObject));
252
253   newobj->levels = levels;
254   newobj->type = GD_MAZE;
255   newobj->x1 = x1;
256   newobj->y1 = y1;
257   newobj->x2 = x2;
258   newobj->y2 = y2;
259   newobj->dx = wall_w;
260   newobj->dy = path_w;
261   newobj->element = wall_e;
262   newobj->fill_element = path_e;
263   newobj->horiz = horiz_percent;
264
265   for (i = 0; i < 5; ++i)
266     newobj->seed[i] = seed[i];
267
268   return newobj;
269 }
270
271 GdObject *gd_object_new_maze_unicursal(GdObjectLevels levels, int x1, int y1, int x2, int y2,
272                                        int wall_w, int path_w, GdElement wall_e, GdElement path_e,
273                                        int horiz_percent, const int seed[5])
274 {
275   int i;
276   GdObject *newobj = checked_calloc(sizeof(GdObject));
277
278   newobj->levels = levels;
279   newobj->type = GD_MAZE_UNICURSAL;
280   newobj->x1 = x1;
281   newobj->y1 = y1;
282   newobj->x2 = x2;
283   newobj->y2 = y2;
284   newobj->dx = wall_w;
285   newobj->dy = path_w;
286   newobj->element = wall_e;
287   newobj->fill_element = path_e;
288   newobj->horiz = horiz_percent;
289
290   for (i = 0; i < 5; ++i)
291     newobj->seed[i] = seed[i];
292
293   return newobj;
294 }
295
296 GdObject *gd_object_new_maze_braid(GdObjectLevels levels, int x1, int y1, int x2, int y2,
297                                    int wall_w, int path_w, GdElement wall_e, GdElement path_e,
298                                    int horiz_percent, const int seed[5])
299 {
300   int i;
301   GdObject *newobj = checked_calloc(sizeof(GdObject));
302
303   newobj->levels = levels;
304   newobj->type = GD_MAZE_BRAID;
305   newobj->x1 = x1;
306   newobj->y1 = y1;
307   newobj->x2 = x2;
308   newobj->y2 = y2;
309   newobj->dx = wall_w;
310   newobj->dy = path_w;
311   newobj->element = wall_e;
312   newobj->fill_element = path_e;
313   newobj->horiz = horiz_percent;
314
315   for (i = 0; i < 5; ++i)
316     newobj->seed[i] = seed[i];
317
318   return newobj;
319 }
320
321 GdObject *gd_object_new_random_fill(GdObjectLevels levels, int x1, int y1, int x2, int y2,
322                                     const int seed[5], GdElement initial,
323                                     const GdElement random[4], const int prob[4],
324                                     GdElement replace_only, boolean c64)
325 {
326   int i;
327   GdObject *newobj = checked_calloc(sizeof(GdObject));
328
329   newobj->levels = levels;
330   newobj->type = GD_RANDOM_FILL;
331   newobj->x1 = x1;
332   newobj->y1 = y1;
333   newobj->x2 = x2;
334   newobj->y2 = y2;
335   newobj->fill_element = initial;
336
337   for (i = 0; i < 5; ++i)
338     newobj->seed[i] = seed[i];
339
340   for (i = 0; i < 4; ++i)
341   {
342     newobj->random_fill[i] = random[i];
343     newobj->random_fill_probability[i] = prob[i];
344   }
345
346   newobj->element = replace_only;
347   newobj->c64_random = c64;
348
349   return newobj;
350 }
351
352 GdObject *gd_object_new_copy_paste(GdObjectLevels levels, int x1, int y1, int x2, int y2,
353                                    int dx, int dy, boolean mirror, boolean flip)
354 {
355   GdObject *newobj = checked_calloc(sizeof(GdObject));
356
357   newobj->levels = levels;
358   newobj->type = GD_COPY_PASTE;
359   newobj->x1 = x1;
360   newobj->y1 = y1;
361   newobj->x2 = x2;
362   newobj->y2 = y2;
363   newobj->dx = dx;
364   newobj->dy = dy;
365   newobj->mirror = mirror;
366   newobj->flip = flip;
367
368   return newobj;
369 }
370
371 // create new object from bdcff description.
372 // return new object if ok; return null if failed.
373 GdObject *gd_object_new_from_string(char *str)
374 {
375   char *equalsign;
376   char *name, *param;
377   GdObject object;
378   char elem0[100], elem1[100];
379
380   equalsign = strchr(str, '=');
381   if (!equalsign)
382     return NULL;
383
384   // split string by replacing the equal sign with zero
385   *equalsign = '\0';
386   name = str;
387   param = equalsign + 1;
388
389   // INDIVIDUAL POINT CAVE OBJECT
390   if (strcasecmp(name, "Point") == 0)
391   {
392     object.type = GD_POINT;
393     if (sscanf(param, "%d %d %s", &object.x1, &object.y1, elem0) == 3)
394     {
395       object.element = gd_get_element_from_string(elem0);
396
397       return get_memcpy(&object, sizeof (GdObject));
398     }
399
400     return NULL;
401   }
402
403   // LINE OBJECT
404   if (strcasecmp(name, "Line") == 0)
405   {
406     object.type = GD_LINE;
407     if (sscanf(param, "%d %d %d %d %s", &object.x1, &object.y1, &object.x2, &object.y2, elem0) == 5)
408     {
409       object.element = gd_get_element_from_string(elem0);
410
411       return get_memcpy(&object, sizeof (GdObject));
412     }
413
414     return NULL;
415   }
416
417   // RECTANGLE OBJECT
418   if (strcasecmp(name, "Rectangle") == 0)
419   {
420     if (sscanf(param, "%d %d %d %d %s", &object.x1, &object.y1, &object.x2, &object.y2, elem0) == 5)
421     {
422       object.type = GD_RECTANGLE;
423       object.element = gd_get_element_from_string (elem0);
424
425       return get_memcpy(&object, sizeof (GdObject));
426     }
427
428     return NULL;
429   }
430
431   // FILLED RECTANGLE OBJECT
432   if (strcasecmp(name, "FillRect") == 0)
433   {
434     int paramcount;
435
436     paramcount = sscanf(param, "%d %d %d %d %s %s", &object.x1, &object.y1, &object.x2, &object.y2, elem0, elem1);
437     object.type = GD_FILLED_RECTANGLE;
438
439     if (paramcount == 6)
440     {
441       object.element = gd_get_element_from_string (elem0);
442       object.fill_element = gd_get_element_from_string (elem1);
443
444       return get_memcpy(&object, sizeof (GdObject));
445     }
446
447     if (paramcount == 5)
448     {
449       object.element = object.fill_element = gd_get_element_from_string (elem0);
450
451       return get_memcpy(&object, sizeof (GdObject));
452     }
453
454     return NULL;
455   }
456
457   // RASTER
458   if (strcasecmp(name, "Raster") == 0)
459   {
460     int nx, ny;
461
462     if (sscanf(param, "%d %d %d %d %d %d %s", &object.x1, &object.y1, &nx, &ny, &object.dx, &object.dy, elem0) == 7)
463     {
464       nx--;
465       ny--;
466       object.x2 = object.x1 + nx * object.dx;
467       object.y2 = object.y1 + ny * object.dy;
468       object.type = GD_RASTER;
469       object.element = gd_get_element_from_string (elem0);
470
471       return get_memcpy(&object, sizeof (GdObject));
472     }
473
474     return NULL;
475   }
476
477   // JOIN
478   if (strcasecmp(name, "Join") == 0 ||
479       strcasecmp(name, "Add") == 0)
480   {
481     if (sscanf(param, "%d %d %s %s", &object.dx, &object.dy, elem0, elem1) == 4)
482     {
483       object.type = GD_JOIN;
484       object.element = gd_get_element_from_string (elem0);
485       object.fill_element = gd_get_element_from_string (elem1);
486
487       return get_memcpy(&object, sizeof (GdObject));
488     }
489
490     return NULL;
491   }
492
493   // FILL TO BORDER OBJECT
494   if (strcasecmp(name, "BoundaryFill") == 0)
495   {
496     if (sscanf(param, "%d %d %s %s", &object.x1, &object.y1, elem0, elem1) == 4)
497     {
498       object.type = GD_FLOODFILL_BORDER;
499       object.fill_element = gd_get_element_from_string (elem0);
500       object.element = gd_get_element_from_string (elem1);
501
502       return get_memcpy(&object, sizeof (GdObject));
503     }
504
505     return NULL;
506   }
507
508   // REPLACE FILL OBJECT
509   if (strcasecmp(name, "FloodFill") == 0)
510   {
511     if (sscanf(param, "%d %d %s %s", &object.x1, &object.y1, elem0, elem1) == 4)
512     {
513       object.type = GD_FLOODFILL_REPLACE;
514       object.fill_element = gd_get_element_from_string (elem0);
515       object.element = gd_get_element_from_string (elem1);
516
517       return get_memcpy(&object, sizeof (GdObject));
518     }
519
520     return NULL;
521   }
522
523   // MAZE OBJECT
524   // MAZE UNICURSAL OBJECT
525   // BRAID MAZE OBJECT
526   if (strcasecmp(name, "Maze") == 0)
527   {
528     char type[100] = "perfect";
529
530     if (sscanf(param, "%d %d %d %d %d %d %d %d %d %d %d %d %s %s %s", &object.x1, &object.y1, &object.x2, &object.y2, &object.dx, &object.dy, &object.horiz, &object.seed[0], &object.seed[1], &object.seed[2], &object.seed[3], &object.seed[4], elem0, elem1, type) >= 14)
531     {
532       if (strcasecmp(type, "unicursal") == 0)
533         object.type = GD_MAZE_UNICURSAL;
534       else if (strcasecmp(type, "perfect") == 0)
535         object.type = GD_MAZE;
536       else if (strcasecmp(type, "braid") == 0)
537         object.type = GD_MAZE_BRAID;
538       else
539       {
540         Warn("unknown maze type: %s, defaulting to perfect", type);
541         object.type = GD_MAZE;
542       }
543
544       object.element = gd_get_element_from_string (elem0);
545       object.fill_element = gd_get_element_from_string (elem1);
546
547       return get_memcpy(&object, sizeof (GdObject));
548     }
549
550     return NULL;
551   }
552
553   // RANDOM FILL OBJECT
554   if (strcasecmp(name, "RandomFill") == 0 ||
555       strcasecmp(name, "RandomFillC64") == 0)
556   {
557     static char **words = NULL;
558     int l, i;
559
560     object.type = GD_RANDOM_FILL;
561     if (strcasecmp(name, "RandomFillC64") == 0)
562       // totally the same, but uses c64 random generator
563       object.c64_random = TRUE;
564     else
565       object.c64_random = FALSE;
566
567     if (sscanf(param, "%d %d %d %d", &object.x1, &object.y1, &object.x2, &object.y2) != 4)
568       return NULL;
569
570     if (words)
571       freeStringArray(words);
572
573     words = getSplitStringArray(param, " ", -1);
574     l = getStringArrayLength(words);
575
576     if (l < 10 || l > 19)
577       return NULL;
578
579     for (i = 0; i < 5; i++)
580       if (sscanf(words[4 + i], "%d", &object.seed[i]) != 1)
581         return NULL;
582
583     object.fill_element = gd_get_element_from_string(words[9]);
584
585     for (i = 0; i < 4; i++)
586     {
587       object.random_fill[i] = O_DIRT;
588       object.random_fill_probability[i] = 0;
589     }
590
591     for (i = 10; i < l - 1; i += 2)
592     {
593       object.random_fill[(i - 10) / 2] = gd_get_element_from_string(words[i]);
594       if (sscanf(words[i + 1], "%d", &object.random_fill_probability[(i - 10) / 2]) == 0)
595         return NULL;
596     }
597
598     object.element = O_NONE;
599
600     if (l > 10 && l % 2 == 1)
601       object.element = gd_get_element_from_string(words[l - 1]);
602
603     return get_memcpy(&object, sizeof (GdObject));
604   }
605
606   // COPY PASTE OBJECT
607   if (strcasecmp(name, "CopyPaste") == 0)
608   {
609     char mirror[100] = "nomirror";
610     char flip[100] = "noflip";
611     object.type = GD_COPY_PASTE;
612
613     object.flip = object.mirror = FALSE;
614
615     if (sscanf(param, "%d %d %d %d %d %d %s %s", &object.x1, &object.y1, &object.x2, &object.y2, &object.dx, &object.dy, mirror, flip) < 6)
616       return NULL;
617
618     // MIRROR PROPERTY
619     if (strcasecmp(mirror, "mirror") == 0)
620       object.mirror = TRUE;
621     else if (strcasecmp(mirror, "nomirror") == 0)
622       object.mirror = FALSE;
623     else
624       Warn("invalid setting for copypaste mirror property: %s", mirror);
625
626     // FLIP PROPERTY
627     if (strcasecmp(flip, "flip") == 0)
628       object.flip = TRUE;
629     else if (strcasecmp(flip, "noflip") == 0)
630       object.flip = FALSE;
631     else
632       Warn("invalid setting for copypaste flip property: %s", flip);
633
634     return get_memcpy(&object, sizeof(GdObject));
635   }
636
637   return NULL;
638 }
639
640 // drawing a line, using bresenham's
641 static void draw_line (GdCave *cave, const GdObject *object)
642 {
643   int x, y, x1, y1, x2, y2;
644   boolean steep;
645   int error, dx, dy, ystep;
646
647   x1 = object->x1;
648   y1 = object->y1, x2 = object->x2;
649   y2 = object->y2;
650   steep = ABS (y2 - y1) > ABS (x2 - x1);
651
652   if (steep)
653   {
654     x = x1;
655     x1 = y1;
656     y1 = x;
657     x = x2;
658     x2 = y2;
659     y2 = x;
660   }
661
662   if (x1 > x2)
663   {
664     x = x1;
665     x1 = x2;
666     x2 = x;
667     x = y1;
668     y1 = y2;
669     y2 = x;
670   }
671
672   dx = x2 - x1;
673   dy = ABS (y2 - y1);
674   y = y1;
675   error = 0;
676   ystep = (y1 < y2) ? 1 : -1;
677
678   for (x = x1; x <= x2; x++)
679   {
680     if (steep)
681       gd_cave_store_rc (cave, y, x, object->element, object);
682     else
683       gd_cave_store_rc (cave, x, y, object->element, object);
684
685     error += dy;
686
687     if (error * 2 >= dx)
688     {
689       y += ystep;
690       error -= dx;
691     }
692   }
693 }
694
695
696
697 static void draw_fill_replace_proc(GdCave *cave, int x, int y, const GdObject *object)
698 {
699   // fill with border so we do not come back
700   gd_cave_store_rc(cave, x, y, object->fill_element, object);
701
702   if (x > 0 && gd_cave_get_rc(cave, x - 1, y) == object->element)
703     draw_fill_replace_proc(cave, x - 1, y, object);
704
705   if (y > 0 && gd_cave_get_rc(cave, x, y - 1) == object->element)
706     draw_fill_replace_proc(cave, x, y - 1, object);
707
708   if (x < cave->w - 1 && gd_cave_get_rc(cave, x + 1, y) == object->element)
709     draw_fill_replace_proc(cave, x + 1, y, object);
710
711   if (y < cave->h - 1 && gd_cave_get_rc(cave, x, y + 1) == object->element)
712     draw_fill_replace_proc(cave, x, y + 1, object);
713 }
714
715 static void draw_fill_replace (GdCave *cave, const GdObject *object)
716 {
717   // check bounds
718   if (object->x1 < 0 ||
719       object->y1 < 0 ||
720       object->x1 >= cave->w ||
721       object->y1 >= cave->h)
722     return;
723
724   if (object->element == object->fill_element)
725     return;
726
727   // this procedure fills the area with the object->element.
728   draw_fill_replace_proc(cave, object->x1, object->y1, object);
729 }
730
731 static void draw_fill_border_proc (GdCave *cave, int x, int y, const GdObject *object)
732 {
733   // fill with border so we do not come back
734   gd_cave_store_rc(cave, x, y, object->element, object);
735
736   if (x > 0 && gd_cave_get_rc(cave, x - 1, y) != object->element)
737     draw_fill_border_proc(cave, x - 1, y, object);
738
739   if (y > 0 && gd_cave_get_rc(cave, x, y - 1) != object->element)
740     draw_fill_border_proc(cave, x, y - 1, object);
741
742   if (x < cave->w - 1 && gd_cave_get_rc(cave, x + 1, y) != object->element)
743     draw_fill_border_proc(cave, x + 1, y, object);
744
745   if (y < cave->h-1 && gd_cave_get_rc(cave, x, y + 1) != object->element)
746     draw_fill_border_proc(cave, x, y + 1, object);
747 }
748
749 static void draw_fill_border (GdCave *cave, const GdObject *object)
750 {
751   int x, y;
752
753   // check bounds
754   if (object->x1 < 0 ||
755       object->y1 < 0 ||
756       object->x1 >= cave->w ||
757       object->y1 >= cave->h)
758     return;
759
760   // this procedure fills the area with the object->element.
761   draw_fill_border_proc(cave, object->x1, object->y1, object);
762
763   // after the fill, we change all filled cells to the fill_element.
764   // we find those by looking at the object_order[][]
765   for (y = 0; y < cave->h; y++)
766     for (x = 0; x < cave->w; x++)
767       if (cave->objects_order[y][x] == object)
768         cave->map[y][x] = object->fill_element;
769 }
770
771 // rectangle, frame only
772 static void draw_rectangle(GdCave *cave, const GdObject *object)
773 {
774   int x1, y1, x2, y2, x, y;
775
776   // reorder coordinates if not drawing from northwest to southeast
777   x1 = object->x1;
778   y1 = object->y1, x2 = object->x2;
779   y2 = object->y2;
780
781   if (y1 > y2)
782   {
783     y = y1;
784     y1 = y2;
785     y2 = y;
786   }
787
788   if (x1 > x2)
789   {
790     x = x1;
791     x1 = x2;
792     x2 = x;
793   }
794
795   for (x = x1; x <= x2; x++)
796   {
797     gd_cave_store_rc(cave, x, object->y1, object->element, object);
798     gd_cave_store_rc(cave, x, object->y2, object->element, object);
799   }
800
801   for (y = y1; y <= y2; y++)
802   {
803     gd_cave_store_rc(cave, object->x1, y, object->element, object);
804     gd_cave_store_rc(cave, object->x2, y, object->element, object);
805   }
806 }
807
808 // rectangle, filled one
809 static void draw_filled_rectangle(GdCave *cave, const GdObject *object)
810 {
811   int x1, y1, x2, y2, x, y;
812
813   // reorder coordinates if not drawing from northwest to southeast
814   x1 = object->x1;
815   y1 = object->y1, x2 = object->x2;
816   y2 = object->y2;
817
818   if (y1 > y2)
819   {
820     y = y1;
821     y1 = y2;
822     y2 = y;
823   }
824
825   if (x1 > x2)
826   {
827     x = x1;
828     x1 = x2;
829     x2 = x;
830   }
831
832   for (y = y1; y <= y2; y++)
833     for (x = x1; x <= x2; x++)
834       gd_cave_store_rc(cave, x, y, (y == object->y1 ||
835                                     y == object->y2 ||
836                                     x == object->x1 ||
837                                     x == object->x2) ? object->element : object->fill_element, object);
838 }
839
840 // something like ordered fill, increment is dx and dy.
841 static void draw_raster(GdCave *cave, const GdObject *object)
842 {
843   int x, y, x1, y1, x2, y2;
844   int dx, dy;
845
846   // reorder coordinates if not drawing from northwest to southeast
847   x1 = object->x1;
848   y1 = object->y1;
849   x2 = object->x2;
850   y2 = object->y2;
851
852   if (y1 > y2)
853   {
854     y = y1;
855     y1 = y2;
856     y2 = y;
857   }
858
859   if (x1 > x2)
860   {
861     x = x1;
862     x1 = x2;
863     x2 = x;
864   }
865
866   dx = object->dx;
867
868   if (dx < 1)
869     dx = 1;
870
871   dy = object->dy;
872
873   if (dy < 1)
874     dy = 1;
875
876   for (y = y1; y <= y2; y += dy)
877     for (x = x1; x <= x2; x += dx)
878       gd_cave_store_rc(cave, x, y, object->element, object);
879 }
880
881 // find every object, and put fill_element next to it. relative coordinates dx,dy
882 static void draw_join(GdCave *cave, const GdObject *object)
883 {
884   int x, y;
885
886   for (y = 0; y < cave->h; y++)
887   {
888     for (x = 0; x < cave->w; x++)
889     {
890       if (cave->map[y][x] == object->element)
891       {
892         int nx = x + object->dx;
893         int ny = y + object->dy;
894         // this one implements wraparound for joins.
895         // it is needed by many caves in profi boulder series
896         while (nx >= cave->w)
897           nx -= cave->w, ny++;
898
899         gd_cave_store_rc(cave, nx, ny, object->fill_element, object);
900       }
901     }
902   }
903 }
904
905 // create a maze in a boolean **maze.
906 // recursive algorithm.
907 static void mazegen(GdRand *rand, boolean **maze, int width, int height, int x, int y, int horiz)
908 {
909   int dirmask = 15;
910
911   maze[y][x] = TRUE;
912   while (dirmask != 0)
913   {
914     int dir;
915
916     // horiz or vert
917     dir = gd_rand_int_range(rand, 0, 100) < horiz ? 2 : 0;
918
919     // if no horizontal movement possible, choose vertical
920     if (dir == 2 && (dirmask & 12) == 0)
921       dir = 0;
922     else if (dir == 0 && (dirmask & 3) == 0)    // and vice versa
923       dir = 2;
924
925     dir += gd_rand_int_range(rand, 0, 2);                // dir
926     if (dirmask & (1 << dir))
927     {
928       dirmask &= ~(1 << dir);
929
930       switch (dir)
931       {
932         case 0:    // up
933           if (y >= 2 && !maze[y - 2][x])
934           {
935             maze[y - 1][x] = TRUE;
936             mazegen(rand, maze, width, height, x, y - 2, horiz);
937           }
938           break;
939
940         case 1:    // down
941           if (y < height-2 && !maze[y + 2][x]) {
942             maze[y + 1][x] = TRUE;
943             mazegen(rand, maze, width, height, x, y + 2, horiz);
944           }
945           break;
946
947         case 2:    // left
948           if (x >= 2 && !maze[y][x - 2]) {
949             maze[y][x - 1] = TRUE;
950             mazegen(rand, maze, width, height, x - 2, y, horiz);
951           }
952           break;
953
954         case 3:    // right
955           if (x < width - 2 && !maze[y][x + 2]) {
956             maze[y][x + 1] = TRUE;
957             mazegen(rand, maze, width, height, x + 2, y, horiz);
958           }
959           break;
960
961         default:
962           break;
963       }
964     }
965   }
966 }
967
968 static void braidmaze(GdRand *rand, boolean **maze, int w, int h)
969 {
970   int x, y;
971
972   for (y = 0; y < h; y += 2)
973   {
974     for (x = 0; x < w; x += 2)
975     {
976       int closed = 0, dirs = 0;
977       int closed_dirs[4];
978
979       // if it is the edge of the map, OR no path carved, then we can't go in that direction.
980       if (x < 1 || !maze[y][x - 1])
981       {
982         // closed from this side.
983         closed++;
984
985         // if not the edge, we might open this wall (carve a path) to remove a dead end
986         if (x > 0)
987           closed_dirs[dirs++] = GD_MV_LEFT;
988       }
989
990       // other 3 directions similar
991       if (y < 1 || !maze[y - 1][x])
992       {
993         closed++;
994         if (y > 0)
995           closed_dirs[dirs++] = GD_MV_UP;
996       }
997
998       if (x >= w - 1 || !maze[y][x + 1])
999       {
1000         closed++;
1001         if (x < w - 1)
1002           closed_dirs[dirs++] = GD_MV_RIGHT;
1003       }
1004
1005       if (y >= h - 1 || !maze[y + 1][x]) {
1006         closed++;
1007         if (y < h - 1)
1008           closed_dirs[dirs++] = GD_MV_DOWN;
1009       }
1010
1011       // if closed from 3 sides, then it is a dead end. also check dirs != 0,
1012       // that might fail for a 1x1 maze :)
1013       if (closed == 3 && dirs != 0)
1014       {
1015         // make up a random direction, and open in that direction, so dead end is removed
1016         int dir = closed_dirs[gd_rand_int_range(rand, 0, dirs)];
1017
1018         switch (dir)
1019         {
1020           case GD_MV_LEFT:
1021             maze[y][x - 1] = TRUE; break;
1022           case GD_MV_UP:
1023             maze[y - 1][x] = TRUE; break;
1024           case GD_MV_RIGHT:
1025             maze[y][x + 1] = TRUE; break;
1026           case GD_MV_DOWN:
1027             maze[y + 1][x] = TRUE; break;
1028         }
1029       }
1030     }
1031   }
1032 }
1033
1034 static void draw_maze(GdCave *cave, const GdObject *object, int level)
1035 {
1036   int x, y;
1037   boolean **map;
1038   int x1 = object->x1;
1039   int y1 = object->y1;
1040   int x2 = object->x2;
1041   int y2 = object->y2;
1042   int w, h, path, wall;
1043   int xk, yk;
1044   GdRand *rand;
1045   int i,j;
1046
1047   // change coordinates if not in correct order
1048   if (y1 > y2)
1049   {
1050     y = y1;
1051     y1 = y2;
1052     y2 = y;
1053   }
1054
1055   if (x1 > x2)
1056   {
1057     x = x1;
1058     x1 = x2;
1059     x2 = x;
1060   }
1061
1062   wall = object->dx;
1063   if (wall < 1)
1064     wall = 1;
1065
1066   path = object->dy;
1067   if (path < 1)
1068     path = 1;
1069
1070   /*
1071     calculate the width and height of the maze.
1072     n = number of passages, path = path width, wall = wall width, maze = maze width.
1073     if given the number of passages, the width of the maze is:
1074
1075     n * path + (n - 1) * wall = maze
1076     n * path + n * wall - wall = maze
1077     n * (path + wall) = maze + wall
1078     n = (maze + wall) / (path + wall)
1079   */
1080
1081   // number of passages for each side
1082   w = (x2 - x1 + 1 + wall) / (path + wall);
1083   h = (y2 - y1 + 1 + wall) / (path + wall);
1084
1085   // and we calculate the size of the internal map
1086   if (object->type == GD_MAZE_UNICURSAL)
1087   {
1088     // for unicursal maze, width and height must be mod2 = 0,
1089     // and we will convert to paths & walls later
1090     w = w / 2 * 2;
1091     h = h / 2 * 2;
1092   }
1093   else
1094   {
1095     // for normal maze
1096     w = 2 * (w - 1) + 1;
1097     h = 2 * (h - 1) + 1;
1098   }
1099
1100   // twodimensional boolean array to generate map in
1101   map = checked_malloc((h) * sizeof(boolean *));
1102   for (y = 0; y < h; y++)
1103     map[y] = checked_calloc(w * sizeof(boolean));
1104
1105   // start generation, if map is big enough.
1106   // otherwise the application would crash, as the editor places maze objects
1107   // during mouse click & drag that have no sense
1108   rand = gd_rand_new_with_seed(object->seed[level] == -1 ?
1109                                gd_rand_int(cave->random) : object->seed[level]);
1110
1111   if (w >= 1 && h >= 1)
1112     mazegen(rand, map, w, h, 0, 0, object->horiz);
1113
1114   if (object->type == GD_MAZE_BRAID)
1115     braidmaze(rand, map, w, h);
1116
1117   gd_rand_free(rand);
1118
1119   if (w >= 1 && h >= 1 && object->type == GD_MAZE_UNICURSAL)
1120   {
1121     boolean **unicursal;
1122
1123     // convert to unicursal maze
1124     /* original:
1125         xxx x
1126           x x
1127         xxxxx
1128
1129         unicursal:
1130         xxxxxxx xxx
1131         x     x x x
1132         xxxxx x x x
1133             x x x x
1134         xxxxx xxx x
1135         x         x
1136         xxxxxxxxxxx
1137     */
1138
1139     unicursal = checked_malloc((h * 2 - 1) * sizeof(boolean *));
1140
1141     for (y = 0; y < h * 2 - 1; y++)
1142       unicursal[y] = checked_calloc((w * 2 - 1) * sizeof(boolean));
1143
1144     for (y = 0; y < h; y++)
1145     {
1146       for(x = 0; x < w; x++)
1147       {
1148         if (map[y][x]) {
1149           unicursal[y * 2][x * 2] = TRUE;
1150           unicursal[y * 2][x * 2 + 2] = TRUE;
1151           unicursal[y * 2 + 2][x * 2] = TRUE;
1152           unicursal[y * 2 + 2][x * 2 + 2] = TRUE;
1153
1154           if (x < 1      || !map[y][x - 1]) unicursal[y * 2 + 1][x * 2] = TRUE;
1155           if (y < 1      || !map[y - 1][x]) unicursal[y * 2][x * 2 + 1] = TRUE;
1156           if (x >= w - 1 || !map[y][x + 1]) unicursal[y * 2 + 1][x * 2 + 2] = TRUE;
1157           if (y >= h - 1 || !map[y + 1][x]) unicursal[y * 2 + 2][x * 2 + 1] = TRUE;
1158         }
1159       }
1160     }
1161
1162     // free original map
1163     for (y = 0; y < h; y++)
1164       free(map[y]);
1165     free(map);
1166
1167     // change to new map - the unicursal maze
1168     map = unicursal;
1169     h = h * 2 - 1;
1170     w = w * 2 - 1;
1171   }
1172
1173   // copy map to cave with correct elements and size
1174   /* now copy the map into the cave. the copying works like this...
1175      pwpwp
1176      xxxxx p
1177      x x   w
1178      x xxx p
1179      x     w
1180      xxxxx p
1181      columns and rows denoted with "p" are to be drawn with path width,
1182      the others with wall width. */
1183
1184   yk = y1;
1185
1186   for (y = 0; y < h; y++)
1187   {
1188     for (i = 0; i < (y % 2 == 0 ? path : wall); i++)
1189     {
1190       xk = x1;
1191
1192       for (x = 0; x < w; x++)
1193         for (j = 0; j < (x % 2 == 0 ? path : wall); j++)
1194           gd_cave_store_rc(cave, xk++, yk, map[y][x] ? object->fill_element : object->element, object);
1195
1196       // if width is smaller than requested, fill with wall
1197       for(x = xk; x <= x2; x++)
1198         gd_cave_store_rc(cave, x, yk, object->element, object);
1199
1200       yk++;
1201     }
1202   }
1203
1204   // if height is smaller than requested, fill with wall
1205   for (y = yk; y <= y2; y++)
1206     for (x = x1; x <= x2; x++)
1207       gd_cave_store_rc(cave, x, y, object->element, object);
1208
1209   // free map
1210   for (y = 0; y < h; y++)
1211     free(map[y]);
1212   free(map);
1213 }
1214
1215 static void draw_random_fill(GdCave *cave, const GdObject *object, int level)
1216 {
1217   int x, y;
1218   int x1 = object->x1;
1219   int y1 = object->y1;
1220   int x2 = object->x2;
1221   int y2 = object->y2;
1222   GdRand *rand;
1223   GdC64RandomGenerator c64_rand;
1224   unsigned int seed;
1225
1226   // -1 means that it should be different every time played.
1227   if (object->seed[level] == -1)
1228     seed = gd_rand_int(cave->random);
1229   else
1230     seed = object->seed[level];
1231
1232   rand = gd_rand_new_with_seed(seed);
1233   // for c64 random, use the 2*8 lsb.
1234   gd_c64_random_set_seed(&c64_rand, seed / 256 % 256, seed % 256);
1235
1236   // change coordinates if not in correct order
1237   if (y1 > y2)
1238   {
1239     y = y1;
1240     y1 = y2;
1241     y2 = y;
1242   }
1243
1244   if (x1 > x2)
1245   {
1246     x = x1;
1247     x1 = x2;
1248     x2 = x;
1249   }
1250
1251   for (y = y1; y <= y2; y++)
1252   {
1253     for (x = x1; x <= x2; x++)
1254     {
1255       unsigned int randm;
1256       GdElement element;
1257
1258       if (object->c64_random)
1259         // use c64 random generator
1260         randm = gd_c64_random(&c64_rand);
1261       else
1262         // use the much better glib random generator
1263         randm = gd_rand_int_range(rand, 0, 256);
1264
1265       element = object->fill_element;
1266       if (randm < object->random_fill_probability[0])
1267         element = object->random_fill[0];
1268       if (randm < object->random_fill_probability[1])
1269         element = object->random_fill[1];
1270       if (randm < object->random_fill_probability[2])
1271         element = object->random_fill[2];
1272       if (randm < object->random_fill_probability[3])
1273         element = object->random_fill[3];
1274
1275       if (object->element == O_NONE ||
1276           gd_cave_get_rc(cave, x, y) == object->element)
1277         gd_cave_store_rc(cave, x, y, element, object);
1278     }
1279   }
1280
1281   gd_rand_free(rand);
1282 }
1283
1284
1285 static void draw_copy_paste(GdCave *cave, const GdObject *object)
1286 {
1287   int x1 = object->x1, y1 = object->y1, x2 = object->x2, y2 = object->y2;
1288   int x, y;    // iterators
1289   int w, h;
1290   GdElement *clipboard;
1291
1292   // reorder coordinates if not drawing from northwest to southeast
1293   if (x2 < x1)
1294   {
1295     x = x2;
1296     x2 = x1;
1297     x1 = x;
1298   }
1299
1300   if (y2 < y1)
1301   {
1302     y = y2;
1303     y2 = y1;
1304     y1 = y;
1305   }
1306
1307   w = x2 - x1 + 1;
1308   h = y2 - y1 + 1;
1309
1310   clipboard = checked_malloc((w * h) * sizeof(GdElement));
1311
1312   // copy to "clipboard"
1313   for (y = 0; y < h; y++)
1314     for (x = 0; x < w; x++)
1315       clipboard[y * w + x] = gd_cave_get_rc(cave, x + x1, y + y1);
1316
1317   for (y = 0; y < h; y++)
1318   {
1319     int ydest;
1320
1321     ydest = object->flip ? h - 1 - y : y;
1322
1323     for (x = 0; x < w; x++)
1324     {
1325       int xdest;
1326
1327       xdest = object->mirror ? w - 1 - x : x;
1328
1329       // dx and dy are used here are "paste to" coordinates
1330       gd_cave_store_rc(cave, object->dx + xdest, object->dy + ydest,
1331                        clipboard[y * w + x], object);
1332     }
1333   }
1334
1335   free(clipboard);
1336 }
1337
1338 // draw the specified game object into cave's data.
1339 // also remember, which cell was set by which cave object.
1340 void gd_cave_draw_object(GdCave *cave, const GdObject *object, int level)
1341 {
1342   switch (object->type)
1343   {
1344     case GD_POINT:
1345       // single point
1346       gd_cave_store_rc(cave, object->x1, object->y1, object->element, object);
1347       break;
1348
1349     case GD_LINE:
1350       draw_line(cave, object);
1351       break;
1352
1353     case GD_RECTANGLE:
1354       draw_rectangle(cave, object);
1355       break;
1356
1357     case GD_FILLED_RECTANGLE:
1358       draw_filled_rectangle(cave, object);
1359       break;
1360
1361     case GD_RASTER:
1362       draw_raster(cave, object);
1363       break;
1364
1365     case GD_JOIN:
1366       draw_join(cave, object);
1367       break;
1368
1369     case GD_FLOODFILL_BORDER:
1370       draw_fill_border(cave, object);
1371       break;
1372
1373     case GD_FLOODFILL_REPLACE:
1374       draw_fill_replace(cave, object);
1375       break;
1376
1377     case GD_MAZE:
1378     case GD_MAZE_UNICURSAL:
1379     case GD_MAZE_BRAID:
1380       draw_maze(cave, object, level);
1381       break;
1382
1383     case GD_RANDOM_FILL:
1384       draw_random_fill(cave, object, level);
1385       break;
1386
1387     case GD_COPY_PASTE:
1388       draw_copy_paste(cave, object);
1389       break;
1390
1391     case NONE:
1392       break;
1393
1394     default:
1395       Error("Unknown object %d", object->type);
1396       break;
1397   }
1398 }
1399
1400 // load cave to play... also can be called rendering the cave elements
1401 GdCave *gd_cave_new_rendered(const GdCave *data, const int level, const unsigned int seed)
1402 {
1403   GdCave *cave;
1404   GdElement element;
1405   int x, y;
1406   List *iter;
1407
1408   // make a copy
1409   cave = gd_cave_new_from_cave(data);
1410   cave->rendered = level + 1;
1411
1412   cave->render_seed = seed;
1413   cave->random = gd_rand_new_with_seed(cave->render_seed);
1414
1415   // maps needed during drawing and gameplay
1416   cave->objects_order = gd_cave_map_new(cave, void *);
1417
1418   cave->time                   = data->level_time[level];
1419   cave->timevalue              = data->level_timevalue[level];
1420   cave->diamonds_needed        = data->level_diamonds[level];
1421   cave->magic_wall_time        = data->level_magic_wall_time[level];
1422   cave->slime_permeability     = data->level_slime_permeability[level];
1423   cave->slime_permeability_c64 = data->level_slime_permeability_c64[level];
1424   cave->time_bonus             = data->level_bonus_time[level];
1425   cave->time_penalty           = data->level_penalty_time[level];
1426   cave->amoeba_time            = data->level_amoeba_time[level];
1427   cave->amoeba_max_count       = data->level_amoeba_threshold[level];
1428   cave->amoeba_2_time          = data->level_amoeba_2_time[level];
1429   cave->amoeba_2_max_count     = data->level_amoeba_2_threshold[level];
1430   cave->hatching_delay_time    = data->level_hatching_delay_time[level];
1431   cave->hatching_delay_frame   = data->level_hatching_delay_frame[level];
1432
1433   if (!cave->map)
1434   {
1435     // if we have no map, fill with predictable random generator.
1436     cave->map = gd_cave_map_new(cave, GdElement);
1437
1438     // IF CAVE HAS NO MAP, USE THE RANDOM NUMBER GENERATOR
1439     // init c64 randomgenerator
1440     if (data->level_rand[level] < 0)
1441       gd_cave_c64_random_set_seed(cave, gd_rand_int_range(cave->random, 0, 256),
1442                                   gd_rand_int_range(cave->random, 0, 256));
1443     else
1444       gd_cave_c64_random_set_seed(cave, 0, data->level_rand[level]);
1445
1446     // generate random fill
1447     //
1448     // start from row 1 (0 skipped), and fill also the borders on left and right hand side,
1449     // as c64 did. this way works the original random generator the right way.
1450     // also, do not fill last row, that is needed for the random seeds to be correct
1451     // after filling! predictable slime will use it.
1452     for (y = 1; y < cave->h - 1; y++)
1453     {
1454       for (x = 0; x < cave->w; x++)
1455       {
1456         unsigned int randm;
1457
1458         if (data->level_rand[level] < 0)
1459           // use the much better glib random generator
1460           randm = gd_rand_int_range(cave->random, 0, 256);
1461         else
1462           // use c64
1463           randm = gd_cave_c64_random(cave);
1464
1465         element = data->initial_fill;
1466         if (randm < data->random_fill_probability[0])
1467           element = data->random_fill[0];
1468         if (randm < data->random_fill_probability[1])
1469           element = data->random_fill[1];
1470         if (randm < data->random_fill_probability[2])
1471           element = data->random_fill[2];
1472         if (randm < data->random_fill_probability[3])
1473           element = data->random_fill[3];
1474
1475         gd_cave_store_rc(cave, x, y, element, NULL);
1476       }
1477     }
1478
1479     // draw initial border
1480     for (y = 0; y < cave->h; y++)
1481     {
1482       gd_cave_store_rc(cave, 0,           y, cave->initial_border, NULL);
1483       gd_cave_store_rc(cave, cave->w - 1, y, cave->initial_border, NULL);
1484     }
1485
1486     for (x = 0; x < cave->w; x++)
1487     {
1488       gd_cave_store_rc(cave, x,           0, cave->initial_border, NULL);
1489       gd_cave_store_rc(cave, x, cave->h - 1, cave->initial_border, NULL);
1490     }
1491
1492     // store if random number generator needs correction for static random seed
1493     cave->slime_correct_random = (data->level_rand[level] >= 0);
1494   }
1495   else
1496   {
1497     // IF CAVE HAS A MAP, SIMPLY USE IT... no need to fill with random elements
1498
1499     // initialize c64 predictable random for slime.
1500     // the values were taken from afl bd, see docs/internals.txt
1501     gd_cave_c64_random_set_seed(cave, 0, 0x1e);
1502
1503     // correct random number generator if cave was rendered with static random seed
1504     if (cave->slime_correct_random)
1505     {
1506       int i;
1507
1508       // set static random seed used when rendering the cave
1509       gd_cave_c64_random_set_seed(cave, 0, data->level_rand[level]);
1510
1511       for (i = 0; i < cave->w * (cave->h - 2); i++)
1512         gd_cave_c64_random(cave);
1513     }
1514   }
1515
1516   if (data->level_slime_seed_c64[level] != -1)
1517   {
1518     // if a specific slime seed is requested, change it now.
1519
1520     gd_cave_c64_random_set_seed(cave,
1521                                 data->level_slime_seed_c64[level] / 256,
1522                                 data->level_slime_seed_c64[level] % 256);
1523   }
1524
1525   // render cave objects above random data or map
1526   for (iter = data->objects; iter; iter = list_next(iter))
1527   {
1528     GdObject *object = (GdObject *)iter->data;
1529
1530     if (object->levels & gd_levels_mask[level])
1531       gd_cave_draw_object(cave, iter->data, level);
1532   }
1533
1534   // check if we use c64 ckdelay or milliseconds for timing
1535   if (cave->scheduling == GD_SCHEDULING_MILLISECONDS)
1536     cave->speed = data->level_speed[level];        // exact timing
1537   else
1538   {
1539     // delay loop based timing... set something for first iteration,
1540     // then later it will be calculated
1541     cave->speed = 120;
1542
1543     // this one may be used by iterate routine to calculate actual delay
1544     // if c64scheduling is selected
1545     cave->c64_timing = data->level_ckdelay[level];
1546   }
1547
1548   gd_cave_correct_visible_size(cave);
1549
1550   return cave;
1551 }
1552
1553 /*
1554   render cave at specified level.
1555   copy result to the map; remove objects.
1556   the cave will be map-based.
1557 */
1558 void gd_flatten_cave(GdCave *cave, const int level)
1559 {
1560   GdCave *rendered;
1561
1562   if (cave == NULL)
1563     return;
1564
1565   // render cave at specified level to obtain map. seed = 0
1566   rendered = gd_cave_new_rendered(cave, level, 0);
1567
1568   // forget old map without objects
1569   gd_cave_map_free(cave->map);
1570
1571   // copy new map to cave
1572   cave->map = gd_cave_map_dup(rendered, map);
1573   gd_cave_free(rendered);
1574
1575   // forget objects
1576   list_foreach(cave->objects, (list_fn) free, NULL);
1577   cave->objects = NULL;
1578 }