#define BDCFF_VERSION "0.5"
-/* these are used for bdcff loading, storing the sizes of caves */
+// these are used for bdcff loading, storing the sizes of caves
static int cavesize[6], intermissionsize[6];
static boolean replay_store_from_bdcff(GdReplay *replay, const char *str)
break;
case '.':
- /* do nothing, as all other movements are false */
+ // do nothing, as all other movements are false
break;
case 'c':
case 'C':
- /* bdcff 'combined' flags. do nothing. */
+ // bdcff 'combined' flags. do nothing.
break;
default:
{
int i;
- /* bdcff engine flag............ */
+ // bdcff engine flag............
if (strcasecmp(attrib, "Engine") == 0)
return TRUE;
- /* old flags - for compatibility */
+ // old flags - for compatibility
if (strcasecmp(attrib, "BD1Scheduling") == 0)
return TRUE;
if (strcasecmp(attrib, "AmoebaProperties") == 0)
return TRUE;
- /* search in property database */
+ // search in property database
for (i = 0; gd_cave_properties[i].identifier != NULL; i++)
if (strcasecmp(gd_cave_properties[i].identifier, attrib) == 0)
return TRUE;
{
int i;
- /* search in property database */
+ // search in property database
for (i = 0; gd_caveset_properties[i].identifier != NULL; i++)
if (strcasecmp(gd_caveset_properties[i].identifier, attrib) == 0)
return TRUE;
paramcount = getStringArrayLength(params);
identifier_found = FALSE;
- /* check all known tags. do not exit this loop if identifier_found == true...
- as there are more lines in the array which have the same identifier. */
+ // check all known tags. do not exit this loop if identifier_found == true...
+ // as there are more lines in the array which have the same identifier.
was_string = FALSE;
for (i = 0; prop_desc[i].identifier != NULL; i++)
{
if (strcasecmp(prop_desc[i].identifier, attrib) == 0)
{
- /* found the identifier */
+ // found the identifier
void *value = STRUCT_MEMBER_P(str, prop_desc[i].offset);
- /* these point to the same, but to avoid the awkward cast syntax */
+ // these point to the same, but to avoid the awkward cast syntax
int *ivalue = value;
GdElement *evalue = value;
GdDirection *dvalue = value;
if (prop_desc[i].type == GD_TYPE_STRING)
{
- /* strings are treated different, as occupy the whole length of the line */
+ // strings are treated different, as occupy the whole length of the line
gd_strcpy(value, param);
- /* remember this to skip checking the number of parameters at the end of the function */
+ // remember this to skip checking the number of parameters at the end of the function
was_string = TRUE;
continue;
checked_free(*str);
*str = getUnescapedString(param);
- /* remember this to skip checking the number of parameters at the end of the function */
+ // remember this to skip checking the number of parameters at the end of the function
was_string = TRUE;
continue;
}
- /* not a string, so use scanf calls */
- /* ALSO, if no more parameters to process, exit loop */
+ // not a string, so use scanf calls
+ // ALSO, if no more parameters to process, exit loop
for (j = 0; j < prop_desc[i].count && params[paramindex] != NULL; j++)
{
boolean success = FALSE;
{
case GD_TYPE_LONGSTRING:
case GD_TYPE_STRING:
- /* handled above */
+ // handled above
case GD_TAB:
case GD_LABEL:
- /* do nothing */
+ // do nothing
break;
case GD_TYPE_BOOLEAN:
}
}
- /* if we are processing an array, fill other values with these.
- if there are other values specified, those will be overwritten. */
+ // if we are processing an array, fill other values with these.
+ // if there are other values specified, those will be overwritten.
if (success)
for (k = j + 1; k < prop_desc[i].count; k++)
bvalue[k] = bvalue[j];
case GD_TYPE_INT:
success = sscanf(params[paramindex], "%d", &ivalue[j]) == 1;
if (success)
- /* copy to other if array */
+ // copy to other if array
for (k = j + 1; k < prop_desc[i].count; k++)
ivalue[k] = ivalue[j];
break;
case GD_TYPE_PROBABILITY:
- errno = 0; /* must be reset before calling strtod() to detect overflow/underflow */
+ // must be reset before calling strtod() to detect overflow/underflow
+ errno = 0;
res = strtod(params[paramindex], NULL);
if (errno == 0 && res >= 0 && res <= 1)
{
- /* fill all remaining items in array - may be only one */
+ // fill all remaining items in array - may be only one
for (k = j; k < prop_desc[i].count; k++)
- /* probabilities are stored inside as ppm (1E6) */
+ // probabilities are stored inside as ppm (1E6)
ivalue[k] = res * 1E6 + 0.5;
success = TRUE;
break;
case GD_TYPE_RATIO:
- errno = 0; /* must be reset before calling strtod() to detect overflow/underflow */
+ // must be reset before calling strtod() to detect overflow/underflow
+ errno = 0;
res = strtod (params[paramindex], NULL);
if (errno == 0 && res >= 0 && res <= 1)
{
case GD_TYPE_ELEMENT:
evalue[j] = gd_get_element_from_string(params[paramindex]);
- /* copy to all remaining elements in array */
+ // copy to all remaining elements in array
for (k = j + 1; k < prop_desc[i].count; k++)
evalue[k] = evalue[j];
- /* this shows error message on its own, do treat as always succeeded */
+ // this shows error message on its own, do treat as always succeeded
success = TRUE;
break;
case GD_TYPE_DIRECTION:
dvalue[j] = gd_direction_from_string(params[paramindex]);
- /* copy to all remaining items in array */
+ // copy to all remaining items in array
for (k = j + 1; k < prop_desc[i].count; k++)
dvalue[k] = dvalue[j];
case GD_TYPE_SCHEDULING:
svalue[j] = gd_scheduling_from_string(params[paramindex]);
- /* copy to all remaining items in array */
+ // copy to all remaining items in array
for (k = j + 1; k < prop_desc[i].count; k++)
svalue[k] = svalue[j];
- /* if there was an error, already reported by gd_scheduling_from_string */
+ // if there was an error, already reported by gd_scheduling_from_string
success = TRUE;
break;
case GD_TYPE_COLOR:
case GD_TYPE_EFFECT:
- /* shoud have handled this elsewhere */
+ // shoud have handled this elsewhere
break;
}
if (success)
- paramindex++; /* go to next parameter to process */
+ paramindex++; // go to next parameter to process
else
Warn("invalid parameter '%s' for attribute %s", params[paramindex], attrib);
}
}
}
- /* if we found the identifier, but still could not process all parameters... */
- /* of course, not for strings, as the whole line is the string */
+ // if we found the identifier, but still could not process all parameters...
+ // of course, not for strings, as the whole line is the string
if (identifier_found && !was_string && paramindex < paramcount)
Warn("excess parameters for attribute '%s': '%s'", attrib, params[paramindex]);
return identifier_found;
}
-/********************************************************************************
- *
- * BDCFF LOADING
- *
- */
+
+// ============================================================================
+// BDCFF LOADING
+// ============================================================================
static boolean replay_store_more_from_bdcff(GdReplay *replay, const char *param)
{
return result;
}
-/* report all remaining tags; called after the above function. */
+// report all remaining tags; called after the above function.
static void replay_report_unknown_tags_func(const char *attrib, const char *param, void *data)
{
Warn("unknown replay tag '%s'", attrib);
}
-/* a GHashTable foreach func.
- keys are attribs; values are params;
- the user data is the cave the hash table belongs to. */
+// a GHashTable foreach func.
+// keys are attribs; values are params;
+// the user data is the cave the hash table belongs to.
static boolean replay_process_tags_func(const char *attrib, const char *param, GdReplay *replay)
{
boolean identifier_found = FALSE;
- /* movements */
+ // movements
if (strcasecmp(attrib, "Movements") == 0)
{
identifier_found = TRUE;
}
else
{
- /* any other tag */
- /* 0: for ratio types; not used */
+ // any other tag
+ // 0: for ratio types; not used
identifier_found = struct_set_property(replay, gd_replay_properties,
attrib, param, 0);
}
- /* a ghrfunc should return true if the identifier is to be removed */
+ // a ghrfunc should return true if the identifier is to be removed
return identifier_found;
}
-/* ... */
+// ...
static void replay_process_tags(GdReplay *replay, HashTable *tags)
{
- /* process all tags */
+ // process all tags
hashtable_foreach_remove(tags, (hashtable_remove_fn)replay_process_tags_func, replay);
}
-/* a GHashTable foreach func.
- keys are attribs; values are params;
- the user data is the cave the hash table belongs to. */
+// a GHashTable foreach func.
+// keys are attribs; values are params;
+// the user data is the cave the hash table belongs to.
static boolean cave_process_tags_func(const char *attrib, const char *param, GdCave *cave)
{
char **params;
if (strcasecmp(attrib, "SnapExplosions") == 0)
{
- /* handle compatibility with old snapexplosions flag */
+ // handle compatibility with old snapexplosions flag
identifier_found = TRUE;
}
else if (strcasecmp(attrib, "BD1Scheduling") == 0)
{
- /* handle compatibility with old bd1scheduling flag */
+ // handle compatibility with old bd1scheduling flag
identifier_found = TRUE;
}
else if (strcasecmp(attrib, "Engine") == 0)
{
- /* handle bdcff engine flag */
+ // handle bdcff engine flag
identifier_found = TRUE;
}
else if (strcasecmp(attrib, "AmoebaProperties") == 0)
{
- /* handle compatibility with old AmoebaProperties flag */
+ // handle compatibility with old AmoebaProperties flag
GdElement elem1 = O_STONE, elem2 = O_DIAMOND;
}
else if (strcasecmp(attrib, "Colors") == 0)
{
- /* colors attribute is a mess, have to process explicitly */
+ // colors attribute is a mess, have to process explicitly
boolean ok = TRUE;
- /* Colors = [border background] foreground1 foreground2 foreground3 [amoeba slime] */
+ // Colors = [border background] foreground1 foreground2 foreground3 [amoeba slime]
identifier_found = TRUE;
if (paramcount == 3)
{
- /* only color1,2,3 */
- cave->colorb = gd_c64_color(0); /* border - black */
- cave->color0 = gd_c64_color(0); /* background - black */
+ // only color1,2,3
+ cave->colorb = gd_c64_color(0); // border - black
+ cave->color0 = gd_c64_color(0); // background - black
cave->color1 = gd_color_get_from_string(params[0]);
cave->color2 = gd_color_get_from_string(params[1]);
cave->color3 = gd_color_get_from_string(params[2]);
- cave->color4 = cave->color3; /* amoeba */
- cave->color5 = cave->color1; /* slime */
+ cave->color4 = cave->color3; // amoeba
+ cave->color5 = cave->color1; // slime
}
else if (paramcount == 5)
{
- /* bg,color0,1,2,3 */
+ // bg,color0,1,2,3
cave->colorb = gd_color_get_from_string(params[0]);
cave->color0 = gd_color_get_from_string(params[1]);
cave->color1 = gd_color_get_from_string(params[2]);
cave->color2 = gd_color_get_from_string(params[3]);
cave->color3 = gd_color_get_from_string(params[4]);
- cave->color4 = cave->color3; /* amoeba */
- cave->color5 = cave->color1; /* slime */
+ cave->color4 = cave->color3; // amoeba
+ cave->color5 = cave->color1; // slime
}
else if (paramcount == 7)
{
- /* bg,color0,1,2,3,amoeba,slime */
+ // bg,color0,1,2,3,amoeba,slime
cave->colorb = gd_color_get_from_string(params[0]);
cave->color0 = gd_color_get_from_string(params[1]);
cave->color1 = gd_color_get_from_string(params[2]);
cave->color2 = gd_color_get_from_string(params[3]);
cave->color3 = gd_color_get_from_string(params[4]);
- cave->color4 = gd_color_get_from_string(params[5]); /* amoeba */
- cave->color5 = gd_color_get_from_string(params[6]); /* slime */
+ cave->color4 = gd_color_get_from_string(params[5]); // amoeba
+ cave->color5 = gd_color_get_from_string(params[6]); // slime
}
else
{
ok = FALSE;
}
- /* now check and maybe make up some new. */
+ // now check and maybe make up some new.
if (!ok ||
gd_color_is_unknown(cave->colorb) ||
gd_color_is_unknown(cave->color0) ||
{
Warn("created a new C64 color scheme.");
- gd_cave_set_random_c64_colors(cave); /* just create some random */
+ gd_cave_set_random_c64_colors(cave); // just create some random
}
}
else
freeStringArray(params);
- /* a ghrfunc should return true if the identifier is to be removed */
+ // a ghrfunc should return true if the identifier is to be removed
return identifier_found;
}
-/* report all remaining tags; called after the above function. */
+// report all remaining tags; called after the above function.
static void cave_report_and_copy_unknown_tags_func(char *attrib, char *param, void *data)
{
GdCave *cave = (GdCave *)data;
hashtable_insert(cave->tags, getStringCopy(attrib), getStringCopy(param));
}
-/* having read all strings belonging to the cave, process it. */
+// having read all strings belonging to the cave, process it.
static void cave_process_tags(GdCave *cave, HashTable *tags, List *maplines)
{
char *value;
- /* first check cave name, so we can report errors correctly (saying that GdCave xy: error foobar) */
+ // first check cave name, so we can report errors correctly (saying that GdCave xy: error foobar)
value = hashtable_search(tags, "Name");
if (value)
cave_process_tags_func("Name", value, cave);
- /* process lame engine tag first so its settings may be overwritten later */
+ // process lame engine tag first so its settings may be overwritten later
value = hashtable_search(tags, "Engine");
if (value)
{
hashtable_remove(tags, "Engine");
}
- /* check if this is an intermission, so we can set to cavesize or intermissionsize */
+ // check if this is an intermission, so we can set to cavesize or intermissionsize
value = hashtable_search(tags, "Intermission");
if (value)
{
if (cave->intermission)
{
- /* set to IntermissionSize */
+ // set to IntermissionSize
cave->w = intermissionsize[0];
cave->h = intermissionsize[1];
cave->x1 = intermissionsize[2];
}
else
{
- /* set to CaveSize */
+ // set to CaveSize
cave->w = cavesize[0];
cave->h = cavesize[1];
cave->x1 = cavesize[2];
cave->y2 = cavesize[5];
}
- /* process size at the beginning... as ratio types depend on this. */
+ // process size at the beginning... as ratio types depend on this.
value = hashtable_search(tags, "Size");
if (value)
{
hashtable_remove(tags, "Size");
}
- /* these are read from the hash table, but also have some implications */
- /* we do not delete them from the hash table here; as _their values will be processed later_. */
- /* here we only set their implicite meanings. */
- /* these also set predictability */
+ // these are read from the hash table, but also have some implications
+ // we do not delete them from the hash table here; as _their values will be processed later_.
+ // here we only set their implicite meanings.
+ // these also set predictability
if (hashtable_search(tags, "SlimePermeability"))
cave->slime_predictable = FALSE;
if (hashtable_search(tags, "SlimePermeabilityC64"))
cave->slime_predictable = TRUE;
- /* these set scheduling type. framedelay takes precedence, if there are both; so we check it later. */
+ // these set scheduling type.
+ // framedelay takes precedence, if there are both; so we check it later.
if (hashtable_search(tags, "CaveDelay"))
{
- /* only set scheduling type, when it is not the gdash-default. */
- /* this allows settings cavescheduling = bd1 in the [game] section, for example. */
- /* in that case, this one will not overwrite it. */
+ // only set scheduling type, when it is not the gdash-default.
+ // this allows settings cavescheduling = bd1 in the [game] section, for example.
+ // in that case, this one will not overwrite it.
if (cave->scheduling == GD_SCHEDULING_MILLISECONDS)
cave->scheduling = GD_SCHEDULING_PLCK;
}
+ // but if the cave has a frametime setting, always switch to milliseconds.
if (hashtable_search(tags, "FrameTime"))
- /* but if the cave has a frametime setting, always switch to milliseconds. */
cave->scheduling = GD_SCHEDULING_MILLISECONDS;
- /* process all tags */
+ // process all tags
hashtable_foreach_remove(tags, (hashtable_remove_fn)cave_process_tags_func, cave);
- /* and at the end, when read all tags (especially the size= tag) */
- /* process map, if any. */
- /* only report if map read is bigger than size= specified. */
- /* some old bdcff files use smaller intermissions than the one specified. */
+ // and at the end, when read all tags (especially the size= tag)
+ // process map, if any.
+ // only report if map read is bigger than size= specified.
+ // some old bdcff files use smaller intermissions than the one specified.
if (maplines)
{
int x, y, length = list_length(maplines);
List *iter;
- /* create map and fill with initial border, in case that map strings are shorter or somewhat */
+ // create map and fill with initial border, in case that map strings are shorter or somewhat
cave->map = gd_cave_map_new(cave, GdElement);
for (y = 0; y < cave->h; y++)
Warn("map error in row %d: cave width = %d (%d visible), map width = %d",
y, cave->w, cave->x2 - cave->x1 + 1, slen);
- /* use number of cells from cave or string, whichever is smaller.
- so will not overwrite array! */
+ // use number of cells from cave or string, whichever is smaller.
+ // so will not overwrite array!
for (x = 0; x < MIN(cave->w, slen); x++)
cave->map[y][x] = gd_get_element_from_character (line[x]);
}
}
}
-/* sets the cavesize array to default values */
+// sets the cavesize array to default values
static void set_cavesize_defaults(void)
{
cavesize[0] = 40;
cavesize[5] = 21;
}
-/* sets the cavesize array to default values */
+// sets the cavesize array to default values
static void set_intermissionsize_defaults(void)
{
intermissionsize[0] = 40;
boolean reading_highscore = FALSE;
boolean reading_objects = FALSE;
boolean reading_bdcff_demo = FALSE;
- /* assume version to be 0.32, also when the file does not specify it explicitly */
+ // assume version to be 0.32, also when the file does not specify it explicitly
GdString version_read = "0.32";
List *mapstrings = NULL;
int linenum;
tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
replay_tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
- /* split into lines */
+ // split into lines
lines = getSplitStringArray (contents, "\n", 0);
- /* attributes read will be set in cave. if no [cave]; they are stored
- in the default cave; like in a [game] */
+ // attributes read will be set in cave. if no [cave]; they are stored
+ // in the default cave; like in a [game] */
default_cave = gd_cave_new();
cave = default_cave;
char *line = lines[lineno];
char *r;
- /* remove windows-nightmare \r-s */
- while((r = strchr(line, '\r')))
+ // remove windows-nightmare \r-s
+ while ((r = strchr(line, '\r')))
strcpy(r, r + 1);
- if (strlen (line) == 0)
- continue; /* skip empty lines */
+ // skip empty lines
+ if (strlen(line) == 0)
+ continue;
- /* just skip comments. be aware that map lines may start with a semicolon... */
+ // just skip comments. be aware that map lines may start with a semicolon...
if (!reading_map && line[0] == ';')
continue;
- /* STARTING WITH A BRACKET [ IS A SECTION */
+ // STARTING WITH A BRACKET [ IS A SECTION
if (line[0] == '[')
{
if (strcasecmp(line, "[cave]") == 0)
{
- /* new cave */
+ // new cave
if (mapstrings)
{
Warn("incorrect file format: new [cave] section, but already read some map lines");
mapstrings = NULL;
}
- /* process any pending tags for game ... */
+ // process any pending tags for game ...
cave_process_tags(default_cave, tags, NULL);
- /* ... to be able to create a copy for a new cave. */
+ // ... to be able to create a copy for a new cave.
cave = gd_cave_new_from_cave(default_cave);
gd_caveset = list_append (gd_caveset, cave);
}
hashtable_foreach(tags, (hashtable_fn)cave_report_and_copy_unknown_tags_func, cave);
hashtable_remove_all(tags);
- /* set this to point the pseudo-cave which holds default values */
+ // set this to point the pseudo-cave which holds default values
cave = default_cave;
}
else if (strcasecmp(line, "[map]") == 0)
{
replay = gd_replay_new();
replay->saved = TRUE;
- replay->success = TRUE; /* we think that it is a successful demo */
+ replay->success = TRUE; // we think that it is a successful demo
cave->replays = list_append(cave->replays, replay);
- gd_strcpy(replay->player_name, "???"); /* name not saved */
+ gd_strcpy(replay->player_name, "???"); // name not saved
}
else
{
reading_replay = FALSE;
replay = gd_replay_new();
- /* set "saved" flag, so this replay will be written when the caveset is saved again */
+ // set "saved" flag, so this replay will be written when the caveset is saved again
replay->saved = TRUE;
replay_process_tags(replay, replay_tags);
#if 1
- /* BDCFF numbers levels from 1 to 5, but internally we number levels from 0 to 4 */
+ // BDCFF numbers levels from 1 to 5, but internally we number levels from 0 to 4
if (replay->level > 0)
replay->level--;
#endif
- /* report any remaining unknown tags */
+ // report any remaining unknown tags
hashtable_foreach(replay_tags, (hashtable_fn)replay_report_unknown_tags_func, NULL);
hashtable_remove_all(replay_tags);
gd_replay_free(replay);
}
}
- /* GOSH i hate bdcff */
+ // GOSH i hate bdcff
else if (strncasecmp(line, "[level=", strlen("[level=")) == 0)
{
int l[5];
int num;
char *nums;
- /* there IS an equal sign, and we also skip that, so this points to the numbers */
+ // there IS an equal sign, and we also skip that, so this points to the numbers
nums = strchr(line, '=') + 1;
num = sscanf(nums, "%d,%d,%d,%d,%d", l + 0, l + 1, l + 2, l + 3, l + 4);
levels = 0;
if (reading_map)
{
- /* just append to the mapstrings list. we will process it later */
+ // just append to the mapstrings list. we will process it later
mapstrings = list_append(mapstrings, line);
continue;
}
- /* strip leading and trailing spaces AFTER checking if we are reading a map.
- map lines might begin or end with spaces */
+ // strip leading and trailing spaces AFTER checking if we are reading a map.
+ // map lines might begin or end with spaces */
stripString(line);
if (reading_highscore)
int score;
if (sscanf(line, "%d", &score) != 1 || strchr(line, ' ') == NULL)
- { /* first word is the score */
+ {
+ // first word is the score
Warn("highscore format incorrect");
}
else
{
if (cave == default_cave)
- /* if we are reading the [game], add highscore to that one. */
- /* from first space: the name */
+ // if we are reading the [game], add highscore to that one.
+ // from first space: the name
gd_add_highscore(gd_caveset_data->highscore, strchr(line, ' ') + 1, score);
else
- /* if a cave, add highscore to that. */
+ // if a cave, add highscore to that.
gd_add_highscore(cave->highscore, strchr(line, ' ') + 1, score);
}
continue;
}
- /* read bdcff-style [demo], similar to a complete replay but cannot store like anything */
+ // read bdcff-style [demo], similar to a complete replay but cannot store like anything
if (reading_bdcff_demo)
{
GdReplay *replay;
List *iter;
- /* demo must be in [cave] section. we already showed an error message for this. */
+ // demo must be in [cave] section. we already showed an error message for this.
if (cave == default_cave)
continue;
new_object = gd_object_new_from_string(line);
if (new_object)
{
- new_object->levels = levels; /* apply levels to new object */
+ new_object->levels = levels; // apply levels to new object
cave->objects = list_append(cave->objects, new_object);
}
else
continue;
}
- /* has an equal sign -> some_attrib = parameters type line. */
+ // has an equal sign -> some_attrib = parameters type line.
if (strchr (line, '=') != NULL)
{
char *attrib, *param;
- attrib = line; /* attrib is from the first char */
- param = strchr(line, '=') + 1; /* param is after equal sign */
- *strchr (line, '=') = 0; /* delete equal sign - line is therefore splitted */
+ attrib = line; // attrib is from the first char
+ param = strchr(line, '=') + 1; // param is after equal sign
+ *strchr (line, '=') = 0; // delete equal sign - line is therefore splitted
- /* own tag: not too much thinking :P */
+ // own tag: not too much thinking :P
if (reading_replay)
{
hashtable_insert(replay_tags, getStringCopy(attrib), getStringCopy(param));
{
if (strcasecmp("Length", attrib) == 0)
{
- /* we do not support map code width != 1 */
+ // we do not support map code width != 1
if (strcmp(param, "1") != 0)
Warn(_("Only one-character map codes are currently supported!"));
}
else
{
- /* the first character of the attribute is the element code itself */
+ // the first character of the attribute is the element code itself
gd_char_to_element[(int)attrib[0]] = gd_get_element_from_string(param);
}
}
- /* BDCFF version */
else if (strcasecmp("Version", attrib) == 0)
{
+ // BDCFF version
gd_strcpy(version_read, param);
}
- /* CAVES = x */
else if (strcasecmp(attrib, "Caves") == 0)
{
- /* BDCFF files sometimes state how many caves they have */
- /* we ignore this field. */
+ // CAVES = x
+
+ // BDCFF files sometimes state how many caves they have
+ // we ignore this field.
}
- /* LEVELS = x */
else if (strcasecmp(attrib, "Levels") == 0)
{
- /* BDCFF files sometimes state how many levels they have */
- /* we ignore this field. */
+ // LEVELS = x
+
+ // BDCFF files sometimes state how many levels they have
+ // we ignore this field.
}
else if (strcasecmp(attrib, "CaveSize") == 0)
{
cavesize + 4,
cavesize + 5);
- /* allowed: 2 or 6 numbers */
+ // allowed: 2 or 6 numbers
if (i == 2)
{
cavesize[2] = 0;
intermissionsize + 4,
intermissionsize + 5);
- /* allowed: 2 or 6 numbers */
+ // allowed: 2 or 6 numbers
if (i == 2)
{
intermissionsize[2] = 0;
}
else if (strcasecmp(attrib, "Effect") == 0)
{
- /* CHECK IF IT IS AN EFFECT */
+ // CHECK IF IT IS AN EFFECT
char **params;
params = getSplitStringArray(param, " ", -1);
- /* an effect command has two parameters */
+ // an effect command has two parameters
if (getStringArrayLength(params) == 2)
{
int i;
for (i = 0; gd_cave_properties[i].identifier != NULL; i++)
{
- /* we have to search for this effect */
+ // we have to search for this effect
if (gd_cave_properties[i].type == GD_TYPE_EFFECT &&
strcasecmp(params[0], gd_cave_properties[i].identifier) == 0)
{
- /* found identifier */
+ // found identifier
void *value = STRUCT_MEMBER_P (cave, gd_cave_properties[i].offset);
*((GdElement *) value) = gd_get_element_from_string (params[1]);
}
}
- /* if we didn't find first element name */
+ // if we didn't find first element name
if (gd_cave_properties[i].identifier == NULL)
{
- /* for compatibility with tim stridmann's memorydump->bdcff converter... .... ... */
+ // for compatibility with tim stridmann's memorydump->bdcff converter... .... ...
if (strcasecmp(params[0], "BOUNCING_BOULDER") == 0)
cave->stone_bouncing_effect = gd_get_element_from_string (params[1]);
else if (strcasecmp(params[0], "EXPLOSION3S") == 0)
cave->explosion_effect = gd_get_element_from_string(params[1]);
- /* falling with one l... */
+ // falling with one l...
else if (strcasecmp(params[0], "STARTING_FALING_DIAMOND") == 0)
cave->diamond_falling_effect = gd_get_element_from_string (params[1]);
- /* dirt lookslike */
+ // dirt lookslike
else if (strcasecmp(params[0], "DIRT") == 0)
cave->dirt_looks_like = gd_get_element_from_string (params[1]);
- else if (strcasecmp(params[0], "HEXPANDING_WALL") == 0 && strcasecmp(params[1], "STEEL_HEXPANDING_WALL") == 0)
+ else if (strcasecmp(params[0], "HEXPANDING_WALL") == 0 &&
+ strcasecmp(params[1], "STEEL_HEXPANDING_WALL") == 0)
{
cave->expanding_wall_looks_like = O_STEEL;
}
else
- /* didn't find at all */
+ {
+ // didn't find at all
Warn("invalid effect name '%s'", params[0]);
+ }
}
}
else
+ {
Warn("invalid effect specification '%s'", param);
+ }
freeStringArray(params);
}
else
{
- /* no special handling: this is a normal attribute. */
+ // no special handling: this is a normal attribute.
if (cave == default_cave)
{
- /* we are reading the [game] */
+ // we are reading the [game]
if (attrib_is_valid_for_caveset(attrib))
{
- /* if it is a caveset attrib, process it for the caveset. */
+ // if it is a caveset attrib, process it for the caveset.
struct_set_property(gd_caveset_data, gd_caveset_properties, attrib, param, 0);
}
else if (attrib_is_valid_for_cave(attrib))
{
- /* it must be a default setting for all caves. is it a valid identifier? */
- /* yes, it is. add to the hash table, which will be copied for all caves. */
+ // it must be a default setting for all caves. is it a valid identifier?
+ // yes, it is. add to the hash table, which will be copied for all caves.
hashtable_insert(tags, getStringCopy(attrib), getStringCopy(param));
}
else
{
- /* unknown setting - report. */
+ // unknown setting - report.
Warn("invalid attribute for [game] '%s'", attrib);
}
}
else
{
- /* we are reading a [cave] */
- /* cave settings are immediately added to cave hash table. */
- /* if it is unknown, we have to remember it, and save it again. */
+ // we are reading a [cave]
+ // cave settings are immediately added to cave hash table.
+ // if it is unknown, we have to remember it, and save it again.
hashtable_insert(tags, getStringCopy(attrib), getStringCopy(param));
}
}
mapstrings = NULL;
}
- /* the [game] section had some values which are default if not specified in [cave] sections. */
- /* these are used only for loading, so forget them now */
+ // the [game] section had some values which are default if not specified in [cave] sections.
+ // these are used only for loading, so forget them now
if (default_cave->map)
Warn(_("Invalid BDCFF: [game] section has a map"));
if (default_cave->objects)
Warn(_("Invalid BDCFF: [game] section has drawing objects defined"));
- /* cleanup */
+ // cleanup
freeStringArray(lines);
hashtable_destroy(tags);
hashtable_destroy(replay_tags);
gd_cave_free(default_cave);
- /* old bdcff files hack. explanation follows. */
- /* there were 40x22 caves in c64 bd, intermissions were also 40x22, but the visible */
- /* part was the upper left corner, 20x12. 40x22 caves are needed, as 20x12 caves would */
- /* look different (random cave elements needs the correct size.) */
- /* also, in older bdcff files, there is no size= tag. caves default to 40x22 and 20x12. */
- /* even the explicit drawrect and other drawing instructions, which did set up intermissions */
- /* to be 20x12, are deleted. very very bad decision. */
- /* here we try to detect and correct this. */
+ // old bdcff files hack. explanation follows.
+ // there were 40x22 caves in c64 bd, intermissions were also 40x22, but the visible
+ // part was the upper left corner, 20x12. 40x22 caves are needed, as 20x12 caves would
+ // look different (random cave elements needs the correct size.)
+ // also, in older bdcff files, there is no size= tag. caves default to 40x22 and 20x12.
+ // even the explicit drawrect and other drawing instructions, which did set up intermissions
+ // to be 20x12, are deleted. very very bad decision.
+ // here we try to detect and correct this.
if (strEqual(version_read, "0.32"))
{
{
GdCave *cave = (GdCave *)iter->data;
- /* only applies to intermissions */
- /* not applied to mapped caves, as maps are filled with initial border, if the map read is smaller */
+ // only applies to intermissions; not applied to mapped caves, as maps are filled with
+ // initial border, if the map read is smaller
if (cave->intermission && !cave->map)
{
- /* we do not set the cave to 20x12, rather to 40x22 with 20x12 visible. */
+ // we do not set the cave to 20x12, rather to 40x22 with 20x12 visible.
GdObject object;
cave->w = 40;
cave->x2 = 19;
cave->y2 = 11;
- /* and cover the invisible area */
+ // and cover the invisible area
object.type = GD_FILLED_RECTANGLE;
object.x1 = 0;
- object.y1 = 11; /* 11, because this will also be the border */
+ object.y1 = 11; // 11, because this will also be the border
object.x2 = 39;
object.y2 = 21;
object.element = cave->initial_border;
cave->objects = list_prepend(cave->objects, get_memcpy(&object, sizeof(object)));
object.x1 = 19;
- object.y1 = 0; /* 19, as it is also the border */
+ object.y1 = 0; // 19, as it is also the border
- cave->objects = list_prepend(cave->objects, get_memcpy(&object, sizeof(object))); /* another */
+ // another
+ cave->objects = list_prepend(cave->objects, get_memcpy(&object, sizeof(object)));
}
}
}
if (!strEqual(version_read, BDCFF_VERSION))
Warn("BDCFF version %s, loaded caveset may have errors.", version_read);
- /* check for replays which are problematic */
+ // check for replays which are problematic
for (iter = gd_caveset; iter != NULL; iter = iter->next)
gd_cave_check_replays((GdCave *)iter->data, TRUE, FALSE, FALSE);
- /* if there was some error message - return fail XXX */
+ // if there was some error message - return fail XXX
return TRUE;
}
-/********************************************************************************
- *
- * BDCFF saving
- *
- */
+
+// ============================================================================
+// BDCFF saving
+// ============================================================================
#define GD_PTR_ARRAY_MINIMUM_INITIAL_SIZE 64
checked_free(array);
}
-/* ratio: max cave size for GD_TYPE_RATIO. should be set to cave->w*cave->h when calling */
+// ratio: max cave size for GD_TYPE_RATIO. should be set to cave->w*cave->h when calling
static void save_properties(GdPtrArray *out, void *str, void *str_def,
const GdStructDescriptor *prop_desc, int ratio)
{
{
void *value, *default_value;
+ // used only by the gui
if (prop_desc[i].type == GD_TAB || prop_desc[i].type == GD_LABEL)
- /* used only by the gui */
continue;
- /* these are handled explicitly */
+ // these are handled explicitly
if (prop_desc[i].flags & GD_DONT_SAVE)
continue;
- /* string data */
- /* write together with identifier, as one string per line. */
+ // string data
+ // write together with identifier, as one string per line.
if (prop_desc[i].type == GD_TYPE_STRING)
{
- /* treat strings as special - do not even write identifier if no string. */
+ // treat strings as special - do not even write identifier if no string.
char *text = STRUCT_MEMBER_P(str, prop_desc[i].offset);
if (strlen(text) > 0)
continue;
}
- /* dynamic string: need to escape newlines */
+ // dynamic string: need to escape newlines
if (prop_desc[i].type == GD_TYPE_LONGSTRING)
{
char *string = STRUCT_MEMBER(char *, str, prop_desc[i].offset);
continue;
}
- /* if identifier differs from the previous, write out the line collected, and start a new one */
+ // if identifier differs from the previous, write out the line collected, and start a new one
if (identifier == NULL || !strEqual(prop_desc[i].identifier, identifier))
{
if (should_write)
{
- /* write lines only which carry information other than the default settings */
+ // write lines only which carry information other than the default settings
gd_ptr_array_add(out, getStringCopy(line));
}
else
setStringPrint(&line, "%s=", prop_desc[i].identifier);
- parameter_written = FALSE; /* no value written yet */
+ parameter_written = FALSE; // no value written yet
should_write = FALSE;
- /* remember identifier */
+ // remember identifier
identifier = prop_desc[i].identifier;
}
- /* if we always save this identifier, remember now */
+ // if we always save this identifier, remember now
if (prop_desc[i].flags & GD_ALWAYS_SAVE)
should_write = TRUE;
for (j = 0; j < prop_desc[i].count; j++)
{
- /* separate values by spaces. of course no space required for the first one */
+ // separate values by spaces. of course no space required for the first one
if (parameter_written)
appendStringPrint(&line, " ");
- parameter_written = TRUE; /* at least one value written, so write space the next time */
+ parameter_written = TRUE; // at least one value written, so write space the next time
switch (prop_desc[i].type)
{
break;
case GD_TYPE_PROBABILITY:
- appendStringPrint(&line, "%6.5f", ((int *) value)[j] / 1E6); /* probabilities are stored as *1E6 */
+ // probabilities are stored as *1E6
+ appendStringPrint(&line, "%6.5f", ((int *) value)[j] / 1E6);
if (((double *) value)[j] != ((double *) default_value)[j])
should_write = TRUE;
break;
case GD_TYPE_EFFECT:
- /* for effects, the property identifier is the effect name. "Effect=" is hardcoded; see above. */
- appendStringPrint(&line, "%s %s", prop_desc[i].identifier, gd_elements[((GdElement *) value)[j]].filename);
+ // for effects, the property identifier is the effect name.
+ // "Effect=" is hardcoded; see above.
+ appendStringPrint(&line, "%s %s", prop_desc[i].identifier,
+ gd_elements[((GdElement *) value)[j]].filename);
if (((GdElement *) value)[j] != ((GdElement *) default_value)[j])
should_write = TRUE;
break;
case GD_TAB:
case GD_LABEL:
- /* used by the editor ui */
+ // used by the editor ui
break;
case GD_TYPE_STRING:
case GD_TYPE_LONGSTRING:
- /* never reached */
+ // never reached
break;
}
}
}
- /* write remaining data */
+ // write remaining data
if (should_write)
gd_ptr_array_add(out, getStringCopy(line));
checked_free(line);
}
-/* remove a line from the list of strings. */
-/* the prefix should be a property; add an equal sign! so properties which have names like
- "slime" and "slimeproperties" won't match each other. */
+// remove a line from the list of strings.
+// the prefix should be a property; add an equal sign! so properties which have names like
+// "slime" and "slimeproperties" won't match each other.
static void cave_properties_remove(GdPtrArray *out, const char *prefix)
{
int i;
if (!strSuffix(prefix, "="))
Warn("string '%s' should have suffix '='", prefix);
- /* search for strings which match, and set them to NULL. */
- /* also free them. */
+ // search for strings which match, and set them to NULL.
+ // also free them.
for (i = 0; i < out->size; i++)
{
if (strPrefix(gd_ptr_array_index(out, i), prefix))
}
}
- /* remove all "null" occurrences */
+ // remove all "null" occurrences
while (gd_ptr_array_remove(out, NULL))
;
}
-/* output properties of a structure to a file. */
-/* list_foreach func, so "out" is the last parameter! */
+// output properties of a structure to a file.
+// list_foreach func, so "out" is the last parameter!
static void caveset_save_cave_func(GdCave *cave, GdPtrArray *out)
{
GdCave *default_cave;
GdPtrArray *this_out;
- char *line = NULL; /* used for various purposes */
+ char *line = NULL; // used for various purposes
int i;
gd_ptr_array_add(out, getStringCopy(""));
gd_ptr_array_add(out, getStringCopy("[cave]"));
- /* first add the properties to a local ptr array. */
- /* later, some are deleted (slime permeability, for example) - this is needed because of the inconsistencies of the bdcff. */
- /* finally, remaining will be added to the normal "out" array. */
+ // first add the properties to a local ptr array.
+ // later, some are deleted (slime permeability, for example) - this is needed because of the
+ // inconsistencies of the bdcff.
+ // finally, remaining will be added to the normal "out" array.
this_out = gd_ptr_array_new();
default_cave = gd_cave_new();
save_properties(this_out, cave, default_cave, gd_cave_properties, cave->w * cave->h);
gd_cave_free(default_cave);
- /* properties which are handled explicitly. these cannot be handled easily above,
- as they have some special meaning. for example, slime_permeability=x sets permeability to
- x, and sets predictable to false. bdcff format is simply inconsistent in these aspects. */
+ // properties which are handled explicitly. these cannot be handled easily above,
+ // as they have some special meaning. for example, slime_permeability=x sets permeability to
+ // x, and sets predictable to false. bdcff format is simply inconsistent in these aspects.
- /* slime permeability is always set explicitly, as it also sets predictability. */
+ // slime permeability is always set explicitly, as it also sets predictability.
if (cave->slime_predictable)
- /* if slime is predictable, remove permeab. flag, as that would imply unpredictable slime. */
+ // if slime is predictable, remove permeab. flag, as that would imply unpredictable slime.
cave_properties_remove(this_out, "SlimePermeability=");
else
- /* if slime is UNpredictable, remove permeabc64 flag, as that would imply predictable slime. */
+ // if slime is UNpredictable, remove permeabc64 flag, as that would imply predictable slime.
cave_properties_remove(this_out, "SlimePermeabilityC64=");
- /* add tags to output, and free local array */
+ // add tags to output, and free local array
for (i = 0; i < this_out->size; i++)
gd_ptr_array_add(out, gd_ptr_array_index(this_out, i));
- /* do not free data pointers, which were just added to array "out" */
+ // do not free data pointers, which were just added to array "out"
gd_ptr_array_free(this_out, FALSE);
#if 0
- /* save unknown tags as they are */
+ // save unknown tags as they are
if (cave->tags)
{
List *hashkeys;
}
#endif
- /* map */
+ // map
if (cave->map)
{
int x, y;
line = checked_calloc(cave->w + 1);
- /* save map */
+ // save map
for (y = 0; y < cave->h; y++)
{
for (x = 0; x < cave->w; x++)
{
- /* check if character is non-zero; the ...save() should have assigned a character to every element */
+ // check if character is non-zero;
+ // the ...save() should have assigned a character to every element
if (gd_elements[cave->map[y][x]].character_new == 0)
Warn("gd_elements[cave->map[y][x]].character_new should be non-zero");
gd_ptr_array_add(out, getStringCopy("[/map]"));
}
- /* save drawing objects */
+ // save drawing objects
if (cave->objects)
{
List *listiter;
GdObject *object = listiter->data;
char *text;
- /* not for all levels? */
+ // not for all levels?
if (object->levels != GD_OBJECT_LEVEL_ALL)
{
int i;
- boolean once; /* true if already written one number */
+ boolean once; // true if already written one number
setStringPrint(&line, "[Level=");
once = FALSE;
{
if (object->levels & gd_levels_mask[i])
{
- if (once) /* if written at least one number so far, we need a comma */
+ if (once) // if written at least one number so far, we need a comma
appendStringPrint(&line, ",");
appendStringPrint(&line, "%d", i+1);
checked_free(line);
}
-/* save cave in bdcff format. */
-/* "out" will be added lines of bdcff description. */
+// save cave in bdcff format.
+// "out" will be added lines of bdcff description.
GdPtrArray *gd_caveset_save_to_bdcff(void)
{
GdPtrArray *out = gd_ptr_array_sized_new(512);
List *iter;
int i;
- /* check if we need an own mapcode table ------ */
- /* copy original characters to character_new fields; new elements will be added to that one */
+ // check if we need an own mapcode table ------
+ // copy original characters to character_new fields; new elements will be added to that one
for (i = 0; i < O_MAX; i++)
gd_elements[i].character_new = gd_elements[i].character;
- /* also regenerate this table as we use it */
+ // also regenerate this table as we use it
gd_create_char_to_element_table();
- /* check all caves */
+ // check all caves
for (iter = gd_caveset; iter != NULL; iter = iter->next)
{
GdCave *cave = (GdCave *)iter->data;
- /* if they have a map (random elements+object based maps do not need characters) */
+ // if they have a map (random elements+object based maps do not need characters)
if (cave->map)
{
int x, y;
- /* check every element of map */
+ // check every element of map
for(y = 0; y < cave->h; y++)
for (x = 0; x < cave->w; x++)
{
GdElement e = cave->map[y][x];
- /* if no character assigned */
+ // if no character assigned
if (gd_elements[e].character_new == 0)
{
int j;
- /* we found at least one, so later we have to write the mapcodes */
+ // we found at least one, so later we have to write the mapcodes
write_mapcodes = TRUE;
- /* find a character which is not yet used for any element */
+ // find a character which is not yet used for any element
for (j = 32; j < 128; j++)
{
- /* the string contains the characters which should not be used. */
+ // the string contains the characters which should not be used.
if (strchr("<>&[]/=\\", j) == NULL && gd_char_to_element[j] == O_UNKNOWN)
break;
}
- /* if no more space... XXX we should rather report to the user */
+ // if no more space... XXX we should rather report to the user
if (j == 128)
Warn("variable j should be != 128");
gd_elements[e].character_new = j;
- /* we also record to this table, as we use it ^^ a few lines above */
+ // we also record to this table, as we use it ^^ a few lines above
gd_char_to_element[j] = e;
}
}
gd_ptr_array_add(out, getStringCopy("[BDCFF]"));
gd_ptr_array_add(out, getStringPrint("Version=%s", BDCFF_VERSION));
- /* this flag was set above if we need to write mapcodes */
+ // this flag was set above if we need to write mapcodes
if (write_mapcodes)
{
int i;
for (i = 0; i < O_MAX; i++)
{
- /* if no character assigned by specification BUT (AND) we assigned one */
+ // if no character assigned by specification BUT (AND) we assigned one
if (gd_elements[i].character == 0 && gd_elements[i].character_new != 0)
gd_ptr_array_add(out, getStringPrint("%c=%s", gd_elements[i].character_new, gd_elements[i].filename));
}
gd_ptr_array_add(out, getStringCopy("[/game]"));
gd_ptr_array_add(out, getStringCopy("[/BDCFF]"));
- /* saved to ptrarray */
+ // saved to ptrarray
return out;
}
#include "main_bd.h"
-/* make all caves selectable. */
+// make all caves selectable.
static boolean gd_import_as_all_caves_selectable = TRUE;
-/* conversion table for imported bd1 caves. */
+// conversion table for imported bd1 caves.
static const GdElement bd1_import_table[] =
{
/* 0 */ O_SPACE, O_DIRT, O_BRICK, O_MAGIC_WALL,
/* c */ O_FIREFLY_1, O_FIREFLY_2, O_FIREFLY_3, O_FIREFLY_4,
/* 10 */ O_STONE, O_STONE, O_STONE_F, O_STONE_F,
/* 14 */ O_DIAMOND, O_DIAMOND, O_DIAMOND_F, O_DIAMOND_F,
- /* 18 */ O_ACID, O_ACID, O_EXPLODE_1, O_EXPLODE_2, /* ACID: marek roth extension in crazy dream 3 */
+ // ----- ACID: marek roth extension in crazy dream 3
+ /* 18 */ O_ACID, O_ACID, O_EXPLODE_1, O_EXPLODE_2,
/* 1c */ O_EXPLODE_3, O_EXPLODE_4, O_EXPLODE_5, O_PRE_DIA_1,
/* 20 */ O_PRE_DIA_2, O_PRE_DIA_3, O_PRE_DIA_4, O_PRE_DIA_5,
/* 24 */ O_PRE_DIA_5, O_INBOX, O_PRE_PL_1, O_PRE_PL_2,
/* 3c */ O_VOODOO, O_INVIS_OUTBOX, O_SLIME, O_UNKNOWN
};
-/* conversion table for imported plck caves. */
+// conversion table for imported plck caves.
static const GdElement plck_import_nybble[] =
{
/* 0 */ O_STONE, O_DIAMOND, O_MAGIC_WALL, O_BRICK,
/* 12 */ O_PRE_INVIS_OUTBOX, O_PRE_OUTBOX, O_INBOX, O_SPACE
};
-/* conversion table for imported 1stb caves. */
+// conversion table for imported 1stb caves.
static const GdElement firstboulder_import_table[] =
{
/* 0 */ O_SPACE, O_DIRT, O_BRICK, O_MAGIC_WALL,
/* 1c */ O_BITER_SWITCH, O_BITER_SWITCH, O_BLADDER_SPENDER, O_PRE_DIA_1,
/* 20 */ O_PRE_DIA_1, O_PRE_DIA_2, O_PRE_DIA_3, O_PRE_DIA_4,
/* 24 */ O_PRE_DIA_5, O_INBOX, O_PRE_PL_1, O_PRE_PL_2,
- /* 28 */ O_PRE_PL_3, O_CLOCK, O_H_EXPANDING_WALL, O_H_EXPANDING_WALL, /* CLOCK: not mentioned in marek's bd inside faq */
+ // ----- CLOCK: not mentioned in marek's bd inside faq
+ /* 28 */ O_PRE_PL_3, O_CLOCK, O_H_EXPANDING_WALL, O_H_EXPANDING_WALL,
/* 2c */ O_CREATURE_SWITCH, O_CREATURE_SWITCH, O_EXPANDING_WALL_SWITCH, O_EXPANDING_WALL_SWITCH,
/* 30 */ O_BUTTER_3, O_BUTTER_4, O_BUTTER_1, O_BUTTER_2,
/* 34 */ O_BUTTER_3, O_BUTTER_4, O_BUTTER_1, O_BUTTER_2,
/* 7c */ O_BITER_1, O_BITER_2, O_BITER_3, O_BITER_4,
};
-/* conversion table for imported crazy dream caves. */
+// conversion table for imported crazy dream caves.
static const GdElement crazydream_import_table[] =
{
/* 0 */ O_SPACE, O_DIRT, O_BRICK, O_MAGIC_WALL,
/* 10 */ O_STONE, O_STONE, O_STONE_F, O_STONE_F,
/* 14 */ O_DIAMOND, O_DIAMOND, O_DIAMOND_F, O_DIAMOND_F,
/* 18 */ O_PRE_CLOCK_1, O_PRE_CLOCK_2, O_PRE_CLOCK_3, O_PRE_CLOCK_4,
- /* 1c */ O_BITER_SWITCH, O_BITER_SWITCH, O_BLADDER_SPENDER, O_PRE_DIA_1, /* 6 different stages */
+ /* 1c */ O_BITER_SWITCH, O_BITER_SWITCH, O_BLADDER_SPENDER, O_PRE_DIA_1, // 6 different stages
/* 20 */ O_PRE_DIA_1, O_PRE_DIA_2, O_PRE_DIA_3, O_PRE_DIA_4,
/* 24 */ O_PRE_DIA_5, O_INBOX, O_PRE_PL_1, O_PRE_PL_2,
- /* 28 */ O_PRE_PL_3, O_CLOCK, O_H_EXPANDING_WALL, O_H_EXPANDING_WALL, /* CLOCK: not mentioned in marek's bd inside faq */
+ // ----- CLOCK: not mentioned in marek's bd inside faq
+ /* 28 */ O_PRE_PL_3, O_CLOCK, O_H_EXPANDING_WALL, O_H_EXPANDING_WALL,
/* 2c */ O_CREATURE_SWITCH, O_CREATURE_SWITCH, O_EXPANDING_WALL_SWITCH, O_EXPANDING_WALL_SWITCH,
/* 30 */ O_BUTTER_3, O_BUTTER_4, O_BUTTER_1, O_BUTTER_2,
/* 34 */ O_BUTTER_3, O_BUTTER_4, O_BUTTER_1, O_BUTTER_2,
/* fc */ O_WATER, O_WATER, O_WATER, O_WATER,
};
-/* conversion table for imported 1stb caves. */
+// conversion table for imported 1stb caves.
const GdElement gd_crazylight_import_table[] =
{
/* 0 */ O_SPACE, O_DIRT, O_BRICK, O_MAGIC_WALL,
/* 10 */ O_STONE, O_STONE|SCANNED, O_STONE_F, O_STONE_F|SCANNED,
/* 14 */ O_DIAMOND, O_DIAMOND|SCANNED, O_DIAMOND_F, O_DIAMOND_F|SCANNED,
/* 18 */ O_PRE_CLOCK_1, O_PRE_CLOCK_2, O_PRE_CLOCK_3, O_PRE_CLOCK_4,
- /* 1c */ O_BITER_SWITCH, O_BITER_SWITCH, O_BLADDER_SPENDER, O_PRE_DIA_1, /* 6 different stages, the first is the pre_dia_0 */
+ /* 1c */ O_BITER_SWITCH, O_BITER_SWITCH, O_BLADDER_SPENDER, O_PRE_DIA_1, // 6 different stages, the first is the pre_dia_0
/* 20 */ O_PRE_DIA_1, O_PRE_DIA_2, O_PRE_DIA_3, O_PRE_DIA_4,
/* 24 */ O_PRE_DIA_5, O_INBOX, O_PRE_PL_1, O_PRE_PL_2,
- /* 28 */ O_PRE_PL_3, O_CLOCK, O_H_EXPANDING_WALL, O_H_EXPANDING_WALL|SCANNED, /* CLOCK: not mentioned in marek's bd inside faq */
+ // ----- CLOCK: not mentioned in marek's bd inside faq
+ /* 28 */ O_PRE_PL_3, O_CLOCK, O_H_EXPANDING_WALL, O_H_EXPANDING_WALL|SCANNED,
/* 2c */ O_CREATURE_SWITCH, O_CREATURE_SWITCH, O_EXPANDING_WALL_SWITCH, O_EXPANDING_WALL_SWITCH,
/* 30 */ O_BUTTER_3, O_BUTTER_4, O_BUTTER_1, O_BUTTER_2,
/* 34 */ O_BUTTER_3|SCANNED, O_BUTTER_4|SCANNED, O_BUTTER_1|SCANNED, O_BUTTER_2|SCANNED,
{CAVE_OFFSET(level_hatching_delay_time[0]), 2},
{CAVE_OFFSET(intermission_instantlife), TRUE},
{CAVE_OFFSET(intermission_rewardlife), FALSE},
- {CAVE_OFFSET(magic_wall_stops_amoeba), FALSE}, /* marek roth bd inside faq 3.0 */
+ {CAVE_OFFSET(magic_wall_stops_amoeba), FALSE}, // marek roth bd inside faq 3.0
{CAVE_OFFSET(magic_timer_wait_for_hatching), FALSE},
{CAVE_OFFSET(pushing_stone_prob), 250000},
{CAVE_OFFSET(pushing_stone_prob_sweet), 1000000},
{CAVE_OFFSET(pal_timing), TRUE},
{CAVE_OFFSET(scheduling), GD_SCHEDULING_PLCK},
- {CAVE_OFFSET(amoeba_enclosed_effect), O_PRE_DIA_1}, /* not immediately to diamond, but with animation */
+ {CAVE_OFFSET(amoeba_enclosed_effect), O_PRE_DIA_1}, // not immediately to diamond, but with animation
{CAVE_OFFSET(dirt_looks_like), O_DIRT2},
{-1},
{CAVE_OFFSET(pal_timing), TRUE},
{CAVE_OFFSET(scheduling), GD_SCHEDULING_CRDR},
- {CAVE_OFFSET(amoeba_enclosed_effect), O_PRE_DIA_1}, /* not immediately to diamond, but with animation */
+ {CAVE_OFFSET(amoeba_enclosed_effect), O_PRE_DIA_1}, // not immediately to diamond, but with animation
{CAVE_OFFSET(water_does_not_flow_down), TRUE},
- {CAVE_OFFSET(skeletons_worth_diamonds), 1}, /* in crdr, skeletons can also be used to open the gate */
- {CAVE_OFFSET(gravity_affects_all), FALSE}, /* the intermission "survive" needs this flag */
+ {CAVE_OFFSET(skeletons_worth_diamonds), 1}, // in crdr, skeletons can also be used to open the gate
+ {CAVE_OFFSET(gravity_affects_all), FALSE}, // the intermission "survive" needs this flag
{-1},
};
{CAVE_OFFSET(pal_timing), TRUE},
{CAVE_OFFSET(scheduling), GD_SCHEDULING_PLCK},
- {CAVE_OFFSET(amoeba_enclosed_effect), O_PRE_DIA_1}, /* not immediately to diamond, but with animation */
+ {CAVE_OFFSET(amoeba_enclosed_effect), O_PRE_DIA_1}, // not immediately to diamond, but with animation
{-1},
};
-/* internal character (letter) codes in c64 games.
- missing: "triple line" after >, diamond between ()s, player's head after )
- used for converting names of caves imported from crli and other types of binary data */
-const char gd_bd_internal_chars[] = " ,!./0123456789:*<=> ABCDEFGHIJKLMNOPQRSTUVWXYZ( ) _";
+// internal character (letter) codes in c64 games.
+// missing: "triple line" after >, diamond between ()s, player's head after )
+// used for converting names of caves imported from crli and other types of binary data
+const char gd_bd_internal_chars[] =
+ " ,!./0123456789:*<=> ABCDEFGHIJKLMNOPQRSTUVWXYZ( ) _";
-/* used for bdcff engine flag. */
+// used for bdcff engine flag.
const char *gd_engines[] =
{
"BD1",
"CrLi"
};
-/* to convert predictable slime values to bit masks */
+// to convert predictable slime values to bit masks
static int slime_shift_msb(int c64_data)
{
int i, perm;
perm = 0;
for (i = 0; i < c64_data; i++)
- /* shift in this many msb 1's */
+ // shift in this many msb 1's
perm = (0x100|perm) >> 1;
return perm;
return O_UNKNOWN;
}
-/* deluxe caves 1 contained a special element, non-sloped brick. */
+// deluxe caves 1 contained a special element, non-sloped brick.
static GdElement deluxecaves_1_import(byte c, int i)
{
GdElement e = bd1_import(c, i);
static GdElement crazylight_import(byte c, int i)
{
if (c < ARRAY_SIZE(gd_crazylight_import_table))
- return gd_crazylight_import_table[c] & O_MASK; /* & O_MASK: do not import "scanned" flag */
+ return gd_crazylight_import_table[c] & O_MASK; // & O_MASK: do not import "scanned" flag
Warn("Invalid CrLi element in imported file at cave data %d: %d", i, c);
return gd_defaults_crli;
break;
- /* to avoid compiler warning */
+ // to avoid compiler warning
case GD_ENGINE_INVALID:
break;
}
{
gd_cave_set_defaults_from_array(cave, gd_get_engine_default_array(engine));
- /* these have hardcoded ckdelay. */
- /* setting this ckdelay array does not fit into the gd_struct_default scheme. */
+ // these have hardcoded ckdelay.
+ // setting this ckdelay array does not fit into the gd_struct_default scheme.
if (engine == GD_ENGINE_BD1)
{
cave->level_ckdelay[0] = 12;
if (engine == GD_ENGINE_BD2)
{
- cave->level_ckdelay[0] = 9; /* 180ms */
- cave->level_ckdelay[1] = 8; /* 160ms */
- cave->level_ckdelay[2] = 7; /* 140ms */
- cave->level_ckdelay[3] = 6; /* 120ms */
- cave->level_ckdelay[4] = 6; /* 120ms (!) not faster than level4 */
+ cave->level_ckdelay[0] = 9; // 180ms
+ cave->level_ckdelay[1] = 8; // 160ms
+ cave->level_ckdelay[2] = 7; // 140ms
+ cave->level_ckdelay[3] = 6; // 120ms
+ cave->level_ckdelay[4] = 6; // 120ms (!) not faster than level4
}
}
return GD_ENGINE_INVALID;
}
-/****************************************************************************
- *
- * cave import routines.
- * take a cave, data, and maybe remaining bytes.
- * return the number of bytes read, -1 if error.
- *
- ****************************************************************************/
+// ============================================================================
+//
+// cave import routines.
+// take a cave, data, and maybe remaining bytes.
+// return the number of bytes read, -1 if error.
+//
+// ============================================================================
/*
take care of required diamonds values == 0 or > 100.
http://www.boulder-dash.nl/forum/viewtopic.php?t=88
*/
-/* import bd1 cave data into our format. */
+// import bd1 cave data into our format.
static int cave_copy_from_bd1(GdCave *cave, const byte *data, int remaining_bytes,
GdCavefileFormat format)
{
GdElement (* import_func) (byte c, int i);
int i;
- /* cant be shorted than this: header + no objects + delimiter */
+ // cant be shorted than this: header + no objects + delimiter
if (remaining_bytes < 33)
{
Error("truncated BD1 cave data, %d bytes", remaining_bytes);
else
import_func = bd1_import;
- /* set visible size for intermission */
+ // set visible size for intermission
if (cave->intermission)
{
cave->x2 = 19;
cave->y2 = 11;
}
- /* cave number data[0] */
+ // cave number data[0]
cave->diamond_value = data[2];
cave->extra_diamond_value = data[3];
{
cave->level_amoeba_time[level] = data[1];
- /* 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
if (cave->level_amoeba_time[level] == 0)
cave->level_amoeba_time[level] = 999;
cave->level_magic_wall_time[level] = data[1];
cave->level_rand[level] = data[4 + level];
- cave->level_diamonds[level] = data[9 + level] % 100; /* check comment above */
+ cave->level_diamonds[level] = data[9 + level] % 100; // check comment above
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here means 100 to collect */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here means 100 to collect
if (cave->level_diamonds[level] == 0)
cave->level_diamonds[level] = 100;
cave->level_time[level] = data[14 + level];
}
- /* LogicDeLuxe extension: acid
- $16 Acid speed (unused in the original BD1)
- $17 Bit 2: if set, Acid's original position converts to explosion puff during spreading.
- Otherwise, Acid remains intact, ie. it's just growing. (unused in the original BD1)
- $1C Acid eats this element. (also Probability of element 1)
-
- there is no problem importing these; as other bd1 caves did not contain acid at all,
- so it does not matter how we set the values.
+ /*
+ LogicDeLuxe extension: acid
+ $16 Acid speed (unused in the original BD1)
+ $17 Bit 2: if set, Acid's original position converts to explosion puff during spreading.
+ Otherwise, Acid remains intact, ie. it's just growing. (unused in the original BD1)
+ $1C Acid eats this element. (also Probability of element 1)
+
+ there is no problem importing these; as other bd1 caves did not contain acid at all,
+ so it does not matter how we set the values.
*/
- /* 0x1c index: same as probability1 !!!!! don't be surprised. we do a &0x3f because of this */
+ // 0x1c index: same as probability1 !!!!! don't be surprised. we do a &0x3f because of this
cave->acid_eats_this = import_func(data[0x1c] & 0x3F, 0x1c);
- /* acid speed, *1e6 as probabilities are stored in int */
+ // acid speed, *1e6 as probabilities are stored in int
cave->acid_spread_ratio = data[0x16] / 255.0 * 1E6 + 0.5;
cave->acid_turns_to = (data[0x17] & (1 << 2)) ? O_EXPLODE_3 : O_ACID;
- cave->colorb = GD_GDASH_BLACK; /* border - black */
- cave->color0 = GD_GDASH_BLACK; /* background - black */
+ cave->colorb = GD_GDASH_BLACK; // border - black
+ cave->color0 = GD_GDASH_BLACK; // background - black
cave->color1= GD_GDASH_RED;
cave->color2 = GD_GDASH_PURPLE;
cave->color3 = GD_GDASH_YELLOW;
- cave->color4 = cave->color3; /* in bd1, amoeba was color3 */
- cave->color5 = cave->color3; /* no slime, but let it be color 3 */
+ cave->color4 = cave->color3; // in bd1, amoeba was color3
+ cave->color5 = cave->color3; // no slime, but let it be color 3
- /* random fill */
+ // random fill
for (i = 0; i < 4; i++)
{
cave->random_fill[i] = import_func(data[24 + i], 24 + i);
{
code = data[index];
- /* crazy dream 3 extension: */
+ // crazy dream 3 extension:
if (code == 0x0f)
{
int x1, y1, nx, ny, dx, dy;
int x, y;
- /* as this one uses nonstandard dx dy values, create points instead */
+ // as this one uses nonstandard dx dy values, create points instead
elem = import_func(data[index + 1], index + 1);
x1 = data[index + 2];
y1 = data[index + 3] - 2;
}
else
{
- /* object is code & 3f, object type is upper 2 bits */
+ // object is code & 3f, object type is upper 2 bits
elem = import_func(code & 0x3F, index);
switch ((code >> 6) & 3)
{
- case 0: /* 00: POINT */
+ case 0: // 00: POINT
x1 = data[index + 1];
y1 = data[index + 2] - 2;
index += 3;
break;
- case 1: /* 01: LINE */
+ case 1: // 01: LINE
x1 = data[index + 1];
y1 = data[index + 2] - 2;
length = (byte)data[index + 3] - 1;
index += 5;
break;
- case 2: /* 10: FILLED RECTANGLE */
+ case 2: // 10: FILLED RECTANGLE
x1 = data[index + 1];
y1 = data[index + 2] - 2;
- x2 = x1 + data[index + 3] - 1; /* width */
- y2 = y1 + data[index + 4] - 1; /* height */
+ x2 = x1 + data[index + 3] - 1; // width
+ y2 = y1 + data[index + 4] - 1; // height
if (x1 >= cave->w ||
y1 >= cave->h ||
index += 6;
break;
- case 3: /* 11: OPEN RECTANGLE (OUTLINE) */
+ case 3: // 11: OPEN RECTANGLE (OUTLINE)
x1 = data[index + 1];
y1 = data[index + 2] - 2;
x2 = x1 + data[index + 3] - 1;
return index + 1;
}
-/* import bd2 cave data into our format. return number of bytes if pointer passed.
- this is pretty much the same as above, only the encoding was different. */
+// import bd2 cave data into our format. return number of bytes if pointer passed.
+// this is pretty much the same as above, only the encoding was different.
static int cave_copy_from_bd2(GdCave *cave, const byte *data, int remaining_bytes,
GdCavefileFormat format)
{
if (format == GD_FORMAT_BD2_ATARI)
cave->scheduling = GD_SCHEDULING_BD2_PLCK_ATARI;
- /* set visible size for intermission */
+ // set visible size for intermission
if (cave->intermission)
{
cave->x2 = 19;
for (i = 0; i < 5; i++)
{
- /* 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
cave->level_amoeba_time[i] = data[0] == 0 ? 999 : data[0];
cave->level_rand[i] = data[13 + i];
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 needed */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 needed
cave->level_diamonds[i] = data[8 + i] == 0 ? 1000 : data[8 + i];
cave->level_time[i] = data[3 + i];
cave->level_magic_wall_time[i] = data[0];
switch (data[index])
{
- case 0: /* LINE */
+ case 0: // LINE
elem = bd1_import(data[index + 1], index + 1);
y1 = data[index + 2];
x1 = data[index + 3];
- /* they are multiplied by two - 0 is up, 2 is upright, 4 is right... */
+ // they are multiplied by two - 0 is up, 2 is upright, 4 is right...
direction = data[index + 4] / 2;
length = data[index + 5] - 1;
index += 6;
break;
- case 1: /* OPEN RECTANGLE */
+ case 1: // OPEN RECTANGLE
elem = bd1_import(data[index + 1], index + 1);
y1 = data[index + 2];
x1 = data[index + 3];
- y2 = y1 + data[index + 4] - 1; /* height */
+ y2 = y1 + data[index + 4] - 1; // height
x2 = x1 + data[index + 5] - 1;
if (x1 >= cave->w ||
index += 6;
break;
- case 2: /* FILLED RECTANGLE */
+ case 2: // FILLED RECTANGLE
elem = bd1_import(data[index + 1], index + 1);
y1 = data[index + 2];
x1 = data[index + 3];
index += 7;
break;
- case 3: /* POINT */
+ case 3: // POINT
elem = bd1_import(data[index + 1], index + 1);
y1 = data[index + 2];
x1 = data[index + 3];
index += 4;
break;
- case 4: /* RASTER */
+ case 4: // RASTER
elem = bd1_import(data[index + 1], index + 1);
- y1 = data[index + 2]; /* starting pos */
+ y1 = data[index + 2]; // starting pos
x1 = data[index + 3];
- ny = data[index + 4] - 1; /* number of elements */
+ ny = data[index + 4] - 1; // number of elements
nx = data[index + 5] - 1;
- dy = data[index + 6]; /* displacement */
+ dy = data[index + 6]; // displacement
dx = data[index + 7];
- y2 = y1 + dy * ny; /* calculate rectangle */
+ y2 = y1 + dy * ny; // calculate rectangle
x2 = x1 + dx * nx;
- /* guess this has to be here, after x2,y2 calculation, because of some bugs in imported data */
+ // guess this has to be here, after x2,y2 calculation, because of some bugs in imported data
if (dy < 1)
dy = 1;
if (dx < 1)
break;
case 5:
- /* profi boulder extension: bitmap */
+ // profi boulder extension: bitmap
elem = bd1_import(data[index + 1], index + 1);
- bytes = data[index + 2]; /* number of bytes in bitmap */
+ bytes = data[index + 2]; // number of bytes in bitmap
if (bytes >= cave->w * cave->h / 8)
Warn("invalid bitmap length at byte %d", index - 4);
addr = 0;
- addr += data[index + 3]; /*msb */
- addr += data[index + 4] << 8; /*lsb */
+ addr += data[index + 3]; // msb
+ addr += data[index + 4] << 8; // lsb
- /* this was a pointer to the cave work memory (used during game). */
+ // this was a pointer to the cave work memory (used during game).
addr -= 0x0850;
if (addr >= cave->w * cave->h)
for (i = 0; i < bytes; i++)
{
- /* for ("bytes" number of bytes) */
+ // for ("bytes" number of bytes)
val = data[index + 5 + i];
for (n = 0; n < 8; n++)
{
- /* for (8 bits in a byte) */
- if ((val & 1) != 0) /* convert to single points... */
+ // for (8 bits in a byte)
+ if ((val & 1) != 0) // convert to single points...
cave->objects = list_append(cave->objects, gd_object_new_point(GD_OBJECT_LEVEL_ALL, x1, y1, elem));
val >>= 1;
- x1++; /* next cave pos */
+ x1++; // next cave pos
if (x1 >= cave->w)
{
- /* maybe next line in map */
+ // maybe next line in map
x1 = 0;
y1++;
}
}
}
- index += 5 + bytes; /* 5 description bytes and "bytes" data bytes */
+ index += 5 + bytes; // 5 description bytes and "bytes" data bytes
break;
- case 6: /* JOIN */
+ case 6: // JOIN
dy = data[index + 3] / 40;
- dx = data[index + 3] % 40; /* same byte!!! */
+ dx = data[index + 3] % 40; // same byte!!!
cave->objects = list_append(cave->objects, gd_object_new_join(GD_OBJECT_LEVEL_ALL, dx, dy, bd1_import(data[index+1], index+1), bd1_import(data[index+2], index+2)));
index += 4;
break;
- case 7: /* SLIME PERMEABILITY */
- /* interesting this is set here, and not in the cave header */
+ case 7: // SLIME PERMEABILITY
+ // interesting this is set here, and not in the cave header
for (i = 0; i < 5; i++)
cave->level_slime_permeability_c64[i] = data[index + 1];
break;
case 9:
- /* profi boulder extension by player: plck-like cave map. the import
- routine (any2gdash) inserts it here. */
+ // profi boulder extension by player: plck-like cave map. the import
+ // routine (any2gdash) inserts it here.
if (cave->map != NULL)
{
Error("contains more than one PLCK map");
for (x = 0; x < cave->w; x++)
{
- /* fill the first and the last row with steel wall. */
+ // fill the first and the last row with steel wall.
cave->map[0][x] = O_STEEL;
cave->map[cave->h - 1][x] = O_STEEL;
}
- n = 0; /* number of bytes read from map */
+ n = 0; // number of bytes read from map
- /* the first and the last rows are not stored. */
+ // the first and the last rows are not stored.
for (y = 1; y < cave->h - 1; y++)
{
for (x = 0; x < cave->w; x += 2)
{
- cave->map[y][x] = plck_import_nybble[data[index + 3 + n] >> 4]; /* msb 4 bits */
- cave->map[y][x + 1] = plck_import_nybble[data[index + 3 + n] % 16]; /* lsb 4 bits */
+ cave->map[y][x] = plck_import_nybble[data[index + 3 + n] >> 4]; // msb 4 bits
+ cave->map[y][x + 1] = plck_import_nybble[data[index + 3 + n] % 16]; // lsb 4 bits
n++;
}
}
- /* the position of inbox is stored. this is to check the cave */
+ // the position of inbox is stored. this is to check the cave
ry = data[index + 1] - 2;
rx = data[index + 2];
- /* at the start of the cave, bd scrolled to the last player placed during the drawing
- (setup) of the cave.
- i think this is why a map also stored the coordinates of the player - we can use
- this to check its integrity */
+ // at the start of the cave, bd scrolled to the last player placed during the drawing
+ // (setup) of the cave.
+ // i think this is why a map also stored the coordinates of the player - we can use
+ // this to check its integrity
if (rx >= cave->w || ry < 0 ||
ry >= cave->h || cave->map[ry][rx] != O_INBOX)
Warn ("embedded PLCK map may be corrupted, player coordinates %d,%d", rx, rx);
default:
Warn ("unknown bd2 extension no. %02x at byte %d", data[index], index);
- index += 1; /* skip that byte */
+ index += 1; // skip that byte
}
}
return -1;
}
- /* skip delimiter */
+ // skip delimiter
index++;
- /* animation byte - told the engine which objects to animate - to make game faster */
+ // animation byte - told the engine which objects to animate - to make game faster
index++;
- /* the colors from the memory dump are appended here by any2gdash */
- cave->colorb = GD_GDASH_BLACK; /* border - black */
- cave->color0 = GD_GDASH_BLACK; /* background - black */
+ // the colors from the memory dump are appended here by any2gdash
+ cave->colorb = GD_GDASH_BLACK; // border - black
+ cave->color0 = GD_GDASH_BLACK; // background - black
cave->color1 = GD_GDASH_RED;
cave->color2 = GD_GDASH_PURPLE;
cave->color3 = GD_GDASH_YELLOW;
- cave->color4 = cave->color3; /* in bd1, amoeba was color3 */
- cave->color5 = cave->color3; /* no slime, but let it be color 3 */
+ cave->color4 = cave->color3; // in bd1, amoeba was color3
+ cave->color5 = cave->color3; // no slime, but let it be color 3
return index;
}
-/* import plck cave data into our format.
- length is always 512 bytes, and contains if it is an intermission cave. */
+// import plck cave data into our format.
+// length is always 512 bytes, and contains if it is an intermission cave.
static int cave_copy_from_plck(GdCave *cave, const byte *data,
int remaining_bytes, GdCavefileFormat format)
{
- /* i don't really think that all this table is needed, but included to be complete. */
- /* this is for the dirt and expanding wall looks like effect. */
- /* it also contains the individual frames */
+ // i don't really think that all this table is needed, but included to be complete.
+ // this is for the dirt and expanding wall looks like effect.
+ // it also contains the individual frames
static GdElement plck_graphic_table[] =
{
/* 3000 */ O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN,
if (cave->intermission)
{
- /* set visible size for intermission */
+ // set visible size for intermission
cave->x2 = 19;
cave->y2 = 11;
}
- /* cave selection table, was not part of cave data, rather given in game packers.
- * if a new enough version of any2gdash is used, it will put information after the cave.
- * detect this here and act accordingly */
+ // cave selection table, was not part of cave data, rather given in game packers.
+ // if a new enough version of any2gdash is used, it will put information after the cave.
+ // detect this here and act accordingly
if ((data[0x1f0] == data[0x1f1] - 1) &&
(data[0x1f0] == 0x19 ||
data[0x1f0] == 0x0e))
{
int j;
- /* found selection table */
+ // found selection table
cave->selectable = data[0x1f0] == 0x19;
gd_strcpy(cave->name, " ");
for (j = 0; j < 12; j++)
cave->name[j] = data[0x1f2 + j];
- chompString(cave->name); /* remove spaces */
+ chompString(cave->name); // remove spaces
}
else
{
- /* no selection info found, let intermissions be unselectable */
+ // no selection info found, let intermissions be unselectable
cave->selectable = !cave->intermission;
}
for (i = 0; i < 5; i++)
{
- /* plck doesnot really have levels, so just duplicate data five times */
+ // plck doesnot really have levels, so just duplicate data five times
cave->level_amoeba_time[i] = data[0x1c4];
- /* immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
if (cave->level_amoeba_time[i] == 0)
cave->level_amoeba_time[i] = 999;
cave->level_time[i] = data[0x1ba];
cave->level_diamonds[i] = data[0x1bc];
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 needed */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 needed
if (cave->level_diamonds[i] == 0)
cave->level_diamonds[i] = 1000;
cave->level_slime_permeability_c64[i] = slime_shift_msb(data[0x1c2]);
}
- cave->colorb = GD_GDASH_BLACK; /* border - black */
- cave->color0 = GD_GDASH_BLACK; /* background - black */
+ cave->colorb = GD_GDASH_BLACK; // border - black
+ cave->color0 = GD_GDASH_BLACK; // background - black
cave->color1 = GD_GDASH_RED;
cave->color2 = GD_GDASH_PURPLE;
cave->color3 = GD_GDASH_YELLOW;
- cave->color4 = cave->color3; /* in bd1, amoeba was color3 */
- cave->color5 = cave->color3; /* no slime, but let it be color 3 */
+ cave->color4 = cave->color3; // in bd1, amoeba was color3
+ cave->color5 = cave->color3; // no slime, but let it be color 3
- /* ... the cave is stored like a map. */
+ // ... the cave is stored like a map.
cave->map = gd_cave_map_new(cave, GdElement);
- /* cave map looked like this. */
- /* two rows of steel wall ($44's), then cave description, 20 bytes (40 nybbles) for each line. */
- /* the bottom and top lines were not stored... originally. */
- /* some games write to the top line; so we import that, too. */
- /* also dlp 155 allowed writing to the bottom line; the first 20 $44-s now store the bottom line. */
- /* so the cave is essentially shifted one row down in the file: cave->map[y][x] = data[... y+1 mod height ][x] */
+ // cave map looked like this.
+ // two rows of steel wall ($44's), then cave description, 20 bytes (40 nybbles) for each line.
+ // the bottom and top lines were not stored... originally.
+ // some games write to the top line; so we import that, too.
+ // also dlp 155 allowed writing to the bottom line; the first 20 $44-s now store the bottom line.
+ // so the cave is essentially shifted one row down in the file:
+ // cave->map[y][x] = data[... y+1 mod height ][x]
for (y = 0; y < cave->h; y++)
{
for (x = 0; x < cave->w; x += 2)
{
- /* msb 4 bits: we do not check index ranges, as >>4 and %16 will result in 0..15 */
+ // msb 4 bits: we do not check index ranges, as >>4 and %16 will result in 0..15
cave->map[y][x] = plck_import_nybble[data[((y + 1) % cave->h) * 20 + x / 2] >> 4];
- /* lsb 4 bits */
+ // lsb 4 bits
cave->map[y][x + 1] = plck_import_nybble[data[((y + 1) % cave->h) * 20 + x / 2] % 16];
}
}
- /* FOR NOW, WE DO NOT IMPORT THE BOTTOM BORDER */
+ // FOR NOW, WE DO NOT IMPORT THE BOTTOM BORDER
for (x = 0; x < cave->w; x++)
cave->map[cave->h - 1][x] = O_STEEL;
cave->map[cave->h - 1][0] = cave->map[cave->h - 1][1] = O_STEEL;
*/
- /* check for diego-effects */
- /* c64 magic values (byte sequences) 0x20 0x90 0x46, also 0xa9 0x1c 0x85 */
+ // check for diego-effects
+ // c64 magic values (byte sequences) 0x20 0x90 0x46, also 0xa9 0x1c 0x85
if ((data[0x1e5] == 0x20 &&
data[0x1e6] == 0x90 &&
data[0x1e7] == 0x46) ||
data[0x1e6] == 0x1c &&
data[0x1e7] == 0x85))
{
- /* diego effects enabled. */
+ // diego effects enabled.
cave->stone_bouncing_effect = bd1_import(data[0x1ea], 0x1ea);
cave->diamond_falling_effect = bd1_import(data[0x1eb], 0x1eb);
- /* explosions: 0x1e was explosion 5, if this is set to default, we also do not read it,
- as in our engine this would cause an O_EXPLODE_5 to stay there. */
+ // explosions: 0x1e was explosion 5, if this is set to default, we also do not read it,
+ // as in our engine this would cause an O_EXPLODE_5 to stay there.
if (data[0x1ec] != 0x1e)
cave->explosion_effect = bd1_import(data[0x1ec], 0x1ec);
- /* pointer to element graphic.
- two bytes/column (one element), that is data[xxx] % 16 / 2.
- also there are 16bytes/row.
- that is, 0x44 = stone, upper left character. 0x45 = upper right,
- 0x54 = lower right, 0x55 = lower right.
- so high nybble must be shifted right twice -> data[xxx]/16*4. */
+ /*
+ pointer to element graphic.
+ two bytes/column (one element), that is data[xxx] % 16 / 2.
+ also there are 16bytes/row.
+ that is, 0x44 = stone, upper left character. 0x45 = upper right,
+ 0x54 = lower right, 0x55 = lower right.
+ so high nybble must be shifted right twice -> data[xxx]/16*4.
+ */
cave->dirt_looks_like = plck_graphic_table[(data[0x1ed] / 16) * 4 + (data[0x1ed] % 16) / 2];
cave->expanding_wall_looks_like = plck_graphic_table[(data[0x1ee] / 16) * 4 + (data[0x1ee] % 16) / 2];
return 512;
}
-/* no one's delight boulder dash essentially: rle compressed plck maps. */
+// no one's delight boulder dash essentially: rle compressed plck maps.
static int cave_copy_from_dlb(GdCave *cave, const byte *data, int remaining_bytes)
{
byte decomp[512];
enum
{
- START, /* initial state */
- SEPARATOR, /* got a separator */
- RLE, /* after a separator, got the byte to duplicate */
- NORMAL /* normal, copy bytes till separator */
+ START, // initial state
+ SEPARATOR, // got a separator
+ RLE, // after a separator, got the byte to duplicate
+ NORMAL // normal, copy bytes till separator
} state;
int pos, cavepos, i, x, y;
byte byte, separator;
- gd_cave_set_engine_defaults(cave, GD_ENGINE_PLCK); /* essentially the plck engine */
+ gd_cave_set_engine_defaults(cave, GD_ENGINE_PLCK); // essentially the plck engine
for (i = 0; i < 5; i++)
{
- /* does not really have levels, so just duplicate data five times */
+ // does not really have levels, so just duplicate data five times
cave->level_time[i] = data[1];
cave->level_diamonds[i] = data[2];
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 needed */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 needed
if (cave->level_diamonds[i] == 0)
cave->level_diamonds[i] = 1000;
cave->level_ckdelay[i] = data[0];
cave->level_amoeba_time[i] = data[6];
- /* 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
if (cave->level_amoeba_time[i] == 0)
cave->level_amoeba_time[i] = 999;
cave->diamond_value = data[3];
cave->extra_diamond_value = data[4];
- /* then 5 color bytes follow */
- cave->colorb = gd_c64_color(data[8] & 0xf); /* border */
+ // then 5 color bytes follow
+ cave->colorb = gd_c64_color(data[8] & 0xf); // border
cave->color0 = gd_c64_color(data[9] & 0xf);
cave->color1 = gd_c64_color(data[10] & 0xf);
cave->color2 = gd_c64_color(data[11] & 0xf);
- cave->color3 = gd_c64_color(data[12] & 0x7); /* lower 3 bits only! */
- cave->color4 = cave->color3; /* in plck, amoeba was color3 */
- cave->color5 = cave->color3; /* same for slime */
+ cave->color3 = gd_c64_color(data[12] & 0x7); // lower 3 bits only!
+ cave->color4 = cave->color3; // in plck, amoeba was color3
+ cave->color5 = cave->color3; // same for slime
- /* cave map */
- pos = 13; /* those 13 bytes were the cave values above */
+ // cave map
+ pos = 13; // those 13 bytes were the cave values above
cavepos = 0;
- byte = 0; /* just to get rid of compiler warning */
- separator = 0; /* just to get rid of compiler warning */
+ byte = 0; // just to get rid of compiler warning
+ separator = 0; // just to get rid of compiler warning
- /* employ a state machine. */
+ // employ a state machine.
state = START;
while (cavepos < 400 && pos < remaining_bytes)
switch (state)
{
case START:
- /* first byte is a separator. remember it */
+ // first byte is a separator. remember it
separator = data[pos];
- /* after the first separator, no rle data, just copy. */
+ // after the first separator, no rle data, just copy.
state = NORMAL;
break;
case SEPARATOR:
- /* we had a separator. remember this byte, as this will be duplicated (or more) */
+ // we had a separator. remember this byte, as this will be duplicated (or more)
byte = data[pos];
state = RLE;
break;
case RLE:
- /* we had the first byte, duplicate this n times. */
+ // we had the first byte, duplicate this n times.
if (data[pos] == 0xff)
{
- /* if it is a 0xff, we will have another byte, which is also a length specifier. */
- /* and for this one, duplicate only 254 times */
+ // if it is a 0xff, we will have another byte, which is also a length specifier.
+ // and for this one, duplicate only 254 times
if (cavepos + 254 > 400)
{
Error("DLB import error: RLE data overflows buffer");
}
else
{
- /* if not 0xff, duplicate n times and back to copy mode */
+ // if not 0xff, duplicate n times and back to copy mode
if (cavepos + data[pos] > 400)
{
Error("DLB import error: RLE data overflows buffer");
break;
case NORMAL:
- /* bytes duplicated; now only copy the remaining, till the next separator. */
+ // bytes duplicated; now only copy the remaining, till the next separator.
if (data[pos] == separator)
state = SEPARATOR;
else
- decomp[cavepos++] = data[pos]; /* copy this byte and state is still NORMAL */
+ decomp[cavepos++] = data[pos]; // copy this byte and state is still NORMAL
break;
}
return -1;
}
- /* process uncompressed map */
+ // process uncompressed map
cave->map = gd_cave_map_new(cave, GdElement);
for (x = 0; x < cave->w; x++)
{
- /* fill the first and the last row with steel wall. */
+ // fill the first and the last row with steel wall.
cave->map[0][x] = O_STEEL;
cave->map[cave->h - 1][x] = O_STEEL;
}
{
for (x = 0; x < cave->w; x += 2)
{
- /* msb 4 bits */
+ // msb 4 bits
cave->map[y][x] = plck_import_nybble[decomp[((y - 1) * cave->w + x) / 2] >> 4];
- /* lsb 4 bits */
+ // lsb 4 bits
cave->map[y][x + 1] = plck_import_nybble[decomp[((y - 1) * cave->w + x) / 2] % 16];
}
}
- /* return number of bytes read from buffer */
+ // return number of bytes read from buffer
return pos;
}
-/* import plck cave data into our format. */
+// import plck cave data into our format.
static int cave_copy_from_1stb(GdCave *cave, const byte *data, int remaining_bytes)
{
int i;
gd_cave_set_engine_defaults(cave, GD_ENGINE_1STB);
- /* copy name */
+ // copy name
gd_strcpy(cave->name, " ");
for (i = 0; i < 14; i++)
{
int c = data[0x3a0 + i];
- /* import cave name; a conversion table is used for each character */
+ // import cave name; a conversion table is used for each character
if (c < 0x40)
c = gd_bd_internal_chars[c];
else if (c == 0x74)
else if (c == 0x76)
c = '?';
else
- c = ' '; /* don't know this, so change to space */
+ c = ' '; // don't know this, so change to space
if (i > 0)
c = tolower(c);
cave->intermission = data[0x389] != 0;
- /* if it is intermission but not scrollable */
+ // if it is intermission but not scrollable
if (cave->intermission && !data[0x38c])
{
cave->x2 = 19;
for (i = 0; i < 5; i++)
{
- /* plck doesnot really have levels, so just duplicate data five times */
+ // plck doesnot really have levels, so just duplicate data five times
cave->level_time[i] = 100 * data[0x370] + 10 * data[0x370+1] + data[0x370 + 2];
- /* same as gate opening after 0 diamonds */
+ // same as gate opening after 0 diamonds
if (cave->level_time[i] == 0)
cave->level_time[i] = 1000;
cave->level_diamonds[i] = 100 * data[0x373] + 10 * data[0x373 + 1] + data[0x373 + 2];
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 (!) needed */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 (!) needed
if (cave->level_diamonds[i] == 0)
cave->level_diamonds[i] = 1000;
cave->level_ckdelay[i] = data[0x38a];
cave->level_amoeba_time[i] = 256 * (int)data[0x37c] + data[0x37d];
- /* 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
if (cave->level_amoeba_time[i] == 0)
cave->level_amoeba_time[i] = 999;
cave->level_amoeba_threshold[i] = 256 * (int)data[0x390] + data[0x390 + 1];
}
- /* also has no random data... */
- cave->colorb = gd_c64_color(data[0x384] & 0xf); /* border */
+ // also has no random data...
+ cave->colorb = gd_c64_color(data[0x384] & 0xf); // border
cave->color0 = gd_c64_color(data[0x385] & 0xf);
cave->color1 = gd_c64_color(data[0x386] & 0xf);
cave->color2 = gd_c64_color(data[0x387] & 0xf);
- cave->color3 = gd_c64_color(data[0x388] & 0x7); /* lower 3 bits only! */
+ cave->color3 = gd_c64_color(data[0x388] & 0x7); // lower 3 bits only!
cave->color4 = cave->color1;
cave->color5 = cave->color1;
- cave->amoeba_growth_prob = (4.0 * 1E6 / (data[0x382] + 1)) + 0.5; /* probabilities store *1M */
+ cave->amoeba_growth_prob = (4.0 * 1E6 / (data[0x382] + 1)) + 0.5; // probabilities store *1M
if (cave->amoeba_growth_prob > 1000000)
cave->amoeba_growth_prob = 1000000;
else
cave->diagonal_movements = data[0x381] != 0;
- /* ... the cave is stored like a map. */
+ // ... the cave is stored like a map.
cave->map = gd_cave_map_new(cave, GdElement);
for (y = 0; y < cave->h; y++)
for (x = 0; x < cave->w; x++)
cave->magic_wall_sound = data[0x38d] == 0xf1;
- /* 2d was a normal switch, 2e a changed one. */
+ // 2d was a normal switch, 2e a changed one.
cave->creatures_backwards = data[0x38f] == 0x2d;
- /* 2e horizontal, 2f vertical. */
+ // 2e horizontal, 2f vertical.
cave->expanding_wall_changed = data[0x38e] == 0x2f;
cave->biter_delay_frame = data[0x394];
- cave->magic_wall_stops_amoeba = data[0x395] == 0; /* negated!! */
+ cave->magic_wall_stops_amoeba = data[0x395] == 0; // negated!!
cave->bomb_explosion_effect = firstboulder_import(data[0x396], 0x396);
cave->explosion_effect = firstboulder_import(data[0x397], 0x397);
cave->slime_converts_2 = firstboulder_import(data[0x39f] + 3, 0x39f);
cave->magic_diamond_to = firstboulder_import(data[0x39a], 0x39a);
- /* length is always 1024 bytes */
+ // length is always 1024 bytes
return 1024;
}
-/* crazy dream 7 */
+// crazy dream 7
static int cave_copy_from_crdr_7(GdCave *cave, const byte *data, int remaining_bytes)
{
int i, index;
byte checksum;
- /* if we have name, convert */
+ // if we have name, convert
gd_strcpy(cave->name, " ");
for (i = 0; i < 14; i++)
{
int c = data[i];
- /* import cave name; a conversion table is used for each character */
+ // import cave name; a conversion table is used for each character
if (c < 0x40)
c = gd_bd_internal_chars[c];
else if (c == 0x74)
cave->name[i] = c;
}
- chompString(cave->name); /* remove trailing and leading spaces */
+ chompString(cave->name); // remove trailing and leading spaces
cave->selectable = data[14] != 0;
- /* jump 15 bytes, 14 was the name and 15 selectability */
+ // jump 15 bytes, 14 was the name and 15 selectability
data += 15;
if (memcmp((char *)data + 0x30, "V4\0020", 4) != 0)
{
cave->level_time[i] = (int)data[0x0] * 100 + data[0x1] * 10 + data[0x2];
- /* same as gate opening after 0 diamonds */
+ // same as gate opening after 0 diamonds
if (cave->level_time[i] == 0)
cave->level_time[i] = 1000;
cave->level_diamonds[i] = (int)data[0x3] * 100 + data[0x4] * 10 + data[0x5];
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 (!) needed */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 (!) needed
if (cave->level_diamonds[i] == 0)
cave->level_diamonds[i] = 1000;
cave->level_rand[i] = data[0x40];
cave->level_amoeba_time[i] = (int)data[0xC] * 256 + data[0xD];
- /* 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
if (cave->level_amoeba_time[i] == 0)
cave->level_amoeba_time[i] = 999;
if (data[0x10])
cave->creatures_direction_auto_change_time = data[0x11];
- cave->colorb = gd_c64_color(data[0x14] & 0xf); /* border */
+ cave->colorb = gd_c64_color(data[0x14] & 0xf); // border
cave->color0 = gd_c64_color(data[0x15] & 0xf);
cave->color1 = gd_c64_color(data[0x16] & 0xf);
cave->color2 = gd_c64_color(data[0x17] & 0xf);
- cave->color3 = gd_c64_color(data[0x18] & 0x7); /* lower 3 bits only! */
+ cave->color3 = gd_c64_color(data[0x18] & 0x7); // lower 3 bits only!
cave->color4 = cave->color3;
cave->color5 = cave->color1;
cave->intermission = data[0x19] != 0;
- /* if it is intermission but not scrollable */
+ // if it is intermission but not scrollable
if (cave->intermission && !data[0x1c])
{
cave->x2 = 19;
cave->y2 = 11;
}
- /* AMOEBA in crazy dash 8:
- jsr $2500 ; generate true random
- and $94 ; binary and the current "probability"
- cmp #$04 ; compare to 4
- bcs out ; jump out (do not expand) if carry set, ie. result was less than 4.
-
- prob values can be like num = 3, 7, 15, 31, 63, ... n lsb bits count.
- 0..3>=4? 0..7>=4? 0..15>=4? and similar.
- this way, probability of growing is 4/(num+1)
+ /*
+ AMOEBA in crazy dash 8:
+ jsr $2500 ; generate true random
+ and $94 ; binary and the current "probability"
+ cmp #$04 ; compare to 4
+ bcs out ; jump out (do not expand) if carry set, ie. result was less than 4.
+
+ prob values can be like num = 3, 7, 15, 31, 63, ... n lsb bits count.
+ 0..3>=4? 0..7>=4? 0..15>=4? and similar.
+ this way, probability of growing is 4/(num+1)
*/
- cave->amoeba_growth_prob = (4.0 * 1E6 / (data[0x12] + 1)) + 0.5; /* probabilities store * 1M */
+ cave->amoeba_growth_prob = (4.0 * 1E6 / (data[0x12] + 1)) + 0.5; // probabilities store * 1M
if (cave->amoeba_growth_prob > 1000000)
cave->amoeba_growth_prob = 1000000;
if (cave->amoeba_fast_growth_prob > 1000000)
cave->amoeba_fast_growth_prob = 1000000;
- /* expanding wall direction change - 2e horizontal, 2f vertical */
+ // expanding wall direction change - 2e horizontal, 2f vertical
cave->expanding_wall_changed = data[0x1e] == 0x2f;
- /* 2c was a normal switch, 2d a changed one. */
+ // 2c was a normal switch, 2d a changed one.
cave->creatures_backwards = data[0x1f] == 0x2d;
cave->biter_delay_frame = data[0x24];
- cave->magic_wall_stops_amoeba = data[0x25] == 0; /* negated!! */
+ cave->magic_wall_stops_amoeba = data[0x25] == 0; // negated!!
cave->bomb_explosion_effect = crazydream_import_table[data[0x26]];
cave->explosion_effect = crazydream_import_table[data[0x27]];
ie. random<=ratio, then acid grows.
*/
- /* 1e6, probabilities are stored as int */
+ // 1e6, probabilities are stored as int
cave->acid_spread_ratio = data[0x38] / 255.0 * 1E6 + 0.5;
cave->acid_eats_this = crazydream_import_table[data[0x39]];
cave->snap_element = ((data[0x3a] & 4) != 0) ? O_EXPLODE_1 : O_SPACE;
- /* we do not know the values for these, so do not import */
+ // we do not know the values for these, so do not import
// cave->dirt_looks_like... data[0x3c]
// cave->expanding_wall_looks_like... data[0x3b]
for (i = 0; i < 4; i++)
int nx, ny;
int length, direction;
- /* for copy&paste; copy&paste are different objects, static = ugly solution :) */
+ // for copy&paste; copy&paste are different objects, static = ugly solution :)
static int cx1, cy1, cw, ch;
switch (data[index])
{
- case 1: /* point */
+ case 1: // point
elem = crazydream_import_table[data[index + 1]];
x1 = data[index + 2];
y1 = data[index + 3];
index += 4;
break;
- case 2: /* rectangle */
+ case 2: // rectangle
elem = crazydream_import_table[data[index + 1]];
x1 = data[index + 2];
y1 = data[index + 3];
x2 = x1 + data[index + 4] - 1;
- y2 = y1 + data[index + 5] - 1; /* height */
+ y2 = y1 + data[index + 5] - 1; // height
if (x1 >= cave->w ||
y1 >= cave->h ||
index += 6;
break;
- case 3: /* fillrect */
+ case 3: // fillrect
x1 = data[index + 2];
y1 = data[index + 3];
x2 = x1 + data[index + 4] - 1;
y2 >= cave->h)
Warn("invalid filled rectangle coordinates %d,%d %d,%d at byte %d", x1, y1, x2, y2, index);
- /* border and inside of fill is the same element. */
+ // border and inside of fill is the same element.
cave->objects = list_append(cave->objects, gd_object_new_filled_rectangle(GD_OBJECT_LEVEL_ALL, x1, y1, x2, y2, crazydream_import_table[data[index + 1]], crazydream_import_table[data[index + 1]]));
index += 6;
break;
- case 4: /* line */
+ case 4: // line
elem = crazydream_import_table[data[index + 1]];
if (elem == O_UNKNOWN)
Warn("unknown element at %d: %x", index + 1, data[index + 1]);
x2 = x1 + (length - 1) * nx;
y2 = y1 + (length - 1) * ny;
- /* if either is bigger than one, we cannot treat this as a line. create points instead */
+ // if either is bigger than one, we cannot treat this as a line. create points instead
if (ABS(nx) >= 2 || ABS(ny) >= 2)
{
for (i = 0; i < length; i++)
}
else
{
- /* this is a normal line, and will be appended. only do the checking here */
+ // this is a normal line, and will be appended. only do the checking here
if (x1 >= cave->w ||
y1 >= cave->h ||
x2 >= cave->w ||
index += 6;
break;
- case 6: /* copy */
+ case 6: // copy
cx1 = data[index + 1];
cy1 = data[index + 2];
cw = data[index + 3];
index += 5;
break;
- case 7: /* paste */
+ case 7: // paste
x1 = cx1;
y1 = cy1;
- /* original stored width and height, we store the coordinates of the source area */
+ // original stored width and height, we store the coordinates of the source area
x2 = cx1 + cw - 1;
y2 = cy1 + ch - 1;
- dx = data[index + 1]; /* new pos */
+ dx = data[index + 1]; // new pos
dy = data[index + 2];
if (dx >= cave->w ||
index += 3;
break;
- case 11: /* raster */
+ case 11: // raster
elem = crazydream_import_table[data[index + 1]];
x1 = data[index + 2];
y1 = data[index + 3];
dy = data[index + 5];
nx = data[index + 6] - 1;
ny = data[index + 7] - 1;
- x2 = x1 + dx * nx; /* calculate rectangle we use */
+ x2 = x1 + dx * nx; // calculate rectangle we use
y2 = y1 + dy * ny;
if (dx < 1)
default:
Warn ("unknown crdr extension no. %02x at byte %d", data[index], index);
- index += 1; /* skip that byte */
+ index += 1; // skip that byte
break;
}
}
- index++; /* skip $ff */
+ index++; // skip $ff
- /* crazy dream 7 hack */
+ // crazy dream 7 hack
checksum = 0;
for (i = 0; i < 0x3b0; i++)
byte checksum;
int i;
- /* crazy dream 9 hack */
+ // crazy dream 9 hack
checksum = 0;
for (i = 0; i < length; i++)
checksum = checksum^buf[i];
- /* check cave name and the checksum. both are hardcoded here */
+ // check cave name and the checksum. both are hardcoded here
if (strEqual(cave->name, "Rockfall") && checksum == 134)
{
GdElement rand[4] = { O_DIAMOND, O_STONE, O_ACID, O_DIRT };
cave->objects = list_append(cave->objects, gd_object_new_maze(GD_OBJECT_LEVEL_ALL, 4, 1, 38, 19, 1, 3, O_NONE, O_BLADDER_SPENDER, 50, seeds));
cave->objects = list_append(cave->objects, gd_object_new_random_fill(GD_OBJECT_LEVEL_ALL, 4, 1, 38, 19, seeds, O_DIRT, rand, prob, O_BLADDER_SPENDER, FALSE));
- cave->creatures_backwards = TRUE; /* for some reason, this level worked like that */
+ cave->creatures_backwards = TRUE; // for some reason, this level worked like that
}
if (strEqual(cave->name, "All the way") && checksum == 33)
cave->objects = list_append(cave->objects, gd_object_new_maze_unicursal(GD_OBJECT_LEVEL_ALL, 1, 1, 35, 19, 1, 1, O_BRICK, O_PRE_DIA_1, 50, seeds));
- /* a point which "breaks" the unicursal maze, making it one very long path */
+ // a point which "breaks" the unicursal maze, making it one very long path
cave->objects = list_append(cave->objects, gd_object_new_point(GD_OBJECT_LEVEL_ALL, 35, 18, O_BRICK));
}
}
-/* crazy light contruction kit */
+// crazy light contruction kit
static int cave_copy_from_crli(GdCave *cave, const byte *data, int remaining_bytes)
{
byte uncompressed[1024];
enum
{
none,
- V2_2, /* XXX whats the difference between 2.2 and 2.6?*/
+ V2_2, // XXX whats the difference between 2.2 and 2.6?
V2_6,
V3_0
} version = none;
- GdElement (*import) (byte c, int i) = NULL; /* import function */
+ GdElement (*import) (byte c, int i) = NULL; // import function
gd_cave_set_engine_defaults(cave, GD_ENGINE_CRLI);
- /* detect if this is a cavefile */
+ // detect if this is a cavefile
if (data[0] == 0 &&
data[1] == 0xc4 &&
data[2] == 'D' &&
data[3] == 'L' &&
data[4] == 'P')
{
- datapos = 5; /* cavefile, skipping 0x00 0xc4 D L P */
+ datapos = 5; // cavefile, skipping 0x00 0xc4 D L P
cavefile = TRUE;
}
else
{
- /* converted from snapshot, skip "selectable" and 14byte name */
+ // converted from snapshot, skip "selectable" and 14byte name
datapos = 15;
cavefile = FALSE;
}
- /* if we have name, convert */
+ // if we have name, convert
if (!cavefile)
{
gd_strcpy(cave->name, " ");
{
int c = data[i + 1];
- /* import cave name; a conversion table is used for each character */
+ // import cave name; a conversion table is used for each character
if (c < 0x40)
c = gd_bd_internal_chars[c];
else if (c == 0x74)
cave->name[i] = c;
}
- chompString(cave->name); /* remove trailing and leading spaces */
+ chompString(cave->name); // remove trailing and leading spaces
}
- /* uncompress rle data */
+ // uncompress rle data
cavepos = 0;
while (cavepos < 0x3b0)
{
- /* <- loop until the uncompressed reaches its size */
+ // <- loop until the uncompressed reaches its size
if (datapos >= remaining_bytes)
{
Error("truncated crli cave data");
if (data[datapos] == 0xbf)
{
- /* magic value 0xbf is the escape byte */
+ // magic value 0xbf is the escape byte
if (datapos + 2 >= remaining_bytes)
{
Error("truncated crli cave data");
if (data[datapos + 2] + datapos >= sizeof(uncompressed))
{
- /* we would run out of buffer, this must be some error */
+ // we would run out of buffer, this must be some error
Error("invalid crli cave data - RLE length value is too big");
return -1;
}
- /* 0xbf, number, byte to dup */
+ // 0xbf, number, byte to dup
for (i = 0; i < data[datapos + 2]; i++)
uncompressed[cavepos++] = data[datapos + 1];
}
}
- /* check crli version */
+ // check crli version
for (i = 0; i < ARRAY_SIZE(versions); i++)
if (memcmp((char *)uncompressed + 0x3a0, versions[i], 4) == 0)
version = i + 1;
- /* v3.0 has falling wall and box, and no ghost. */
+ // v3.0 has falling wall and box, and no ghost.
import = version >= V3_0 ? crazylight_import : firstboulder_import;
if (version == none)
import = crazylight_import;
}
- /* process map */
+ // process map
cave->map = gd_cave_map_new(cave, GdElement);
for (y = 0; y < cave->h; y++)
}
}
- /* crli has no levels */
+ // crli has no levels
for (i = 0; i < 5; i++)
{
cave->level_time[i] = (int)uncompressed[0x370] * 100 + uncompressed[0x371] * 10 + uncompressed[0x372];
- /* same as gate opening after 0 diamonds */
+ // same as gate opening after 0 diamonds
if (cave->level_time[i] == 0)
cave->level_time[i] = 1000;
cave->level_diamonds[i] = (int)uncompressed[0x373] * 100 + uncompressed[0x374] * 10 + uncompressed[0x375];
- /* gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 (!) needed */
+ // gate opening is checked AFTER adding to diamonds collected, so 0 here is 1000 (!) needed
if (cave->level_diamonds[i] == 0)
cave->level_diamonds[i] = 1000;
cave->level_ckdelay[i] = uncompressed[0x38A];
cave->level_amoeba_time[i] = (int)uncompressed[0x37C] * 256 + uncompressed[0x37D];
- /* 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02. */
+ // 0 immediately underflowed to 999, so we use 999. example: sendydash 3, cave 02.
if (cave->level_amoeba_time[i] == 0)
cave->level_amoeba_time[i] = 999;
if (uncompressed[0x380])
cave->creatures_direction_auto_change_time = uncompressed[0x381];
- cave->colorb = gd_c64_color(uncompressed[0x384] & 0xf); /* border */
+ cave->colorb = gd_c64_color(uncompressed[0x384] & 0xf); // border
cave->color0 = gd_c64_color(uncompressed[0x385] & 0xf);
cave->color1 = gd_c64_color(uncompressed[0x386] & 0xf);
cave->color2 = gd_c64_color(uncompressed[0x387] & 0xf);
- cave->color3 = gd_c64_color(uncompressed[0x388] & 0x7); /* lower 3 bits only! */
+ cave->color3 = gd_c64_color(uncompressed[0x388] & 0x7); // lower 3 bits only!
cave->color4 = cave->color3;
cave->color5 = cave->color1;
cave->intermission = uncompressed[0x389] != 0;
- /* if it is intermission but not scrollable */
+ // if it is intermission but not scrollable
if (cave->intermission && !uncompressed[0x38c])
{
cave->x2 = 19;
cave->y2 = 11;
}
- /* AMOEBA in crazy dash 8:
- jsr $2500 ; generate true random
- and $94 ; binary and the current "probability"
- cmp #$04 ; compare to 4
- bcs out ; jump out (do not expand) if carry set, ie. result was less than 4.
-
- prob values can be like num = 3, 7, 15, 31, 63, ... n lsb bits count.
- 0..3>=4? 0..7>=4? 0..15>=4? and similar.
- this way, probability of growing is 4/(num+1)
+ /*
+ AMOEBA in crazy dash 8:
+ jsr $2500 ; generate true random
+ and $94 ; binary and the current "probability"
+ cmp #$04 ; compare to 4
+ bcs out ; jump out (do not expand) if carry set, ie. result was less than 4.
+
+ prob values can be like num = 3, 7, 15, 31, 63, ... n lsb bits count.
+ 0..3>=4? 0..7>=4? 0..15>=4? and similar.
+ this way, probability of growing is 4/(num+1)
*/
- /* probabilities store * 1M */
+ // probabilities store * 1M
cave->amoeba_growth_prob = (1E6 * 4.0 / (uncompressed[0x382] + 1)) + 0.5;
if (cave->amoeba_growth_prob > 1000000)
if (cave->amoeba_fast_growth_prob > 1000000)
cave->amoeba_fast_growth_prob = 1000000;
- /* 2c was a normal switch, 2d a changed one. */
+ // 2c was a normal switch, 2d a changed one.
cave->creatures_backwards = uncompressed[0x38f] == 0x2d;
cave->magic_wall_sound = uncompressed[0x38d] == 0xf1;
- /* 2e horizontal, 2f vertical. we implement this by changing them */
+ // 2e horizontal, 2f vertical. we implement this by changing them
if (uncompressed[0x38e] == 0x2f)
{
for (y = 0; y < cave->h; y++)
}
cave->biter_delay_frame = uncompressed[0x394];
- cave->magic_wall_stops_amoeba = uncompressed[0x395] == 0; /* negated!! */
+ cave->magic_wall_stops_amoeba = uncompressed[0x395] == 0; // negated!!
cave->bomb_explosion_effect = import(uncompressed[0x396], 0x396);
cave->explosion_effect = import(uncompressed[0x397], 0x397);
cave->stone_bouncing_effect = import(uncompressed[0x398], 0x398);
cave->slime_eats_2 = import(uncompressed[0x39f], 0x39f);
cave->slime_converts_2 = import(uncompressed[0x39f] + 3, 0x39f);
- /* v3.0 has some new properties. */
+ // v3.0 has some new properties.
if (version >= V3_0)
{
cave->diagonal_movements = uncompressed[0x3a4] != 0;
ie. random<=ratio, then acid grows.
*/
- /* * 1e6, probabilities are stored as int */
+ // * 1e6, probabilities are stored as int
cave->acid_spread_ratio = uncompressed[0x3a8] / 255.0 * 1E6;
cave->acid_eats_this = import(uncompressed[0x3a9], 0x3a9);
cave->expanding_wall_looks_like = import(uncompressed[0x3ab], 0x3ab);
}
else
{
- /* version is <= 3.0, so this is a 1stb cave. */
- /* the only parameters, for which this matters, are these: */
+ // version is <= 3.0, so this is a 1stb cave.
+ // the only parameters, for which this matters, are these:
if (uncompressed[0x380] != 0)
cave->creatures_direction_auto_change_time = uncompressed[0x381];
else
}
if (cavefile)
- cave->selectable = !cave->intermission; /* best we can do */
+ cave->selectable = !cave->intermission; // best we can do
else
- cave->selectable = !data[0]; /* given by converter */
+ cave->selectable = !data[0]; // given by converter
return datapos;
}
return GD_FORMAT_UNKNOWN;
}
-/*
- Load caveset from memory buffer.
- Loads the caveset from a memory buffer.
- returns: List * of caves.
-*/
+
+// ----------------------------------------------------------------------------
+// Load caveset from memory buffer.
+// Loads the caveset from a memory buffer.
+// returns: List * of caves.
+// ----------------------------------------------------------------------------
+
List *gd_caveset_import_from_buffer (const byte *buf, size_t length)
{
boolean numbering;
while (bufp < length)
{
GdCave *newcave;
- /* default is to append cave to caveset; list_insert appends when pos = -1 */
+ // default is to append cave to caveset; list_insert appends when pos = -1
int insertpos = -1;
newcave = gd_cave_new();
- cavelength = 0; /* to avoid compiler warning */
+ cavelength = 0; // to avoid compiler warning
switch (format)
{
- case GD_FORMAT_BD1: /* boulder dash 1 */
- case GD_FORMAT_BD1_ATARI: /* boulder dash 1, atari version */
- case GD_FORMAT_DC1: /* deluxe caves 1 */
- case GD_FORMAT_BD2: /* boulder dash 2 */
- case GD_FORMAT_BD2_ATARI: /* boulder dash 2 */
- /* these are not in the data so we guess */
+ case GD_FORMAT_BD1: // boulder dash 1
+ case GD_FORMAT_BD1_ATARI: // boulder dash 1, atari version
+ case GD_FORMAT_DC1: // deluxe caves 1
+ case GD_FORMAT_BD2: // boulder dash 2
+ case GD_FORMAT_BD2_ATARI: // boulder dash 2
+ // these are not in the data so we guess
newcave->selectable = (cavenum < 16) && (cavenum % 4 == 0);
newcave->intermission = cavenum > 15;
- /* no name, so we make up one */
+ // no name, so we make up one
if (newcave->intermission)
snprintf(newcave->name, sizeof(newcave->name), _("Intermission %d"), cavenum - 15);
else
break;
};
- /* original bd1 had level order ABCDEFGH... and then the last four were the intermissions.
- * those should be inserted between D-E, H-I... caves. */
+ // original bd1 had level order ABCDEFGH... and then the last four were the intermissions.
+ // those should be inserted between D-E, H-I... caves.
if (cavenum > 15)
insertpos = (cavenum - 15) * 5 - 1;
break;
case GD_FORMAT_FIRSTB:
cavelength = cave_copy_from_1stb(newcave, buf + bufp, length - bufp);
- /* every fifth cave (4+1 intermission) is selectable. */
+ // every fifth cave (4+1 intermission) is selectable.
newcave->selectable = cavenum % 5 == 0;
break;
- case GD_FORMAT_PLC: /* peter liepa construction kit */
- case GD_FORMAT_PLC_ATARI: /* peter liepa construction kit, atari version */
+ case GD_FORMAT_PLC: // peter liepa construction kit
+ case GD_FORMAT_PLC_ATARI: // peter liepa construction kit, atari version
cavelength = cave_copy_from_plck(newcave, buf + bufp, length - bufp, format);
break;
case GD_FORMAT_DLB:
- /* no one's delight boulder dash, something like rle compressed plck caves */
- /* but there are 20 of them, as if it was a bd1 or bd2 game. also num%5 = 4 is intermission. */
- /* we have to set intermission flag on our own, as the file did not contain the info explicitly */
+ // no one's delight boulder dash, something like rle compressed plck caves
+ // but there are 20 of them, as if it was a bd1 or bd2 game. also num%5 = 4 is intermission.
+ // we have to set intermission flag on our own, as the file did not contain the info explicitly
newcave->intermission = (cavenum % 5) == 4;
if (newcave->intermission)
{
- /* also set visible size */
+ // also set visible size
newcave->x2 = 19;
newcave->y2 = 11;
}
- newcave->selectable = cavenum % 5 == 0; /* original selection scheme */
+ newcave->selectable = cavenum % 5 == 0; // original selection scheme
if (newcave->intermission)
snprintf(newcave->name, sizeof(newcave->name), _("Intermission %d"), cavenum / 5 + 1);
else
cavenum++;
bufp += cavelength;
- /* hack: some dlb files contain junk data after 20 caves. */
+ // hack: some dlb files contain junk data after 20 caves.
if (format == GD_FORMAT_DLB && cavenum == 20)
{
if (bufp < length)
}
}
- /* try to detect if plc caves are in standard layout. */
- /* that is, caveset looks like an original, (4 cave,1 intermission)+ */
+ // try to detect if plc caves are in standard layout.
+ // that is, caveset looks like an original, (4 cave,1 intermission)+
if (format == GD_FORMAT_PLC)
- /* if no selection table stored by any2gdash */
+ // if no selection table stored by any2gdash
if ((buf[2 + 0x1f0] != buf[2 + 0x1f1] - 1) ||
(buf[2 + 0x1f0] != 0x19 && buf[2 + 0x1f0] != 0x0e))
{
int n;
boolean standard;
- standard = (list_length(caveset)%5) == 0; /* cave count % 5 != 0 -> nonstandard */
+ standard = (list_length(caveset)%5) == 0; // cave count % 5 != 0 -> nonstandard
for (n = 0, iter = caveset; iter != NULL; n++, iter = iter->next)
{
if ((n % 5 == 4 && !cave->intermission) ||
(n % 5 != 4 && cave->intermission))
- standard = FALSE; /* 4 cave, 1 intermission */
+ standard = FALSE; // 4 cave, 1 intermission
}
- /* if test passed, update selectability */
+ // if test passed, update selectability
if (standard)
for (n = 0, iter = caveset; iter != NULL; n++, iter = iter->next)
{
GdCave *cave = iter->data;
- /* update "selectable" */
+ // update "selectable"
cave->selectable = (n % 5) == 0;
}
}
- /* try to give some names for the caves */
+ // try to give some names for the caves
cavenum = 1;
intermissionnum = 1;
num = 1;
- /* use numbering instead of letters, if following formats or too many caves
- (as we would run out of letters) */
+ // use numbering instead of letters, if following formats or too many caves
+ // (as we would run out of letters)
numbering = format == GD_FORMAT_PLC || format == GD_FORMAT_CRLI || list_length(caveset) > 26;
for (iter = caveset; iter != NULL; iter = iter->next)
{
GdCave *cave = (GdCave *)iter->data;
- if (!strEqual(cave->name, "")) /* if it already has a name, skip */
+ if (!strEqual(cave->name, "")) // if it already has a name, skip
continue;
if (cave->intermission)
{
- /* intermission */
+ // intermission
if (numbering)
snprintf(cave->name, sizeof(cave->name), _("Intermission %02d"), num);
else
cavenum++;
}
- /* if the user requests, we make all caves selectable. intermissions not. */
+ // if the user requests, we make all caves selectable. intermissions not.
if (gd_import_as_all_caves_selectable)
{
for (iter = caveset; iter != NULL; iter = iter->next)
{
GdCave *cave = (GdCave *)iter->data;
- /* make selectable if not an intermission. */
- /* also selectable, if it was selectable originally, for some reason. */
+ // make selectable if not an intermission.
+ // also selectable, if it was selectable originally, for some reason.
cave->selectable = cave->selectable || !cave->intermission;
}
}
return caveset;
}
-/* to be called at program start. */
-void
-gd_c64_import_init_tables(void)
+// to be called at program start.
+void gd_c64_import_init_tables(void)
{
}
extern const char gd_bd_internal_chars[];
extern const GdElement gd_crazylight_import_table[];
-/* file formats */
+// file formats
typedef enum _gd_cavefile_format
{
- GD_FORMAT_UNKNOWN, /* unknown format */
- GD_FORMAT_BD1, /* boulder dash 1 */
- GD_FORMAT_BD1_ATARI, /* boulder dash 1 atari version */
- GD_FORMAT_DC1, /* boulder dash 1, deluxe caves 1 extension -
- non-sloped brick wall. */
- GD_FORMAT_BD2, /* boulder dash 2 with rockford's extensions */
- GD_FORMAT_BD2_ATARI, /* boulder dash 2, atari version */
- GD_FORMAT_PLC, /* peter liepa construction kit */
- GD_FORMAT_PLC_ATARI, /* peter liepa construction kit, atari version */
- GD_FORMAT_DLB, /* no one's delight boulder dash */
- GD_FORMAT_CRLI, /* crazy light construction kit */
- GD_FORMAT_CRDR_7, /* crazy dream 7 */
- GD_FORMAT_CRDR_9, /* crazy dream 9 - is a crli caveset with hardcoded mazes */
- GD_FORMAT_FIRSTB, /* first boulder */
+ GD_FORMAT_UNKNOWN, // unknown format
+ GD_FORMAT_BD1, // boulder dash 1
+ GD_FORMAT_BD1_ATARI, // boulder dash 1 atari version
+ GD_FORMAT_DC1, // boulder dash 1, deluxe caves 1 extension - non-sloped brick wall
+ GD_FORMAT_BD2, // boulder dash 2 with rockford's extensions
+ GD_FORMAT_BD2_ATARI, // boulder dash 2, atari version
+ GD_FORMAT_PLC, // peter liepa construction kit
+ GD_FORMAT_PLC_ATARI, // peter liepa construction kit, atari version
+ GD_FORMAT_DLB, // no one's delight boulder dash
+ GD_FORMAT_CRLI, // crazy light construction kit
+ GD_FORMAT_CRDR_7, // crazy dream 7
+ GD_FORMAT_CRDR_9, // crazy dream 9 - is a crli caveset with hardcoded mazes
+ GD_FORMAT_FIRSTB, // first boulder
} GdCavefileFormat;
-/* engines */
+// engines
typedef enum _gd_engine
{
GD_ENGINE_BD1,
GD_ENGINE_1STB,
GD_ENGINE_CRDR7,
GD_ENGINE_CRLI,
- GD_ENGINE_INVALID, /* fake */
+ GD_ENGINE_INVALID, // fake
} GdEngine;
extern const char *gd_engines[];
#include "main_bd.h"
-/* arrays for movements */
-/* also no1 and bd2 cave data import helpers; line direction coordinates */
+// arrays for movements
+// also no1 and bd2 cave data import helpers; line direction coordinates
const int gd_dx[] =
{
0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 2, 2, 2, 0, -2, -2, -2
0, -1, -1, 0, 1, 1, 1, 0, -1, -2, -2, 0, 2, 2, 2, 0, -2
};
-/* TRANSLATORS:
- None here means "no direction to move"; when there is no gravity while stirring the pot. */
+// TRANSLATORS:
+// None here means "no direction to move"; when there is no gravity while stirring the pot.
static const char* direction_name[] =
{
N_("None"),
static HashTable *name_to_element;
GdElement gd_char_to_element[256];
-/* color of flashing the screen, gate opening to exit */
+// color of flashing the screen, gate opening to exit
const GdColor gd_flash_color = 0xFFFFC0;
-/* selected object in editor */
+// selected object in editor
const GdColor gd_select_color = 0x8080FF;
-/* direction to string and vice versa */
+// direction to string and vice versa
const char *gd_direction_get_visible_name(GdDirection dir)
{
return direction_name[dir];
return GD_MV_DOWN;
}
-/* scheduling name to string and vice versa */
+// scheduling name to string and vice versa
const char *gd_scheduling_get_filename(GdScheduling sched)
{
return scheduling_filename[sched];
for (i = 0; defaults[i].offset != -1; i++)
{
void *pvalue = STRUCT_MEMBER_P(str, defaults[i].offset);
- /* these point to the same, but to avoid the awkward cast syntax */
+ // these point to the same, but to avoid the awkward cast syntax
int *ivalue = pvalue;
GdElement *evalue = pvalue;
GdDirection *dvalue = pvalue;
GdColor *cvalue = pvalue;
int j, n;
- /* check which property we are talking about: find it in gd_cave_properties. */
+ // check which property we are talking about: find it in gd_cave_properties.
n = defaults[i].property_index;
if (n == 0)
{
properties[n].offset != defaults[i].offset)
n++;
- /* remember so we will be fast later*/
+ // remember so we will be fast later
defaults[i].property_index = n;
}
- /* some properties are arrays. this loop fills all with the same values */
+ // some properties are arrays. this loop fills all with the same values
for (j = 0; j < properties[n].count; j++)
{
switch (properties[n].type)
{
- /* these are for the gui; do nothing */
+ // these are for the gui; do nothing
case GD_TAB:
case GD_LABEL:
- /* no default value for strings */
+ // no default value for strings
case GD_TYPE_STRING:
case GD_TYPE_LONGSTRING:
break;
case GD_TYPE_RATIO:
- /* this is also an integer, difference is only when saving to bdcff */
+ // this is also an integer, difference is only when saving to bdcff
case GD_TYPE_INT:
if (defaults[i].defval < properties[n].min ||
defaults[i].defval > properties[n].max)
break;
case GD_TYPE_PROBABILITY:
- /* floats are stored as integer, /million; but are integers */
+ // floats are stored as integer, /million; but are integers
if (defaults[i].defval < 0 ||
defaults[i].defval > 1000000)
Warn("integer property %s out of range", properties[n].identifier);
}
}
-/* creates the character->element conversion table; using
- the fixed-in-the-bdcff characters. later, this table
- may be filled with more elements.
+/*
+ creates the character->element conversion table; using
+ the fixed-in-the-bdcff characters. later, this table
+ may be filled with more elements.
*/
void gd_create_char_to_element_table(void)
{
int i;
- /* fill all with unknown */
+ // fill all with unknown
for (i = 0; i < ARRAY_SIZE(gd_char_to_element); i++)
gd_char_to_element[i] = O_UNKNOWN;
- /* then set fixed characters */
+ // then set fixed characters
for (i = 0; i < O_MAX; i++)
{
int c = gd_elements[i].character;
}
}
-/* search the element database for the specified character, and return the element. */
+// search the element database for the specified character, and return the element.
GdElement gd_get_element_from_character (byte character)
{
if (gd_char_to_element[character] != O_UNKNOWN)
{
int i;
- /* put names to a hash table */
- /* this is a helper for file read operations */
- /* maps copied strings to elements (integers) */
+ // put names to a hash table
+ // this is a helper for file read operations
+ // maps copied strings to elements (integers)
name_to_element = create_hashtable(gd_str_case_hash, gd_str_case_equal, NULL, NULL);
for (i = 0; i < O_MAX; i++)
key = getStringToUpper(gd_elements[i].filename);
- if (hashtable_exists(name_to_element, key)) /* hash value may be 0 */
+ if (hashtable_exists(name_to_element, key)) // hash value may be 0
Warn("Name %s already used for element %x", key, i);
hashtable_insert(name_to_element, key, INT_TO_PTR(i));
- /* ^^^ do not free "key", as hash table needs it during the whole time! */
+ // ^^^ do not free "key", as hash table needs it during the whole time!
- key = getStringCat2("SCANNED_", key); /* new string */
+ key = getStringCat2("SCANNED_", key); // new string
hashtable_insert(name_to_element, key, INT_TO_PTR(i));
- /* once again, do not free "key" ^^^ */
+ // once again, do not free "key" ^^^
}
- /* for compatibility with tim stridmann's memorydump->bdcff converter... .... ... */
+ // for compatibility with tim stridmann's memorydump->bdcff converter... .... ...
hashtable_insert(name_to_element, "HEXPANDING_WALL", INT_TO_PTR(O_H_EXPANDING_WALL));
hashtable_insert(name_to_element, "FALLING_DIAMOND", INT_TO_PTR(O_DIAMOND_F));
hashtable_insert(name_to_element, "FALLING_BOULDER", INT_TO_PTR(O_STONE_F));
hashtable_insert(name_to_element, "EXPLOSION5D", INT_TO_PTR(O_PRE_DIA_5));
hashtable_insert(name_to_element, "WALL2", INT_TO_PTR(O_STEEL_EXPLODABLE));
- /* compatibility with old bd-faq (pre disassembly of bladder) */
+ // compatibility with old bd-faq (pre disassembly of bladder)
hashtable_insert(name_to_element, "BLADDERd9", INT_TO_PTR(O_BLADDER_8));
- /* create table to show errors at the start of the application */
+ // create table to show errors at the start of the application
gd_create_char_to_element_table();
}
-/* search the element database for the specified name, and return the element */
+// search the element database for the specified name, and return the element
GdElement gd_get_element_from_string (const char *string)
{
char *upper = getStringToUpper(string);
return O_UNKNOWN;
}
- found = hashtable_exists(name_to_element, upper); /* hash value may be 0 */
+ found = hashtable_exists(name_to_element, upper); // hash value may be 0
if (found)
value = hashtable_search(name_to_element, upper);
free(upper);
gd_cave_set_defaults_from_array(cave, gd_cave_defaults_gdash);
- /* these did not fit into the descriptor array */
+ // these did not fit into the descriptor array
for (i = 0; i < 5; i++)
{
cave->level_rand[i] = i;
}
}
-/* for quicksort. compares two highscores. */
+// for quicksort. compares two highscores.
int gd_highscore_compare(const void *a, const void *b)
{
const GdHighScore *ha = a;
return hs[0].score > 0;
}
-/* return true if score achieved is a highscore */
+// return true if score achieved is a highscore
boolean gd_is_highscore(GdHighScore *scores, int score)
{
- /* if score is above zero AND bigger than the last one */
+ // if score is above zero AND bigger than the last one
if (score > 0 && score > scores[GD_HIGHSCORE_NUM-1].score)
return TRUE;
if (!gd_is_highscore(highscores, score))
return -1;
- /* overwrite the last one */
+ // overwrite the last one
gd_strcpy(highscores[GD_HIGHSCORE_NUM-1].name, name);
highscores[GD_HIGHSCORE_NUM-1].score = score;
- /* and sort */
+ // and sort
qsort(highscores, GD_HIGHSCORE_NUM, sizeof(GdHighScore), gd_highscore_compare);
for (i = 0; i < GD_HIGHSCORE_NUM; i++)
return -1;
}
-/* for the case-insensitive hash keys */
+// for the case-insensitive hash keys
int gd_str_case_equal(void *s1, void *s2)
{
return strcasecmp(s1, s2) == 0;
cave = checked_calloc(sizeof(GdCave));
- /* hash table which stores unknown tags as strings. */
+ // hash table which stores unknown tags as strings.
cave->tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
gd_cave_set_gdash_defaults(cave);
return cave;
}
-/* cave maps.
- cave maps are continuous areas in memory. the allocated memory
- is width * height * bytes_per_cell long.
- the cave map[0] stores the pointer given by g_malloc().
- the map itself is also an allocated array of pointers to the
- beginning of rows.
- therefore:
- rows = new (pointers to rows);
- rows[0] = new map
- rows[1..h-1] = rows[0] + width * bytes
-
- freeing this:
- free(rows[0])
- free(rows)
+/*
+ cave maps.
+ cave maps are continuous areas in memory. the allocated memory
+ is width * height * bytes_per_cell long.
+ the cave map[0] stores the pointer given by g_malloc().
+ the map itself is also an allocated array of pointers to the
+ beginning of rows.
+ therefore:
+ rows = new (pointers to rows);
+ rows[0] = new map
+ rows[1..h-1] = rows[0] + width * bytes
+
+ freeing this:
+ free(rows[0])
+ free(rows)
*/
/*
*/
void *gd_cave_map_new_for_cave(const GdCave *cave, const int cell_size)
{
- void **rows; /* this is void**, pointer to array of ... */
+ void **rows; // this is void**, pointer to array of ...
int y;
rows = checked_malloc((cave->h) * sizeof(void *));
rows[0] = checked_calloc(cell_size * cave->w * cave->h);
for (y = 1; y < cave->h; y++)
- /* base pointer + num_of_bytes_per_element * width * number_of_row; as sizeof(char) = 1 */
+ // base pointer + num_of_bytes_per_element * width * number_of_row; as sizeof(char) = 1
rows[y] = (char *)rows[0] + cell_size * cave->w * y;
return rows;
if (cave->tags)
hashtable_destroy(cave->tags);
- if (cave->random) /* random generator is a GdRand * */
+ if (cave->random) // random generator is a GdRand *
gd_rand_free(cave->random);
- /* free strings */
+ // free strings
for (i = 0; gd_cave_properties[i].identifier != NULL; i++)
if (gd_cave_properties[i].type == GD_TYPE_LONGSTRING)
checked_free(STRUCT_MEMBER(char *, cave, gd_cave_properties[i].offset));
- /* map */
+ // map
gd_cave_map_free(cave->map);
- /* rendered data */
+ // rendered data
gd_cave_map_free(cave->objects_order);
- /* hammered walls to reappear data */
+ // hammered walls to reappear data
gd_cave_map_free(cave->hammered_reappear);
- /* free objects */
+ // free objects
list_foreach(cave->objects, (list_fn) free, NULL);
list_free(cave->objects);
- /* free replays */
+ // free replays
list_foreach(cave->replays, (list_fn) gd_replay_free, NULL);
list_free(cave->replays);
- /* freeing main pointer */
+ // freeing main pointer
free (cave);
}
hashtable_insert(dest, getStringCopy(key), getStringCopy(value));
}
-/* copy cave from src to destination, with duplicating dynamically allocated data */
+// copy cave from src to destination, with duplicating dynamically allocated data
void gd_cave_copy(GdCave *dest, const GdCave *src)
{
int i;
- /* copy entire data */
+ // copy entire data
memmove(dest, src, sizeof(GdCave));
- /* but duplicate dynamic data */
+ // but duplicate dynamic data
dest->tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
if (src->tags)
dest->map = gd_cave_map_dup(src, map);
dest->hammered_reappear = gd_cave_map_dup(src, hammered_reappear);
- /* for longstrings */
+ // for longstrings
for (i = 0; gd_cave_properties[i].identifier != NULL; i++)
if (gd_cave_properties[i].type == GD_TYPE_LONGSTRING)
STRUCT_MEMBER(char *, dest, gd_cave_properties[i].offset) =
getStringCopy(STRUCT_MEMBER(char *, src, gd_cave_properties[i].offset));
- /* no reason to copy this */
+ // no reason to copy this
dest->objects_order = NULL;
- /* copy objects list */
+ // copy objects list
if (src->objects)
{
List *iter;
- dest->objects = NULL; /* new empty list */
- for (iter = src->objects; iter != NULL; iter = iter->next) /* do a deep copy */
+ dest->objects = NULL; // new empty list
+ for (iter = src->objects; iter != NULL; iter = iter->next) // do a deep copy
dest->objects = list_append(dest->objects, get_memcpy (iter->data, sizeof (GdObject)));
}
- /* copy replays */
+ // copy replays
if (src->replays)
{
List *iter;
dest->replays = NULL;
- for (iter = src->replays; iter != NULL; iter = iter->next) /* do a deep copy */
+ for (iter = src->replays; iter != NULL; iter = iter->next) // do a deep copy
dest->replays = list_append(dest->replays, gd_replay_new_from_replay(iter->data));
}
- /* copy random number generator */
+ // copy random number generator
if (src->random)
dest->random = gd_rand_copy(src->random);
}
-/* create new cave, which is a copy of the cave given. */
+// create new cave, which is a copy of the cave given.
GdCave *gd_cave_new_from_cave(const GdCave *orig)
{
GdCave *cave;
Performs range checking.
If wraparound objects are selected, wraps around x coordinates, with or without lineshift.
(The y coordinate is not wrapped, as it did not work like that on the c64)
- order is a pointer to the GdObject describing this object. Thus the editor can identify which cell was created by which object.
+ order is a pointer to the GdObject describing this object. Thus the editor can identify
+ which cell was created by which object.
*/
void gd_cave_store_rc(GdCave *cave, int x, int y, const GdElement element, const void *order)
{
- /* if we do not need to draw, exit now */
+ // if we do not need to draw, exit now
if (element == O_NONE)
return;
- /* check bounds */
+ // check bounds
if (cave->wraparound_objects)
{
if (cave->lineshift)
{
- /* fit x coordinate within range, with correcting y at the same time */
+ // fit x coordinate within range, with correcting y at the same time
while (x < 0)
{
- x += cave->w; /* out of bounds on the left... */
- y--; /* previous row */
+ x += cave->w; // out of bounds on the left...
+ y--; // previous row
}
while (x >= cave->w)
y++;
}
- /* lineshifting does not fix the y coordinates.
- if out of bounds, element will not be displayed. */
- /* if such an object appeared in the c64 game, well, it was a buffer overrun. */
+ // lineshifting does not fix the y coordinates.
+ // if out of bounds, element will not be displayed.
+ // if such an object appeared in the c64 game, well, it was a buffer overrun.
}
else
{
- /* non lineshifting: changing x does not change y coordinate. */
+ // non lineshifting: changing x does not change y coordinate.
while (x < 0)
x += cave->w;
while (x >= cave->w)
x -= cave->w;
- /* after that, fix y coordinate */
+ // after that, fix y coordinate
while (y < 0)
y += cave->h;
}
}
- /* if the above wraparound code fixed the coordinates, this will always be true. */
- /* but see the above comment for lineshifting y coordinate */
+ // if the above wraparound code fixed the coordinates, this will always be true.
+ // but see the above comment for lineshifting y coordinate
if (x >= 0 && x < cave->w && y >= 0 && y < cave->h)
{
cave->map[y][x] = element;
GdElement gd_cave_get_rc(const GdCave *cave, int x, int y)
{
- /* always fix coordinates as if cave was wraparound. */
+ // always fix coordinates as if cave was wraparound.
- /* fix x coordinate */
+ // fix x coordinate
if (cave->lineshift)
{
- /* fit x coordinate within range, with correcting y at the same time */
+ // fit x coordinate within range, with correcting y at the same time
while (x < 0)
{
- x += cave->w; /* out of bounds on the left... */
- y--; /* previous row */
+ x += cave->w; // out of bounds on the left...
+ y--; // previous row
}
while (x >= cave->w)
{
}
else
{
- /* non lineshifting: changing x does not change y coordinate. */
+ // non lineshifting: changing x does not change y coordinate.
while (x < 0)
x += cave->w;
x -= cave->w;
}
- /* after that, fix y coordinate */
+ // after that, fix y coordinate
while (y < 0)
y += cave->h;
const int bright_colors[] = { 1, 3, 7 };
const int dark_colors[] = { 2, 6, 8, 9, 11 };
- /* always black */
+ // always black
cave->colorb = gd_c64_color(0);
cave->color0 = gd_c64_color(0);
- /* choose some bright color for brick */
+ // choose some bright color for brick
cave->color3 = gd_c64_color(bright_colors[gd_random_int_range(0, ARRAY_SIZE(bright_colors))]);
- /* choose a dark color for dirt, but should not be == color of brick */
+ // choose a dark color for dirt, but should not be == color of brick
do
{
cave->color1 = gd_c64_color(dark_colors[gd_random_int_range(0, ARRAY_SIZE(dark_colors))]);
}
- while (cave->color1 == cave->color3); /* so it is not the same as color 1 */
+ while (cave->color1 == cave->color3); // so it is not the same as color 1
- /* choose any but black for steel wall, but should not be == brick or dirt */
+ // choose any but black for steel wall, but should not be == brick or dirt
do
{
- /* between 1 and 15 - do not use black for this. */
+ // between 1 and 15 - do not use black for this.
cave->color2 = gd_c64_color(gd_random_int_range(1, 16));
}
- while (cave->color1 == cave->color2 || cave->color2 == cave->color3); /* so colors are not the same */
+ while (cave->color1 == cave->color2 || cave->color2 == cave->color3); // so colors are not the same
- /* copy amoeba and slime color */
+ // copy amoeba and slime color
cave->color4 = cave->color3;
cave->color5 = cave->color1;
}
}
empty;
- /* set to maximum size, then try to shrink */
+ // set to maximum size, then try to shrink
cave->x1 = 0;
cave->y1 = 0;
cave->x2 = cave->w - 1;
cave->y2 = cave->h - 1;
- /* search for empty, steel-wall-only last rows. */
- /* clear all lines, which are only steel wall.
- * and clear only one line, which is steel wall, but also has a player or an outbox. */
+ // search for empty, steel-wall-only last rows.
+ // clear all lines, which are only steel wall.
+ // and clear only one line, which is steel wall, but also has a player or an outbox.
empty = STEEL_ONLY;
do
{
switch (gd_cave_get_rc (cave, x, y))
{
- /* if steels only, this is to be deleted. */
+ // if steels only, this is to be deleted.
case O_STEEL:
break;
if (empty == STEEL_OR_OTHER)
empty = NO_SHRINK;
- /* if this, delete only this one, and exit. */
+ // if this, delete only this one, and exit.
if (empty == STEEL_ONLY)
empty = STEEL_OR_OTHER;
break;
default:
- /* anything else, that should be left in the cave. */
+ // anything else, that should be left in the cave.
empty = NO_SHRINK;
break;
}
}
}
- /* shrink if full steel or steel and player/outbox. */
+ // shrink if full steel or steel and player/outbox.
if (empty != NO_SHRINK)
- cave->y2--; /* one row shorter */
+ cave->y2--; // one row shorter
}
- while (empty == STEEL_ONLY); /* if found just steels, repeat. */
+ while (empty == STEEL_ONLY); // if found just steels, repeat.
- /* search for empty, steel-wall-only first rows. */
+ // search for empty, steel-wall-only first rows.
empty = STEEL_ONLY;
do
case O_PRE_OUTBOX:
case O_PRE_INVIS_OUTBOX:
case O_INBOX:
- /* shrink only lines, which have only ONE player or outbox.
- this is for bd4 intermission 2, for example. */
+ // shrink only lines, which have only ONE player or outbox.
+ // this is for bd4 intermission 2, for example.
if (empty == STEEL_OR_OTHER)
empty = NO_SHRINK;
if (empty == STEEL_ONLY)
if (empty != NO_SHRINK)
cave->y1++;
}
- while (empty == STEEL_ONLY); /* if found one, repeat. */
+ while (empty == STEEL_ONLY); // if found one, repeat.
- /* empty last columns. */
+ // empty last columns.
empty = STEEL_ONLY;
do
}
}
- /* just remember that one column shorter.
- free will know the size of memchunk, no need to realloc! */
+ // just remember that one column shorter.
+ // free will know the size of memchunk, no need to realloc!
if (empty != NO_SHRINK)
cave->x2--;
}
- while (empty == STEEL_ONLY); /* if found one, repeat. */
+ while (empty == STEEL_ONLY); // if found one, repeat.
- /* empty first columns. */
+ // empty first columns.
empty = STEEL_ONLY;
do
if (empty != NO_SHRINK)
cave->x1++;
}
- while (empty == STEEL_ONLY); /* if found one, repeat. */
+ while (empty == STEEL_ONLY); // if found one, repeat.
}
-/* check if cave visible part coordinates
- are outside cave sizes, or not in the right order.
- correct them if needed.
+/*
+ check if cave visible part coordinates
+ are outside cave sizes, or not in the right order.
+ correct them if needed.
*/
void gd_cave_correct_visible_size(GdCave *cave)
{
- /* change visible coordinates if they do not point to upperleft and lowerright */
+ // change visible coordinates if they do not point to upperleft and lowerright
if (cave->x2 < cave->x1)
{
int t = cave->x2;
cave->ckdelay_extra_for_animation += 2600;
}
-/* do some init - setup some cave variables before the game. */
+// do some init - setup some cave variables before the game.
void gd_cave_setup_for_game(GdCave *cave)
{
int x, y;
cave_set_ckdelay_extra_for_animation(cave);
- /* find the player which will be the one to scroll to at the beginning of the game
- (before the player's birth) */
+ // find the player which will be the one to scroll to at the beginning of the game
+ // (before the player's birth)
if (cave->active_is_first_found)
{
- /* uppermost player is active */
+ // uppermost player is active
for (y = cave->h - 1; y >= 0; y--)
{
for (x = cave->w - 1; x >= 0; x--)
}
else
{
- /* lowermost player is active */
+ // lowermost player is active
for (y = 0; y < cave->h; y++)
{
for (x = 0; x < cave->w; x++)
}
}
- /* select number of milliseconds (for pal and ntsc) */
+ // select number of milliseconds (for pal and ntsc)
cave->timing_factor = cave->pal_timing ? 1200 : 1000;
cave->time *= cave->timing_factor;
cave->hammered_reappear = gd_cave_map_new(cave, int);
}
-/* cave diamonds needed can be set to n<=0. */
-/* if so, count the diamonds at the time of the hatching, and decrement that value from */
-/* the number of diamonds found. */
-/* of course, this function is to be called from the cave engine, at the exact time of hatching. */
+// cave diamonds needed can be set to n<=0.
+// if so, count the diamonds at the time of the hatching, and decrement that value from
+// the number of diamonds found.
+// of course, this function is to be called from the cave engine, at the exact time of hatching.
void gd_cave_count_diamonds(GdCave *cave)
{
int x, y;
- /* if automatically counting diamonds. if this was negative,
- * the sum will be this less than the number of all the diamonds in the cave */
+ // if automatically counting diamonds. if this was negative,
+ // the sum will be this less than the number of all the diamonds in the cave
if (cave->diamonds_needed <= 0)
{
for (y = 0; y < cave->h; y++)
if (cave->map[y][x] == O_DIAMOND)
cave->diamonds_needed++;
- /* if still below zero, let this be 0, so gate will be open immediately */
+ // if still below zero, let this be 0, so gate will be open immediately
if (cave->diamonds_needed < 0)
cave->diamonds_needed = 0;
}
}
-/* takes a cave and a gfx buffer, and fills the buffer with cell indexes.
- the indexes might change if bonus life flash is active (small lines in
- "SPACE" cells),
- for the paused state (which is used in gdash but not in sdash) - yellowish
- color.
- also one can select the animation frame (0..7) to draw the cave on. so the
- caller manages
- increasing that.
-
- if a cell is changed, it is flagged with GD_REDRAW; the flag can be cleared
- by the caller.
+/*
+ takes a cave and a gfx buffer, and fills the buffer with cell indexes.
+ the indexes might change if bonus life flash is active (small lines in
+ "SPACE" cells),
+ for the paused state (which is used in gdash but not in sdash) - yellowish
+ color.
+ also one can select the animation frame (0..7) to draw the cave on. so the
+ caller manages
+ increasing that.
+
+ if a cell is changed, it is flagged with GD_REDRAW; the flag can be cleared
+ by the caller.
*/
void gd_drawcave_game(const GdCave *cave, int **element_buffer, int **gfx_buffer,
boolean bonus_life_flash, int animcycle, boolean hate_invisible_outbox)
if (cave->last_direction)
{
- /* he is moving, so stop blinking and tapping. */
+ // he is moving, so stop blinking and tapping.
player_blinking = 0;
player_tapping = 0;
}
else
{
- /* he is idle, so animations can be done. */
+ // he is idle, so animations can be done.
if (animcycle == 0)
{
- /* blinking and tapping is started at the beginning of animation sequences. */
- /* 1/4 chance of blinking, every sequence. */
+ // blinking and tapping is started at the beginning of animation sequences.
+ // 1/4 chance of blinking, every sequence.
player_blinking = gd_random_int_range(0, 4) == 0;
- /* 1/16 chance of starting or stopping tapping. */
+ // 1/16 chance of starting or stopping tapping.
if (gd_random_int_range(0, 16) == 0)
player_tapping = !player_tapping;
}
elemdrawing[O_REPLICATOR_SWITCH] = gd_elements[cave->replicators_active ? O_REPLICATOR_SWITCH_ON : O_REPLICATOR_SWITCH_OFF].image_game;
if (cave->replicators_active)
- /* if the replicators are active, animate them. */
+ // if the replicators are active, animate them.
elemmapping[O_REPLICATOR] = O_REPLICATOR_ACTIVE;
if (!cave->replicators_active)
- /* if the replicators are inactive, do not animate them. */
+ // if the replicators are inactive, do not animate them.
elemdrawing[O_REPLICATOR] = ABS(elemdrawing[O_REPLICATOR]);
elemmapping[O_CONVEYOR_SWITCH] = (cave->conveyor_belts_active ? O_CONVEYOR_SWITCH_ON : O_CONVEYOR_SWITCH_OFF);
if (cave->conveyor_belts_direction_changed)
{
- /* if direction is changed, animation is changed. */
+ // if direction is changed, animation is changed.
int temp;
elemmapping[O_CONVEYOR_LEFT] = O_CONVEYOR_RIGHT;
if (cave->conveyor_belts_active)
{
- /* keep potentially changed direction */
+ // keep potentially changed direction
int offset = (O_CONVEYOR_LEFT_ACTIVE - O_CONVEYOR_LEFT);
- /* if they are running, animate them. */
+ // if they are running, animate them.
elemmapping[O_CONVEYOR_LEFT] += offset;
elemmapping[O_CONVEYOR_RIGHT] += offset;
}
if (!cave->conveyor_belts_active)
{
- /* if they are not running, do not animate them. */
+ // if they are not running, do not animate them.
elemdrawing[O_CONVEYOR_LEFT] = ABS(elemdrawing[O_CONVEYOR_LEFT]);
elemdrawing[O_CONVEYOR_RIGHT] = ABS(elemdrawing[O_CONVEYOR_RIGHT]);
}
if (animcycle & 2)
{
- /* also a hack, like biter_switch */
+ // also a hack, like biter_switch
elemdrawing[O_PNEUMATIC_ACTIVE_LEFT] += 2;
elemdrawing[O_PNEUMATIC_ACTIVE_RIGHT] += 2;
elemdrawing[O_PLAYER_PNEUMATIC_LEFT] += 2;
if ((cave->last_direction) == GD_MV_STILL)
{
- /* player is idle. */
+ // player is idle.
if (player_blinking && player_tapping)
{
map = O_PLAYER_TAP_BLINK;
}
else
{
- /* of course this is GD_MV_RIGHT. */
+ // of course this is GD_MV_RIGHT.
map = O_PLAYER_RIGHT;
draw = gd_elements[O_PLAYER_RIGHT].image_game;
}
elemdrawing[O_PLAYER] = draw;
elemdrawing[O_PLAYER_GLUED] = draw;
- /* player with bomb does not blink or tap - no graphics drawn for that.
- running is drawn using w/o bomb cells */
+ // player with bomb does not blink or tap - no graphics drawn for that.
+ // running is drawn using w/o bomb cells */
if (cave->last_direction != GD_MV_STILL)
{
elemmapping[O_PLAYER_BOMB] = map;
elemmapping[O_OUTBOX] = (cave->inbox_flash_toggle ? O_OUTBOX_OPEN : O_OUTBOX_CLOSED);
elemdrawing[O_OUTBOX] = gd_elements[cave->inbox_flash_toggle ? O_OUTBOX_OPEN : O_OUTBOX_CLOSED].image_game;
- /* hack, not fit into gd_elements */
+ // hack, not fit into gd_elements
elemmapping[O_BITER_SWITCH] = O_BITER_SWITCH_1 + cave->biter_delay_frame;
- /* hack, not fit into gd_elements */
+ // hack, not fit into gd_elements
elemdrawing[O_BITER_SWITCH] = gd_elements[O_BITER_SWITCH].image_game + cave->biter_delay_frame;
- /* visual effects */
+ // visual effects
elemmapping[O_DIRT] = cave->dirt_looks_like;
elemmapping[O_EXPANDING_WALL] = cave->expanding_wall_looks_like;
elemmapping[O_V_EXPANDING_WALL] = cave->expanding_wall_looks_like;
elemmapping[O_H_EXPANDING_WALL] = cave->expanding_wall_looks_like;
elemmapping[O_AMOEBA_2] = cave->amoeba_2_looks_like;
- /* visual effects */
+ // visual effects
elemdrawing[O_DIRT] = elemdrawing[cave->dirt_looks_like];
elemdrawing[O_EXPANDING_WALL] = elemdrawing[cave->expanding_wall_looks_like];
elemdrawing[O_V_EXPANDING_WALL] = elemdrawing[cave->expanding_wall_looks_like];
elemdrawing[O_H_EXPANDING_WALL] = elemdrawing[cave->expanding_wall_looks_like];
elemdrawing[O_AMOEBA_2] = elemdrawing[cave->amoeba_2_looks_like];
- /* change only graphically */
+ // change only graphically
if (hate_invisible_outbox)
{
elemmapping[O_PRE_INVIS_OUTBOX] = O_PRE_OUTBOX;
{
GdElement actual = cave->map[y][x];
- /* if covered, real element is not important */
+ // if covered, real element is not important
if (actual & COVERED)
map = O_COVERED;
else
map = elemmapping[actual];
- /* if covered, real element is not important */
+ // if covered, real element is not important
if (actual & COVERED)
draw = gd_elements[O_COVERED].image_game;
else
draw = elemdrawing[actual];
- /* if negative, animated. */
+ // if negative, animated.
if (draw < 0)
draw = -draw + animcycle;
- /* flash */
+ // flash
if (cave->gate_open_flash)
draw += GD_NUM_OF_CELLS;
- /* set to buffer, with caching */
+ // set to buffer, with caching
if (element_buffer[y][x] != map)
element_buffer[y][x] = map;
}
}
-/* cave time is rounded _UP_ to seconds. so at the exact moment when it
- changes from
- 2sec remaining to 1sec remaining, the player has exactly one second.
- when it changes
- to zero, it is the exact moment of timeout. */
-/* internal time is milliseconds (or 1200 milliseconds for pal timing). */
+/*
+ cave time is rounded _UP_ to seconds. so at the exact moment when it
+ changes from
+ 2sec remaining to 1sec remaining, the player has exactly one second.
+ when it changes
+ to zero, it is the exact moment of timeout.
+
+ internal time is milliseconds (or 1200 milliseconds for pal timing).
+*/
int gd_cave_time_show(const GdCave *cave, int internal_time)
{
return (internal_time + cave->timing_factor - 1) / cave->timing_factor;
rep = get_memcpy(orig, sizeof(GdReplay));
- /* replicate dynamic data */
+ // replicate dynamic data
rep->comment = getStringCopy(orig->comment);
rep->movements = get_memcpy(orig->movements, sizeof(GdReplayMovements));
free(replay);
}
-/* store movement in a replay */
+// store movement in a replay
void gd_replay_store_movement(GdReplay *replay, GdDirection player_move,
boolean player_fire, boolean suicide)
{
}
}
-/* calculate adler checksum for a rendered cave; this can be used for more caves. */
+// calculate adler checksum for a rendered cave; this can be used for more caves.
void gd_cave_adler_checksum_more(GdCave *cave, unsigned int *a, unsigned int *b)
{
int x, y;
}
}
-/* calculate adler checksum for a single rendered cave. */
+// calculate adler checksum for a single rendered cave.
unsigned int gd_cave_adler_checksum(GdCave *cave)
{
unsigned int a = 1;
#include "bd_random.h"
-/******************************************
- *
- * BIG STRUCT HANDLING
- *
- */
+// ============================================================================
+// BIG STRUCT HANDLING
+// ============================================================================
-/* possible types handled */
+// possible types handled
typedef enum _gd_type
{
- /* not real types, only used by editor to build ui */
+ // not real types, only used by editor to build ui
GD_TAB,
GD_LABEL,
- /* gd types */
- GD_TYPE_STRING, /* static string, fixed array of characters */
- GD_TYPE_LONGSTRING, /* long string which has its own notebook page in
- the editor */
+ // gd types
+ GD_TYPE_STRING, // static string, fixed array of characters
+ GD_TYPE_LONGSTRING, // long string which has its own notebook page in the editor
GD_TYPE_INT,
GD_TYPE_RATIO,
GD_TYPE_ELEMENT,
GD_TYPE_BOOLEAN,
- GD_TYPE_PROBABILITY, /* probabilities are stored in parts per million,
- ie. *1E6, converted to int. */
+ GD_TYPE_PROBABILITY, // probabilities are stored in parts per million,
+ // ie. *1E6, converted to int.
GD_TYPE_COLOR,
GD_TYPE_EFFECT,
GD_TYPE_DIRECTION,
typedef struct _gd_struct_descriptor
{
- char *identifier; /* bdcff identifier */
- GdType type; /* data type */
- int flags; /* flags for bdcff saving/loading */
- char *name; /* name in editor */
- int offset; /* byte offset in a GdCave structure. use the CAVE_OFFSET macro */
- int count; /* size of array; usually 1, for non-arrays. */
- char *tooltip; /* tooltip text in editor */
- int min, max; /* integers have minimum and maximum */
+ char *identifier; // bdcff identifier
+ GdType type; // data type
+ int flags; // flags for bdcff saving/loading
+ char *name; // name in editor
+ int offset; // byte offset in a GdCave structure. use the CAVE_OFFSET macro
+ int count; // size of array; usually 1, for non-arrays.
+ char *tooltip; // tooltip text in editor
+ int min, max; // integers have minimum and maximum
} GdStructDescriptor;
typedef struct _gd_property_default
{
- int offset; /* data offset (bytes) in a cave structure */
- int defval; /* default value, converted to int. if type is a float, *1000000 */
+ int offset; // data offset (bytes) in a cave structure
+ int defval; // default value, converted to int. if type is a float, *1000000
- int property_index; /* index in gd_cave_properties; created at runtime */
+ int property_index; // index in gd_cave_properties; created at runtime
} GdPropertyDefault;
void gd_struct_set_defaults_from_array(void *str, const GdStructDescriptor *properties, GdPropertyDefault *defaults);
-/* these define the number of the cells in the png file */
-#define GD_NUM_OF_CELLS_X 8
-#define GD_NUM_OF_CELLS_Y 46
+// these define the number of the cells in the png file
+#define GD_NUM_OF_CELLS_X 8
+#define GD_NUM_OF_CELLS_Y 46
-/* +80: placeholder for cells which are rendered by the game;
- for example diamond + arrow = falling diamond */
-#define GD_NUM_OF_CELLS (GD_NUM_OF_CELLS_X * GD_NUM_OF_CELLS_Y + 80)
+// +80: placeholder for cells which are rendered by the game;
+// for example diamond + arrow = falling diamond
+#define GD_NUM_OF_CELLS (GD_NUM_OF_CELLS_X * GD_NUM_OF_CELLS_Y + 80)
-/* maximum replay size (maximum seconds x game cycles per second) */
-#define MAX_REPLAY_LEN (10000 * FRAMES_PER_SECOND / 8)
+// maximum replay size (maximum seconds x game cycles per second)
+#define MAX_REPLAY_LEN (10000 * FRAMES_PER_SECOND / 8)
extern const GdColor gd_flash_color;
extern const GdColor gd_select_color;
enum _element_property
{
- E_P_SLOPED_LEFT, /* stones and diamonds roll down to left on this */
- E_P_SLOPED_RIGHT, /* stones and diamonds roll down to right on this */
+ E_P_SLOPED_LEFT, // stones and diamonds roll down to left on this
+ E_P_SLOPED_RIGHT, // stones and diamonds roll down to right on this
E_P_SLOPED_UP,
E_P_SLOPED_DOWN,
- E_P_BLADDER_SLOPED, /* element act sloped also for the bladder */
-
- E_P_AMOEBA_CONSUMES, /* amoeba can eat this */
- E_P_DIRT, /* it is dirt, or something similar (dirt2 or sloped dirt) */
- E_P_BLOWS_UP_FLIES, /* flies blow up, if they touch this */
- E_P_EXPLODES_BY_HIT, /* explodes if hit by a stone */
-
- E_P_EXPLOSION, /* set for every stage of every explosion. */
- E_P_EXPLOSION_FIRST_STAGE, /* set for first stage of every explosion.
- helps slower/faster explosions changing */
-
- E_P_NON_EXPLODABLE, /* selfexplaining */
- E_P_CCW, /* this creature has a default counterclockwise
- rotation (for example, o_fire_1) */
- E_P_CAN_BE_HAMMERED, /* can be broken by pneumatic hammer */
- E_P_VISUAL_EFFECT, /* if the element can use a visual effect.
- used to check consistency of the code */
- E_P_PLAYER, /* easier to find out if it is a player element */
- E_P_MOVED_BY_CONVEYOR_TOP, /* can be moved by conveyor belt */
- E_P_MOVED_BY_CONVEYOR_BOTTOM, /* can be moved UNDER the conveyor belt */
-
- E_P_COLLECTIBLE, /* can be collected */
+ E_P_BLADDER_SLOPED, // element act sloped also for the bladder
+
+ E_P_AMOEBA_CONSUMES, // amoeba can eat this
+ E_P_DIRT, // it is dirt, or something similar (dirt2 or sloped dirt)
+ E_P_BLOWS_UP_FLIES, // flies blow up, if they touch this
+ E_P_EXPLODES_BY_HIT, // explodes if hit by a stone
+
+ E_P_EXPLOSION, // set for every stage of every explosion.
+ E_P_EXPLOSION_FIRST_STAGE, // set for first stage of every explosion.
+ // helps slower/faster explosions changing
+
+ E_P_NON_EXPLODABLE, // selfexplaining
+ E_P_CCW, // this creature has a default counterclockwise
+ // rotation (for example, o_fire_1)
+ E_P_CAN_BE_HAMMERED, // can be broken by pneumatic hammer
+ E_P_VISUAL_EFFECT, // if the element can use a visual effect.
+ // used to check consistency of the code
+ E_P_PLAYER, // easier to find out if it is a player element
+ E_P_MOVED_BY_CONVEYOR_TOP, // can be moved by conveyor belt
+ E_P_MOVED_BY_CONVEYOR_BOTTOM, // can be moved UNDER the conveyor belt
+
+ E_P_COLLECTIBLE, // can be collected
};
-/* properties */
+// properties
#define P_SLOPED_LEFT (1 << E_P_SLOPED_LEFT)
#define P_SLOPED_RIGHT (1 << E_P_SLOPED_RIGHT)
#define P_SLOPED_UP (1 << E_P_SLOPED_UP)
#define P_SLOPED_DOWN (1 << E_P_SLOPED_DOWN)
-/* flag to say "any direction" */
+// flag to say "any direction"
#define P_SLOPED (P_SLOPED_LEFT | \
P_SLOPED_RIGHT | \
P_SLOPED_UP | \
#define P_COLLECTIBLE (1 << E_P_COLLECTIBLE)
-/* These are states of the magic wall. */
+// These are states of the magic wall.
typedef enum _magic_wall_state
{
- GD_MW_DORMANT, /* Starting with this. */
- GD_MW_ACTIVE, /* Boulder or diamond dropped into. */
- GD_MW_EXPIRED /* Turned off after magic_wall_milling_time. */
+ GD_MW_DORMANT, // Starting with this.
+ GD_MW_ACTIVE, // Boulder or diamond dropped into.
+ GD_MW_EXPIRED // Turned off after magic_wall_milling_time.
} GdMagicWallState;
-/* These are states of Player. */
+// These are states of Player.
typedef enum _player_state
{
- GD_PL_NOT_YET, /* Not yet living. Beginning of cave time. */
- GD_PL_LIVING, /* Ok. */
- GD_PL_TIMEOUT, /* Time is up */
- GD_PL_DIED, /* Died. */
- GD_PL_EXITED /* Exited the cave, proceed to next one */
+ GD_PL_NOT_YET, // Not yet living. Beginning of cave time.
+ GD_PL_LIVING, // Ok.
+ GD_PL_TIMEOUT, // Time is up
+ GD_PL_DIED, // Died.
+ GD_PL_EXITED // Exited the cave, proceed to next one
} GdPlayerState;
-/* States of amoeba */
+// States of amoeba
typedef enum _amoeba_state
{
- GD_AM_SLEEPING, /* sleeping - not yet let out. */
- GD_AM_AWAKE, /* living, growing */
- GD_AM_TOO_BIG, /* grown too big, will convert to stones */
- GD_AM_ENCLOSED, /* enclosed, will convert to diamonds */
+ GD_AM_SLEEPING, // sleeping - not yet let out.
+ GD_AM_AWAKE, // living, growing
+ GD_AM_TOO_BIG, // grown too big, will convert to stones
+ GD_AM_ENCLOSED, // enclosed, will convert to diamonds
} GdAmoebaState;
typedef enum _direction
{
- /* not moving */
+ // not moving
GD_MV_STILL = 0,
GD_MV_THIS = 0,
- /* directions */
+ // directions
GD_MV_UP = 1,
GD_MV_UP_RIGHT = 2,
GD_MV_RIGHT = 3,
GD_MV_LEFT = 7,
GD_MV_UP_LEFT = 8,
- /* to be able to type GD_MV_TWICE + GD_MV_DOWN, for example */
+ // to be able to type GD_MV_TWICE + GD_MV_DOWN, for example
GD_MV_TWICE = 8,
- /* directions * 2 */
+ // directions * 2
GD_MV_UP_2 = 9,
GD_MV_UP_RIGHT_2 = 10,
GD_MV_RIGHT_2 = 11,
};
-/* ELEMENTS DESCRIPTION */
+// ELEMENTS DESCRIPTION
typedef struct _elements
{
- GdElement element; /* element number. for example O_DIRT */
- char *name; /* name in editor, for example "Dirt". some have
- different names than their real engine meaning! */
- unsigned int properties; /* engine properties, like P_SLOPED or P_EXPLODES */
- char *filename; /* name in bdcff file, like "DIRT" */
- char character; /* character representation in bdcff file, like '.' */
- int image; /* image in editor (index in cells.png) */
- int image_simple; /* image for simple view in editor, and for combo box (index in cells.png) */
- int image_game; /* image for game. negative if animated */
- int ckdelay; /* ckdelay ratio - how much time required for a c64 to
- process this element - in microseconds. */
-
- char *lowercase_name; /* lowercase of translated name. for editor; generated inside the game. */
- char character_new; /* character given automatically for elements which
- don't have one defined in original bdcff description */
+ GdElement element; // element number. for example O_DIRT
+ char *name; // name in editor, for example "Dirt". some have
+ // different names than their real engine meaning!
+ unsigned int properties; // engine properties, like P_SLOPED or P_EXPLODES
+ char *filename; // name in bdcff file, like "DIRT"
+ char character; // character representation in bdcff file, like '.'
+ int image; // image in editor (index in cells.png)
+ int image_simple; // image in editor (index in cells.png) (simple view / combo box)
+ int image_game; // image for game. negative if animated
+ int ckdelay; // ckdelay ratio - how much time required for a c64 to
+ // process this element - in microseconds.
+
+ char *lowercase_name; // lowercase of translated name. for editor;
+ // generated inside the game.
+ char character_new; // character given automatically for elements which
+ // don't have one defined in original bdcff description
} GdElements;
unsigned int len;
} GdReplayMovements;
-/* maximum seed value for the cave random generator. should be smaller than a signed int. */
+// maximum seed value for the cave random generator. should be smaller than a signed int.
#define GD_CAVE_SEED_MAX (1 << 30)
typedef struct _gd_cave_replay
{
- int level; /* replay for level n */
- unsigned int seed; /* seed the cave is to be rendered with */
- boolean saved; /* also store it in the saved bdcff */
- GdString recorded_with; /* recorded with - application name and version */
+ int level; // replay for level n
+ unsigned int seed; // seed the cave is to be rendered with
+ boolean saved; // also store it in the saved bdcff
+ GdString recorded_with; // recorded with - application name and version
- GdString player_name; /* who played this */
- GdString date; /* when played */
- char *comment; /* some comments from the player */
+ GdString player_name; // who played this
+ GdString date; // when played
+ char *comment; // some comments from the player
- int score; /* score collected */
- int duration; /* number of seconds played */
- boolean success; /* successful playing of cave? */
- unsigned int checksum; /* checksum of the rendered cave. */
+ int score; // score collected
+ int duration; // number of seconds played
+ boolean success; // successful playing of cave?
+ unsigned int checksum; // checksum of the rendered cave.
boolean wrong_checksum;
GdReplayMovements *movements;
int rand_seed_1, rand_seed_2;
} GdC64RandomGenerator;
-/*
- Structure holding all data belonging to a cave.
-*/
+// ----------------------------------------------------------------------------
+// Structure holding all data belonging to a cave.
+// ----------------------------------------------------------------------------
#define GD_HIGHSCORE_NUM 20
typedef struct _gd_cave
{
- /* Defined by the editor. public data :) */
- GdString name; /* Name of cave */
- GdString description; /* Some words about the cave */
- GdString author; /* Author */
- GdString difficulty; /* difficulty of the game, for info purposes */
- GdString www; /* link to author's webpage */
- GdString date; /* date of creation */
- char *story; /* story for the cave - will be shown when the cave is played. */
- char *remark; /* some note */
-
- GdString charset; /* these are not used by gdash */
+ // Defined by the editor. public data :)
+ GdString name; // name of cave
+ GdString description; // some words about the cave
+ GdString author; // author
+ GdString difficulty; // difficulty of the game, for info purposes
+ GdString www; // link to author's webpage
+ GdString date; // date of creation
+ char *story; // story for the cave - will be shown when cave is played.
+ char *remark; // some note
+
+ GdString charset; // these are not used by gdash
GdString fontset;
- /* and this one the highscores */
+ // and this one the highscores
GdHighScore highscore[GD_HIGHSCORE_NUM];
- HashTable *tags; /* stores read-but-not-understood strings from bdcff, so we can save them later. */
+ HashTable *tags; // stores read-but-not-understood strings from bdcff,
+ // so we can save them later.
- GdElement **map; /* pointer to data for map, non-null if has a map */
+ GdElement **map; // pointer to data for map, non-null if has a map
List *objects;
List *replays;
- boolean intermission; /* is this cave an intermission? */
- boolean intermission_instantlife; /* one life extra, if the intermission is reached */
- boolean intermission_rewardlife; /* one life extra, if the intermission is successfully finished */
- boolean selectable; /* is this selectable as an initial cave for a game? */
- boolean diagonal_movements; /* are diagonal movements allowed? */
- GdElement snap_element; /* snapping (press fire+move) usually leaves space behind, but can be other */
- boolean short_explosions; /* in >=1stb, diamond and creature explosions were of 5 stages */
-
- GdScheduling scheduling; /* scheduling type; see above */
- boolean pal_timing; /* use faster seconds */
-
- boolean active_is_first_found; /* active player is the uppermost. */
- boolean lineshift; /* true is line shifting emulation, false is perfect borders emulation */
- boolean border_scan_first_and_last; /* if true, scans the first and last line of the border. false for plck */
- boolean wraparound_objects; /* if this is true, object drawing (cave rendering) will wraparound as well. */
+ boolean intermission; // is this cave an intermission?
+ boolean intermission_instantlife; // one life extra, if the intermission is reached
+ boolean intermission_rewardlife; // one life extra, if the intermission is finished
+ boolean selectable; // is this selectable as an initial cave for a game?
+ boolean diagonal_movements; // are diagonal movements allowed?
+ GdElement snap_element; // snapping (press fire+move) usually leaves space behind,
+ // but can be other
+ boolean short_explosions; // in >= 1stb, diamond/creature explosions were of 5 stages
+
+ GdScheduling scheduling; // scheduling type; see above
+ boolean pal_timing; // use faster seconds
+
+ boolean active_is_first_found; // active player is the uppermost.
+ boolean lineshift; // true is line shifting emulation,
+ // false is perfect borders emulation
+ boolean border_scan_first_and_last; // if true, scans the first and last line of the border.
+ // false for plck
+ boolean wraparound_objects; // if this is true, object drawing (cave rendering)
+ // will wraparound as well.
GdElement initial_fill;
GdElement initial_border;
- GdElement random_fill[4]; /* Random fill elements. */
- int random_fill_probability[4]; /* Random fill, probability of each element. */
+ GdElement random_fill[4]; // Random fill elements.
+ int random_fill_probability[4]; // Random fill, probability of each element.
- int level_rand[5]; /* Random seed. */
- int level_diamonds[5]; /* Must collect diamonds, on level x */
- int level_speed[5]; /* Time between game cycles in ms */
- int level_ckdelay[5]; /* Timing in original game units */
- int level_time[5]; /* Available time, per level */
- int level_timevalue[5]; /* points for each second remaining, when exiting level */
+ int level_rand[5]; // Random seed.
+ int level_diamonds[5]; // Must collect diamonds, on level x
+ int level_speed[5]; // Time between game cycles in ms
+ int level_ckdelay[5]; // Timing in original game units
+ int level_time[5]; // Available time, per level
+ int level_timevalue[5]; // points for each second remaining, when exiting level
- int max_time; /* the maximum time in seconds. if above, it overflows */
+ int max_time; // the maximum time in seconds. if above, it overflows
- int w, h; /* Sizes of cave, width and height. */
- int x1,y1,x2,y2; /* Visible part of the cave */
- GdColor colorb; /* border color */
- GdColor color0, color1, color2, color3, color4, color5; /* c64-style colors; 4 and 5 are amoeba and slime. */
+ int w, h; // Sizes of cave, width and height.
+ int x1,y1,x2,y2; // Visible part of the cave
+ GdColor colorb; // border color
+ GdColor color0, color1, color2, color3, color4, color5; // c64-style colors;
+ // color 4 and 5 are amoeba and slime.
- int diamond_value; /* Score for a diamond. */
- int extra_diamond_value; /* Score for a diamond, when gate is open. */
+ int diamond_value; // Score for a diamond.
+ int extra_diamond_value; // Score for a diamond, when gate is open.
boolean stone_sound;
boolean nut_sound;
boolean bladder_spender_sound;
boolean bladder_convert_sound;
- int level_magic_wall_time[5]; /* magic wall 'on' state for each level (seconds) */
- boolean magic_wall_stops_amoeba; /* Turning on magic wall changes amoeba to diamonds. Original BD: yes, constkit: no */
- boolean magic_timer_wait_for_hatching; /* magic wall timer does not start before player's birth */
- boolean magic_wall_sound; /* magic wall has sound */
-
- int level_amoeba_time[5]; /* amoeba time for each level */
- int amoeba_growth_prob; /* Amoeba slow growth probability */
- int amoeba_fast_growth_prob; /* Amoeba fast growth probability */
- int level_amoeba_threshold[5]; /* amoeba turns to stones; if count is bigger than this (number of cells) */
- GdElement amoeba_enclosed_effect; /* an enclosed amoeba converts to this element */
- GdElement amoeba_too_big_effect; /* an amoeba grown too big converts to this element */
-
- int level_amoeba_2_time[5]; /* amoeba time for each level */
- int amoeba_2_growth_prob; /* Amoeba slow growth probability */
- int amoeba_2_fast_growth_prob; /* Amoeba fast growth probability */
- int level_amoeba_2_threshold[5]; /* amoeba turns to stones; if count is bigger than this (number of cells) */
- GdElement amoeba_2_enclosed_effect; /* an enclosed amoeba converts to this element */
- GdElement amoeba_2_too_big_effect; /* an amoeba grown too big converts to this element */
- boolean amoeba_2_explodes_by_amoeba; /* amoeba 2 will explode if touched by amoeba1 */
- GdElement amoeba_2_explosion_effect; /* amoeba 2 explosion ends in ... */
- GdElement amoeba_2_looks_like; /* an amoeba 2 looks like this element */
-
- boolean amoeba_timer_started_immediately; /* FALSE: amoeba will start life at the first possibility of growing. */
- boolean amoeba_timer_wait_for_hatching; /* amoeba timer does not start before player's birth */
- boolean amoeba_sound; /* if the living amoeba has sound. */
-
- GdElement acid_eats_this; /* acid eats this element */
- int acid_spread_ratio; /* Probability of acid blowing up, each frame */
- boolean acid_spread_sound; /* acid has sound */
- GdElement acid_turns_to; /* whether acid converts to explosion on spreading or other */
-
- GdElement nut_turns_to_when_crushed; /* when a nut is hit by a stone, it converts to this element */
-
- int level_slime_permeability[5]; /* true random slime */
- int level_slime_permeability_c64[5]; /* Appearing in bd 2 */
- int level_slime_seed_c64[5]; /* predictable slime random seed */
- boolean slime_predictable; /* predictable random start for slime. yes for plck. */
- GdElement slime_eats_1, slime_converts_1; /* slime eats element x and converts to element x; for example diamond -> falling diamond */
- GdElement slime_eats_2, slime_converts_2; /* this is usually stone -> stone_f */
- GdElement slime_eats_3, slime_converts_3; /* this is usually nut -> nut_f */
- boolean slime_sound; /* slime has sound */
-
- boolean lava_sound; /* elements sinking in lava have sound */
-
- int level_hatching_delay_frame[5]; /* Scan frames before Player's birth. */
- int level_hatching_delay_time[5]; /* Scan frames before Player's birth. */
-
- int level_bonus_time[5]; /* bonus time for clock collected. */
- int level_penalty_time[5]; /* Time penalty when voodoo destroyed. */
- boolean voodoo_collects_diamonds; /* Voodoo can collect diamonds */
- boolean voodoo_dies_by_stone; /* Voodoo can be killed by a falling stone */
- boolean voodoo_disappear_in_explosion; /* Voodoo can be destroyed by and explosion */
- boolean voodoo_any_hurt_kills_player; /* If any of the voodoos are hurt in any way, the player is killed. */
-
- boolean water_does_not_flow_down; /* if true, water will not grow downwards, only in other directions. */
- boolean water_sound; /* water has sound */
-
- boolean bladder_sound; /* bladder moving and pushing has sound */
- GdElement bladder_converts_by; /* bladder converts to clock by touching this element */
-
- int biter_delay_frame; /* frame count biters do move */
- GdElement biter_eat; /* biters eat this */
- boolean biter_sound; /* biters have sound */
-
- boolean expanding_wall_changed; /* expanding wall direction is changed */
-
- int replicator_delay_frame; /* replicator delay in frames (number of frames to wait between creating a new element) */
- boolean replicators_active; /* replicators are active. */
- boolean replicator_sound; /* when replicating an element, play sound or not. */
+ int level_magic_wall_time[5]; // magic wall 'on' state for each level (seconds)
+ boolean magic_wall_stops_amoeba; // Turning on magic wall changes amoeba to diamonds.
+ // Original BD: yes, constkit: no
+ boolean magic_timer_wait_for_hatching;// magic wall timer does not start before player's birth
+ boolean magic_wall_sound; // magic wall has sound
+
+ int level_amoeba_time[5]; // amoeba time for each level
+ int amoeba_growth_prob; // Amoeba slow growth probability
+ int amoeba_fast_growth_prob; // Amoeba fast growth probability
+ int level_amoeba_threshold[5]; // amoeba turns to stones; if count is bigger than this
+ // (number of cells)
+ GdElement amoeba_enclosed_effect; // an enclosed amoeba converts to this element
+ GdElement amoeba_too_big_effect; // an amoeba grown too big converts to this element
+
+ int level_amoeba_2_time[5]; // amoeba time for each level
+ int amoeba_2_growth_prob; // Amoeba slow growth probability
+ int amoeba_2_fast_growth_prob; // Amoeba fast growth probability
+ int level_amoeba_2_threshold[5]; // amoeba turns to stones; if count is bigger than this
+ // (number of cells)
+ GdElement amoeba_2_enclosed_effect; // an enclosed amoeba converts to this element
+ GdElement amoeba_2_too_big_effect; // an amoeba grown too big converts to this element
+ boolean amoeba_2_explodes_by_amoeba; // amoeba 2 will explode if touched by amoeba1
+ GdElement amoeba_2_explosion_effect; // amoeba 2 explosion ends in ...
+ GdElement amoeba_2_looks_like; // an amoeba 2 looks like this element
+
+ boolean amoeba_timer_started_immediately; // FALSE: amoeba will start life at the first
+ // possibility of growing.
+ boolean amoeba_timer_wait_for_hatching; // amoeba timer does not start before player's birth
+ boolean amoeba_sound; // if the living amoeba has sound.
+
+ GdElement acid_eats_this; // acid eats this element
+ int acid_spread_ratio; // Probability of acid blowing up, each frame
+ boolean acid_spread_sound; // acid has sound
+ GdElement acid_turns_to; // whether acid converts to explosion on spreading or other
+
+ GdElement nut_turns_to_when_crushed; // when nut is hit by stone, it converts to this element
+
+ int level_slime_permeability[5]; // true random slime
+ int level_slime_permeability_c64[5]; // Appearing in bd 2
+ int level_slime_seed_c64[5]; // predictable slime random seed
+ boolean slime_predictable; // predictable random start for slime. yes for plck.
+ GdElement slime_eats_1, slime_converts_1; // slime eats element x and converts to element x;
+ // for example diamond -> falling diamond
+ GdElement slime_eats_2, slime_converts_2; // this is usually stone -> stone_f
+ GdElement slime_eats_3, slime_converts_3; // this is usually nut -> nut_f
+ boolean slime_sound; // slime has sound
+
+ boolean lava_sound; // elements sinking in lava have sound
+
+ int level_hatching_delay_frame[5]; // Scan frames before Player's birth.
+ int level_hatching_delay_time[5]; // Scan frames before Player's birth.
+
+ int level_bonus_time[5]; // bonus time for clock collected.
+ int level_penalty_time[5]; // Time penalty when voodoo destroyed.
+ boolean voodoo_collects_diamonds; // Voodoo can collect diamonds
+ boolean voodoo_dies_by_stone; // Voodoo can be killed by a falling stone
+ boolean voodoo_disappear_in_explosion;// Voodoo can be destroyed by and explosion
+ boolean voodoo_any_hurt_kills_player; // If any voodoo hurt in any way, player is killed.
+
+ boolean water_does_not_flow_down; // if true, water will not grow downwards,
+ // only in other directions.
+ boolean water_sound; // water has sound
+
+ boolean bladder_sound; // bladder moving and pushing has sound
+ GdElement bladder_converts_by; // bladder converts to clock by touching this element
+
+ int biter_delay_frame; // frame count biters do move
+ GdElement biter_eat; // biters eat this
+ boolean biter_sound; // biters have sound
+
+ boolean expanding_wall_changed; // expanding wall direction is changed
+
+ int replicator_delay_frame; // replicator delay in frames (number of frames
+ // to wait between creating a new element)
+ boolean replicators_active; // replicators are active.
+ boolean replicator_sound; // when replicating an element, play sound or not.
boolean conveyor_belts_active;
boolean conveyor_belts_direction_changed;
- /* effects */
- GdElement explosion_effect; /* explosion converts to this element after its last stage. diego effect. */
- GdElement diamond_birth_effect; /* a diamond birth converts to this element after its last stage. diego effect. */
- GdElement bomb_explosion_effect; /* bombs explode to this element. diego effect (almost). */
- GdElement nitro_explosion_effect; /* nitros explode to this */
-
- GdElement firefly_explode_to; /* fireflies explode to this when hit by a stone */
- GdElement alt_firefly_explode_to; /* alternative fireflies explode to this when hit by a stone */
- GdElement butterfly_explode_to; /* butterflies explode to this when hit by a stone */
- GdElement alt_butterfly_explode_to; /* alternative butterflies explode to this when hit by a stone */
- GdElement stonefly_explode_to; /* stoneflies explode to this when hit by a stone */
- GdElement dragonfly_explode_to; /* dragonflies explode to this when hit by a stone */
-
- GdElement stone_falling_effect; /* a falling stone converts to this element. diego effect. */
- GdElement diamond_falling_effect; /* a falling diamond converts to this element. diego effect. */
- GdElement stone_bouncing_effect; /* a bouncing stone converts to this element. diego effect. */
- GdElement diamond_bouncing_effect; /* a bouncing diamond converts to this element. diego effect. */
-
- GdElement expanding_wall_looks_like; /* an expanding wall looks like this element. diego effect. */
- GdElement dirt_looks_like; /* dirt looks like this element. diego effect. */
-
- GdElement magic_stone_to; /* magic wall converts falling stone to */
- GdElement magic_diamond_to; /* magic wall converts falling diamond to */
- GdElement magic_mega_stone_to; /* magic wall converts a falling mega stone to */
- GdElement magic_nitro_pack_to; /* magic wall converts a falling nitro pack to */
- GdElement magic_nut_to; /* magic wall converts a falling nut to */
- GdElement magic_flying_stone_to; /* flying stones are converted to */
- GdElement magic_flying_diamond_to; /* flying diamonds are converted to */
-
- int pushing_stone_prob; /* probability of pushing stone */
- int pushing_stone_prob_sweet; /* probability of pushing, after eating sweet */
- boolean mega_stones_pushable_with_sweet; /* mega stones may be pushed with sweet */
-
- boolean creatures_backwards; /* creatures changed direction */
- boolean creatures_direction_auto_change_on_start; /* the change occurs also at the start signal */
- int creatures_direction_auto_change_time; /* creatures automatically change direction every x seconds */
- boolean creature_direction_auto_change_sound; /* automatically changing creature direction may have the sound of the creature dir switch */
-
- int skeletons_needed_for_pot; /* how many skeletons to be collected, to use a pot */
- int skeletons_worth_diamonds; /* for crazy dream 7 compatibility: collecting skeletons might open the cave door. */
+ // effects
+ GdElement explosion_effect; // explosion converts to this element after its last stage.
+ // diego effect.
+ GdElement diamond_birth_effect; // a diamond birth converts to this element after its last
+ // stage. diego effect.
+ GdElement bomb_explosion_effect; // bombs explode to this element. diego effect (almost).
+ GdElement nitro_explosion_effect; // nitros explode to this
+
+ GdElement firefly_explode_to; // fireflies explode to this when hit by stone
+ GdElement alt_firefly_explode_to; // alternative fireflies explode to this when hit by stone
+ GdElement butterfly_explode_to; // butterflies explode to this when hit by stone
+ GdElement alt_butterfly_explode_to; // alternative butterflies explode to this when hit by stone
+ GdElement stonefly_explode_to; // stoneflies explode to this when hit by stone
+ GdElement dragonfly_explode_to; // dragonflies explode to this when hit by stone
+
+ GdElement stone_falling_effect; // falling stone converts to this element. diego effect.
+ GdElement diamond_falling_effect; // falling diamond converts to this element. diego effect.
+ GdElement stone_bouncing_effect; // bouncing stone converts to this element. diego effect.
+ GdElement diamond_bouncing_effect; // bouncing diamond converts to this element. diego effect.
+
+ GdElement expanding_wall_looks_like; // an expanding wall looks like this element. diego effect.
+ GdElement dirt_looks_like; // dirt looks like this element. diego effect.
+
+ GdElement magic_stone_to; // magic wall converts falling stone to
+ GdElement magic_diamond_to; // magic wall converts falling diamond to
+ GdElement magic_mega_stone_to; // magic wall converts a falling mega stone to
+ GdElement magic_nitro_pack_to; // magic wall converts a falling nitro pack to
+ GdElement magic_nut_to; // magic wall converts a falling nut to
+ GdElement magic_flying_stone_to; // flying stones are converted to
+ GdElement magic_flying_diamond_to; // flying diamonds are converted to
+
+ int pushing_stone_prob; // probability of pushing stone
+ int pushing_stone_prob_sweet; // probability of pushing, after eating sweet
+ boolean mega_stones_pushable_with_sweet; // mega stones may be pushed with sweet
+
+ boolean creatures_backwards; // creatures changed direction
+ boolean creatures_direction_auto_change_on_start; // the change occurs also at the start signal
+ int creatures_direction_auto_change_time; // creatures automatically change direction every x
+ // seconds
+ boolean creature_direction_auto_change_sound; // automatically changing creature direction may
+ // have the sound of the creature dir switch
+
+ int skeletons_needed_for_pot; // how many skeletons to be collected, to use a pot
+ int skeletons_worth_diamonds; // for crazy dream 7 compatibility: collecting skeletons
+ // might open the cave door.
GdDirection gravity;
int gravity_change_time;
boolean gravity_change_sound;
- boolean gravity_affects_all; /* if true, gravity also affects falling wall, bladder and waiting stones */
- boolean gravity_switch_active; /* true if gravity switch is activated, and can be used. */
+ boolean gravity_affects_all; // if true, gravity also affects falling wall, bladder
+ // and waiting stones
+ boolean gravity_switch_active; // true if gravity switch is activated, and can be used.
boolean hammered_walls_reappear;
int pneumatic_hammer_frame;
int hammered_wall_reappear_frame;
boolean pneumatic_hammer_sound;
- /* internal variables, used during the game. private data :) */
+ // internal variables, used during the game. private data :)
- /* returns range corrected x/y position (points to perfect or line shifting get function) */
+ // returns range corrected x/y position (points to perfect or line shifting get function)
int (*getx) (const struct _gd_cave*, int x, int y);
int (*gety) (const struct _gd_cave*, int x, int y);
- /* returns pointer to element at x, y (points to perfect border or a line shifting get function) */
+ // returns pointer to element at x, y (points to perfect border or a line shifting get function)
GdElement* (*getp) (const struct _gd_cave*, int x, int y);
- boolean hatched; /* hatching has happened. (timers may run, ...) */
- boolean gate_open; /* self-explaining */
- unsigned int render_seed; /* the seed value, which was used to render the cave, is saved here. will be used by record&playback */
- GdRand *random; /* random number generator of rendered cave */
- int rendered; /* if not zero, rendered at level x */
- int timing_factor; /* number of "milliseconds" in each second :) 1000 for ntsc, 1200 for pal. */
- void ***objects_order; /* two-dimensional map of cave; each cell is a pointer to the drawing object, which created this element. NULL if map or random. */
- int **hammered_reappear; /* integer map of cave; if non-zero, a brick wall will appear there */
-
- int speed; /* Time between game cycles in ms */
- int c64_timing; /* a ckdelay value for the level this cave is rendered for */
- int ckdelay; /* ckdelay value for the current iteration */
- int ckdelay_extra_for_animation; /* bd1 and similar engines had animation bits in cave data, to set which elements to animate (firefly, butterfly, amoeba).
- animating an element also caused some delay each frame; according to my measurements, around 2.6 ms/element. */
-
- int frame; /* XXX */
+ boolean hatched; // hatching has happened. (timers may run, ...)
+ boolean gate_open; // self-explaining
+ unsigned int render_seed; // the seed value, which was used to render the cave,
+ // is saved here. will be used by record&playback
+ GdRand *random; // random number generator of rendered cave
+ int rendered; // if not zero, rendered at level x
+ int timing_factor; // number of "milliseconds" in each second :)
+ // 1000 for ntsc, 1200 for pal.
+ void ***objects_order; // two-dimensional map of cave; each cell is a pointer
+ // to the drawing object, which created this element.
+ // NULL if map or random.
+ int **hammered_reappear; // integer map of cave; if non-zero, a brick wall will
+ // appear there
+
+ int speed; // Time between game cycles in ms
+ int c64_timing; // a ckdelay value for the level this cave is rendered for
+ int ckdelay; // ckdelay value for the current iteration
+ int ckdelay_extra_for_animation; // bd1 and similar engines had animation bits in cave data,
+ // to set which elements to animate (firefly, butterfly,
+ // amoeba).
+ // animating an element also caused some delay each frame;
+ // according to my measurements, around 2.6 ms/element.
+
+ int frame; // XXX
int hatching_delay_frame;
int hatching_delay_time;
- int time_bonus; /* bonus time for clock collected. */
- int time_penalty; /* Time penalty when voodoo destroyed. */
- int time; /* milliseconds remaining to finish cave */
- int timevalue; /* points for remaining seconds - for current level */
- int diamonds_needed; /* diamonds needed to open outbox */
- int diamonds_collected; /* diamonds collected */
- int skeletons_collected; /* number of skeletons collected */
- int gate_open_flash; /* flashing of screen when gate opens */
- int score; /* Score got this frame. */
- int amoeba_time; /* Amoeba growing slow (low probability, default 3%) for milliseconds. After that, fast growth default (25%) */
- int amoeba_2_time; /* Amoeba growing slow (low probability, default 3%) for milliseconds. After that, fast growth default (25%) */
- int amoeba_max_count; /* selected amoeba 1 threshold for this level */
- int amoeba_2_max_count; /* selected amoeba 2 threshold for this level */
- GdAmoebaState amoeba_state; /* state of amoeba 1 */
- GdAmoebaState amoeba_2_state; /* state of amoeba 2 */
- int magic_wall_time; /* magic wall 'on' state for seconds */
- int slime_permeability; /* true random slime */
- int slime_permeability_c64; /* Appearing in bd 2 */
- GdMagicWallState magic_wall_state; /* State of magic wall */
- GdPlayerState player_state; /* Player state. not yet living, living, exited... */
- int player_seen_ago; /* player was seen this number of scans ago */
- boolean voodoo_touched; /* as its name says */
- boolean kill_player; /* Voodoo died, or used pressed escape to restart level. */
- boolean sweet_eaten; /* player ate sweet, he's strong. prob_sweet applies, and also able to push chasing stones */
- int player_x, player_y; /* Coordinates of player (for scrolling) */
- int px[16], py[16]; /* coordinates of player, for chasing stone */
- int key1, key2, key3; /* The player is holding this number of keys of each color */
- boolean diamond_key_collected; /* Key collected, so trapped diamonds convert to diamonds */
- boolean inbox_flash_toggle; /* negated every scan. helps drawing inboxes, and making players be born at different times. */
- GdDirection last_direction; /* last direction player moved. used by draw routines */
+ int time_bonus; // bonus time for clock collected.
+ int time_penalty; // Time penalty when voodoo destroyed.
+ int time; // milliseconds remaining to finish cave
+ int timevalue; // points for remaining seconds - for current level
+ int diamonds_needed; // diamonds needed to open outbox
+ int diamonds_collected; // diamonds collected
+ int skeletons_collected; // number of skeletons collected
+ int gate_open_flash; // flashing of screen when gate opens
+ int score; // Score got this frame.
+ int amoeba_time; // Amoeba growing slow (low probability, default 3%) for
+ // milliseconds. After that, fast growth default (25%)
+ int amoeba_2_time; // Amoeba growing slow (low probability, default 3%) for
+ // milliseconds. After that, fast growth default (25%)
+ int amoeba_max_count; // selected amoeba 1 threshold for this level
+ int amoeba_2_max_count; // selected amoeba 2 threshold for this level
+ GdAmoebaState amoeba_state; // state of amoeba 1
+ GdAmoebaState amoeba_2_state; // state of amoeba 2
+ int magic_wall_time; // magic wall 'on' state for seconds
+ int slime_permeability; // true random slime
+ int slime_permeability_c64; // Appearing in bd 2
+ GdMagicWallState magic_wall_state; // State of magic wall
+ GdPlayerState player_state; // Player state. not yet living, living, exited...
+ int player_seen_ago; // player was seen this number of scans ago
+ boolean voodoo_touched; // as its name says
+ boolean kill_player; // Voodoo died, or used pressed escape to restart level.
+ boolean sweet_eaten; // player ate sweet, he's strong. prob_sweet applies,
+ // and also able to push chasing stones
+ int player_x, player_y; // Coordinates of player (for scrolling)
+ int px[16], py[16]; // coordinates of player, for chasing stone
+ int key1, key2, key3; // The player is holding this number of keys of each color
+ boolean diamond_key_collected; // Key collected, so trapped diamonds convert to diamonds
+ boolean inbox_flash_toggle; // negated every scan. helps drawing inboxes, and making
+ // players be born at different times.
+ GdDirection last_direction; // last direction player moved. used by draw routines
GdDirection last_horizontal_direction;
- int biters_wait_frame; /* number of frames to wait until biters will move again */
- int replicators_wait_frame; /* number of frames to wait until replicators are activated again */
- int creatures_direction_will_change; /* creatures automatically change direction every x seconds */
- GdC64RandomGenerator c64_rand; /* used for predictable random generator during the game. */
-
- int gravity_will_change; /* gravity will change in this number of milliseconds */
- boolean gravity_disabled; /* when the player is stirring the pot, there is no gravity. */
- GdDirection gravity_next_direction; /* next direction when the gravity changes. will be set by the player "getting" a gravity switch */
- boolean got_pneumatic_hammer; /* true if the player has a pneumatic hammer */
- int pneumatic_hammer_active_delay; /* number of frames to wait, till pneumatic hammer will destroy the wall */
- GdSound sound1, sound2, sound3; /* sound set for 3 channels after each iteration */
+ int biters_wait_frame; // number of frames to wait until biters will move again
+ int replicators_wait_frame; // number of frames to wait until replicators are
+ // activated again
+ int creatures_direction_will_change; // creatures automatically change direction every x seconds
+ GdC64RandomGenerator c64_rand; // used for predictable random generator during the game.
+
+ int gravity_will_change; // gravity will change in this number of milliseconds
+ boolean gravity_disabled; // when player is stirring the pot, there is no gravity.
+ GdDirection gravity_next_direction; // next direction when the gravity changes.
+ // will be set by the player "getting" a gravity switch
+ boolean got_pneumatic_hammer; // true if the player has a pneumatic hammer
+ int pneumatic_hammer_active_delay; // number of frames to wait, till pneumatic hammer will
+ // destroy the wall
+ GdSound sound1, sound2, sound3; // sound set for 3 channels after each iteration
} GdCave;
#define CAVE_OFFSET(property) (STRUCT_OFFSET(GdCave, property))
-/* arrays for movements */
-/* also no1 and bd2 cave data import helpers; line direction coordinates */
+// arrays for movements
+// also no1 and bd2 cave data import helpers; line direction coordinates
extern const int gd_dx[], gd_dy[];
extern GdElement gd_char_to_element[];
GdElement gd_get_element_from_character(unsigned char character);
GdElement gd_get_element_from_string(const char *string);
-/* init cave engine */
+// init cave engine
void gd_cave_init(void);
-/* for cave tags hash table */
+// for cave tags hash table
int gd_str_case_equal(void *s1, void *s2);
unsigned int gd_str_case_hash(void *v);
-/* cave highscore functions */
+// cave highscore functions
int gd_highscore_compare(const void *a, const void *b);
boolean gd_is_highscore(GdHighScore *scores, int score);
int gd_add_highscore(GdHighScore *highscores, const char *name, int score);
void gd_clear_highscore(GdHighScore *hs);
boolean gd_has_highscore(GdHighScore *hs);
-/* cave creator and destructor functions */
+// cave creator and destructor functions
GdCave *gd_cave_new(void);
GdCave *gd_cave_new_from_cave(const GdCave *orig);
void gd_cave_copy(GdCave *dest, const GdCave *src);
void gd_cave_free(GdCave *cave);
-/* cave manipulation */
+// cave manipulation
void gd_cave_set_gdash_defaults(GdCave *cave);
void gd_cave_set_defaults_from_array(GdCave* cave, GdPropertyDefault *defaults);
void gd_cave_correct_visible_size(GdCave *cave);
void gd_cave_setup_for_game(GdCave *cave);
void gd_cave_count_diamonds(GdCave *cave);
-/* c64 random generator support for cave fill */
+// c64 random generator support for cave fill
unsigned int gd_c64_random(GdC64RandomGenerator *rand);
unsigned int gd_cave_c64_random(GdCave *);
void gd_c64_random_set_seed(GdC64RandomGenerator *rand, int seed1, int seed2);
void gd_cave_c64_random_set_seed(GdCave *cave, int seed1, int seed2);
void gd_cave_set_random_c64_colors(GdCave *cave);
-/* support */
+// support
void *gd_cave_map_new_for_cave(const GdCave *cave, const int cell_size);
void *gd_cave_map_dup_size(const GdCave * cave, const void *map, const int cell_size);
#define gd_cave_map_new(CAVE, TYPE) ((TYPE **)gd_cave_map_new_for_cave((CAVE), sizeof(TYPE)))
void gd_cave_store_rc(GdCave * cave, int x, int y, const GdElement element, const void* order);
GdElement gd_cave_get_rc (const GdCave *cave, int x, int y);
-/* direction */
+// direction
const char *gd_direction_get_visible_name(GdDirection dir);
const char *gd_direction_get_filename(GdDirection dir);
GdDirection gd_direction_from_string(const char *str);
-/* scheduling */
+// scheduling
const char *gd_scheduling_get_visible_name(GdScheduling sched);
const char *gd_scheduling_get_filename(GdScheduling sched);
GdScheduling gd_scheduling_from_string(const char *str);
-/* game playing helpers */
+// game playing helpers
#define GD_REDRAW (1 << 10)
void gd_drawcave_game(const GdCave *cave, int **element_buffer, int **gfx_buffer,
boolean bonus_life_flash, int animcycle, boolean hate_invisible_outbox);
-/* function to copy a GdString */
+// function to copy a GdString
static inline char *gd_strcpy(GdString dest, const GdString src)
{
return strncpy(dest, src, sizeof(GdString));
#include "main_bd.h"
-/* some cells are created inside the game (by merging two cells from the png etc);
- those are used only in the editor.
- this enum is used to give each and every one a different index automatically. */
+// some cells are created inside the game (by merging two cells from the png etc);
+// those are used only in the editor.
+// this enum is used to give each and every one a different index automatically.
enum _generated_cells_indexes
{
- /* the first one gets the first available index. */
- /* the following ones will be generated by the compiler automatically. */
+ // the first one gets the first available index.
+ // the following ones will be generated by the compiler automatically.
i_stonefly_1 = GD_NUM_OF_CELLS_X * GD_NUM_OF_CELLS_Y,
i_stonefly_2,
i_stonefly_3,
i_pre_invis_outbox,
i_unknown,
i_waiting_stone,
- i_pre_outbox_frame_1, /* this will have 8 frames. */
+ i_pre_outbox_frame_1, // this will have 8 frames.
i_pre_outbox_frame_2,
i_pre_outbox_frame_3,
i_pre_outbox_frame_4,
i_max_cell_num
};
-/* elements description array. do not miss an index!
- the game will check if one is missing and stop the game.
- the identifier in the saved file might also not match, reading an "outbox" from
- the file should store an O_PRE_OUTBOX.
-
- images are: image in editor, image in editor - animated, game image
- indexes which are in the png have to be given as numeric constants.
- for generated cells (ie. guard + an arrow), use the above enum
+/*
+ elements description array. do not miss an index!
+ the game will check if one is missing and stop the game.
+ the identifier in the saved file might also not match, reading an "outbox" from
+ the file should store an O_PRE_OUTBOX.
+
+ images are: image in editor, image in editor - animated, game image
+ indexes which are in the png have to be given as numeric constants.
+ for generated cells (ie. guard + an arrow), use the above enum
*/
GdElements gd_elements[] =
{
{ O_DIRT_SLOPED_UP_LEFT, N_("Sloped dirt (up & left)"), P_DIRT|P_SLOPED_UP|P_SLOPED_LEFT|P_AMOEBA_CONSUMES, "DIRTSLOPEDUPLEFT", 0, 281, 281, 281 },
{ O_DIRT_SLOPED_DOWN_LEFT, N_("Sloped dirt (down & left)"), P_DIRT|P_SLOPED_DOWN|P_SLOPED_LEFT|P_AMOEBA_CONSUMES, "DIRTSLOPEDDOWNLEFT", 0, 282, 282, 282 },
{ O_DIRT_SLOPED_DOWN_RIGHT, N_("Sloped dirt (down & right)"), P_DIRT|P_SLOPED_DOWN|P_SLOPED_RIGHT|P_AMOEBA_CONSUMES, "DIRTSLOPEDDOWNRIGHT", 0, 283, 283, 283 },
- { O_DIRT_BALL, N_("Dirt ball"), P_DIRT|P_SLOPED|P_AMOEBA_CONSUMES|P_MOVED_BY_CONVEYOR_TOP, "DIRTBALL", 0, 289, 289, 289, 120 }, /* has ckdelay */
- { O_DIRT_BALL_F, N_("Dirt ball (falling)"), 0, "DIRTBALLf", 0, 289, 289, 289, 120 }, /* has ckdelay */
- { O_DIRT_LOOSE, N_("Loose dirt"), P_DIRT|P_AMOEBA_CONSUMES|P_MOVED_BY_CONVEYOR_TOP, "DIRTLOOSE", 0, 352, 352, 352, 60 }, /* has ckdelay */
- { O_DIRT_LOOSE_F, N_("Loose dirt (falling)"), 0, "DIRTLOOSEf", 0, 352, 352, 352, 60 }, /* has ckdelay */
+ { O_DIRT_BALL, N_("Dirt ball"), P_DIRT|P_SLOPED|P_AMOEBA_CONSUMES|P_MOVED_BY_CONVEYOR_TOP, "DIRTBALL", 0, 289, 289, 289, 120 }, // has ckdelay
+ { O_DIRT_BALL_F, N_("Dirt ball (falling)"), 0, "DIRTBALLf", 0, 289, 289, 289, 120 }, // has ckdelay
+ { O_DIRT_LOOSE, N_("Loose dirt"), P_DIRT|P_AMOEBA_CONSUMES|P_MOVED_BY_CONVEYOR_TOP, "DIRTLOOSE", 0, 352, 352, 352, 60 }, // has ckdelay
+ { O_DIRT_LOOSE_F, N_("Loose dirt (falling)"), 0, "DIRTLOOSEf", 0, 352, 352, 352, 60 }, // has ckdelay
{ O_DIRT2, N_("Dirt 2"), P_DIRT|P_AMOEBA_CONSUMES, "DIRT2", 0, 3, 3, 3 },
{ O_BRICK, N_("Brick wall"), P_SLOPED|P_BLADDER_SLOPED|P_CAN_BE_HAMMERED, "WALL", 'w', 5, 5, 5 },
{ O_BRICK_SLOPED_UP_RIGHT, N_("Sloped brick wall (up & right)"), P_SLOPED_UP|P_SLOPED_RIGHT|P_BLADDER_SLOPED|P_CAN_BE_HAMMERED, "WALLSLOPEDUPRIGHT", 0, 276, 276, 276 },
{ O_STEEL_EXPLODABLE, N_("Explodable steel wall"), P_CAN_BE_HAMMERED, "STEELWALLDESTRUCTABLE", 'E', 72, 72, 4 },
{ O_STEEL_EATABLE, N_("Eatable steel wall"), 0, "STEELWALLEATABLE", 0, i_steel_eatable, i_steel_eatable, 4 },
{ O_BRICK_EATABLE, N_("Eatable brick wall"), 0, "WALLEATABLE", 0, i_brick_eatable, i_brick_eatable, 5 },
- { O_STONE, N_("Stone"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP, "BOULDER", 'r', 1, 1, 1, 156 }, /* has ckdelay */
- { O_STONE_F, N_("Stone, falling"), 0, "BOULDERf", 'R', i_stone_f, i_stone_f, 1, 156 }, /* has ckdelay */
- { O_FLYING_STONE, N_("Flying stone"), P_SLOPED|P_MOVED_BY_CONVEYOR_BOTTOM, "FLYINGBOULDER", 0, 357, 357, 357, 156 }, /* has ckdelay */
- { O_FLYING_STONE_F, N_("Flying stone, flying"), 0, "FLYINGBOULDERf", 0, i_flying_stone_f, i_flying_stone_f, 357, 156 }, /* has ckdelay */
- { O_MEGA_STONE, N_("Mega stone"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP, "MEGABOULDER", 0, 272, 272, 272, 156 }, /* has ckdelay */
- { O_MEGA_STONE_F, N_("Mega stone, falling"), 0, "MEGABOULDERf", 0, i_mega_stone_falling, i_mega_stone_falling, 272, 156 }, /* has ckdelay */
- { O_DIAMOND, N_("Diamond"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP|P_COLLECTIBLE, "DIAMOND", 'd', 248, -248, -248, 156 }, /* has ckdelay */
- { O_DIAMOND_F, N_("Diamond, falling"), 0, "DIAMONDf", 'D', i_diamond_f, i_diamond_f, -248, 156 }, /* has ckdelay */
- { O_FLYING_DIAMOND, N_("Flying diamond"), P_SLOPED|P_MOVED_BY_CONVEYOR_BOTTOM|P_COLLECTIBLE, "FLYINGDIAMOND", 0, 344, -344, -344, 156 }, /* has ckdelay */
- { O_FLYING_DIAMOND_F, N_("Flying diamond, flying"), 0, "FLYINGDIAMONDf", 0, i_flying_diamond_f, i_flying_diamond_f, -344, 156 }, /* has ckdelay */
- { O_NUT, N_("Nut"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP, "NUT", 0, 358, 358, 358, 156 }, /* has ckdelay */
- { O_NUT_F, N_("Nut, falling"), 0, "NUTf", 0, i_nut_f, i_nut_f, 358, 156 }, /* has ckdelay */
- { O_BLADDER_SPENDER, N_("Bladder Spender"), 0, "BLADDERSPENDER", 0, 6, 6, 6, 20 }, /* has ckdelay */
+ { O_STONE, N_("Stone"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP, "BOULDER", 'r', 1, 1, 1, 156 }, // has ckdelay
+ { O_STONE_F, N_("Stone, falling"), 0, "BOULDERf", 'R', i_stone_f, i_stone_f, 1, 156 }, // has ckdelay
+ { O_FLYING_STONE, N_("Flying stone"), P_SLOPED|P_MOVED_BY_CONVEYOR_BOTTOM, "FLYINGBOULDER", 0, 357, 357, 357, 156 }, // has ckdelay
+ { O_FLYING_STONE_F, N_("Flying stone, flying"), 0, "FLYINGBOULDERf", 0, i_flying_stone_f, i_flying_stone_f, 357, 156 }, // has ckdelay
+ { O_MEGA_STONE, N_("Mega stone"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP, "MEGABOULDER", 0, 272, 272, 272, 156 }, // has ckdelay
+ { O_MEGA_STONE_F, N_("Mega stone, falling"), 0, "MEGABOULDERf", 0, i_mega_stone_falling, i_mega_stone_falling, 272, 156 }, // has ckdelay
+ { O_DIAMOND, N_("Diamond"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP|P_COLLECTIBLE, "DIAMOND", 'd', 248, -248, -248, 156 }, // has ckdelay
+ { O_DIAMOND_F, N_("Diamond, falling"), 0, "DIAMONDf", 'D', i_diamond_f, i_diamond_f, -248, 156 }, // has ckdelay
+ { O_FLYING_DIAMOND, N_("Flying diamond"), P_SLOPED|P_MOVED_BY_CONVEYOR_BOTTOM|P_COLLECTIBLE, "FLYINGDIAMOND", 0, 344, -344, -344, 156 }, // has ckdelay
+ { O_FLYING_DIAMOND_F, N_("Flying diamond, flying"), 0, "FLYINGDIAMONDf", 0, i_flying_diamond_f, i_flying_diamond_f, -344, 156 }, // has ckdelay
+ { O_NUT, N_("Nut"), P_SLOPED|P_MOVED_BY_CONVEYOR_TOP, "NUT", 0, 358, 358, 358, 156 }, // has ckdelay
+ { O_NUT_F, N_("Nut, falling"), 0, "NUTf", 0, i_nut_f, i_nut_f, 358, 156 }, // has ckdelay
+ { O_BLADDER_SPENDER, N_("Bladder Spender"), 0, "BLADDERSPENDER", 0, 6, 6, 6, 20 }, // has ckdelay
{ O_INBOX, N_("Inbox"), 0, "INBOX", 'P', 35, 35, 22 },
- { O_H_EXPANDING_WALL, N_("Expanding wall, horizontal"), P_VISUAL_EFFECT | P_CAN_BE_HAMMERED, "HEXPANDINGWALL", 'x', i_h_expanding_wall, i_h_expanding_wall, 5, 111 }, /* has ckdelay */
- { O_V_EXPANDING_WALL, N_("Expanding wall, vertical"), P_VISUAL_EFFECT | P_CAN_BE_HAMMERED, "VEXPANDINGWALL", 'v', i_v_expanding_wall, i_v_expanding_wall, 5, 111 }, /* has ckdelay */
- { O_EXPANDING_WALL, N_("Expanding wall"), P_VISUAL_EFFECT | P_CAN_BE_HAMMERED, "EXPANDINGWALL", 'e', i_expanding_wall, i_expanding_wall, 5, 111 }, /* has ckdelay */
- { O_H_EXPANDING_STEEL_WALL, N_("Expanding steel wall, horizontal"), P_NON_EXPLODABLE, "HEXPANDINGSTEELWALL", 0, i_h_expanding_steel_wall, i_h_expanding_steel_wall, 4, 111 }, /* has ckdelay */
- { O_V_EXPANDING_STEEL_WALL, N_("Expanding steel wall, vertical"), P_NON_EXPLODABLE, "VEXPANDINGSTEELWALL", 0, i_v_expanding_steel_wall, i_v_expanding_steel_wall, 4, 111 }, /* has ckdelay */
- { O_EXPANDING_STEEL_WALL, N_("Expanding steel wall"), P_NON_EXPLODABLE, "EXPANDINGSTEELWALL", 0, i_expanding_steel_wall, i_expanding_steel_wall, 4, 111 }, /* has ckdelay */
+ { O_H_EXPANDING_WALL, N_("Expanding wall, horizontal"), P_VISUAL_EFFECT | P_CAN_BE_HAMMERED, "HEXPANDINGWALL", 'x', i_h_expanding_wall, i_h_expanding_wall, 5, 111 }, // has ckdelay
+ { O_V_EXPANDING_WALL, N_("Expanding wall, vertical"), P_VISUAL_EFFECT | P_CAN_BE_HAMMERED, "VEXPANDINGWALL", 'v', i_v_expanding_wall, i_v_expanding_wall, 5, 111 }, // has ckdelay
+ { O_EXPANDING_WALL, N_("Expanding wall"), P_VISUAL_EFFECT | P_CAN_BE_HAMMERED, "EXPANDINGWALL", 'e', i_expanding_wall, i_expanding_wall, 5, 111 }, // has ckdelay
+ { O_H_EXPANDING_STEEL_WALL, N_("Expanding steel wall, horizontal"), P_NON_EXPLODABLE, "HEXPANDINGSTEELWALL", 0, i_h_expanding_steel_wall, i_h_expanding_steel_wall, 4, 111 }, // has ckdelay
+ { O_V_EXPANDING_STEEL_WALL, N_("Expanding steel wall, vertical"), P_NON_EXPLODABLE, "VEXPANDINGSTEELWALL", 0, i_v_expanding_steel_wall, i_v_expanding_steel_wall, 4, 111 }, // has ckdelay
+ { O_EXPANDING_STEEL_WALL, N_("Expanding steel wall"), P_NON_EXPLODABLE, "EXPANDINGSTEELWALL", 0, i_expanding_steel_wall, i_expanding_steel_wall, 4, 111 }, // has ckdelay
{ O_EXPANDING_WALL_SWITCH, N_("Expanding wall switch"), 0, "EXPANDINGWALLSWITCH", 0, 40, 40, 40 },
{ O_CREATURE_SWITCH, N_("Creature direction switch"), 0, "FIREFLYBUTTERFLYSWITCH", 0, 18, 18, 18 },
{ O_BITER_SWITCH, N_("Biter switch"), 0, "BITERSWITCH", 0, 12, 12, 12 },
{ O_REPLICATOR_SWITCH, N_("Replicator switch"), 0, "REPLICATORSWITCH", 0, 290, 290, 290 },
{ O_CONVEYOR_SWITCH, N_("Conveyor belt power switch"), 0, "CONVEYORSWITCH", 0, 356, 356, 356 },
{ O_CONVEYOR_DIR_SWITCH, N_("Conveyor belt direction switch"), 0, "CONVEYORDIRECTIONSWITCH", 0, 353, 353, 353 },
- { O_ACID, N_("Acid"), 0, "ACID", 0, 20, 20, 20, 128 }, /* has ckdelay */
- { O_FALLING_WALL, N_("Falling wall"), P_CAN_BE_HAMMERED, "FALLINGWALL", 0, i_falling_wall, i_falling_wall, 5, 80 }, /* has ckdelay */
- { O_FALLING_WALL_F, N_("Falling wall, falling"), P_CAN_BE_HAMMERED, "FALLINGWALLf", 0, i_falling_wall_falling, i_falling_wall_falling, 5, 80 }, /* has ckdelay */
+ { O_ACID, N_("Acid"), 0, "ACID", 0, 20, 20, 20, 128 }, // has ckdelay
+ { O_FALLING_WALL, N_("Falling wall"), P_CAN_BE_HAMMERED, "FALLINGWALL", 0, i_falling_wall, i_falling_wall, 5, 80 }, // has ckdelay
+ { O_FALLING_WALL_F, N_("Falling wall, falling"), P_CAN_BE_HAMMERED, "FALLINGWALLf", 0, i_falling_wall_falling, i_falling_wall_falling, 5, 80 }, // has ckdelay
{ O_BOX, N_("Box"), 0, "SOKOBANBOX", 0, 21, 21, 21 },
{ O_TIME_PENALTY, N_("Time penalty"), P_NON_EXPLODABLE, "TIMEPENALTY", 0, i_time_penalty, i_time_penalty, 9 },
{ O_GRAVESTONE, N_("Gravestone"), P_NON_EXPLODABLE, "GRAVESTONE", 'G', 9, 9, 9 },
{ O_PNEUMATIC_HAMMER, N_("Pneumatic hammer"), P_COLLECTIBLE, "PNEUMATIC_HAMMER", 0, 62, 62, 62 },
{ O_TELEPORTER, N_("Teleporter"), 0, "TELEPORTER", 0, 61, 61, 61 },
{ O_SKELETON, N_("Skeleton"), 0, "SKELETON", 0, 273, 273, 273 },
- { O_WATER, N_("Water"), 0, "WATER", 0, 96, -96, -96, 100 }, /* has ckdelay */
+ { O_WATER, N_("Water"), 0, "WATER", 0, 96, -96, -96, 100 }, // has ckdelay
{ O_WATER_1, N_("Water (1)"), 0, "WATER1", 0, 96, -96, -96 },
{ O_WATER_2, N_("Water (2)"), 0, "WATER2", 0, 96, -96, -96 },
{ O_WATER_3, N_("Water (3)"), 0, "WATER3", 0, 96, -96, -96 },
{ O_WATER_14, N_("Water (14)"), 0, "WATER14", 0, 96, -96, -96 },
{ O_WATER_15, N_("Water (15)"), 0, "WATER15", 0, 96, -96, -96 },
{ O_WATER_16, N_("Water (16)"), 0, "WATER16", 0, 96, -96, -96 },
- { O_COW_1, N_("Cow (left)"), P_CCW, "COWl", 0, i_cow_1, -88, -88, 384 }, /* has ckdelay */
- { O_COW_2, N_("Cow (up)"), P_CCW, "COWu", 0, i_cow_2, -88, -88, 384 }, /* has ckdelay */
- { O_COW_3, N_("Cow (right)"), P_CCW, "COWr", 0, i_cow_3, -88, -88, 384 }, /* has ckdelay */
- { O_COW_4, N_("Cow (down)"), P_CCW, "COWd", 0, i_cow_4, -88, -88, 384 }, /* has ckdelay */
- { O_COW_ENCLOSED_1, N_("Cow (enclosed, 1)"), 0, "COW_ENCLOSED1", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
- { O_COW_ENCLOSED_2, N_("Cow (enclosed, 2)"), 0, "COW_ENCLOSED2", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
- { O_COW_ENCLOSED_3, N_("Cow (enclosed, 3)"), 0, "COW_ENCLOSED3", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
- { O_COW_ENCLOSED_4, N_("Cow (enclosed, 4)"), 0, "COW_ENCLOSED4", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
- { O_COW_ENCLOSED_5, N_("Cow (enclosed, 5)"), 0, "COW_ENCLOSED5", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
- { O_COW_ENCLOSED_6, N_("Cow (enclosed, 6)"), 0, "COW_ENCLOSED6", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
- { O_COW_ENCLOSED_7, N_("Cow (enclosed, 7)"), 0, "COW_ENCLOSED7", 0, i_cow_enclosed, -88, -88, 120 }, /* has ckdelay */
+ { O_COW_1, N_("Cow (left)"), P_CCW, "COWl", 0, i_cow_1, -88, -88, 384 }, // has ckdelay
+ { O_COW_2, N_("Cow (up)"), P_CCW, "COWu", 0, i_cow_2, -88, -88, 384 }, // has ckdelay
+ { O_COW_3, N_("Cow (right)"), P_CCW, "COWr", 0, i_cow_3, -88, -88, 384 }, // has ckdelay
+ { O_COW_4, N_("Cow (down)"), P_CCW, "COWd", 0, i_cow_4, -88, -88, 384 }, // has ckdelay
+ { O_COW_ENCLOSED_1, N_("Cow (enclosed, 1)"), 0, "COW_ENCLOSED1", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
+ { O_COW_ENCLOSED_2, N_("Cow (enclosed, 2)"), 0, "COW_ENCLOSED2", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
+ { O_COW_ENCLOSED_3, N_("Cow (enclosed, 3)"), 0, "COW_ENCLOSED3", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
+ { O_COW_ENCLOSED_4, N_("Cow (enclosed, 4)"), 0, "COW_ENCLOSED4", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
+ { O_COW_ENCLOSED_5, N_("Cow (enclosed, 5)"), 0, "COW_ENCLOSED5", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
+ { O_COW_ENCLOSED_6, N_("Cow (enclosed, 6)"), 0, "COW_ENCLOSED6", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
+ { O_COW_ENCLOSED_7, N_("Cow (enclosed, 7)"), 0, "COW_ENCLOSED7", 0, i_cow_enclosed, -88, -88, 120 }, // has ckdelay
{ O_WALLED_DIAMOND, N_("Walled diamond"), P_CAN_BE_HAMMERED, "WALLED_DIAMOND", 0, i_walled_diamond, i_walled_diamond, 5 },
{ O_WALLED_KEY_1, N_("Walled key 1"), P_CAN_BE_HAMMERED, "WALLED_KEY1", 0, i_walled_key_1, i_walled_key_1, 5 },
{ O_WALLED_KEY_2, N_("Walled key 2"), P_CAN_BE_HAMMERED, "WALLED_KEY2", 0, i_walled_key_2, i_walled_key_2, 5 },
{ O_WALLED_KEY_3, N_("Walled key 3"), P_CAN_BE_HAMMERED, "WALLED_KEY3", 0, i_walled_key_3, i_walled_key_3, 5 },
- { O_AMOEBA, N_("Amoeba"), P_BLOWS_UP_FLIES, "AMOEBA", 'a', 192, -192, -192, 260 }, /* has ckdelay */
- { O_AMOEBA_2, N_("Amoeba 2"), P_BLOWS_UP_FLIES|P_VISUAL_EFFECT, "AMOEBA2", 0, 296, -296, -296, 260 }, /* has ckdelay */
- { O_REPLICATOR, N_("Replicator"), P_NON_EXPLODABLE, "REPLICATOR", 0, 304, 304, 304, 210 }, /* has ckdelay */
- { O_CONVEYOR_LEFT, N_("Conveyor belt (left)"), P_NON_EXPLODABLE, "CONVEYORLEFT", 0, i_conveyor_left, -328, -328, 256 }, /* has ckdelay */
+ { O_AMOEBA, N_("Amoeba"), P_BLOWS_UP_FLIES, "AMOEBA", 'a', 192, -192, -192, 260 }, // has ckdelay
+ { O_AMOEBA_2, N_("Amoeba 2"), P_BLOWS_UP_FLIES|P_VISUAL_EFFECT, "AMOEBA2", 0, 296, -296, -296, 260 }, // has ckdelay
+ { O_REPLICATOR, N_("Replicator"), P_NON_EXPLODABLE, "REPLICATOR", 0, 304, 304, 304, 210 }, // has ckdelay
+ { O_CONVEYOR_LEFT, N_("Conveyor belt (left)"), P_NON_EXPLODABLE, "CONVEYORLEFT", 0, i_conveyor_left, -328, -328, 256 }, // has ckdelay
{ O_CONVEYOR_RIGHT, N_("Conveyor belt (right)"), P_NON_EXPLODABLE, "CONVEYORRIGHT", 0, i_conveyor_right, -320, -320 },
{ O_LAVA, N_("Lava"), P_NON_EXPLODABLE, "LAVA", 0, 312, -312, -312 },
{ O_SWEET, N_("Sweet"), P_COLLECTIBLE, "SWEET", 0, 8, 8, 8 },
{ O_VOODOO, N_("Voodoo doll"), P_BLOWS_UP_FLIES, "DUMMY", 'F', 7, 7, 7 },
- { O_SLIME, N_("Slime"), 0, "SLIME", 's', 200, -200, -200, 211 }, /* has ckdelay */
- { O_BLADDER, N_("Bladder"), 0, "BLADDER", 0, 176, -176, -176, 267 }, /* has ckdelay */
+ { O_SLIME, N_("Slime"), 0, "SLIME", 's', 200, -200, -200, 211 }, // has ckdelay
+ { O_BLADDER, N_("Bladder"), 0, "BLADDER", 0, 176, -176, -176, 267 }, // has ckdelay
{ O_BLADDER_1, N_("Bladder (1)"), 0, "BLADDERd1", 0, 176, -176, -176 },
{ O_BLADDER_2, N_("Bladder (2)"), 0, "BLADDERd2", 0, 176, -176, -176 },
{ O_BLADDER_3, N_("Bladder (3)"), 0, "BLADDERd3", 0, 176, -176, -176 },
{ O_BLADDER_7, N_("Bladder (7)"), 0, "BLADDERd7", 0, 176, -176, -176 },
{ O_BLADDER_8, N_("Bladder (8)"), 0, "BLADDERd8", 0, 176, -176, -176 },
- { O_WAITING_STONE, N_("Waiting stone"), P_SLOPED, "WAITINGBOULDER", 0, i_waiting_stone, i_waiting_stone, 1, 176 }, /* has ckdelay */
- { O_CHASING_STONE, N_("Chasing stone"), P_SLOPED, "CHASINGBOULDER", 0, 17, 17, 17, 269 }, /* has ckdelay */
- { O_GHOST, N_("Ghost"), 0, "GHOST", 'g', 160, -160, -160, 50 }, /* has ckdelay */
- { O_FIREFLY_1, N_("Guard, left"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYl", 'Q', i_guard_1, -136, -136, 384 }, /* has ckdelay */
- { O_FIREFLY_2, N_("Guard, up"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYu", 'o', i_guard_2, -136, -136, 384 }, /* has ckdelay */
- { O_FIREFLY_3, N_("Guard, right"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYr", 'O', i_guard_3, -136, -136, 384 }, /* has ckdelay */
- { O_FIREFLY_4, N_("Guard, down"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYd", 'q', i_guard_4, -136, -136, 384 }, /* has ckdelay */
- { O_ALT_FIREFLY_1, N_("Alternative guard, left"), P_EXPLODES_BY_HIT, "A_FIREFLYl", 0, i_alt_guard_1, -104, -104, 384 }, /* has ckdelay */
- { O_ALT_FIREFLY_2, N_("Alternative guard, up"), P_EXPLODES_BY_HIT, "A_FIREFLYu", 0, i_alt_guard_2, -104, -104, 384 }, /* has ckdelay */
- { O_ALT_FIREFLY_3, N_("Alternative guard, right"), P_EXPLODES_BY_HIT, "A_FIREFLYr", 0, i_alt_guard_3, -104, -104, 384 }, /* has ckdelay */
- { O_ALT_FIREFLY_4, N_("Alternative guard, down"), P_EXPLODES_BY_HIT, "A_FIREFLYd", 0, i_alt_guard_4, -104, -104, 384 }, /* has ckdelay */
- { O_BUTTER_1, N_("Butterfly, left"), P_EXPLODES_BY_HIT, "BUTTERFLYl", 'C', i_butter_1, -144, -144, 384 }, /* has ckdelay */
- { O_BUTTER_2, N_("Butterfly, up"), P_EXPLODES_BY_HIT, "BUTTERFLYu", 'b', i_butter_2, -144, -144, 384 }, /* has ckdelay */
- { O_BUTTER_3, N_("Butterfly, right"), P_EXPLODES_BY_HIT, "BUTTERFLYr", 'B', i_butter_3, -144, -144, 384 }, /* has ckdelay */
- { O_BUTTER_4, N_("Butterfly, down"), P_EXPLODES_BY_HIT, "BUTTERFLYd", 'c', i_butter_4, -144, -144, 384 }, /* has ckdelay */
- { O_ALT_BUTTER_1, N_("Alternative butterfly, left"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYl", 0, i_alt_butter_1, -112, -112, 384 }, /* has ckdelay */
- { O_ALT_BUTTER_2, N_("Alternative butterfly, up"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYu", 0, i_alt_butter_2, -112, -112, 384 }, /* has ckdelay */
- { O_ALT_BUTTER_3, N_("Alternative butterfly, right"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYr", 0, i_alt_butter_3, -112, -112, 384 }, /* has ckdelay */
- { O_ALT_BUTTER_4, N_("Alternative butterfly, down"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYd", 0, i_alt_butter_4, -112, -112, 384 }, /* has ckdelay */
- { O_STONEFLY_1, N_("Stonefly, left"), P_EXPLODES_BY_HIT, "STONEFLYl", 0, i_stonefly_1, -152, -152, 384 }, /* has ckdelay */
- { O_STONEFLY_2, N_("Stonefly, up"), P_EXPLODES_BY_HIT, "STONEFLYu", 0, i_stonefly_2, -152, -152, 384 }, /* has ckdelay */
- { O_STONEFLY_3, N_("Stonefly, right"), P_EXPLODES_BY_HIT, "STONEFLYr", 0, i_stonefly_3, -152, -152, 384 }, /* has ckdelay */
- { O_STONEFLY_4, N_("Stonefly, down"), P_EXPLODES_BY_HIT, "STONEFLYd", 0, i_stonefly_4, -152, -152, 384 }, /* has ckdelay */
- { O_BITER_1, N_("Biter, up"), 0, "BITERu", 0, i_biter_1, -168, -168, 518 }, /* has ckdelay */
- { O_BITER_2, N_("Biter, right"), 0, "BITERr", 0, i_biter_2, -168, -168, 518 }, /* has ckdelay */
- { O_BITER_3, N_("Biter, down"), 0, "BITERd", 0, i_biter_3, -168, -168, 518 }, /* has ckdelay */
- { O_BITER_4, N_("Biter, left"), 0, "BITERl", 0, i_biter_4, -168, -168, 518 }, /* has ckdelay */
- { O_DRAGONFLY_1, N_("Dragonfly, left"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYl", 0, i_dragonfly_1, -336, -336, 256 }, /* has ckdelay */
- { O_DRAGONFLY_2, N_("Dragonfly, up"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYu", 0, i_dragonfly_2, -336, -336, 256 }, /* has ckdelay */
- { O_DRAGONFLY_3, N_("Dragonfly, right"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYr", 0, i_dragonfly_3, -336, -336, 256 }, /* has ckdelay */
- { O_DRAGONFLY_4, N_("Dragonfly, down"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYd", 0, i_dragonfly_4, -336, -336, 256 }, /* has ckdelay */
+ { O_WAITING_STONE, N_("Waiting stone"), P_SLOPED, "WAITINGBOULDER", 0, i_waiting_stone, i_waiting_stone, 1, 176 }, // has ckdelay
+ { O_CHASING_STONE, N_("Chasing stone"), P_SLOPED, "CHASINGBOULDER", 0, 17, 17, 17, 269 }, // has ckdelay
+ { O_GHOST, N_("Ghost"), 0, "GHOST", 'g', 160, -160, -160, 50 }, // has ckdelay
+ { O_FIREFLY_1, N_("Guard, left"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYl", 'Q', i_guard_1, -136, -136, 384 }, // has ckdelay
+ { O_FIREFLY_2, N_("Guard, up"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYu", 'o', i_guard_2, -136, -136, 384 }, // has ckdelay
+ { O_FIREFLY_3, N_("Guard, right"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYr", 'O', i_guard_3, -136, -136, 384 }, // has ckdelay
+ { O_FIREFLY_4, N_("Guard, down"), P_EXPLODES_BY_HIT | P_CCW, "FIREFLYd", 'q', i_guard_4, -136, -136, 384 }, // has ckdelay
+ { O_ALT_FIREFLY_1, N_("Alternative guard, left"), P_EXPLODES_BY_HIT, "A_FIREFLYl", 0, i_alt_guard_1, -104, -104, 384 }, // has ckdelay
+ { O_ALT_FIREFLY_2, N_("Alternative guard, up"), P_EXPLODES_BY_HIT, "A_FIREFLYu", 0, i_alt_guard_2, -104, -104, 384 }, // has ckdelay
+ { O_ALT_FIREFLY_3, N_("Alternative guard, right"), P_EXPLODES_BY_HIT, "A_FIREFLYr", 0, i_alt_guard_3, -104, -104, 384 }, // has ckdelay
+ { O_ALT_FIREFLY_4, N_("Alternative guard, down"), P_EXPLODES_BY_HIT, "A_FIREFLYd", 0, i_alt_guard_4, -104, -104, 384 }, // has ckdelay
+ { O_BUTTER_1, N_("Butterfly, left"), P_EXPLODES_BY_HIT, "BUTTERFLYl", 'C', i_butter_1, -144, -144, 384 }, // has ckdelay
+ { O_BUTTER_2, N_("Butterfly, up"), P_EXPLODES_BY_HIT, "BUTTERFLYu", 'b', i_butter_2, -144, -144, 384 }, // has ckdelay
+ { O_BUTTER_3, N_("Butterfly, right"), P_EXPLODES_BY_HIT, "BUTTERFLYr", 'B', i_butter_3, -144, -144, 384 }, // has ckdelay
+ { O_BUTTER_4, N_("Butterfly, down"), P_EXPLODES_BY_HIT, "BUTTERFLYd", 'c', i_butter_4, -144, -144, 384 }, // has ckdelay
+ { O_ALT_BUTTER_1, N_("Alternative butterfly, left"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYl", 0, i_alt_butter_1, -112, -112, 384 }, // has ckdelay
+ { O_ALT_BUTTER_2, N_("Alternative butterfly, up"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYu", 0, i_alt_butter_2, -112, -112, 384 }, // has ckdelay
+ { O_ALT_BUTTER_3, N_("Alternative butterfly, right"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYr", 0, i_alt_butter_3, -112, -112, 384 }, // has ckdelay
+ { O_ALT_BUTTER_4, N_("Alternative butterfly, down"), P_EXPLODES_BY_HIT | P_CCW, "A_BUTTERFLYd", 0, i_alt_butter_4, -112, -112, 384 }, // has ckdelay
+ { O_STONEFLY_1, N_("Stonefly, left"), P_EXPLODES_BY_HIT, "STONEFLYl", 0, i_stonefly_1, -152, -152, 384 }, // has ckdelay
+ { O_STONEFLY_2, N_("Stonefly, up"), P_EXPLODES_BY_HIT, "STONEFLYu", 0, i_stonefly_2, -152, -152, 384 }, // has ckdelay
+ { O_STONEFLY_3, N_("Stonefly, right"), P_EXPLODES_BY_HIT, "STONEFLYr", 0, i_stonefly_3, -152, -152, 384 }, // has ckdelay
+ { O_STONEFLY_4, N_("Stonefly, down"), P_EXPLODES_BY_HIT, "STONEFLYd", 0, i_stonefly_4, -152, -152, 384 }, // has ckdelay
+ { O_BITER_1, N_("Biter, up"), 0, "BITERu", 0, i_biter_1, -168, -168, 518 }, // has ckdelay
+ { O_BITER_2, N_("Biter, right"), 0, "BITERr", 0, i_biter_2, -168, -168, 518 }, // has ckdelay
+ { O_BITER_3, N_("Biter, down"), 0, "BITERd", 0, i_biter_3, -168, -168, 518 }, // has ckdelay
+ { O_BITER_4, N_("Biter, left"), 0, "BITERl", 0, i_biter_4, -168, -168, 518 }, // has ckdelay
+ { O_DRAGONFLY_1, N_("Dragonfly, left"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYl", 0, i_dragonfly_1, -336, -336, 256 }, // has ckdelay
+ { O_DRAGONFLY_2, N_("Dragonfly, up"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYu", 0, i_dragonfly_2, -336, -336, 256 }, // has ckdelay
+ { O_DRAGONFLY_3, N_("Dragonfly, right"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYr", 0, i_dragonfly_3, -336, -336, 256 }, // has ckdelay
+ { O_DRAGONFLY_4, N_("Dragonfly, down"), P_EXPLODES_BY_HIT|P_CCW, "DRAGONFLYd", 0, i_dragonfly_4, -336, -336, 256 }, // has ckdelay
{ O_PRE_PL_1, N_("Player birth (1)"), 0, "GUYBIRTH1", 0, 32, 32, 32 },
{ O_PRE_PL_2, N_("Player birth (2)"), 0, "GUYBIRTH2", 0, 33, 33, 33 },
{ O_PRE_PL_3, N_("Player birth (3)"), 0, "GUYBIRTH3", 0, 34, 34, 34 },
- { O_PLAYER, N_("Player"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUY", 0, i_player, i_player, 35, 32 }, /* has ckdelay */
- { O_PLAYER_BOMB, N_("Player with bomb"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUYBOMB", 0, 42, 42, 42, 25 }, /* has ckdelay */
- { O_PLAYER_GLUED, N_("Glued player"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT, "GUYGLUED", 0, i_player_glued, i_player_glued, 35 }, /* is not a real player! so active x, y will not find it. no P_PLAYER bit! */
+ { O_PLAYER, N_("Player"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUY", 0, i_player, i_player, 35, 32 }, // has ckdelay
+ { O_PLAYER_BOMB, N_("Player with bomb"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUYBOMB", 0, 42, 42, 42, 25 }, // has ckdelay
+ { O_PLAYER_GLUED, N_("Glued player"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT, "GUYGLUED", 0, i_player_glued, i_player_glued, 35 }, // is not a real player! so active x, y will not find it. no P_PLAYER bit!
{ O_PLAYER_STIRRING, N_("Player stirring"), P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUYSTIRRING", 0, 256, -256, -256 },
{ O_BOMB, N_("Bomb"), P_COLLECTIBLE, "BOMB", 0, 48, 48, 48 },
{ O_NITRO_PACK_F, N_("Nitro pack, falling"), P_EXPLODES_BY_HIT, "NITROf", 0, i_nitro_pack_f, i_nitro_pack_f, 288 },
{ O_NITRO_PACK_EXPLODE, N_("Nitro pack, triggered"), P_EXPLODES_BY_HIT, "NITROtriggered", 0, i_nitro_explode, i_nitro_explode, 288 },
- { O_PRE_CLOCK_1, N_("Clock birth (1)"), P_EXPLOSION_FIRST_STAGE, "CLOCKBIRTH1", 0, 28, 28, 28, 280 }, /* has ckdelay */
- { O_PRE_CLOCK_2, N_("Clock birth (2)"), 0, "CLOCKBIRTH2", 0, 29, 29, 29, 280 }, /* has ckdelay */
- { O_PRE_CLOCK_3, N_("Clock birth (3)"), 0, "CLOCKBIRTH3", 0, 30, 30, 30, 280 }, /* has ckdelay */
- { O_PRE_CLOCK_4, N_("Clock birth (4)"), 0, "CLOCKBIRTH4", 0, 31, 31, 31, 280 }, /* has ckdelay */
- { O_PRE_DIA_1, N_("Diamond birth (1)"), P_EXPLOSION_FIRST_STAGE, "DIAMONDBIRTH1", 0, 56, 56, 56, 280 }, /* has ckdelay */
- { O_PRE_DIA_2, N_("Diamond birth (2)"), 0, "DIAMONDBIRTH2", 0, 57, 57, 57, 280 }, /* has ckdelay */
- { O_PRE_DIA_3, N_("Diamond birth (3)"), 0, "DIAMONDBIRTH3", 0, 58, 58, 58, 280 }, /* has ckdelay */
- { O_PRE_DIA_4, N_("Diamond birth (4)"), 0, "DIAMONDBIRTH4", 0, 59, 59, 59, 280 }, /* has ckdelay */
- { O_PRE_DIA_5, N_("Diamond birth (5)"), 0, "DIAMONDBIRTH5", 0, 60, 60, 60, 280 }, /* has ckdelay */
- { O_EXPLODE_1, N_("Explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "EXPLOSION1", 0, 43, 43, 43, 280 }, /* has ckdelay */
- { O_EXPLODE_2, N_("Explosion (2)"), P_EXPLOSION, "EXPLOSION2", 0, 44, 44, 44, 280 }, /* has ckdelay */
- { O_EXPLODE_3, N_("Explosion (3)"), P_EXPLOSION, "EXPLOSION3", 0, 45, 45, 45, 280 }, /* has ckdelay */
- { O_EXPLODE_4, N_("Explosion (4)"), P_EXPLOSION, "EXPLOSION4", 0, 46, 46, 46, 280 }, /* has ckdelay */
- { O_EXPLODE_5, N_("Explosion (5)"), P_EXPLOSION, "EXPLOSION5", 0, 47, 47, 47, 280 }, /* has ckdelay */
- { O_PRE_STONE_1, N_("Stone birth (1)"), P_EXPLOSION_FIRST_STAGE, "BOULDERBIRTH1", 0, 36, 36, 36, 280 }, /* has ckdelay */
- { O_PRE_STONE_2, N_("Stone birth (2)"), 0, "BOULDERBIRTH2", 0, 37, 37, 37, 280 }, /* has ckdelay */
- { O_PRE_STONE_3, N_("Stone birth (3)"), 0, "BOULDERBIRTH3", 0, 38, 38, 38, 280 }, /* has ckdelay */
- { O_PRE_STONE_4, N_("Stone birth (4)"), 0, "BOULDERBIRTH4", 0, 39, 39, 39, 280 }, /* has ckdelay */
- { O_PRE_STEEL_1, N_("Steel birth (1)"), P_EXPLOSION_FIRST_STAGE, "STEELWALLBIRTH1", 0, 24, 24, 24, 280 }, /* has ckdelay */
- { O_PRE_STEEL_2, N_("Steel birth (2)"), 0, "STEELWALLBIRTH2", 0, 25, 25, 25, 280 }, /* has ckdelay */
- { O_PRE_STEEL_3, N_("Steel birth (3)"), 0, "STEELWALLBIRTH3", 0, 26, 26, 26, 280 }, /* has ckdelay */
- { O_PRE_STEEL_4, N_("Steel birth (4)"), 0, "STEELWALLBIRTH4", 0, 27, 27, 27, 280 }, /* has ckdelay */
- { O_GHOST_EXPL_1, N_("Ghost explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "GHOSTEXPLOSION1", 0, 80, 80, 80, 280 }, /* has ckdelay */
- { O_GHOST_EXPL_2, N_("Ghost explosion (2)"), P_EXPLOSION, "GHOSTEXPLOSION2", 0, 81, 81, 81, 280 }, /* has ckdelay */
- { O_GHOST_EXPL_3, N_("Ghost explosion (3)"), P_EXPLOSION, "GHOSTEXPLOSION3", 0, 82, 82, 82, 280 }, /* has ckdelay */
- { O_GHOST_EXPL_4, N_("Ghost explosion (4)"), P_EXPLOSION, "GHOSTEXPLOSION4", 0, 83, 83, 83, 280 }, /* has ckdelay */
- { O_BOMB_EXPL_1, N_("Bomb explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "BOMBEXPLOSION1", 0, 84, 84, 84, 280 }, /* has ckdelay */
- { O_BOMB_EXPL_2, N_("Bomb explosion (2)"), P_EXPLOSION, "BOMBEXPLOSION2", 0, 85, 85, 85, 280 }, /* has ckdelay */
- { O_BOMB_EXPL_3, N_("Bomb explosion (3)"), P_EXPLOSION, "BOMBEXPLOSION3", 0, 86, 86, 86, 280 }, /* has ckdelay */
- { O_BOMB_EXPL_4, N_("Bomb explosion (4)"), P_EXPLOSION, "BOMBEXPLOSION4", 0, 87, 87, 87, 280 }, /* has ckdelay */
- { O_NITRO_EXPL_1, N_("Nitro pack explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "NITROEXPLOSION1", 0, 44, 44, 44, 280 }, /* has ckdelay */
- { O_NITRO_EXPL_2, N_("Nitro pack explosion (2)"), P_EXPLOSION, "NITROEXPLOSION2", 0, 45, 45, 45, 280 }, /* has ckdelay */
- { O_NITRO_EXPL_3, N_("Nitro pack explosion (3)"), P_EXPLOSION, "NITROEXPLOSION3", 0, 46, 46, 46, 280 }, /* has ckdelay */
- { O_NITRO_EXPL_4, N_("Nitro pack explosion (4)"), P_EXPLOSION, "NITROEXPLOSION4", 0, 47, 47, 47, 280 }, /* has ckdelay */
- { O_AMOEBA_2_EXPL_1, N_("Amoeba 2 explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "AMOEBA2EXPLOSION1", 0, 292, 292, 292, 280 }, /* has ckdelay */
- { O_AMOEBA_2_EXPL_2, N_("Amoeba 2 explosion (2)"), P_EXPLOSION, "AMOEBA2EXPLOSION2", 0, 293, 293, 293, 280 }, /* has ckdelay */
- { O_AMOEBA_2_EXPL_3, N_("Amoeba 2 explosion (3)"), P_EXPLOSION, "AMOEBA2EXPLOSION3", 0, 294, 294, 294, 280 }, /* has ckdelay */
- { O_AMOEBA_2_EXPL_4, N_("Amoeba 2 explosion (4)"), P_EXPLOSION, "AMOEBA2EXPLOSION4", 0, 295, 295, 295, 280 }, /* has ckdelay */
- { O_NUT_EXPL_1, N_("Nut explosion (1)"), P_SLOPED | P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "NUTEXPLOSION1", 0, 360, 360, 360, 280 }, /* has ckdelay */
+ { O_PRE_CLOCK_1, N_("Clock birth (1)"), P_EXPLOSION_FIRST_STAGE, "CLOCKBIRTH1", 0, 28, 28, 28, 280 }, // has ckdelay
+ { O_PRE_CLOCK_2, N_("Clock birth (2)"), 0, "CLOCKBIRTH2", 0, 29, 29, 29, 280 }, // has ckdelay
+ { O_PRE_CLOCK_3, N_("Clock birth (3)"), 0, "CLOCKBIRTH3", 0, 30, 30, 30, 280 }, // has ckdelay
+ { O_PRE_CLOCK_4, N_("Clock birth (4)"), 0, "CLOCKBIRTH4", 0, 31, 31, 31, 280 }, // has ckdelay
+ { O_PRE_DIA_1, N_("Diamond birth (1)"), P_EXPLOSION_FIRST_STAGE, "DIAMONDBIRTH1", 0, 56, 56, 56, 280 }, // has ckdelay
+ { O_PRE_DIA_2, N_("Diamond birth (2)"), 0, "DIAMONDBIRTH2", 0, 57, 57, 57, 280 }, // has ckdelay
+ { O_PRE_DIA_3, N_("Diamond birth (3)"), 0, "DIAMONDBIRTH3", 0, 58, 58, 58, 280 }, // has ckdelay
+ { O_PRE_DIA_4, N_("Diamond birth (4)"), 0, "DIAMONDBIRTH4", 0, 59, 59, 59, 280 }, // has ckdelay
+ { O_PRE_DIA_5, N_("Diamond birth (5)"), 0, "DIAMONDBIRTH5", 0, 60, 60, 60, 280 }, // has ckdelay
+ { O_EXPLODE_1, N_("Explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "EXPLOSION1", 0, 43, 43, 43, 280 }, // has ckdelay
+ { O_EXPLODE_2, N_("Explosion (2)"), P_EXPLOSION, "EXPLOSION2", 0, 44, 44, 44, 280 }, // has ckdelay
+ { O_EXPLODE_3, N_("Explosion (3)"), P_EXPLOSION, "EXPLOSION3", 0, 45, 45, 45, 280 }, // has ckdelay
+ { O_EXPLODE_4, N_("Explosion (4)"), P_EXPLOSION, "EXPLOSION4", 0, 46, 46, 46, 280 }, // has ckdelay
+ { O_EXPLODE_5, N_("Explosion (5)"), P_EXPLOSION, "EXPLOSION5", 0, 47, 47, 47, 280 }, // has ckdelay
+ { O_PRE_STONE_1, N_("Stone birth (1)"), P_EXPLOSION_FIRST_STAGE, "BOULDERBIRTH1", 0, 36, 36, 36, 280 }, // has ckdelay
+ { O_PRE_STONE_2, N_("Stone birth (2)"), 0, "BOULDERBIRTH2", 0, 37, 37, 37, 280 }, // has ckdelay
+ { O_PRE_STONE_3, N_("Stone birth (3)"), 0, "BOULDERBIRTH3", 0, 38, 38, 38, 280 }, // has ckdelay
+ { O_PRE_STONE_4, N_("Stone birth (4)"), 0, "BOULDERBIRTH4", 0, 39, 39, 39, 280 }, // has ckdelay
+ { O_PRE_STEEL_1, N_("Steel birth (1)"), P_EXPLOSION_FIRST_STAGE, "STEELWALLBIRTH1", 0, 24, 24, 24, 280 }, // has ckdelay
+ { O_PRE_STEEL_2, N_("Steel birth (2)"), 0, "STEELWALLBIRTH2", 0, 25, 25, 25, 280 }, // has ckdelay
+ { O_PRE_STEEL_3, N_("Steel birth (3)"), 0, "STEELWALLBIRTH3", 0, 26, 26, 26, 280 }, // has ckdelay
+ { O_PRE_STEEL_4, N_("Steel birth (4)"), 0, "STEELWALLBIRTH4", 0, 27, 27, 27, 280 }, // has ckdelay
+ { O_GHOST_EXPL_1, N_("Ghost explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "GHOSTEXPLOSION1", 0, 80, 80, 80, 280 }, // has ckdelay
+ { O_GHOST_EXPL_2, N_("Ghost explosion (2)"), P_EXPLOSION, "GHOSTEXPLOSION2", 0, 81, 81, 81, 280 }, // has ckdelay
+ { O_GHOST_EXPL_3, N_("Ghost explosion (3)"), P_EXPLOSION, "GHOSTEXPLOSION3", 0, 82, 82, 82, 280 }, // has ckdelay
+ { O_GHOST_EXPL_4, N_("Ghost explosion (4)"), P_EXPLOSION, "GHOSTEXPLOSION4", 0, 83, 83, 83, 280 }, // has ckdelay
+ { O_BOMB_EXPL_1, N_("Bomb explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "BOMBEXPLOSION1", 0, 84, 84, 84, 280 }, // has ckdelay
+ { O_BOMB_EXPL_2, N_("Bomb explosion (2)"), P_EXPLOSION, "BOMBEXPLOSION2", 0, 85, 85, 85, 280 }, // has ckdelay
+ { O_BOMB_EXPL_3, N_("Bomb explosion (3)"), P_EXPLOSION, "BOMBEXPLOSION3", 0, 86, 86, 86, 280 }, // has ckdelay
+ { O_BOMB_EXPL_4, N_("Bomb explosion (4)"), P_EXPLOSION, "BOMBEXPLOSION4", 0, 87, 87, 87, 280 }, // has ckdelay
+ { O_NITRO_EXPL_1, N_("Nitro pack explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "NITROEXPLOSION1", 0, 44, 44, 44, 280 }, // has ckdelay
+ { O_NITRO_EXPL_2, N_("Nitro pack explosion (2)"), P_EXPLOSION, "NITROEXPLOSION2", 0, 45, 45, 45, 280 }, // has ckdelay
+ { O_NITRO_EXPL_3, N_("Nitro pack explosion (3)"), P_EXPLOSION, "NITROEXPLOSION3", 0, 46, 46, 46, 280 }, // has ckdelay
+ { O_NITRO_EXPL_4, N_("Nitro pack explosion (4)"), P_EXPLOSION, "NITROEXPLOSION4", 0, 47, 47, 47, 280 }, // has ckdelay
+ { O_AMOEBA_2_EXPL_1, N_("Amoeba 2 explosion (1)"), P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "AMOEBA2EXPLOSION1", 0, 292, 292, 292, 280 }, // has ckdelay
+ { O_AMOEBA_2_EXPL_2, N_("Amoeba 2 explosion (2)"), P_EXPLOSION, "AMOEBA2EXPLOSION2", 0, 293, 293, 293, 280 }, // has ckdelay
+ { O_AMOEBA_2_EXPL_3, N_("Amoeba 2 explosion (3)"), P_EXPLOSION, "AMOEBA2EXPLOSION3", 0, 294, 294, 294, 280 }, // has ckdelay
+ { O_AMOEBA_2_EXPL_4, N_("Amoeba 2 explosion (4)"), P_EXPLOSION, "AMOEBA2EXPLOSION4", 0, 295, 295, 295, 280 }, // has ckdelay
+ { O_NUT_EXPL_1, N_("Nut explosion (1)"), P_SLOPED | P_EXPLOSION | P_EXPLOSION_FIRST_STAGE, "NUTEXPLOSION1", 0, 360, 360, 360, 280 }, // has ckdelay
{ O_NUT_EXPL_2, N_("Nut explosion (2)"), P_SLOPED | P_EXPLOSION, "NUTEXPLOSION2", 0, 361, 361, 361, 280 }, /* has ckdelay */ /* these are rounded!! */
- { O_NUT_EXPL_3, N_("Nut explosion (3)"), P_SLOPED | P_EXPLOSION, "NUTEXPLOSION3", 0, 362, 362, 362, 280 }, /* has ckdelay */
- { O_NUT_EXPL_4, N_("Nut explosion (4)"), P_SLOPED | P_EXPLOSION, "NUTEXPLOSION4", 0, 363, 363, 363, 280 }, /* has ckdelay */
+ { O_NUT_EXPL_3, N_("Nut explosion (3)"), P_SLOPED | P_EXPLOSION, "NUTEXPLOSION3", 0, 362, 362, 362, 280 }, // has ckdelay
+ { O_NUT_EXPL_4, N_("Nut explosion (4)"), P_SLOPED | P_EXPLOSION, "NUTEXPLOSION4", 0, 363, 363, 363, 280 }, // has ckdelay
{ O_PLAYER_PNEUMATIC_LEFT, NULL /* Player using hammer, left */, P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUYHAMMERl", 0, 265, 265, 265 },
{ O_PLAYER_PNEUMATIC_RIGHT, NULL /* Player using hammer, right */, P_BLOWS_UP_FLIES | P_EXPLODES_BY_HIT | P_PLAYER, "GUYHAMMERr", 0, 268, 268, 268 },
{ O_NONE, N_("No element"), 0, "NONE", 0, 79, 79, 79 },
{ O_MAX },
- /* these are just helpers, for all the element -> image index information to be in this array */
+ // these are just helpers, for all the element -> image index information to be in this array
{ O_FAKE_BONUS, NULL, 0, NULL, 0, 120, -120, -120 },
{ O_INBOX_CLOSED, NULL, 0, NULL, 0, 22, 22, 22 },
{ O_INBOX_OPEN, NULL, 0, NULL, 0, 23, 23, 23 },
- { O_OUTBOX_CLOSED, NULL, 0, NULL, 0, 22, 22, 22 }, /* game graphics - also for imported diego effects, but don't know if it is used anywhere in original games */
+
+ // game graphics
+ // also for imported diego effects, but don't know if it is used anywhere in original games
+ { O_OUTBOX_CLOSED, NULL, 0, NULL, 0, 22, 22, 22 },
{ O_OUTBOX_OPEN, NULL, 0, NULL, 0, 23, 23, 23 },
{ O_COVERED, NULL, 0, NULL, 0, 128, -128, -128 },
{ O_PLAYER_LEFT, NULL, P_PLAYER, NULL, 0, 232, -232, -232 },
{ -1 },
};
-/* entries. */
+// entries.
/* type given for each element;
* GD_TYPE_ELEMENT represents a combo box of gdash objects.
* GD_TAB&LABEL represents a notebook tab or a label.
- * others are self-explanatory. */
+ * others are self-explanatory.
+ */
const GdStructDescriptor gd_cave_properties[] =
{
- /* default data */
+ // default data
{"", GD_TAB, 0, N_("Cave data")},
{"Name", GD_TYPE_STRING, 0, N_("Name"), STRUCT_OFFSET(GdCave, name), 1, N_("Name of game")},
{"Description", GD_TYPE_STRING, 0, N_("Description"), STRUCT_OFFSET(GdCave, description), 1, N_("Some words about the game")},
{"Charset", GD_TYPE_STRING, 0, N_("Character set"), STRUCT_OFFSET(GdCave, charset), 1, N_("Theme used for displaying the game. Not used by GDash.")},
{"Fontset", GD_TYPE_STRING, 0, N_("Font set"), STRUCT_OFFSET(GdCave, fontset), 1, N_("Font used during the game. Not used by GDash.")},
- /* notes - a tab on its own */
+ // notes - a tab on its own
{"Story", GD_TYPE_LONGSTRING, 0, N_("Story"), STRUCT_OFFSET(GdCave, story), 1, N_("Story for the cave. It will be shown when the cave is played.")},
- /* remark - also a tab on its own */
+ // remark - also a tab on its own
{"Remark", GD_TYPE_LONGSTRING, 0, N_("Remark"), STRUCT_OFFSET(GdCave, remark), 1, N_("Remark (informative). Can contain supplementary information about the design of the cave. It is not shown during the game, only when the user requests the cave info dialog, so can also contain spoilers and hints.")},
{"", GD_TAB, 0, N_("Colors")},
{"Colors", GD_TYPE_COLOR, GD_ALWAYS_SAVE, N_("Amoeba color"), STRUCT_OFFSET(GdCave, color4), 1, N_("Amoeba color for C64 graphics")},
{"Colors", GD_TYPE_COLOR, GD_ALWAYS_SAVE, N_("Slime color"), STRUCT_OFFSET(GdCave, color5), 1, N_("Slime color for C64 graphics")},
- /* difficulty */
+ // difficulty
{"", GD_TAB, 0, N_("Difficulty")},
{"", GD_LABEL, GD_SHOW_LEVEL_LABEL, N_("Diamonds")},
{"DiamondsRequired", GD_TYPE_INT, GD_ALWAYS_SAVE, N_("Diamonds needed"), CAVE_OFFSET(level_diamonds[0]), 5, N_("Here zero means automatically count diamonds before level start. If negative, the value is subtracted from that. This is useful for totally random caves."), -100, 999},
{"CaveDelay", GD_TYPE_INT, GD_ALWAYS_SAVE, N_(" Delay (C64-style)"), CAVE_OFFSET(level_ckdelay[0]), 5, N_("The length of the delay loop between game frames. Used when milliseconds-based timing is inactive, ie. some kind of C64 or Atari scheduling is selected."), 0, 32},
{"HatchingTime", GD_TYPE_INT, 0, N_(" Hatching time (seconds)"), CAVE_OFFSET(level_hatching_delay_time[0]), 5, N_("This value sets how much the cave will move until the player enters the cave. This is used for the C64-like schedulings."), 1, 40},
- /* initial fill */
+ // initial fill
{"RandSeed", GD_TYPE_INT, GD_DONT_SHOW_IN_EDITOR, NULL /* random seed value */, CAVE_OFFSET(level_rand[0]), 5, NULL, -1, 255},
{"InitialBorder", GD_TYPE_ELEMENT, GD_DONT_SHOW_IN_EDITOR, NULL /* Initial border */, CAVE_OFFSET(initial_border), 1, NULL},
{"InitialFill", GD_TYPE_ELEMENT, GD_DONT_SHOW_IN_EDITOR, NULL /* Initial fill */, CAVE_OFFSET(initial_fill), 1, NULL},
{"RandomFill", GD_TYPE_ELEMENT, GD_DONT_SHOW_IN_EDITOR, NULL /* Random fill 4 */, CAVE_OFFSET(random_fill[3]), 1, NULL},
{"RandomFill", GD_TYPE_INT, GD_DONT_SHOW_IN_EDITOR, NULL /* Probability 4 */, CAVE_OFFSET(random_fill_probability[3]), 1, NULL, 0, 255},
- /* PLAYER */
+ // PLAYER
{"", GD_TAB, 0, N_("Player")},
- /* player */
+
+ // player
{"", GD_LABEL, 0, N_("Player movements")},
{"DiagonalMovement", GD_TYPE_BOOLEAN, 0, N_("Diagonal movements"), CAVE_OFFSET(diagonal_movements), 1, N_("Controls if the player can move diagonally.")},
{"ActiveGuyIsFirst", GD_TYPE_BOOLEAN, 0, N_("Uppermost player active"), CAVE_OFFSET(active_is_first_found), 1, N_("In 1stB, cave is scrolled to the uppermost and leftmost player found, whereas in the original game to the last one. Chasing stones also follow the active player.")},
{"", GD_LABEL, 0, N_("Sweet")},
{"PushingBoulderProb", GD_TYPE_PROBABILITY, 0, N_("Probability of pushing (%)"), CAVE_OFFSET(pushing_stone_prob_sweet), 1, N_("Chance of player managing to push a stone, every game cycle he tries. This is used after eating sweet.")},
{"PushingMegaStonesAfterSweet", GD_TYPE_BOOLEAN, 0, N_("Mega stones pushable"), CAVE_OFFSET(mega_stones_pushable_with_sweet), 1, N_("If it is true, mega stones can be pushed after eating sweet.")},
- /* pneumatic hammer */
+ // pneumatic hammer
{"", GD_LABEL, 0, N_("Pneumatic hammer")},
{"PneumaticHammer.frames", GD_TYPE_INT, 0, N_("Time for hammer (frames)"), CAVE_OFFSET(pneumatic_hammer_frame), 1, N_("This is the number of game frames, a pneumatic hammer is required to break a wall."), 1, 100},
{"PneumaticHammer.wallsreappear", GD_TYPE_BOOLEAN, 0, N_("Hammered walls reappear"), CAVE_OFFSET(hammered_walls_reappear), 1, N_("If this is set to true, walls broken with a pneumatic hammer will reappear later.")},
{"PneumaticHammer.wallsreappearframes", GD_TYPE_INT, 0, N_(" Timer for reappear (frames)"), CAVE_OFFSET(hammered_wall_reappear_frame), 1, N_("This sets the number of game frames, after hammered walls reappear, when the above setting is true."), 1, 200},
- /* clock */
+
+ // clock
{"", GD_LABEL, GD_SHOW_LEVEL_LABEL, N_("Clock")},
{"BonusTime", GD_TYPE_INT, 0, N_("Time bonus (s)"), CAVE_OFFSET(level_bonus_time), 5, N_("Bonus time when a clock is collected."), -100, 100},
- /* voodoo */
+
+ // voodoo
{"", GD_LABEL, 0, N_("Voodoo Doll")},
{"DummyProperties.diamondcollector", GD_TYPE_BOOLEAN, 0, N_("Can collect diamonds"), CAVE_OFFSET(voodoo_collects_diamonds), 1, N_("Controls if a voodoo doll can collect diamonds for the player.")},
{"DummyProperties.penalty", GD_TYPE_BOOLEAN, 0, N_("Dies if hit by a stone"), CAVE_OFFSET(voodoo_dies_by_stone), 1, N_("Controls if the voodoo doll dies if it is hit by a stone. Then the player gets a time penalty, and it is turned to a gravestone surrounded by steel wall.")},
{"DummyProperties.alwayskillsplayer", GD_TYPE_BOOLEAN, 0, N_("Any way hurt, player explodes"), CAVE_OFFSET(voodoo_any_hurt_kills_player), 1, N_("If this setting is enabled, the player will explode if the voodoo is hurt in any possible way, ie. touched by a firefly, hit by a stone or an explosion.")},
{"PenaltyTime", GD_TYPE_INT, 0, N_("Time penalty (s)"), CAVE_OFFSET(level_penalty_time), 5, N_("Penalty time when the voodoo is destroyed by a stone."), 0, 100},
- /* AMOEBA */
+ // AMOEBA
{"", GD_TAB, 0, N_("Amoeba")},
{"AmoebaProperties.immediately", GD_TYPE_BOOLEAN, 0, N_("Timer started immediately"), CAVE_OFFSET(amoeba_timer_started_immediately), 1, N_("If this flag is enabled, the amoeba slow growth timer will start at the beginning of the cave, regardless of the amoeba being let free or not. This can make a big difference when playing the cave!")},
{"AmoebaProperties.waitforhatching", GD_TYPE_BOOLEAN, 0, N_("Timer waits for hatching"), CAVE_OFFSET(amoeba_timer_wait_for_hatching), 1, N_("This determines if the amoeba timer starts before the player appearing. Amoeba can always be activated before that; but if this is set to true, the timer will not start. This setting is for compatiblity for some old imported caves. As the player is usually born within a few seconds, changing this setting makes not much difference. It is not advised to change it, set the slow growth time to fit your needs instead.")},
- /* amoeba */
+
+ // amoeba
{"", GD_LABEL, GD_SHOW_LEVEL_LABEL, N_("Amoeba")},
{"AmoebaThreshold", GD_TYPE_RATIO, 0, N_("Threshold (cells)"), CAVE_OFFSET(level_amoeba_threshold), 5, N_("If the amoeba grows more than this fraction of the cave, it is considered too big and it converts to the element specified below."), 0, 16383},
{"AmoebaTime", GD_TYPE_INT, 0, N_("Slow growth time (s)"), CAVE_OFFSET(level_amoeba_time), 5, N_("After this time, amoeba will grow very quickly."), 0, 999},
{"AMOEBA2DIAMONDeffect", GD_TYPE_EFFECT, 0, N_("If enclosed, converts to"), CAVE_OFFSET(amoeba_2_enclosed_effect), 1, N_("Controls which element an enclosed amoeba converts to.")},
{"AMOEBA2LOOKSLIKEeffect", GD_TYPE_EFFECT, 0, N_("Looks like"), CAVE_OFFSET(amoeba_2_looks_like), 1, N_("Amoeba 2 can look like any other element. Hint: it can also look like a normal amoeba. Or it can look like slime, and then you have two different colored amoebas!")},
- /* magic wall */
+ // magic wall
{"", GD_TAB, 0, N_("Magic Wall")},
{"", GD_LABEL, GD_SHOW_LEVEL_LABEL, N_("Timing")},
{"MagicWallTime", GD_TYPE_INT, 0, N_("Milling time (s)"), CAVE_OFFSET(level_magic_wall_time), 5, N_("Magic wall will stop after this time, and it cannot be activated again."), 0, 999},
{"MagicWallProperties.flyingstoneto", GD_TYPE_ELEMENT, 0, N_("Flying stone to"), CAVE_OFFSET(magic_flying_stone_to), 1, N_("If a flying stone climbs up into the magic wall, it will be turned to this element. Remember that flying stones enter the magic wall from its bottom, not from the top!")},
{"MagicWallProperties.flyingdiamondto", GD_TYPE_ELEMENT, 0, N_("Flying diamonds to"), CAVE_OFFSET(magic_flying_diamond_to), 1, N_("If a flying diamond enters the magic wall, it will be turned to this element. Remember that flying diamonds enter the magic wall from its bottom, not from the top!")},
- /* slime */
+ // slime
{"", GD_TAB, 0, N_("Slime")},
{"", GD_LABEL, GD_SHOW_LEVEL_LABEL, N_("Permeability")},
{"", GD_TYPE_BOOLEAN, GD_DONT_SAVE, N_("Predictable"), CAVE_OFFSET(slime_predictable), 1, N_("Controls if the predictable random generator is used for slime. It is required for compatibility with some older caves.")},
- /* permeabilities are "always" saved; and according to the predictability, one of them is removed. */
+
+ // permeabilities are "always" saved; and according to the predictability, one of them is removed.
{"SlimePermeability", GD_TYPE_PROBABILITY, GD_ALWAYS_SAVE, N_("Permeability (unpredictable, %)"), CAVE_OFFSET(level_slime_permeability[0]), 5, N_("This controls the rate at which elements go through the slime. Higher values represent higher probability of passing. This one is for unpredictable slime.")},
{"SlimePermeabilityC64", GD_TYPE_INT, GD_ALWAYS_SAVE, N_("Permeability (predictable, bits)"), CAVE_OFFSET(level_slime_permeability_c64[0]), 5, N_("This controls the rate at which elements go through the slime. This one is for predictable slime, and the value is used for a bitwise AND function. The values used by the C64 engines are 0, 128, 192, 224, 240, 248, 252, 254 and 255."), 0, 255},
{"SlimePredictableC64.seed", GD_TYPE_INT, 0, N_("Random seed (predictable)"), CAVE_OFFSET(level_slime_seed_c64), 5, N_("The random number seed for predictable slime. Use -1 to leave on its default. Not recommended to change. Does not affect unpredictable slime."), -1, 65535},
{"SlimeProperties", GD_TYPE_ELEMENT, 0, N_("Eats this..."), CAVE_OFFSET(slime_eats_3), 1, N_("Slime can let other elements than stone and diamond go through. It always lets a waiting or a chasing stone pass, though. Also, flying diamonds and stones, as well as bladders are always passed.")},
{"SlimeProperties", GD_TYPE_ELEMENT, 0, N_(" ... and converts to"), CAVE_OFFSET(slime_converts_3), 1, N_("Slime can let other elements than stone and diamond go through. It always lets a waiting or a chasing stone pass, though. Also, flying diamonds and stones, as well as bladders are always passed.")},
- /* ACTIVE 2 */
+ // ACTIVE 2
{"", GD_TAB, 0, N_("Other elements")},
- /* acid */
+
+ // acid
{"", GD_LABEL, 0, N_("Acid")},
{"AcidProperties", GD_TYPE_ELEMENT, 0, N_("Eats this element"), CAVE_OFFSET(acid_eats_this), 1, N_("The element which acid eats. If it cannot find any, it simply disappears.")},
{"AcidProperties", GD_TYPE_PROBABILITY, 0, N_("Spread ratio (%)"), CAVE_OFFSET(acid_spread_ratio), 1, N_("The probability at which an acid will explode and eat neighbouring elements.")},
{"ACIDEffect", GD_TYPE_EFFECT, 0, N_("Leaves this behind"), CAVE_OFFSET(acid_turns_to), 1, N_("If acid converts to an explosion puff on spreading or any other element.")},
- /* biter */
+
+ // biter
{"", GD_LABEL, 0, N_("Biter")},
{"BiterProperties", GD_TYPE_INT, 0, N_("Delay (frame)"), CAVE_OFFSET(biter_delay_frame), 1, N_("Number of frames biters wait between movements."), 0, 3},
{"BiterProperties", GD_TYPE_ELEMENT, 0, N_("Eats this"), CAVE_OFFSET(biter_eat), 1, N_("Biters eat this element. (They always eat dirt.)")},
- /* bladder */
+
+ // bladder
{"", GD_LABEL, 0, N_("Bladder")},
{"BladderProperties", GD_TYPE_ELEMENT, 0, N_("Converts to clock by touching"), CAVE_OFFSET(bladder_converts_by), 1, NULL},
- /* expanding wall */
+
+ // expanding wall
{"", GD_LABEL, 0, N_("Expanding wall")},
{"ExpandingWallDirection.changed", GD_TYPE_BOOLEAN, 0, N_("Direction changed"), CAVE_OFFSET(expanding_wall_changed), 1, N_("If this option is enabled, the direction of growing for the horizontal and vertical expanding wall is switched. As you can use both horizontal and vertical expanding walls in a cave, it is not recommended to change this setting, as it might be confusing. You should rather select the type with the correct direction from the element box when drawing the cave.")},
- /* replicator */
+
+ // replicator
{"", GD_LABEL, 0, N_("Replicator")},
{"ReplicatorActive", GD_TYPE_BOOLEAN, 0, N_("Active at start"), CAVE_OFFSET(replicators_active), 1, N_("Whether the replicators are turned on or off at the cave start.")},
{"ReplicatorDelayFrame", GD_TYPE_INT, 0, N_("Delay (frame)"), CAVE_OFFSET(replicator_delay_frame), 1, N_("Number of frames to wait between replicating elements."), 0, 100},
- /* conveyor belt */
+
+ // conveyor belt
{"", GD_LABEL, 0, N_("Conveyor belt")},
{"ConveyorBeltActive", GD_TYPE_BOOLEAN, 0, N_("Active at start"), CAVE_OFFSET(conveyor_belts_active), 1, N_("Whether the conveyor belts are moving when the cave starts.")},
{"ConveyorBeltDirection.changed", GD_TYPE_BOOLEAN, 0, N_("Direction changed"), CAVE_OFFSET(conveyor_belts_direction_changed), 1, N_("If the conveyor belts' movement is changed, ie. they are running in the opposite direction. As you can freely use left and right going versions of the conveyor belt in a cave, it is not recommended to change this setting, rather you should select the correct one from the element box when drawing.")},
- /* water */
+
+ // water
{"", GD_LABEL, 0, N_("Water")},
{"WaterProperties.doesnotflowdown", GD_TYPE_BOOLEAN, 0, N_("Does not flow downwards"), CAVE_OFFSET(water_does_not_flow_down), 1, N_("In CrDr, the water element had the odd property that it did not flow downwards, only in other directions. This flag emulates this behaviour.")},
- /* nut */
+
+ // nut
{"", GD_LABEL, 0, N_("Nut")},
{"Nut.whencrushed", GD_TYPE_ELEMENT, 0, N_("Turns to when crushed"), CAVE_OFFSET(nut_turns_to_when_crushed), 1, N_("Normally, a nut contains a diamond. If you crush it with a stone, the diamond will appear after the usual nut explosion sequence. This setting can be used to change the element the nut contains.")},
- /* EFFECTS 1 */
+ // EFFECTS 1
{"", GD_TAB, 0, N_("Effects")},
- /* cave effects */
+
+ // cave effects
{"", GD_LABEL, 0, N_("Stone and diamond effects")},
{"BOULDERfallingeffect", GD_TYPE_EFFECT, 0, N_("Falling stones convert to"), CAVE_OFFSET(stone_falling_effect), 1, N_("When a stone begins falling, it converts to this element.")},
{"BOULDERbouncingeffect", GD_TYPE_EFFECT, 0, N_("Bouncing stones convert to"), CAVE_OFFSET(stone_bouncing_effect), 1, N_("When a stone stops falling and rolling, it converts to this element.")},
{"BOMBEXPLOSIONeffect", GD_TYPE_EFFECT, 0, N_("Bombs explosions end in"), CAVE_OFFSET(bomb_explosion_effect), 1, N_("Use this setting to select the element the exploding bomb creates.")},
{"NITROEXPLOSIONeffect", GD_TYPE_EFFECT, 0, N_("Nitro explosions end in"), CAVE_OFFSET(nitro_explosion_effect), 1, N_("The nitro explosions can create some element other than space.")},
- /* EFFECTS 2 */
+ // EFFECTS 2
{"", GD_TAB, 0, N_("More effects")},
- /* visual effects */
+
+ // visual effects
{"", GD_LABEL, 0, N_("Visual effects")},
{"EXPANDINGWALLLOOKSLIKEeffect", GD_TYPE_EFFECT, 0, N_("Expanding wall looks like"), CAVE_OFFSET(expanding_wall_looks_like), 1, N_("This is a compatibility setting for old caves. If you need an expanding wall which looks like steel, you should rather choose the expanding steel wall from the element box.")},
{"DIRTLOOKSLIKEeffect", GD_TYPE_EFFECT, 0, N_("Dirt looks like"), CAVE_OFFSET(dirt_looks_like), 1, N_("Compatibility setting. Use it wisely! Anything other than Dirt 2 (which can be used to emulate the Dirt Mod) is not recommended.")},
- /* creature effects */
+ // creature effects
{"", GD_LABEL, 0, N_("Creature movement")},
{"EnemyDirectionProperties.startbackwards", GD_TYPE_BOOLEAN, 0, N_("Start backwards"), CAVE_OFFSET(creatures_backwards), 1, N_("Whether the direction creatures travel will already be switched at the cave start.")},
{"EnemyDirectionProperties.time", GD_TYPE_INT, 0, N_("Automatically turn (s)"), CAVE_OFFSET(creatures_direction_auto_change_time), 1, N_("If this is greater than zero, creatures will automatically change direction in every x seconds."), 0, 999},
{"EnemyDirectionProperties.changeathatching", GD_TYPE_BOOLEAN, 0, N_("Auto turn on hatching"), CAVE_OFFSET(creatures_direction_auto_change_on_start), 1, N_("If this is set to true, creatures also turn at the start signal. If false, the first change in direction occurs only later.")},
- /* gravity */
+
+ // gravity
{"", GD_LABEL, 0, N_("Gravitation change")},
{"Gravitation", GD_TYPE_DIRECTION, 0, N_("Direction"), CAVE_OFFSET(gravity), 1, N_("The direction where stones and diamonds fall.")},
{"GravitationSwitchActive", GD_TYPE_BOOLEAN, 0, N_("Switch active at start"), CAVE_OFFSET(gravity_switch_active), 1, N_("If set to true, the gravitation switch will be already activated, when the cave is started, as if a pot has already been collected.")},
{"SkeletonsForPot", GD_TYPE_INT, 0, N_("Skeletons needed for pot"), CAVE_OFFSET(skeletons_needed_for_pot), 1, N_("The number of skeletons to be collected to be able to use a pot."), 0, 50},
{"GravitationChangeDelay", GD_TYPE_INT, 0, N_("Gravitation switch delay"), CAVE_OFFSET(gravity_change_time), 1, N_("The gravitation changes after a while using the gravitation switch. This option sets the number of seconds to wait."), 1, 60},
- /* SOUND */
+ // SOUND
{"", GD_TAB, 0, N_("Sound")},
{"", GD_LABEL, 0, N_("Sound for elements")},
{"Diamond.sound", GD_TYPE_BOOLEAN, 0, N_("Diamond"), CAVE_OFFSET(diamond_sound), 1, N_("If true, falling diamonds will have sound.")},
{"GravityChange.sound", GD_TYPE_BOOLEAN, 0, N_("Gravity change"), CAVE_OFFSET(gravity_change_sound), 1, N_("If true, the gravity changing will make sound.")},
{"EnemyDirectionProperties.sound", GD_TYPE_BOOLEAN, 0, N_("Creature direction change"), CAVE_OFFSET(creature_direction_auto_change_sound), 1, N_("If this is set to true, creatures changing direction will be signaled by a sound.")},
- /* COMPATIBILITY */
+ // COMPATIBILITY
{"", GD_TAB, 0, N_("Compatibility")},
{"", GD_LABEL, 0, N_("Skeleton")},
{"SkeletonsWorthDiamonds", GD_TYPE_INT, GD_COMPATIBILITY_SETTING, N_("Skeletons worth diamonds"), CAVE_OFFSET(skeletons_worth_diamonds), 1, N_("The number of diamonds each skeleton is worth. Normally skeletons are used for letting the player use the pot! They are not intended to be used as a second kind of diamond."), 0, 10},
{"ShortExplosions", GD_TYPE_BOOLEAN, 0, N_("Short explosions"), CAVE_OFFSET(short_explosions), 1, N_("In 1stB and newer engines, explosions were longer, they took five cave frames to complete, as opposed to four frames in the original.")},
{"GravityAffectsAll", GD_TYPE_BOOLEAN, 0, N_("Gravity change affects everything"), CAVE_OFFSET(gravity_affects_all), 1, N_("If this is enabled, changing the gravity will also affect bladders (moving and pushing), bladder spenders, falling walls and waiting stones. Otherwise, those elements behave as gravity was always pointing downwards. This is a compatibility setting which is not recommended to change. It is intended for imported caves.")},
- {NULL} /* end of array */
+ {NULL} // end of array
};
-/* entries. */
-/* type given for each element */
+// entries.
+// type given for each element
const GdStructDescriptor gd_replay_properties[] =
{
- /* default data */
+ // default data
{"", GD_TAB, 0, N_("Replay")},
{"Level", GD_TYPE_INT, 0, NULL, STRUCT_OFFSET(GdReplay, level), 1, NULL},
{"RandomSeed", GD_TYPE_INT, 0, NULL, STRUCT_OFFSET(GdReplay, seed), 1, NULL},
- // {"Saved", GD_TYPE_BOOLEAN, 0, NULL, STRUCT_OFFSET(GdReplay, saved), 1, NULL}, /* no need to state in bdcff, as saved replays are saved ones :) */
+ // {"Saved", GD_TYPE_BOOLEAN, 0, NULL, STRUCT_OFFSET(GdReplay, saved), 1, NULL},
+ // no need to state in bdcff, as saved replays are saved ones :)
{"Player", GD_TYPE_STRING, 0, NULL, STRUCT_OFFSET(GdReplay, player_name), 1, NULL},
{"Date", GD_TYPE_STRING, 0, NULL, STRUCT_OFFSET(GdReplay, date), 1, NULL},
{"Comment", GD_TYPE_LONGSTRING, 0, NULL, STRUCT_OFFSET(GdReplay, comment), 1, NULL},
{"Success", GD_TYPE_BOOLEAN, 0, NULL, STRUCT_OFFSET(GdReplay, success), 1, NULL},
{"Checksum", GD_TYPE_INT, 0, NULL, STRUCT_OFFSET(GdReplay, checksum), 1, NULL},
- {NULL} /* end of array */
+ {NULL} // end of array
};
GdPropertyDefault gd_cave_defaults_gdash[] =
{
- /* default data */
+ // default data
{CAVE_OFFSET(selectable), TRUE},
{CAVE_OFFSET(intermission), FALSE},
{CAVE_OFFSET(intermission_instantlife), FALSE},
{CAVE_OFFSET(color4), 5},
{CAVE_OFFSET(color5), 6},
- /* difficulty */
+ // difficulty
{CAVE_OFFSET(level_diamonds[0]), 10},
{CAVE_OFFSET(diamond_value), 0},
{CAVE_OFFSET(extra_diamond_value), 0},
{CAVE_OFFSET(level_hatching_delay_frame[0]), 21},
{CAVE_OFFSET(level_rand[0]), 0},
- /* initial fill */
+ // initial fill
{CAVE_OFFSET(initial_border), O_STEEL},
{CAVE_OFFSET(initial_fill), O_DIRT},
{CAVE_OFFSET(random_fill[0]), O_DIRT},
{CAVE_OFFSET(random_fill[3]), O_DIRT},
{CAVE_OFFSET(random_fill_probability[3]), 0},
- /* PLAYER */
+ // PLAYER
{CAVE_OFFSET(diagonal_movements), FALSE},
{CAVE_OFFSET(active_is_first_found), TRUE},
{CAVE_OFFSET(snap_element), O_SPACE},
{CAVE_OFFSET(voodoo_any_hurt_kills_player), FALSE},
{CAVE_OFFSET(level_penalty_time), 30},
- /* magic wall */
+ // magic wall
{CAVE_OFFSET(level_magic_wall_time), 999},
{CAVE_OFFSET(magic_diamond_to), O_STONE_F},
{CAVE_OFFSET(magic_stone_to), O_DIAMOND_F},
{CAVE_OFFSET(magic_flying_diamond_to), O_FLYING_STONE_F},
{CAVE_OFFSET(magic_wall_stops_amoeba), TRUE},
{CAVE_OFFSET(magic_timer_wait_for_hatching), FALSE},
- /* amoeba */
+
+ // amoeba
{CAVE_OFFSET(amoeba_timer_started_immediately), TRUE},
{CAVE_OFFSET(amoeba_timer_wait_for_hatching), FALSE},
{CAVE_OFFSET(amoeba_timer_wait_for_hatching), FALSE},
{CAVE_OFFSET(amoeba_too_big_effect), O_STONE},
{CAVE_OFFSET(amoeba_enclosed_effect), O_DIAMOND},
- /* amoeba */
+
+ // amoeba
{CAVE_OFFSET(level_amoeba_2_threshold), 200},
{CAVE_OFFSET(amoeba_2_growth_prob), 31250},
{CAVE_OFFSET(amoeba_2_fast_growth_prob), 250000},
{CAVE_OFFSET(amoeba_2_looks_like), O_AMOEBA_2},
{CAVE_OFFSET(amoeba_2_explosion_effect), O_SPACE},
- /* water */
+ // water
{CAVE_OFFSET(water_does_not_flow_down), FALSE},
- /* nut */
+ // nut
{CAVE_OFFSET(nut_turns_to_when_crushed), O_NUT_EXPL_1},
- /* replicator */
+
+ // replicator
{CAVE_OFFSET(replicator_delay_frame), 4},
{CAVE_OFFSET(replicators_active), TRUE},
- /* conveyor belt */
+ // conveyor belt
{CAVE_OFFSET(conveyor_belts_active), TRUE},
{CAVE_OFFSET(conveyor_belts_direction_changed), FALSE},
- /* slime */
+ // slime
{CAVE_OFFSET(slime_predictable), TRUE},
{CAVE_OFFSET(level_slime_seed_c64), -1},
{CAVE_OFFSET(level_slime_permeability_c64), 0},
{CAVE_OFFSET(slime_eats_3), O_NUT},
{CAVE_OFFSET(slime_converts_3), O_NUT_F},
- /* acid */
+ // acid
{CAVE_OFFSET(acid_eats_this), O_DIRT},
{CAVE_OFFSET(acid_spread_ratio), 31250},
{CAVE_OFFSET(acid_turns_to), O_EXPLODE_3},
- /* biter */
+ // biter
{CAVE_OFFSET(biter_delay_frame), 0},
{CAVE_OFFSET(biter_eat), O_DIAMOND},
- /* bladder */
+ // bladder
{CAVE_OFFSET(bladder_converts_by), O_VOODOO},
- /* SOUND */
+ // SOUND
{CAVE_OFFSET(amoeba_sound), TRUE},
{CAVE_OFFSET(magic_wall_sound), TRUE},
{CAVE_OFFSET(slime_sound), TRUE},
{CAVE_OFFSET(gravity_change_sound), TRUE},
{CAVE_OFFSET(creature_direction_auto_change_sound), TRUE},
- /* creature effects */
+ // creature effects
{CAVE_OFFSET(creatures_backwards), FALSE},
{CAVE_OFFSET(creatures_direction_auto_change_time), 0},
{CAVE_OFFSET(creatures_direction_auto_change_on_start), FALSE},
- /* cave effects */
+
+ // cave effects
{CAVE_OFFSET(explosion_effect), O_SPACE},
{CAVE_OFFSET(diamond_birth_effect), O_DIAMOND},
{CAVE_OFFSET(bomb_explosion_effect), O_BRICK},
{CAVE_OFFSET(stone_bouncing_effect), O_STONE},
{CAVE_OFFSET(diamond_falling_effect), O_DIAMOND_F},
{CAVE_OFFSET(diamond_bouncing_effect), O_DIAMOND},
- /* visual effects */
+
+ // visual effects
{CAVE_OFFSET(expanding_wall_looks_like), O_BRICK},
{CAVE_OFFSET(dirt_looks_like), O_DIRT},
- /* gravity */
+
+ // gravity
{CAVE_OFFSET(gravity), GD_MV_DOWN},
{CAVE_OFFSET(gravity_switch_active), FALSE},
{CAVE_OFFSET(skeletons_needed_for_pot), 5},
{CAVE_OFFSET(gravity_change_time), 10},
- /* COMPATIBILITY */
+ // COMPATIBILITY
{CAVE_OFFSET(border_scan_first_and_last), TRUE},
{CAVE_OFFSET(lineshift), FALSE},
{CAVE_OFFSET(wraparound_objects), FALSE},
{-1},
};
-/* return new element, which appears after elem is hammered. */
-/* returns o_none, if elem is invalid for hammering. */
+// return new element, which appears after elem is hammered.
+// returns o_none, if elem is invalid for hammering.
GdElement gd_element_get_hammered(GdElement elem)
{
switch (elem)
{
- /* what is under the pneumatic hammer? */
+ // what is under the pneumatic hammer?
case O_WALLED_KEY_1:
return O_KEY_1;
HashTable *pointers;
boolean lowercase_names = TRUE;
- /* TRANSLATORS: some languages (for example, german) do not have lowercase nouns. */
- /* When gdash generates the list of lowercase element names, this has to be */
- /* taken into account. Therefore we have a string, which must be changed */
- /* by the translator to select the behavior. */
- /* For example, the name of the element is "Brick wall", as in a button, it has to be */
- /* written with an uppercase initial. But if "Line of brick wall", the B is changed to b. */
- /* However, this is not allowed in some languages, for example, German. */
- /* So one writes "Ziegelmauer", and "Linie aus Ziegelmauer", the Z is not changed to z. */
- /* Set the translated string to "lowercase-element-names-yes", if your language */
- /* allows writing nouns with lowercase initials. Set it to "lowercase-element-names-no", */
- /* if not: for example, german. Do not translate the string, but set the behavior! */
+ // TRANSLATORS: some languages (for example, german) do not have lowercase nouns.
+ // When gdash generates the list of lowercase element names, this has to be
+ // taken into account. Therefore we have a string, which must be changed
+ // by the translator to select the behavior.
+ // For example, the name of the element is "Brick wall", as in a button, it has to be
+ // written with an uppercase initial. But if "Line of brick wall", the B is changed to b.
+ // However, this is not allowed in some languages, for example, German.
+ // So one writes "Ziegelmauer", and "Linie aus Ziegelmauer", the Z is not changed to z.
+ // Set the translated string to "lowercase-element-names-yes", if your language
+ // allows writing nouns with lowercase initials. Set it to "lowercase-element-names-no",
+ // if not: for example, german. Do not translate the string, but set the behavior!
if (strEqual(_("lowercase-element-names-yes"), "lowercase-element-names-no"))
lowercase_names = FALSE;
- /* check element database for faults. */
+ // check element database for faults.
for (i = 0; gd_elements[i].element != -1; i++)
{
if (gd_elements[i].element != i)
Error("element: i:0x%x != 0x%x", i, gd_elements[i].element);
- /* if it has a name, create a lowercase name (of the translated one).
- will be used by the editor */
+ // if it has a name, create a lowercase name (of the translated one).
+ // will be used by the editor
if (gd_elements[i].name)
{
if (lowercase_names)
- /* the function allocates a new string, but it is needed as long as the app is running */
+ // the function allocates a new string, but it is needed as long as the app is running
gd_elements[i].lowercase_name = getStringToLower(gettext(gd_elements[i].name));
else
- /* only translate, no lowercase. */
+ // only translate, no lowercase.
gd_elements[i].lowercase_name = gettext(gd_elements[i].name);
}
- /* we do not like generated pixbufs for games. only those that are in the png. */
+ // we do not like generated pixbufs for games. only those that are in the png.
if (ABS(gd_elements[i].image_game) > GD_NUM_OF_CELLS_X * GD_NUM_OF_CELLS_Y)
Error("game pixbuf for element %x (%s) bigger than png size", i, gd_elements[i].name);
Error("element %x (%s) can be hammered, but get_hammered_element does not define another one", i, gd_elements[i].name);
}
- /* NOT REALLY NEEDED ANYMORE, as the enum takes care of it.
- maybe to show that there is an unnecessary one. */
+ /*
+ NOT REALLY NEEDED ANYMORE, as the enum takes care of it.
+ maybe to show that there is an unnecessary one.
+ */
/*
g_print("Free pixbuf indexes: ");
for (i = GD_NUM_OF_CELLS_X*GD_NUM_OF_CELLS_Y; i<GD_NUM_OF_CELLS; i++)
g_print("\n");
*/
- /* uncomment this, to show free element->character characters. */
+ // uncomment this, to show free element->character characters.
/*
gd_create_char_to_element_table();
g_print("Free characters: ");
g_print("\n");
*/
- /* check the cave property database for faults. */
+ // check the cave property database for faults.
pointers = create_hashtable(get_hash_from_integer, hash_key_integers_are_equal, NULL, NULL);
for (i = 0; gd_cave_properties[i].identifier != NULL; i++)
{
case GD_LABEL:
case GD_TAB:
- /* some lines are used for the user interface. these should not have
- an identifier. */
+ // some lines are used for the user interface. these should not have an identifier.
if (strcmp(gd_cave_properties[i].identifier, "") != 0)
{
Error ("ui lines in cave properties should not have identifiers: %s",
break;
case GD_TYPE_STRING:
- /* check if any of the properties are designated as string arrays.
- they are not supported in
- * file read/write and operations, also they do not even make any sense! */
+ // check if any of the properties are designated as string arrays.
+ // they are not supported in file read/write and operations,
+ // also they do not even make any sense!
if (gd_cave_properties[i].count != 1)
{
Error ("string arrays have no sense in cave properties: %s",
break;
case GD_TYPE_EFFECT:
- /* the same applies for effects. */
+ // the same applies for effects.
if (gd_cave_properties[i].count != 1)
{
Error ("effect arrays not supported in cave properties: %s",
break;
case GD_TYPE_COLOR:
- /* the same applies for effects. */
+ // the same applies for effects.
if (gd_cave_properties[i].count != 1)
{
Error ("color arrays not supported in cave properties: %s",
{
const char *another_prop;
- /* other types */
- /* check if its pointer is not the same as another one's */
- /* +1 is added so it is never zero */
+ // other types
+ // check if its pointer is not the same as another one's
+ // +1 is added so it is never zero
if (!(gd_cave_properties[i].flags & GD_DONT_SAVE) && strcmp(gd_cave_properties[i].identifier, "") == 0)
{
Error ("property should have a bdcff identifier: line %d, name %s",
}
else
{
- /* value is the identifier, so we can report the OLD one if the check fails */
+ // value is the identifier, so we can report the OLD one if the check fails
hashtable_insert(pointers, INT_TO_PTR(gd_cave_properties[i].offset + 1),
gd_cave_properties[i].identifier);
}
extern GdPropertyDefault gd_cave_defaults_gdash[];
-/* do some checks on the cave db */
+// do some checks on the cave db
void gd_cave_db_init(void);
GdElement gd_element_get_hammered(GdElement elem);
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-/* IMPORTANT NOTES */
+// IMPORTANT NOTES
/*
* LAVA.
#include "main_bd.h"
-/* for gravity */
+// for gravity
static const GdDirection ccw_eighth[] =
{
GD_MV_STILL,
GD_MV_DOWN_RIGHT
};
-/* sets timeout sound. */
+// sets timeout sound.
void gd_cave_set_seconds_sound(GdCave *cave)
{
// when not counting bonus time, timeout sounds will be played by main game engine;
!game.use_native_bd_sound_engine)
return;
- /* this is an integer division, so 0 seconds can be 0.5 seconds... */
- /* also, when this reaches 8, the player still has 8.9999 seconds.
- so the sound is played at almost t = 9s. */
+ // this is an integer division, so 0 seconds can be 0.5 seconds...
+ // also, when this reaches 8, the player still has 8.9999 seconds.
+ // so the sound is played at almost t = 9s.
switch (cave->time / cave->timing_factor)
{
case 9: gd_sound_play(cave, GD_S_TIMEOUT_10, O_NONE, -1, -1); break;
}
}
-/* play diamond or stone sound of given element. */
+// play diamond or stone sound of given element.
static void play_sound_of_element(GdCave *cave, GdElement element, int x, int y)
{
- /* stone and diamond fall sounds. */
+ // stone and diamond fall sounds.
switch (element)
{
case O_NUT:
break;
default:
- /* do nothing. */
+ // do nothing.
break;
}
}
-/* play sound of given element being pushed. */
+// play sound of given element being pushed.
static void play_sound_of_element_pushing(GdCave *cave, GdElement element, int x, int y)
{
switch (element)
break;
default:
- /* do nothing. */
+ // do nothing.
break;
}
}
return cave->gety(cave, x, y);
}
-/* perfect (non-lineshifting) GET x/y functions; returns range corrected x/y position */
+// perfect (non-lineshifting) GET x/y functions; returns range corrected x/y position
static inline int getx_perfect(const GdCave *cave, const int x, const int y)
{
return (x + cave->w) % cave->w;
return (y + cave->h) % cave->h;
}
-/* line shifting GET x/y function; returns range corrected x/y position */
+// line shifting GET x/y function; returns range corrected x/y position
static inline int getx_shift(const GdCave *cave, int x, int y)
{
return (x + cave->w) % cave->w;
*/
static inline GdElement *getp_perfect(const GdCave *cave, const int x, const int y)
{
- /* (x + n) mod n: this works also for x >= n and -n + 1 < x < 0 */
+ // (x + n) mod n: this works also for x >= n and -n + 1 < x < 0
return &(cave->map[(y + cave->h) % cave->h][(x + cave->w) % cave->w]);
}
return *getp(cave, x, y);
}
-/* returns an element which is somewhere near x,y */
+// returns an element which is somewhere near x,y
static inline GdElement get_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
return (gd_elements[get_dir(cave, x, y, dir) & O_MASK].properties & P_EXPLODES_BY_HIT) != 0;
}
-/* returns true if the element is not explodable, for example the steel wall */
+// returns true if the element is not explodable, for example the steel wall
static inline boolean non_explodable(const GdCave *cave, const int x, const int y)
{
return (gd_elements[get(cave, x,y) & O_MASK].properties & P_NON_EXPLODABLE) != 0;
}
-/* returns true if the element can be eaten by the amoeba, eg. space and dirt. */
+// returns true if the element can be eaten by the amoeba, eg. space and dirt.
static inline boolean amoeba_eats_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
return (gd_elements[get_dir(cave, x, y, dir) & O_MASK].properties & P_AMOEBA_CONSUMES) != 0;
}
-/* returns true if the element is sloped, so stones and diamonds roll down on it.
- for example a stone or brick wall */
+// returns true if the element is sloped, so stones and diamonds roll down on it.
+// for example a stone or brick wall
static inline boolean sloped_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir, const GdDirection slop)
{
return FALSE;
}
-/* returns true if the element is sloped for bladder movement
- (brick = yes, diamond = no, for example) */
+// returns true if the element is sloped for bladder movement
+// (brick = yes, diamond = no, for example)
static inline boolean sloped_for_bladder_dir (const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
return (gd_elements[get_dir(cave, x, y, dir) & O_MASK].properties & P_BLOWS_UP_FLIES) != 0;
}
-/* returns true if the element is a counter-clockwise creature */
+// returns true if the element is a counter-clockwise creature
static inline boolean rotates_ccw (const GdCave *cave, const int x, const int y)
{
return (gd_elements[get(cave, x, y) & O_MASK].properties & P_CCW) != 0;
}
-/* returns true if the element is a player */
+// returns true if the element is a player
static inline boolean is_player(const GdCave *cave, const int x, const int y)
{
return (gd_elements[get(cave, x, y) & O_MASK].properties & P_PLAYER) != 0;
}
-/* returns true if the element is a player */
+// returns true if the element is a player
static inline boolean is_player_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
return (gd_elements[get_dir(cave, x, y, dir) & O_MASK].properties & P_CAN_BE_HAMMERED) != 0;
}
-/* returns true if the element is explodable and explodes to space, for example the player */
+// returns true if the element is explodable and explodes to space, for example the player
static inline boolean is_first_stage_of_explosion(const GdCave *cave, const int x, const int y)
{
return (gd_elements[get(cave, x, y) & O_MASK].properties & P_EXPLOSION_FIRST_STAGE) != 0;
}
-/* returns true if the element is moved by the conveyor belt */
+// returns true if the element is moved by the conveyor belt
static inline boolean moved_by_conveyor_top_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
return (gd_elements[get_dir(cave, x, y, dir) & O_MASK].properties & P_MOVED_BY_CONVEYOR_TOP) != 0;
}
-/* returns true if the element is moved by the conveyor belt */
+// returns true if the element is moved by the conveyor belt
static inline boolean moved_by_conveyor_bottom_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
return (get_dir(cave, x, y, dir) & SCANNED) != 0;
}
-/* returns true if neighbouring element is "e" */
-/* treats dirt specially */
-/* treats lava specially */
+// returns true if neighbouring element is "e"
+// treats dirt specially
+// treats lava specially
static inline boolean is_element_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir, GdElement e)
{
GdElement examined = get_dir(cave, x, y, dir);
- /* if it is a dirt-like, change to dirt, so equality will evaluate to true */
+ // if it is a dirt-like, change to dirt, so equality will evaluate to true
if (gd_elements[examined & O_MASK].properties & P_DIRT)
examined = O_DIRT;
if (gd_elements[e & O_MASK].properties & P_DIRT)
e = O_DIRT;
- /* if the element on the map is a lava, it should be like space */
+ // if the element on the map is a lava, it should be like space
if (examined == O_LAVA)
examined = O_SPACE;
return (e == examined);
}
-/* returns true if neighbouring element is space */
+// returns true if neighbouring element is space
static inline boolean is_space_dir(const GdCave *cave, const int x, const int y,
const GdDirection dir)
{
static inline void store_dir_buffer(GdCave *cave, const int x, const int y, const GdDirection dir)
{
- /* raw values without range correction */
+ // raw values without range correction
int raw_x = x + gd_dx[dir];
int raw_y = y + gd_dy[dir];
- /* final values with range correction */
+
+ // final values with range correction
int new_x = getx(cave, raw_x, raw_y);
int new_y = gety(cave, raw_x, raw_y);
int new_dir = (dir > GD_MV_TWICE ? dir - GD_MV_TWICE : dir);
game_bd.game->dir_buffer[new_y][new_x] = new_dir;
}
-/* store an element at the given position */
+// store an element at the given position
static inline void store(GdCave *cave, const int x, const int y, const GdElement element)
{
GdElement *e = getp(cave, x, y);
*e = element;
}
-/* store an element with SCANNED flag turned on */
+// store an element with SCANNED flag turned on
static inline void store_sc(GdCave *cave, const int x, const int y, const GdElement element)
{
store(cave, x, y, element | SCANNED);
}
-/* store an element to a neighbouring cell */
+// store an element to a neighbouring cell
static inline void store_dir(GdCave *cave, const int x, const int y,
const GdDirection dir, const GdElement element)
{
store(cave, x + gd_dx[dir], y + gd_dy[dir], element | SCANNED);
}
-/* store an element to a neighbouring cell */
+// store an element to a neighbouring cell
static inline void store_dir_no_scanned(GdCave *cave, const int x, const int y,
const GdDirection dir, const GdElement element)
{
store(cave, x + gd_dx[dir], y + gd_dy[dir], element);
}
-/* move element to direction; then place space at x, y */
+// move element to direction; then place space at x, y
static inline void move(GdCave *cave, const int x, const int y,
const GdDirection dir, const GdElement e)
{
store(cave, x, y, O_SPACE);
}
-/* increment a cave element; can be used for elements which are one after
- the other, for example bladder1, bladder2, bladder3... */
+// increment a cave element; can be used for elements which are one after
+// the other, for example bladder1, bladder2, bladder3...
static inline void next(GdCave *cave, const int x, const int y)
{
(*getp(cave, x, y))++;
cave->voodoo_touched = TRUE;
if (get(cave, x, y) == O_VOODOO && !cave->voodoo_disappear_in_explosion)
- /* voodoo turns into a time penalty */
+ // voodoo turns into a time penalty
store_sc(cave, x, y, O_TIME_PENALTY);
else if (get(cave, x, y) == O_NITRO_PACK ||
get(cave, x, y) == O_NITRO_PACK_F)
- /* nitro pack inside an explosion - it is now triggered */
+ // nitro pack inside an explosion - it is now triggered
store_sc(cave, x, y, O_NITRO_PACK_EXPLODE);
else
- /* for everything else */
+ // for everything else
store_sc(cave, x, y, explode_to);
}
-/* a creature explodes to a 3x3 something. */
+// a creature explodes to a 3x3 something.
static void creature_explode(GdCave *cave, int x, int y, GdElement explode_to)
{
int xx, yy;
- /* the processing of an explosion took pretty much time: processing 3x3 = 9 elements */
+ // the processing of an explosion took pretty much time: processing 3x3 = 9 elements
cave->ckdelay += 1200;
gd_sound_play(cave, GD_S_EXPLODING, get(cave, x, y), x, y);
{
int xx, yy;
- /* the processing of an explosion took pretty much time: processing 3x3 = 9 elements */
+ // the processing of an explosion took pretty much time: processing 3x3 = 9 elements
cave->ckdelay += 1200;
gd_sound_play(cave, GD_S_NITRO_PACK_EXPLODING, get(cave, x, y), x, y);
for (xx = x - 1; xx <= x + 1; xx++)
cell_explode(cave, xx, yy, O_NITRO_EXPL_1);
- /* the current cell is explicitly changed into a nitro expl,
- as cell_explode changes it to a triggered nitro pack */
+ // the current cell is explicitly changed into a nitro expl,
+ // as cell_explode changes it to a triggered nitro pack
store_sc(cave, x, y, O_NITRO_EXPL_1);
}
-/* a voodoo explodes, leaving a 3x3 steel and a time penalty behind. */
+// a voodoo explodes, leaving a 3x3 steel and a time penalty behind.
static void voodoo_explode(GdCave *cave, int x, int y)
{
int xx, yy;
- /* the processing of an explosion took pretty much time: processing 3x3 = 9 elements */
+ // the processing of an explosion took pretty much time: processing 3x3 = 9 elements
cave->ckdelay += 1000;
gd_sound_play(cave, GD_S_VOODOO_EXPLODING, get(cave, x, y), x, y);
if (cave->voodoo_any_hurt_kills_player)
cave->voodoo_touched = TRUE;
- /* voodoo explodes to 3x3 steel */
+ // voodoo explodes to 3x3 steel
for (yy = y - 1; yy <= y + 1; yy++)
for (xx = x - 1; xx <= x + 1; xx++)
store_sc(cave, xx, yy, O_PRE_STEEL_1);
- /* middle is a time penalty (which will be turned into a gravestone) */
+ // middle is a time penalty (which will be turned into a gravestone)
store_sc(cave, x, y, O_TIME_PENALTY);
}
-/* a bomb does not explode the voodoo, neither does the ghost.
- this function check this, and stores the new element or not.
- destroying the voodoo is also controlled by the
- voodoo_disappear_in_explosion flag. */
+/*
+ a bomb does not explode the voodoo, neither does the ghost.
+ this function check this, and stores the new element or not.
+ destroying the voodoo is also controlled by the
+ voodoo_disappear_in_explosion flag.
+*/
static void explode_try_skip_voodoo(GdCave *cave, const int x, const int y, const GdElement expl)
{
if (non_explodable (cave, x, y))
return;
- /* bomb does not explode voodoo */
+ // bomb does not explode voodoo
if (!cave->voodoo_disappear_in_explosion && get(cave, x, y) == O_VOODOO)
return;
store_sc (cave, x, y, expl);
}
-/* X shaped ghost explosion; does not touch voodoo! */
+// X shaped ghost explosion; does not touch voodoo!
static void ghost_explode(GdCave *cave, const int x, const int y)
{
gd_sound_play(cave, GD_S_GHOST_EXPLODING, get(cave, x, y), x, y);
- /* the processing of an explosion took pretty much time: processing 5 elements */
+ // the processing of an explosion took pretty much time: processing 5 elements
cave->ckdelay += 650;
explode_try_skip_voodoo(cave, x, y, O_GHOST_EXPL_1);
explode_try_skip_voodoo(cave, x + 1, y - 1, O_GHOST_EXPL_1);
}
-/* +shaped bomb explosion; does not touch voodoo! */
+// +shaped bomb explosion; does not touch voodoo!
static void bomb_explode(GdCave *cave, const int x, const int y)
{
gd_sound_play(cave, GD_S_BOMB_EXPLODING, get(cave, x, y), x, y);
- /* the processing of an explosion took pretty much time: processing 5 elements */
+ // the processing of an explosion took pretty much time: processing 5 elements
cave->ckdelay += 650;
explode_try_skip_voodoo(cave, x, y, O_BOMB_EXPL_1);
gd_sound_play(cave, GD_S_DIAMOND_KEY_COLLECTING, object, x, y);
return O_SPACE;
- /* KEYS AND DOORS */
+ // KEYS AND DOORS
case O_KEY_1:
gd_sound_play(cave, GD_S_KEY_COLLECTING, object, x, y);
cave->key1++;
cave->key3--;
return O_SPACE;
- /* SWITCHES */
- case O_CREATURE_SWITCH: /* creatures change direction. */
+ // SWITCHES
+ case O_CREATURE_SWITCH: // creatures change direction.
gd_sound_play(cave, GD_S_SWITCH_CREATURES, object, x, y);
cave->creatures_backwards = !cave->creatures_backwards;
return object;
- case O_EXPANDING_WALL_SWITCH: /* expanding wall change direction. */
+ case O_EXPANDING_WALL_SWITCH: // expanding wall change direction.
gd_sound_play(cave, GD_S_SWITCH_EXPANDING, object, x, y);
cave->expanding_wall_changed = !cave->expanding_wall_changed;
return object;
- case O_BITER_SWITCH: /* biter change delay */
+ case O_BITER_SWITCH: // biter change delay
gd_sound_play(cave, GD_S_SWITCH_BITER, object, x, y);
cave->biter_delay_frame++;
if (cave->biter_delay_frame == 4)
cave->biter_delay_frame = 0;
return object;
- case O_REPLICATOR_SWITCH: /* replicator on/off switch */
+ case O_REPLICATOR_SWITCH: // replicator on/off switch
gd_sound_play(cave, GD_S_SWITCH_REPLICATOR, object, x, y);
cave->replicators_active = !cave->replicators_active;
return object;
- case O_CONVEYOR_SWITCH: /* conveyor belts on/off */
+ case O_CONVEYOR_SWITCH: // conveyor belts on/off
gd_sound_play(cave, GD_S_SWITCH_CONVEYOR, object, x, y);
cave->conveyor_belts_active = !cave->conveyor_belts_active;
return object;
- case O_CONVEYOR_DIR_SWITCH: /* conveyor belts switch direction */
+ case O_CONVEYOR_DIR_SWITCH: // conveyor belts switch direction
gd_sound_play(cave, GD_S_SWITCH_CONVEYOR, object, x, y);
cave->conveyor_belts_direction_changed = !cave->conveyor_belts_direction_changed;
return object;
- /* USUAL STUFF */
+ // USUAL STUFF
case O_DIRT:
case O_DIRT2:
case O_STEEL_EATABLE:
return O_SPACE;
case O_CLOCK:
- /* bonus time */
+ // bonus time
gd_sound_play(cave, GD_S_CLOCK_COLLECTING, object, x, y);
cave->time += cave->time_bonus * cave->timing_factor;
if (cave->time > cave->max_time * cave->timing_factor)
cave->time -= cave->max_time * cave->timing_factor;
- /* no space, rather a dirt remains there... */
+ // no space, rather a dirt remains there...
return O_DIRT;
case O_DIAMOND:
{
cave->gate_open = TRUE;
- /* extra is worth more points. */
+ // extra is worth more points.
cave->diamond_value = cave->extra_diamond_value;
cave->gate_open_flash = 1;
case O_SKELETON:
cave->skeletons_collected++;
- /* as if player got a diamond */
+ // as if player got a diamond
for (i = 0; i < cave->skeletons_worth_diamonds; i++)
player_get_element(cave, O_DIAMOND, -1, -1);
- /* _after_ calling get_element for the fake diamonds, so we overwrite its sounds */
+ // _after_ calling get_element for the fake diamonds, so we overwrite its sounds
gd_sound_play(cave, GD_S_SKELETON_COLLECTING, object, x, y);
return O_SPACE;
case O_OUTBOX:
case O_INVIS_OUTBOX:
- cave->player_state = GD_PL_EXITED; /* player now exits the cave! */
+ cave->player_state = GD_PL_EXITED; // player now exits the cave!
return O_SPACE;
case O_SPACE:
- case O_LAVA: /* player goes into lava, as if it was space */
+ case O_LAVA: // player goes into lava, as if it was space
gd_sound_play(cave, GD_S_EMPTY_WALKING, object, x, y);
return O_SPACE;
default:
- /* the object will remain there. */
+ // the object will remain there.
return object;
}
}
do
{
- /* jump to next element; wrap around columns and rows. */
+ // jump to next element; wrap around columns and rows.
tx++;
if (tx >= cave->w)
ty = 0;
}
- /* if we found a teleporter... */
+ // if we found a teleporter...
if (get(cave, tx, ty) == O_TELEPORTER &&
is_space_dir(cave, tx, ty, player_move))
{
- /* new player appears near teleporter found */
+ // new player appears near teleporter found
store_dir(cave, tx, ty, player_move, get(cave, px, py));
- /* current player disappears */
+ // current player disappears
store(cave, px, py, O_SPACE);
gd_sound_play(cave, GD_S_TELEPORTER, O_TELEPORTER, tx, ty);
- return TRUE; /* return true as teleporter worked */
+ return TRUE; // return true as teleporter worked
}
}
- /* loop until we get back to original coordinates */
+ // loop until we get back to original coordinates
while (tx != px || ty != py);
- /* return false as we did not find any usable teleporter */
+ // return false as we did not find any usable teleporter
return FALSE;
}
boolean result;
GdElement what = get_dir(cave, x, y, player_move);
- /* gravity for falling wall, bladder, ... */
+ // gravity for falling wall, bladder, ...
GdDirection grav_compat = cave->gravity_affects_all ? cave->gravity : GD_MV_DOWN;
result = FALSE;
case O_MEGA_STONE:
case O_FLYING_STONE:
case O_NUT:
- /* pushing some kind of stone or nut */
- /* directions possible: 90degrees cw or ccw to current gravity. */
- /* only push if player dir is orthogonal to gravity,
- ie. gravity down, pushing left & right possible */
+ // pushing some kind of stone or nut
+ // directions possible: 90degrees cw or ccw to current gravity.
+ // only push if player dir is orthogonal to gravity,
+ // ie. gravity down, pushing left & right possible
if (player_move == ccw_fourth[cave->gravity] ||
player_move == cw_fourth[cave->gravity])
{
prob = 0;
- /* different probabilities for different elements. */
+ // different probabilities for different elements.
switch (what)
{
case O_WAITING_STONE:
- /* waiting stones are light, can always push */
+ // waiting stones are light, can always push
prob = 1000000;
break;
case O_CHASING_STONE:
- /* chasing can be pushed if player is turbo */
+ // chasing can be pushed if player is turbo
if (cave->sweet_eaten)
prob = 1000000;
break;
case O_MEGA_STONE:
- /* mega may(!) be pushed if player is turbo */
+ // mega may(!) be pushed if player is turbo
if (cave->mega_stones_pushable_with_sweet && cave->sweet_eaten)
prob = 1000000;
break;
case O_FLYING_STONE:
case O_NITRO_PACK:
if (cave->sweet_eaten)
- prob = cave->pushing_stone_prob_sweet; /* probability with sweet */
+ prob = cave->pushing_stone_prob_sweet; // probability with sweet
else
- prob = cave->pushing_stone_prob; /* probability without sweet. */
+ prob = cave->pushing_stone_prob; // probability without sweet.
break;
default:
if (is_space_dir(cave, x, y, GD_MV_TWICE + player_move) &&
gd_rand_int_range(cave->random, 0, 1000000) < prob)
{
- /* if decided that he will be able to push, */
+ // if decided that he will be able to push,
store_dir(cave, x, y, GD_MV_TWICE + player_move, what);
play_sound_of_element_pushing(cave, what, x, y);
result = TRUE;
case O_BLADDER_6:
case O_BLADDER_7:
case O_BLADDER_8:
- /* pushing a bladder. keep in mind that after pushing, we always get an O_BLADDER,
- * not an O_BLADDER_x. */
- /* there is no "delayed" state of a bladder, so we use store_dir_no_scanned! */
+ // pushing a bladder. keep in mind that after pushing, we always get an O_BLADDER,
+ // not an O_BLADDER_x.
+ // there is no "delayed" state of a bladder, so we use store_dir_no_scanned!
- /* first check: we cannot push a bladder "up" */
+ // first check: we cannot push a bladder "up"
if (player_move != opposite[grav_compat])
{
- /* pushing a bladder "down". p = player, o = bladder, 1, 2, 3 = directions to check. */
- /* player moving in the direction of gravity. */
- /* p p g */
- /* 2o3 | | */
- /* 1 v v */
+ // pushing a bladder "down". p = player, o = bladder, 1, 2, 3 = directions to check.
+ // player moving in the direction of gravity.
+ // p p g
+ // 2o3 | |
+ // 1 v v
if (player_move == grav_compat)
{
- /* pushing bladder down */
+ // pushing bladder down
if (is_space_dir(cave, x, y, GD_MV_TWICE + player_move))
store_dir_no_scanned(cave, x, y, GD_MV_TWICE + player_move, O_BLADDER), result = TRUE;
- /* if no space to push down, maybe left (down-left to player) */
+ // if no space to push down, maybe left (down-left to player)
else if (is_space_dir(cave, x, y, cw_eighth[grav_compat]))
- /* left is "down, turned right (cw)" */
+ // left is "down, turned right (cw)"
store_dir_no_scanned(cave, x, y, cw_eighth[grav_compat], O_BLADDER), result = TRUE;
- /* if not, maybe right (down-right to player) */
+ // if not, maybe right (down-right to player)
else if (is_space_dir(cave, x, y, ccw_eighth[grav_compat]))
store_dir_no_scanned(cave, x, y, ccw_eighth[grav_compat], O_BLADDER), result = TRUE;
}
- /* pushing a bladder "left". p = player, o = bladder, 1, 2, 3 = directions to check. */
- /* 3 g */
- /* 1op <-p | */
- /* 2 v */
+ // pushing a bladder "left". p = player, o = bladder, 1, 2, 3 = directions to check.
+ // 3 g
+ // 1op <-p |
+ // 2 v
else if (player_move == cw_fourth[grav_compat])
{
- if (is_space_dir(cave, x, y, GD_MV_TWICE + cw_fourth[grav_compat])) /* pushing it left */
+ if (is_space_dir(cave, x, y, GD_MV_TWICE + cw_fourth[grav_compat])) // pushing it left
store_dir_no_scanned(cave, x, y, GD_MV_TWICE + cw_fourth[grav_compat], O_BLADDER), result = TRUE;
- else if (is_space_dir(cave, x, y, cw_eighth[grav_compat])) /* maybe down, and player will move left */
+ else if (is_space_dir(cave, x, y, cw_eighth[grav_compat])) // maybe down, and player will move left
store_dir_no_scanned(cave, x, y, cw_eighth[grav_compat], O_BLADDER), result = TRUE;
- else if (is_space_dir(cave, x, y, cw_eighth[player_move])) /* maybe up, and player will move left */
+ else if (is_space_dir(cave, x, y, cw_eighth[player_move])) // maybe up, and player will move left
store_dir_no_scanned(cave, x, y, cw_eighth[player_move], O_BLADDER), result = TRUE;
}
- /* pushing a bladder "right". p = player, o = bladder, 1, 2, 3 = directions to check. */
- /* 3 g */
- /* po1 p-< | */
- /* 2 v */
+ // pushing a bladder "right". p = player, o = bladder, 1, 2, 3 = directions to check.
+ // 3 g
+ // po1 p-< |
+ // 2 v
else if (player_move == ccw_fourth[grav_compat])
{
- if (is_space_dir(cave, x, y, GD_MV_TWICE + player_move)) /* pushing it right */
+ if (is_space_dir(cave, x, y, GD_MV_TWICE + player_move)) // pushing it right
store_dir_no_scanned(cave, x, y, GD_MV_TWICE + player_move, O_BLADDER), result = TRUE;
- else if (is_space_dir(cave, x, y, ccw_eighth[grav_compat])) /* maybe down, and player will move right */
+ else if (is_space_dir(cave, x, y, ccw_eighth[grav_compat])) // maybe down, and player will move right
store_dir_no_scanned(cave, x, y, ccw_eighth[grav_compat], O_BLADDER), result = TRUE;
- else if (is_space_dir(cave, x, y, ccw_eighth[player_move])) /* maybe up, and player will move right */
+ else if (is_space_dir(cave, x, y, ccw_eighth[player_move])) // maybe up, and player will move right
store_dir_no_scanned(cave, x, y, ccw_eighth[player_move], O_BLADDER), result = TRUE;
}
break;
case O_BOX:
- /* a box is only pushed with the fire pressed */
+ // a box is only pushed with the fire pressed
if (player_fire)
{
- /* but always with 100% probability */
+ // but always with 100% probability
switch (player_move)
{
case GD_MV_LEFT:
case GD_MV_RIGHT:
case GD_MV_UP:
case GD_MV_DOWN:
- /* pushing in some dir, two steps in that dir - is there space? */
+ // pushing in some dir, two steps in that dir - is there space?
if (is_space_dir(cave, x, y, player_move + GD_MV_TWICE))
{
- /* yes, so push. */
+ // yes, so push.
store_dir(cave, x, y, player_move + GD_MV_TWICE, O_BOX);
result = TRUE;
gd_sound_play(cave, GD_S_BOX_PUSHING, what, x, y);
break;
default:
- /* push in no other directions possible */
+ // push in no other directions possible
break;
}
}
break;
- /* pushing of other elements not possible */
+ // pushing of other elements not possible
default:
break;
}
return result;
}
-/* from the key press booleans, create a direction */
+// from the key press booleans, create a direction
GdDirection gd_direction_from_keypress(boolean up, boolean down, boolean left, boolean right)
{
GdDirection player_move;
- /* from the key press booleans, create a direction */
+ // from the key press booleans, create a direction
if (up && right)
player_move = GD_MV_UP_RIGHT;
else if (down && right)
return player_move;
}
-/* clear these to no sound; and they will be set during iteration. */
+// clear these to no sound; and they will be set during iteration.
void gd_cave_clear_sounds(GdCave *cave)
{
cave->sound1 = GD_S_NONE;
if (is_space_dir(cave, x, y, falling_direction))
{
- /* beginning to fall */
+ // beginning to fall
play_sound_of_element(cave, get(cave, x, y), x, y);
move(cave, x, y, falling_direction, falling_element);
}
- /* check if it is on a sloped element, and it can roll. */
- /* for example, sloped wall looks like: */
- /* /| */
- /* /_| */
- /* this is tagged as sloped up&left. */
- /* first check if the stone or diamond is coming from "up" (ie. opposite of gravity) */
- /* then check the direction to roll (left or right) */
- /* this way, gravity can also be pointing right, and the above slope will work as one would expect */
+ // check if it is on a sloped element, and it can roll.
+ // for example, sloped wall looks like:
+ // /|
+ // /_|
+ // this is tagged as sloped up&left.
+ // first check if the stone or diamond is coming from "up" (ie. opposite of gravity)
+ // then check the direction to roll (left or right)
+ // this way, gravity can also be pointing right, and the above slope will work as one would expect
else if (sloped_dir(cave, x, y, falling_direction, opposite[falling_direction]))
{
- /* rolling down, if sitting on a sloped object */
+ // rolling down, if sitting on a sloped object
if (sloped_dir(cave, x, y, falling_direction, cw_fourth[falling_direction]) &&
is_space_dir(cave, x, y, cw_fourth[falling_direction]) &&
is_space_dir(cave, x, y, cw_eighth[falling_direction]))
{
- /* rolling left? - keep in mind that ccw_fourth rotates gravity ccw,
- so here we use cw_fourth */
+ // rolling left? - keep in mind that ccw_fourth rotates gravity ccw,
+ // so here we use cw_fourth
play_sound_of_element(cave, get(cave, x, y), x, y);
move(cave, x, y, cw_fourth[falling_direction], falling_element);
}
is_space_dir(cave, x, y, ccw_fourth[falling_direction]) &&
is_space_dir(cave, x, y, ccw_eighth[falling_direction]))
{
- /* rolling right? */
+ // rolling right?
play_sound_of_element(cave, get(cave, x, y), x, y);
move(cave, x, y, ccw_fourth[falling_direction], falling_element);
}
if (get_dir(cave, x, y, fall_dir) == O_VOODOO &&
cave->voodoo_dies_by_stone)
{
- /* this is a 1stB-style vodo. explodes by stone, collects diamonds */
+ // this is a 1stB-style vodo. explodes by stone, collects diamonds
explode_dir(cave, x, y, fall_dir);
return TRUE;
}
if (get_dir(cave, x, y, fall_dir) == O_VOODOO &&
cave->voodoo_collects_diamonds)
{
- /* this is a 1stB-style voodoo. explodes by stone, collects diamonds */
- player_get_element(cave, O_DIAMOND, x, y); /* as if player got diamond */
- store(cave, x, y, O_SPACE); /* diamond disappears */
+ // this is a 1stB-style voodoo. explodes by stone, collects diamonds
+ player_get_element(cave, O_DIAMOND, x, y); // as if player got diamond
+ store(cave, x, y, O_SPACE); // diamond disappears
return TRUE;
}
else
if (get_dir(cave, x, y, fall_dir) == O_NUT ||
get_dir(cave, x, y, fall_dir) == O_NUT_F)
{
- /* stones */
+ // stones
store(cave, x, y, bouncing);
store_dir(cave, x, y, fall_dir, cave->nut_turns_to_when_crushed);
{
if (get_dir(cave, x, y, fall_dir) == O_MAGIC_WALL)
{
- play_sound_of_element(cave, O_DIAMOND, x, y); /* always play diamond sound */
+ play_sound_of_element(cave, O_DIAMOND, x, y); // always play diamond sound
if (cave->magic_wall_state == GD_MW_DORMANT)
cave->magic_wall_state = GD_MW_ACTIVE;
if (cave->magic_wall_state == GD_MW_ACTIVE &&
is_space_dir(cave, x, y, GD_MV_TWICE+fall_dir))
{
- /* if magic wall active and place underneath, it turns element
- into anything the effect says to do. */
+ // if magic wall active and place underneath, it turns element
+ // into anything the effect says to do.
store_dir(cave, x, y, GD_MV_TWICE+fall_dir, magic);
}
- /* active or non-active or anything, element falling in will always disappear */
+ // active or non-active or anything, element falling in will always disappear
store(cave, x, y, O_SPACE);
return TRUE;
{
if (is_space_dir(cave, x, y, fall_dir))
{
- /* falling further */
+ // falling further
move(cave, x, y, fall_dir, get(cave, x, y));
return TRUE;
}
- /* check if it is on a sloped element, and it can roll. */
- /* for example, sloped wall looks like: */
- /* /| */
- /* /_| */
- /* this is tagged as sloped up&left. */
- /* first check if the stone or diamond is coming from "up" (ie. opposite of gravity) */
- /* then check the direction to roll (left or right) */
- /* this way, gravity can also be pointing right, and the above slope will work as one would expect */
+ // check if it is on a sloped element, and it can roll.
+ // for example, sloped wall looks like:
+ // /|
+ // /_|
+ // this is tagged as sloped up&left.
+ // first check if the stone or diamond is coming from "up" (ie. opposite of gravity)
+ // then check the direction to roll (left or right)
+ // this way, gravity can also be pointing right, and the above slope will work as one would expect
if (sloped_dir(cave, x, y, fall_dir, opposite[fall_dir]))
{
- /* sloped element, falling to left or right */
+ // sloped element, falling to left or right
if (sloped_dir(cave, x, y, fall_dir, cw_fourth[fall_dir]) &&
is_space_dir(cave, x, y, cw_eighth[fall_dir]) &&
is_space_dir(cave, x, y, cw_fourth[fall_dir]))
{
play_sound_of_element(cave, get(cave, x, y), x, y);
- /* try to roll left first - see O_STONE to understand why cw_fourth */
+ // try to roll left first - see O_STONE to understand why cw_fourth
move(cave, x, y, cw_fourth[fall_dir], get(cave, x, y));
}
else if (sloped_dir(cave, x, y, fall_dir, ccw_fourth[fall_dir]) &&
{
play_sound_of_element(cave, get(cave, x, y), x, y);
- /* if not, try to roll right */
+ // if not, try to roll right
move(cave, x, y, ccw_fourth[fall_dir], get(cave, x, y));
}
else
{
- /* cannot roll in any direction, so it stops */
+ // cannot roll in any direction, so it stops
play_sound_of_element(cave, get(cave, x, y), x, y);
store(cave, x, y, bouncing);
}
return TRUE;
}
- /* any other element, stops */
+ // any other element, stops
play_sound_of_element(cave, get(cave, x, y), x, y);
store(cave, x, y, bouncing);
return TRUE;
static void update_cave_speed(GdCave *cave)
{
- /* update timing calculated by iterating and counting elements which were slow to process on c64 */
+ // update timing calculated by iterating and counting elements which were slow to process on c64
switch (cave->scheduling)
{
case GD_SCHEDULING_MILLISECONDS:
- /* cave->speed already contains the milliseconds value, do not touch it */
+ // cave->speed already contains the milliseconds value, do not touch it
break;
case GD_SCHEDULING_BD1:
if (!cave->intermission)
- /* non-intermissions */
+ // non-intermissions
cave->speed = (88 + 3.66 * cave->c64_timing + (cave->ckdelay + cave->ckdelay_extra_for_animation) / 1000);
else
- /* intermissions were quicker, as only lines 1-12 were processed by the engine. */
+ // intermissions were quicker, as only lines 1-12 were processed by the engine.
cave->speed = (60 + 3.66 * cave->c64_timing + (cave->ckdelay + cave->ckdelay_extra_for_animation) / 1000);
break;
case GD_SCHEDULING_BD1_ATARI:
- /* about 20ms/frame faster than c64 version */
+ // about 20ms/frame faster than c64 version
if (!cave->intermission)
- cave->speed = (74 + 3.2 * cave->c64_timing + (cave->ckdelay) / 1000); /* non-intermissions */
+ cave->speed = (74 + 3.2 * cave->c64_timing + (cave->ckdelay) / 1000); // non-intermissions
else
- cave->speed = (65 + 2.88 * cave->c64_timing + (cave->ckdelay) / 1000); /* for intermissions */
+ cave->speed = (65 + 2.88 * cave->c64_timing + (cave->ckdelay) / 1000); // for intermissions
break;
case GD_SCHEDULING_BD2:
- /* 60 is a guess. */
+ // 60 is a guess.
cave->speed = MAX(60 + (cave->ckdelay + cave->ckdelay_extra_for_animation)/1000, cave->c64_timing * 20);
break;
case GD_SCHEDULING_PLCK:
- /* 65 is totally empty cave in construction kit, with delay = 0) */
+ // 65 is totally empty cave in construction kit, with delay = 0)
cave->speed = MAX(65 + cave->ckdelay / 1000, cave->c64_timing * 20);
break;
case GD_SCHEDULING_BD2_PLCK_ATARI:
- /* a really fast engine; timing works like c64 plck. */
- /* 40 ms was measured in the construction kit, with delay = 0 */
+ // a really fast engine; timing works like c64 plck.
+ // 40 ms was measured in the construction kit, with delay = 0
cave->speed = MAX(40 + cave->ckdelay / 1000, cave->c64_timing * 20);
break;
case GD_SCHEDULING_CRDR:
- if (cave->hammered_walls_reappear) /* this made the engine very slow. */
+ if (cave->hammered_walls_reappear) // this made the engine very slow.
cave->ckdelay += 60000;
cave->speed = MAX(130 + cave->ckdelay / 1000, cave->c64_timing * 20);
break;
}
}
-/* process a cave. */
+// process a cave.
void gd_cave_iterate(GdCave *cave, GdDirection player_move, boolean player_fire, boolean suicide)
{
int x, y, i;
- /* for border scan */
+ // for border scan
int ymin, ymax;
- /* amoeba found to be enclosed. if not, this is cleared */
+ // amoeba found to be enclosed. if not, this is cleared
boolean amoeba_found_enclosed, amoeba_2_found_enclosed;
- /* counting the number of amoebas. after scan, check if too much */
+ // counting the number of amoebas. after scan, check if too much
int amoeba_count, amoeba_2_count;
- /* cave scan found water - for sound */
+ // cave scan found water - for sound
boolean found_water;
boolean inbox_toggle;
boolean start_signal;
- /* gravity for falling wall, bladder, ... */
+ // gravity for falling wall, bladder, ...
GdDirection grav_compat = cave->gravity_affects_all ? cave->gravity : GD_MV_DOWN;
- /* directions for o_something_1, 2, 3 and 4 (creatures) */
+ // directions for o_something_1, 2, 3 and 4 (creatures)
static const GdDirection creature_dir[] =
{
GD_MV_LEFT,
};
int time_decrement_sec;
- /* biters eating elements preference, they try to go in this order */
+ // biters eating elements preference, they try to go in this order
GdElement biter_try[] =
{
O_DIRT,
gd_cave_clear_sounds(cave);
- /* if diagonal movements not allowed, */
- /* horizontal movements have precedence. [BROADRIBB] */
+ // if diagonal movements not allowed,
+ // horizontal movements have precedence. [BROADRIBB]
if (!cave->diagonal_movements)
{
switch (player_move)
break;
default:
- /* no correction needed */
+ // no correction needed
break;
}
}
- /* set cave get function; to implement perfect or lineshifting borders */
+ // set cave get function; to implement perfect or lineshifting borders
if (cave->lineshift)
{
cave->getp = getp_shift;
cave->gety = gety_perfect;
}
- /* increment this. if the scan routine comes across player, clears it (sets to zero). */
+ // increment this. if the scan routine comes across player, clears it (sets to zero).
if (cave->player_seen_ago < 100)
cave->player_seen_ago++;
if (cave->pneumatic_hammer_active_delay > 0)
cave->pneumatic_hammer_active_delay--;
- /* inboxes and outboxes flash with the rhythm of the game, not the display.
- * also, a player can be born only from an open, not from a steel-wall-like inbox. */
+ // inboxes and outboxes flash with the rhythm of the game, not the display.
+ // also, a player can be born only from an open, not from a steel-wall-like inbox.
cave->inbox_flash_toggle = !cave->inbox_flash_toggle;
inbox_toggle = cave->inbox_flash_toggle;
if (cave->gate_open_flash > 0)
cave->gate_open_flash--;
- /* score collected this frame */
+ // score collected this frame
cave->score = 0;
- /* suicide only kills the active player */
- /* player_x, player_y was set by the previous iterate routine, or the cave setup. */
- /* we must check if there is a player or not - he may have exploded or something like that */
+ // suicide only kills the active player
+ // player_x, player_y was set by the previous iterate routine, or the cave setup.
+ // we must check if there is a player or not - he may have exploded or something like that
if (suicide && cave->player_state == GD_PL_LIVING &&
is_player(cave, cave->player_x, cave->player_y))
store(cave, cave->player_x, cave->player_y, O_EXPLODE_1);
- /* check for walls reappearing */
+ // check for walls reappearing
if (cave->hammered_reappear)
{
for (y = 0; y < cave->h; y++)
{
for (x = 0; x < cave->w; x++)
{
- /* timer for the cell > 0? */
+ // timer for the cell > 0?
if (cave->hammered_reappear[y][x] > 0)
{
- /* decrease timer */
+ // decrease timer
cave->hammered_reappear[y][x]--;
- /* check if it became zero */
+ // check if it became zero
if (cave->hammered_reappear[y][x] == 0)
{
store(cave, x, y, O_BRICK);
}
}
- /* variables to check during the scan */
+ // variables to check during the scan
- /* will be set to false if any of the amoeba is found free. */
+ // will be set to false if any of the amoeba is found free.
amoeba_found_enclosed = TRUE;
amoeba_2_found_enclosed = TRUE;
amoeba_count = 0;
cave->ckdelay = 0;
time_decrement_sec = 0;
- /* check whether to scan the first and last line */
+ // check whether to scan the first and last line
if (cave->border_scan_first_and_last)
{
ymin = 0;
ymax = cave->h - 2;
}
- /* the cave scan routine */
+ // the cave scan routine
for (y = ymin; y <= ymax; y++)
{
for (x = 0; x < cave->w; x++)
{
- /* if we find a scanned element, change it to the normal one, and that's all. */
- /* this is required, for example for chasing stones, which have moved, always passing slime! */
+ // if we find a scanned element, change it to the normal one, and that's all.
+ // this is required, for example for chasing stones, which have moved, always passing slime!
if (get(cave, x, y) & SCANNED)
{
store(cave, x, y, get(cave, x, y) & ~SCANNED);
continue;
}
- /* add the ckdelay correction value for every element seen. */
+ // add the ckdelay correction value for every element seen.
cave->ckdelay += gd_elements[get(cave, x, y)].ckdelay;
switch (get(cave, x, y))
{
- /*
- * P L A Y E R S
- */
+ // ============================================================================
+ // P L A Y E R S
+ // ============================================================================
+
case O_PLAYER:
if (cave->kill_player)
{
}
cave->player_seen_ago = 0;
- /* bd4 intermission caves have many players. so if one of them has exited,
- * do not change the flag anymore. so this if () is needed */
+ // bd4 intermission caves have many players. so if one of them has exited,
+ // do not change the flag anymore. so this if () is needed
if (cave->player_state != GD_PL_EXITED)
cave->player_state = GD_PL_LIVING;
- /* check for pneumatic hammer things */
- /* 1) press fire, 2) have pneumatic hammer 4) space on left or right
- for hammer 5) stand on something */
+ // check for pneumatic hammer things
+ // 1) press fire, 2) have pneumatic hammer 4) space on left or right
+ // for hammer 5) stand on something
if (player_fire && cave->got_pneumatic_hammer &&
is_space_dir(cave, x, y, player_move) &&
!is_space_dir(cave, x, y, GD_MV_DOWN))
cave->pneumatic_hammer_active_delay = cave->pneumatic_hammer_frame;
store_dir(cave, x, y, GD_MV_LEFT, O_PNEUMATIC_ACTIVE_LEFT);
store(cave, x, y, O_PLAYER_PNEUMATIC_LEFT);
- break; /* finished. */
+ break; // finished.
}
if (player_move == GD_MV_RIGHT &&
cave->pneumatic_hammer_active_delay = cave->pneumatic_hammer_frame;
store_dir(cave, x, y, GD_MV_RIGHT, O_PNEUMATIC_ACTIVE_RIGHT);
store(cave, x, y, O_PLAYER_PNEUMATIC_RIGHT);
- break; /* finished. */
+ break; // finished.
}
}
if (player_move != GD_MV_STILL)
{
- /* only do every check if he is not moving */
+ // only do every check if he is not moving
GdElement what = get_dir(cave, x, y, player_move);
GdElement remains = what;
boolean push;
- /* if we are 'eating' a teleporter, and the function returns true
- (teleporting worked), break here */
+ // if we are 'eating' a teleporter, and the function returns true
+ // (teleporting worked), break here
if (what == O_TELEPORTER && do_teleporter(cave, x, y, player_move))
break;
- /* try to push element; if successful, break */
+ // try to push element; if successful, break
push = do_push(cave, x, y, player_move, player_fire);
if (push)
{
switch (what)
{
case O_BOMB:
- /* if its a bomb, remember he now has one. */
- /* we do not change the "remains" and "what" variables,
- so that part of the code will be ineffective */
+ // if its a bomb, remember he now has one.
+ // we do not change the "remains" and "what" variables,
+ // so that part of the code will be ineffective
gd_sound_play(cave, GD_S_BOMB_COLLECTING, what, x, y);
store_dir(cave, x, y, player_move, O_SPACE);
break;
case O_POT:
- /* we do not change the "remains" and "what" variables,
- so that part of the code will be ineffective */
+ // we do not change the "remains" and "what" variables,
+ // so that part of the code will be ineffective
if (!player_fire && !cave->gravity_switch_active &&
cave->skeletons_collected >= cave->skeletons_needed_for_pot)
{
break;
case O_GRAVITY_SWITCH:
- /* (we cannot use player_get for this as it does not have player_move parameter) */
- /* only allow changing direction if the new dir is not diagonal */
+ // (we cannot use player_get for this as it does not have player_move parameter)
+ // only allow changing direction if the new dir is not diagonal
if (cave->gravity_switch_active &&
(player_move == GD_MV_LEFT ||
player_move == GD_MV_RIGHT ||
break;
default:
- /* get element - process others.
- if cannot get, player_get_element will return the same */
+ // get element - process others.
+ // if cannot get, player_get_element will return the same
remains = player_get_element(cave, what, x, y);
break;
}
if (remains != what || remains == O_SPACE)
{
- /* if anything changed, apply the change. */
+ // if anything changed, apply the change.
- /* if snapping anything and we have snapping explosions set.
- but these is not true for pushing. */
+ // if snapping anything and we have snapping explosions set.
+ // but these is not true for pushing.
if (remains == O_SPACE && player_fire && !push)
remains = cave->snap_element;
if (remains != O_SPACE || player_fire)
- /* if any other element than space, player cannot move.
- also if pressing fire, will not move. */
+ // if any other element than space, player cannot move.
+ // also if pressing fire, will not move.
store_dir(cave, x, y, player_move, remains);
else
- /* if space remains there, the player moves. */
+ // if space remains there, the player moves.
move(cave, x, y, player_move, O_PLAYER);
}
}
break;
case O_PLAYER_BOMB:
- /* much simpler; cannot steal stones */
+ // much simpler; cannot steal stones
if (cave->kill_player)
{
explode(cave, x, y);
}
cave->player_seen_ago = 0;
- /* bd4 intermission caves have many players. so if one of them has exited,
- * do not change the flag anymore. so this if () is needed */
+ // bd4 intermission caves have many players. so if one of them has exited,
+ // do not change the flag anymore. so this if () is needed
if (cave->player_state != GD_PL_EXITED)
cave->player_state = GD_PL_LIVING;
if (player_move != GD_MV_STILL)
{
- /* if the player does not move, nothing to do */
+ // if the player does not move, nothing to do
GdElement what = get_dir(cave, x, y, player_move);
GdElement remains = what;
if (player_fire)
{
- /* placing a bomb into empty space or dirt */
+ // placing a bomb into empty space or dirt
if (is_space_dir(cave, x, y, player_move) ||
is_element_dir(cave, x, y, player_move, O_DIRT))
{
store_dir(cave, x, y, player_move, O_BOMB_TICK_1);
- /* placed bomb, he is normal player again */
+ // placed bomb, he is normal player again
store(cave, x, y, O_PLAYER);
gd_sound_play(cave, GD_S_BOMB_PLACING, O_BOMB, x, y);
}
break;
}
- /* pushing and collecting */
- /* if we are 'eating' a teleporter, and the function returns true
- (teleporting worked), break here */
+ // pushing and collecting
+ // if we are 'eating' a teleporter, and the function returns true
+ // (teleporting worked), break here
if (what == O_TELEPORTER && do_teleporter(cave, x, y, player_move))
break;
- /* player fire is false... */
+ // player fire is false...
if (do_push(cave, x, y, player_move, FALSE))
{
remains = O_SPACE;
switch (what)
{
case O_GRAVITY_SWITCH:
- /* (we cannot use player_get for this as it does not have
- player_move parameter) */
- /* only allow changing direction if the new dir is not diagonal */
+ // (we cannot use player_get for this as it does not have
+ // player_move parameter)
+ // only allow changing direction if the new dir is not diagonal
if (cave->gravity_switch_active &&
(player_move == GD_MV_LEFT ||
player_move == GD_MV_RIGHT ||
break;
default:
- /* get element. if cannot get, player_get_element will return the same */
+ // get element. if cannot get, player_get_element will return the same
remains = player_get_element (cave, what, x, y);
break;
}
}
- /* if element changed, OR there is space, move. */
+ // if element changed, OR there is space, move.
if (remains != what || remains == O_SPACE)
{
- /* if anything changed, apply the change. */
+ // if anything changed, apply the change.
move(cave, x, y, player_move, O_PLAYER_BOMB);
}
}
break;
}
- /* stirring sound, if no other walking sound or explosion */
+ // stirring sound, if no other walking sound or explosion
gd_sound_play(cave, GD_S_STIRRING, O_PLAYER_STIRRING, x, y);
cave->player_seen_ago = 0;
- /* bd4 intermission caves have many players. so if one of them has exited,
- * do not change the flag anymore. so this if () is needed */
+ // bd4 intermission caves have many players. so if one of them has exited,
+ // do not change the flag anymore. so this if () is needed
if (cave->player_state != GD_PL_EXITED)
cave->player_state = GD_PL_LIVING;
if (player_fire)
{
- /* player "exits" stirring the pot by pressing fire */
+ // player "exits" stirring the pot by pressing fire
cave->gravity_disabled = FALSE;
store(cave, x, y, O_PLAYER);
cave->gravity_switch_active = TRUE;
}
break;
- /* player holding pneumatic hammer */
+ // player holding pneumatic hammer
case O_PLAYER_PNEUMATIC_LEFT:
case O_PLAYER_PNEUMATIC_RIGHT:
- /* usual player stuff */
+ // usual player stuff
if (cave->kill_player)
{
explode(cave, x, y);
if (cave->player_state != GD_PL_EXITED)
cave->player_state = GD_PL_LIVING;
- /* if hammering time is up, becomes a normal player again. */
+ // if hammering time is up, becomes a normal player again.
if (cave->pneumatic_hammer_active_delay == 0)
store(cave, x, y, O_PLAYER);
break;
- /* the active pneumatic hammer itself */
+ // the active pneumatic hammer itself
case O_PNEUMATIC_ACTIVE_RIGHT:
case O_PNEUMATIC_ACTIVE_LEFT:
if (cave->pneumatic_hammer_active_delay == 0)
{
GdElement new_elem;
- /* pneumatic hammer element disappears */
+ // pneumatic hammer element disappears
store(cave, x, y, O_SPACE);
- /* which is the new element which appears after that one is hammered? */
+ // which is the new element which appears after that one is hammered?
new_elem = gd_element_get_hammered(get_dir(cave, x, y, GD_MV_DOWN));
- /* if there is a new element, display it */
- /* O_NONE might be returned, for example if the element being
- hammered explodes during hammering (by a nearby explosion) */
+ // if there is a new element, display it
+ // O_NONE might be returned, for example if the element being
+ // hammered explodes during hammering (by a nearby explosion)
if (new_elem != O_NONE)
{
store_dir(cave, x, y, GD_MV_DOWN, new_elem);
- /* and if walls reappear, remember it in array */
+ // and if walls reappear, remember it in array
if (cave->hammered_walls_reappear)
{
int wall_y;
}
break;
- /*
- * S T O N E S, D I A M O N D S
- */
- case O_STONE: /* standing stone */
+ // ============================================================================
+ // S T O N E S, D I A M O N D S
+ // ============================================================================
+
+ case O_STONE: // standing stone
do_start_fall(cave, x, y, cave->gravity, cave->stone_falling_effect);
break;
- case O_MEGA_STONE: /* standing mega_stone */
+ case O_MEGA_STONE: // standing mega_stone
do_start_fall(cave, x, y, cave->gravity, O_MEGA_STONE_F);
break;
- case O_DIAMOND: /* standing diamond */
+ case O_DIAMOND: // standing diamond
do_start_fall(cave, x, y, cave->gravity, cave->diamond_falling_effect);
break;
- case O_NUT: /* standing nut */
+ case O_NUT: // standing nut
do_start_fall(cave, x, y, cave->gravity, O_NUT_F);
break;
- case O_DIRT_BALL: /* standing dirt ball */
+ case O_DIRT_BALL: // standing dirt ball
do_start_fall(cave, x, y, cave->gravity, O_DIRT_BALL_F);
break;
- case O_DIRT_LOOSE: /* standing loose dirt */
+ case O_DIRT_LOOSE: // standing loose dirt
do_start_fall(cave, x, y, cave->gravity, O_DIRT_LOOSE_F);
break;
- case O_FLYING_STONE: /* standing stone */
+ case O_FLYING_STONE: // standing stone
do_start_fall(cave, x, y, opposite[cave->gravity], O_FLYING_STONE_F);
break;
- case O_FLYING_DIAMOND: /* standing diamond */
+ case O_FLYING_DIAMOND: // standing diamond
do_start_fall(cave, x, y, opposite[cave->gravity], O_FLYING_DIAMOND_F);
break;
- /*
- * F A L L I N G E L E M E N T S, F L Y I N G S T O N E S, D I A M O N D S
- */
- case O_DIRT_BALL_F: /* falling dirt ball */
+ // ============================================================================
+ // F A L L I N G E L E M E N T S, F L Y I N G S T O N E S, D I A M O N D S
+ // ============================================================================
+
+ case O_DIRT_BALL_F: // falling dirt ball
if (!cave->gravity_disabled)
do_fall_roll_or_stop(cave, x, y, cave->gravity, O_DIRT_BALL);
break;
- case O_DIRT_LOOSE_F: /* falling loose dirt */
+ case O_DIRT_LOOSE_F: // falling loose dirt
if (!cave->gravity_disabled)
do_fall_roll_or_stop(cave, x, y, cave->gravity, O_DIRT_LOOSE);
break;
- case O_STONE_F: /* falling stone */
+ case O_STONE_F: // falling stone
if (!cave->gravity_disabled)
{
if (do_fall_try_crush_voodoo(cave, x, y, cave->gravity))
}
break;
- case O_MEGA_STONE_F: /* falling mega */
+ case O_MEGA_STONE_F: // falling mega
if (!cave->gravity_disabled)
{
if (do_fall_try_crush_voodoo(cave, x, y, cave->gravity))
}
break;
- case O_DIAMOND_F: /* falling diamond */
+ case O_DIAMOND_F: // falling diamond
if (!cave->gravity_disabled)
{
if (do_fall_try_eat_voodoo(cave, x, y, cave->gravity))
}
break;
- case O_NUT_F: /* falling nut */
+ case O_NUT_F: // falling nut
if (!cave->gravity_disabled)
{
if (do_fall_try_magic(cave, x, y, cave->gravity, cave->magic_nut_to))
}
break;
- case O_FLYING_STONE_F: /* falling stone */
+ case O_FLYING_STONE_F: // falling stone
if (!cave->gravity_disabled)
{
GdDirection fall_dir = opposite[cave->gravity];
}
break;
- case O_FLYING_DIAMOND_F: /* falling diamond */
+ case O_FLYING_DIAMOND_F: // falling diamond
if (!cave->gravity_disabled)
{
GdDirection fall_dir = opposite[cave->gravity];
}
break;
- /*
- * N I T R O P A C K
- */
- case O_NITRO_PACK: /* standing nitro pack */
+ // ============================================================================
+ // N I T R O P A C K
+ // ============================================================================
+
+ case O_NITRO_PACK: // standing nitro pack
do_start_fall(cave, x, y, cave->gravity, O_NITRO_PACK_F);
break;
- case O_NITRO_PACK_F: /* falling nitro pack */
+ case O_NITRO_PACK_F: // falling nitro pack
if (!cave->gravity_disabled)
{
- if (is_space_dir(cave, x, y, cave->gravity)) /* if space, falling further */
+ if (is_space_dir(cave, x, y, cave->gravity)) // if space, falling further
move(cave, x, y, cave->gravity, get(cave, x, y));
else if (do_fall_try_magic(cave, x, y, cave->gravity, cave->magic_nitro_pack_to))
{
- /* try magic wall; if true, function did the work */
+ // try magic wall; if true, function did the work
}
else if (is_element_dir(cave, x, y, cave->gravity, O_DIRT))
{
- /* falling on a dirt, it does NOT explode - just stops at its place. */
+ // falling on a dirt, it does NOT explode - just stops at its place.
play_sound_of_element(cave, O_NITRO_PACK, x, y);
store(cave, x, y, O_NITRO_PACK);
}
else
- /* falling on any other element it explodes */
+ // falling on any other element it explodes
explode(cave, x, y);
}
break;
- case O_NITRO_PACK_EXPLODE: /* a triggered nitro pack */
+ case O_NITRO_PACK_EXPLODE: // a triggered nitro pack
explode(cave, x, y);
break;
- /*
- * C R E A T U R E S
- */
+ // ============================================================================
+ // C R E A T U R E S
+ // ============================================================================
case O_COW_1:
case O_COW_2:
case O_COW_3:
case O_COW_4:
- /* if cannot move in any direction, becomes an enclosed cow */
+ // if cannot move in any direction, becomes an enclosed cow
if (!is_space_dir(cave, x, y, GD_MV_UP) && !is_space_dir(cave, x, y, GD_MV_DOWN) &&
!is_space_dir(cave, x, y, GD_MV_LEFT) && !is_space_dir(cave, x, y, GD_MV_RIGHT))
store(cave, x, y, O_COW_ENCLOSED_1);
else
{
- /* THIS IS THE CREATURE MOVE thing copied. */
+ // THIS IS THE CREATURE MOVE thing copied.
const GdDirection *creature_move;
- boolean ccw = rotates_ccw(cave, x, y); /* check if default is counterclockwise */
- GdElement base; /* base element number (which is like O_***_1) */
- int dir, dirn, dirp; /* direction */
+ boolean ccw = rotates_ccw(cave, x, y); // check if default is counterclockwise
+ GdElement base; // base element number (which is like O_***_1)
+ int dir, dirn, dirp; // direction
base = O_COW_1;
- dir = get(cave, x, y)-base; /* facing where */
+ dir = get(cave, x, y)-base; // facing where
creature_move = cave->creatures_backwards ? creature_chdir : creature_dir;
- /* now change direction if backwards */
+ // now change direction if backwards
if (cave->creatures_backwards)
ccw = !ccw;
if (ccw)
{
- dirn = (dir + 3) & 3; /* fast turn */
- dirp = (dir + 1) & 3; /* slow turn */
+ dirn = (dir + 3) & 3; // fast turn
+ dirp = (dir + 1) & 3; // slow turn
}
else
{
- dirn = (dir + 1) & 3; /* fast turn */
- dirp = (dir + 3) & 3; /* slow turn */
+ dirn = (dir + 1) & 3; // fast turn
+ dirp = (dir + 3) & 3; // slow turn
}
if (is_space_dir(cave, x, y, creature_move[dirn]))
- move(cave, x, y, creature_move[dirn], base + dirn); /* turn and move to preferred dir */
+ move(cave, x, y, creature_move[dirn], base + dirn); // turn and move to preferred dir
else if (is_space_dir(cave, x, y, creature_move[dir]))
- move(cave, x, y, creature_move[dir], base + dir); /* go on */
+ move(cave, x, y, creature_move[dir], base + dir); // go on
else
- store(cave, x, y, base + dirp); /* turn in place if nothing else possible */
+ store(cave, x, y, base + dirp); // turn in place if nothing else possible
}
break;
- /* enclosed cows wait some time before turning to a skeleton */
+ // enclosed cows wait some time before turning to a skeleton
case O_COW_ENCLOSED_1:
case O_COW_ENCLOSED_2:
case O_COW_ENCLOSED_3:
case O_STONEFLY_2:
case O_STONEFLY_3:
case O_STONEFLY_4:
- /* check if touches a voodoo */
+ // check if touches a voodoo
if (get_dir(cave, x, y, GD_MV_LEFT) == O_VOODOO ||
get_dir(cave, x, y, GD_MV_RIGHT) == O_VOODOO ||
get_dir(cave, x, y, GD_MV_UP) == O_VOODOO ||
get_dir(cave, x, y, GD_MV_DOWN) == O_VOODOO)
cave->voodoo_touched = TRUE;
- /* check if touches something bad and should explode (includes voodoo by the flags) */
+ // check if touches something bad and should explode (includes voodoo by the flags)
if (blows_up_flies_dir(cave, x, y, GD_MV_DOWN) ||
blows_up_flies_dir(cave, x, y, GD_MV_UP) ||
blows_up_flies_dir(cave, x, y, GD_MV_LEFT) ||
blows_up_flies_dir(cave, x, y, GD_MV_RIGHT))
explode (cave, x, y);
- /* otherwise move */
+ // otherwise move
else
{
const GdDirection *creature_move;
- boolean ccw = rotates_ccw(cave, x, y); /* check if default is counterclockwise */
- GdElement base = -1; /* base element number (which is like O_***_1) */
- int dir, dirn, dirp; /* direction */
+ boolean ccw = rotates_ccw(cave, x, y); // check if default is counterclockwise
+ GdElement base = -1; // base element number (which is like O_***_1)
+ int dir, dirn, dirp; // direction
if (get(cave, x, y) >= O_FIREFLY_1 &&
get(cave, x, y) <= O_FIREFLY_4)
get(cave, x, y) <= O_ALT_BUTTER_4)
base = O_ALT_BUTTER_1;
- dir = get(cave, x, y) - base; /* facing where */
+ dir = get(cave, x, y) - base; // facing where
creature_move = cave->creatures_backwards ? creature_chdir : creature_dir;
- /* now change direction if backwards */
+ // now change direction if backwards
if (cave->creatures_backwards)
ccw = !ccw;
if (ccw)
{
- dirn = (dir + 3) & 3; /* fast turn */
- dirp = (dir + 1) & 3; /* slow turn */
+ dirn = (dir + 3) & 3; // fast turn
+ dirp = (dir + 1) & 3; // slow turn
}
else
{
- dirn = (dir + 1) & 3; /* fast turn */
- dirp = (dir + 3) & 3; /* slow turn */
+ dirn = (dir + 1) & 3; // fast turn
+ dirp = (dir + 3) & 3; // slow turn
}
if (is_space_dir(cave, x, y, creature_move[dirn]))
- move(cave, x, y, creature_move[dirn], base + dirn); /* turn and move to preferred dir */
+ move(cave, x, y, creature_move[dirn], base + dirn); // turn and move to preferred dir
else if (is_space_dir(cave, x, y, creature_move[dir]))
- move(cave, x, y, creature_move[dir], base + dir); /* go on */
+ move(cave, x, y, creature_move[dir], base + dir); // go on
else
- store(cave, x, y, base + dirp); /* turn in place if nothing else possible */
+ store(cave, x, y, base + dirp); // turn in place if nothing else possible
}
break;
case O_WAITING_STONE:
if (is_space_dir(cave, x, y, grav_compat))
{
- /* beginning to fall */
- /* it wakes up. */
+ // beginning to fall
+ // it wakes up.
move(cave, x, y, grav_compat, O_CHASING_STONE);
}
else if (sloped_dir(cave, x, y, grav_compat, opposite[grav_compat]))
{
- /* rolling down a brick wall or a stone */
+ // rolling down a brick wall or a stone
if (sloped_dir(cave, x, y, grav_compat, cw_fourth[grav_compat]) &&
is_space_dir(cave, x, y, cw_fourth[grav_compat]) &&
is_space_dir(cave, x, y, cw_eighth[grav_compat]))
{
- /* maybe rolling left - see case O_STONE to understand why we use cw_fourth here */
+ // maybe rolling left - see case O_STONE to understand why we use cw_fourth here
move(cave, x, y, cw_fourth[grav_compat], O_WAITING_STONE);
}
else if (sloped_dir(cave, x, y, grav_compat, ccw_fourth[grav_compat]) &&
is_space_dir(cave, x, y, ccw_fourth[grav_compat]) &&
is_space_dir(cave, x, y, ccw_eighth[grav_compat]))
{
- /* or maybe right */
+ // or maybe right
move(cave, x, y, ccw_fourth[grav_compat], O_WAITING_STONE);
}
}
boolean dont_move = FALSE;
int i = 3;
- /* try to move... */
+ // try to move...
while (1)
{
if (horizontal)
{
- /*********************************/
- /* check for a horizontal movement */
+ // ------------------------------------------------------------
+ // check for a horizontal movement
+ // ------------------------------------------------------------
if (px == x)
{
- /* if coordinates are the same */
+ // if coordinates are the same
i -= 1;
horizontal = !horizontal;
}
else
{
- /********************************/
- /* check for a vertical movement */
+ // ------------------------------------------------------------
+ // check for a vertical movement
+ // ------------------------------------------------------------
if (py == y)
{
- /* if coordinates are the same */
+ // if coordinates are the same
i -= 1;
horizontal = !horizontal;
if (i == 2)
break;
}
- /* if we should move in both directions, but can not move in any, stop. */
+ // if we should move in both directions, but can not move in any, stop.
if (!dont_move)
{
if (horizontal)
{
- /* check for horizontal */
+ // check for horizontal
if (x >= px)
{
if (is_space_dir(cave, x, y, GD_MV_UP) &&
}
else
{
- /* check for vertical */
+ // check for vertical
if (y >= py)
{
if (is_space_dir(cave, x, y, GD_MV_LEFT) &&
cave->replicators_active &&
!cave->gravity_disabled)
{
- /* only replicate, if space is under it. */
- /* do not replicate players! */
- /* also obeys gravity settings. */
- /* only replicate element if it is not a scanned one */
- /* do not replicate space... that condition looks like it
- makes no sense, but otherwise it generates SCANNED spaces,
- which cannot be "collected" by the player, so he cannot run
- under a replicator */
+ // only replicate, if space is under it.
+ // do not replicate players!
+ // also obeys gravity settings.
+ // only replicate element if it is not a scanned one
+ // do not replicate space... that condition looks like it
+ // makes no sense, but otherwise it generates SCANNED spaces,
+ // which cannot be "collected" by the player, so he cannot run
+ // under a replicator
if (is_space_dir(cave, x, y, cave->gravity) &&
!is_player_dir(cave, x, y, opposite[cave->gravity]) &&
!is_space_dir(cave, x, y, opposite[cave->gravity]))
GD_MV_LEFT
};
- /* direction, last two bits 0..3 */
+ // direction, last two bits 0..3
int dir = get(cave, x, y) - O_BITER_1;
int dirn = (dir + 3) & 3;
int dirp = (dir + 1) & 3;
{
move(cave, x, y, biter_move[dir], O_BITER_1 + dir);
if (biter_try[i] != O_SPACE)
- made_sound_of = O_BITER_1; /* sound of a biter eating */
+ made_sound_of = O_BITER_1; // sound of a biter eating
break;
}
else if (is_element_dir(cave, x, y, biter_move[dirn], biter_try[i]))
{
move(cave, x, y, biter_move[dirn], O_BITER_1 + dirn);
if (biter_try[i] != O_SPACE)
- made_sound_of = O_BITER_1; /* sound of a biter eating */
+ made_sound_of = O_BITER_1; // sound of a biter eating
break;
}
else if (is_element_dir(cave, x, y, biter_move[dirp], biter_try[i]))
{
move(cave, x, y, biter_move[dirp], O_BITER_1 + dirp);
if (biter_try[i] != O_SPACE)
- made_sound_of = O_BITER_1; /* sound of a biter eating */
+ made_sound_of = O_BITER_1; // sound of a biter eating
break;
}
}
if (i == ARRAY_SIZE(biter_try))
- /* i = number of elements in array: could not move, so just turn */
+ // i = number of elements in array: could not move, so just turn
store(cave, x, y, O_BITER_1 + dirp);
else if (biter_try[i] == O_STONE)
{
- /* if there was a stone there, where we moved...
- do not eat stones, just throw them back */
+ // if there was a stone there, where we moved...
+ // do not eat stones, just throw them back
store(cave, x, y, O_STONE);
made_sound_of = O_STONE;
}
- /* if biter did move, we had sound. play it. */
+ // if biter did move, we had sound. play it.
if (made_sound_of != O_NONE)
play_sound_of_element(cave, made_sound_of, x, y);
}
case O_DRAGONFLY_2:
case O_DRAGONFLY_3:
case O_DRAGONFLY_4:
- /* check if touches a voodoo */
+ // check if touches a voodoo
if (get_dir(cave, x, y, GD_MV_LEFT) == O_VOODOO ||
get_dir(cave, x, y, GD_MV_RIGHT) == O_VOODOO ||
get_dir(cave, x, y, GD_MV_UP) == O_VOODOO ||
get_dir(cave, x, y, GD_MV_DOWN) == O_VOODOO)
cave->voodoo_touched = TRUE;
- /* check if touches something bad and should explode (includes voodoo by the flags) */
+ // check if touches something bad and should explode (includes voodoo by the flags)
if (blows_up_flies_dir(cave, x, y, GD_MV_DOWN) ||
blows_up_flies_dir(cave, x, y, GD_MV_UP) ||
blows_up_flies_dir(cave, x, y, GD_MV_LEFT) ||
blows_up_flies_dir(cave, x, y, GD_MV_RIGHT))
explode (cave, x, y);
- /* otherwise move */
+ // otherwise move
else
{
const GdDirection *creature_move;
- boolean ccw = rotates_ccw(cave, x, y); /* check if default is counterclockwise */
- GdElement base = O_DRAGONFLY_1; /* base element number (which is like O_***_1) */
- int dir, dirn; /* direction */
+ boolean ccw = rotates_ccw(cave, x, y); // check if default is counterclockwise
+ GdElement base = O_DRAGONFLY_1; // base element number (which is like O_***_1)
+ int dir, dirn; // direction
- dir = get(cave, x, y)-base; /* facing where */
+ dir = get(cave, x, y)-base; // facing where
creature_move = cave->creatures_backwards ? creature_chdir : creature_dir;
- /* now change direction if backwards */
+ // now change direction if backwards
if (cave->creatures_backwards)
ccw = !ccw;
if (ccw)
- dirn = (dir + 3) & 3; /* fast turn */
+ dirn = (dir + 3) & 3; // fast turn
else
- dirn = (dir + 1) & 3; /* fast turn */
+ dirn = (dir + 1) & 3; // fast turn
- /* if can move forward, does so. */
+ // if can move forward, does so.
if (is_space_dir(cave, x, y, creature_move[dir]))
move(cave, x, y, creature_move[dir], base + dir);
else
- /* otherwise turns 90 degrees in place. */
+ // otherwise turns 90 degrees in place.
store(cave, x, y, base + dirn);
}
break;
case O_BLADDER_6:
case O_BLADDER_7:
case O_BLADDER_8:
- /* bladder with any delay state: try to convert to clock. */
+ // bladder with any delay state: try to convert to clock.
if (is_element_dir(cave, x, y, opposite[grav_compat], cave->bladder_converts_by) ||
is_element_dir(cave, x, y, cw_fourth[grav_compat], cave->bladder_converts_by) || is_element_dir(cave, x, y, ccw_fourth[grav_compat], cave->bladder_converts_by))
{
- /* if touches the specified element, let it be a clock */
+ // if touches the specified element, let it be a clock
store(cave, x, y, O_PRE_CLOCK_1);
- /* plays the bladder convert sound */
+ // plays the bladder convert sound
play_sound_of_element(cave, O_PRE_CLOCK_1, x, y);
}
else
{
- /* is space over the bladder? */
+ // is space over the bladder?
if (is_space_dir(cave, x, y, opposite[grav_compat]))
{
if (get(cave, x, y) == O_BLADDER_8)
{
- /* if it is a bladder 8, really move up */
+ // if it is a bladder 8, really move up
move(cave, x, y, opposite[grav_compat], O_BLADDER_1);
play_sound_of_element(cave, O_BLADDER, x, y);
}
else
- /* if smaller delay, just increase delay. */
+ // if smaller delay, just increase delay.
next(cave, x, y);
}
else
- /* if not space, is something sloped over the bladder? */
+ // if not space, is something sloped over the bladder?
if (sloped_for_bladder_dir(cave, x, y, opposite[grav_compat]) &&
sloped_dir(cave, x, y, opposite[grav_compat], opposite[grav_compat]))
{
is_space_dir(cave, x, y, ccw_fourth[opposite[grav_compat]]) &&
is_space_dir(cave, x, y, ccw_eighth[opposite[grav_compat]]))
{
- /* rolling up, to left */
+ // rolling up, to left
if (get(cave, x, y) == O_BLADDER_8)
{
- /* if it is a bladder 8, really roll */
+ // if it is a bladder 8, really roll
move(cave, x, y, ccw_fourth[opposite[grav_compat]], O_BLADDER_8);
play_sound_of_element(cave, O_BLADDER, x, y);
}
else
- /* if smaller delay, just increase delay. */
+ // if smaller delay, just increase delay.
next(cave, x, y);
}
else if (sloped_dir(cave, x, y, opposite[grav_compat], cw_fourth[opposite[grav_compat]]) &&
is_space_dir(cave, x, y, cw_fourth[opposite[grav_compat]]) &&
is_space_dir(cave, x, y, cw_eighth[opposite[grav_compat]]))
{
- /* rolling up, to left */
+ // rolling up, to left
if (get(cave, x, y) == O_BLADDER_8)
{
- /* if it is a bladder 8, really roll */
+ // if it is a bladder 8, really roll
move(cave, x, y, cw_fourth[opposite[grav_compat]], O_BLADDER_8);
play_sound_of_element(cave, O_BLADDER, x, y);
}
else
- /* if smaller delay, just increase delay. */
+ // if smaller delay, just increase delay.
next(cave, x, y);
}
}
- /* no space, no sloped thing over it - store bladder 1 and that is for now. */
+ // no space, no sloped thing over it - store bladder 1 and that is for now.
else
store(cave, x, y, O_BLADDER_1);
}
{
int i;
- /* the ghost is given four possibilities to move. */
+ // the ghost is given four possibilities to move.
for (i = 0; i < 4; i++)
{
static GdDirection dirs[] =
if (is_space_dir(cave, x, y, random_dir))
{
move(cave, x, y, random_dir, O_GHOST);
- break; /* ghost did move -> exit loop */
+ break; // ghost did move -> exit loop
}
}
}
break;
- /*
- * A C T I V E E L E M E N T S
- */
+ // ============================================================================
+ // A C T I V E E L E M E N T S
+ // ============================================================================
case O_AMOEBA:
amoeba_count++;
case GD_AM_SLEEPING:
case GD_AM_AWAKE:
- /* if no amoeba found during THIS SCAN yet, which was able to grow, check this one. */
+ // if no amoeba found during THIS SCAN yet, which was able to grow, check this one.
if (amoeba_found_enclosed)
- /* if still found enclosed, check all four directions,
- if this one is able to grow. */
+ // if still found enclosed, check all four directions, if this one is able to grow.
if (amoeba_eats_dir(cave, x, y, GD_MV_UP) ||
amoeba_eats_dir(cave, x, y, GD_MV_DOWN) ||
amoeba_eats_dir(cave, x, y, GD_MV_LEFT) ||
amoeba_eats_dir(cave, x, y, GD_MV_RIGHT))
{
- /* not enclosed. this is a local (per scan) flag! */
+ // not enclosed. this is a local (per scan) flag!
amoeba_found_enclosed = FALSE;
cave->amoeba_state = GD_AM_AWAKE;
}
- /* if alive, check in which dir to grow (or not) */
+ // if alive, check in which dir to grow (or not)
if (cave->amoeba_state == GD_AM_AWAKE)
{
if (gd_rand_int_range(cave->random, 0, 1000000) < cave->amoeba_growth_prob)
{
switch (gd_rand_int_range(cave->random, 0, 4))
{
- /* decided to grow, choose a random direction. */
- case 0: /* let this be up. numbers indifferent. */
+ // decided to grow, choose a random direction.
+ case 0: // let this be up. numbers indifferent.
if (amoeba_eats_dir(cave, x, y, GD_MV_UP))
store_dir(cave, x, y, GD_MV_UP, O_AMOEBA);
break;
- case 1: /* down */
+ case 1: // down
if (amoeba_eats_dir(cave, x, y, GD_MV_DOWN))
store_dir(cave, x, y, GD_MV_DOWN, O_AMOEBA);
break;
- case 2: /* left */
+ case 2: // left
if (amoeba_eats_dir(cave, x, y, GD_MV_LEFT))
store_dir(cave, x, y, GD_MV_LEFT, O_AMOEBA);
break;
- case 3: /* right */
+ case 3: // right
if (amoeba_eats_dir(cave, x, y, GD_MV_RIGHT))
store_dir(cave, x, y, GD_MV_RIGHT, O_AMOEBA);
break;
case O_AMOEBA_2:
amoeba_2_count++;
- /* check if it is touching an amoeba, and explosion is enabled */
+ // check if it is touching an amoeba, and explosion is enabled
if (cave->amoeba_2_explodes_by_amoeba &&
(is_element_dir(cave, x, y, GD_MV_DOWN, O_AMOEBA) ||
is_element_dir(cave, x, y, GD_MV_UP, O_AMOEBA) ||
case GD_AM_SLEEPING:
case GD_AM_AWAKE:
- /* if no amoeba found during THIS SCAN yet, which was able to grow, check this one. */
+ // if no amoeba found during THIS SCAN yet, which was able to grow, check this one.
if (amoeba_2_found_enclosed)
if (amoeba_eats_dir(cave, x, y, GD_MV_UP) ||
amoeba_eats_dir(cave, x, y, GD_MV_DOWN) ||
amoeba_eats_dir(cave, x, y, GD_MV_LEFT) ||
amoeba_eats_dir(cave, x, y, GD_MV_RIGHT))
{
- /* not enclosed. this is a local (per scan) flag! */
+ // not enclosed. this is a local (per scan) flag!
amoeba_2_found_enclosed = FALSE;
cave->amoeba_2_state = GD_AM_AWAKE;
}
- /* if it is alive, decide if it attempts to grow */
+ // if it is alive, decide if it attempts to grow
if (cave->amoeba_2_state == GD_AM_AWAKE)
if (gd_rand_int_range(cave->random, 0, 1000000) < cave->amoeba_2_growth_prob)
{
switch (gd_rand_int_range(cave->random, 0, 4))
{
- /* decided to grow, choose a random direction. */
- case 0: /* let this be up. numbers indifferent. */
+ // decided to grow, choose a random direction.
+ case 0: // let this be up. numbers indifferent.
if (amoeba_eats_dir(cave, x, y, GD_MV_UP))
store_dir(cave, x, y, GD_MV_UP, O_AMOEBA_2);
break;
- case 1: /* down */
+ case 1: // down
if (amoeba_eats_dir(cave, x, y, GD_MV_DOWN))
store_dir(cave, x, y, GD_MV_DOWN, O_AMOEBA_2);
break;
- case 2: /* left */
+ case 2: // left
if (amoeba_eats_dir(cave, x, y, GD_MV_LEFT))
store_dir(cave, x, y, GD_MV_LEFT, O_AMOEBA_2);
break;
- case 3: /* right */
+ case 3: // right
if (amoeba_eats_dir(cave, x, y, GD_MV_RIGHT))
store_dir(cave, x, y, GD_MV_RIGHT, O_AMOEBA_2);
break;
break;
case O_ACID:
- /* choose randomly, if it spreads */
+ // choose randomly, if it spreads
if (gd_rand_int_range(cave->random, 0, 1000000) <= cave->acid_spread_ratio)
{
- /* the current one explodes */
+ // the current one explodes
store(cave, x, y, cave->acid_turns_to);
- /* and if neighbours are eaten, put acid there. */
+ // and if neighbours are eaten, put acid there.
if (is_element_dir(cave, x, y, GD_MV_UP, cave->acid_eats_this))
{
play_sound_of_element(cave, O_ACID, x, y);
found_water = TRUE;
if (!cave->water_does_not_flow_down &&
is_space_dir(cave, x, y, GD_MV_DOWN))
- /* emulating the odd behaviour in crdr */
+ // emulating the odd behaviour in crdr
store_dir(cave, x, y, GD_MV_DOWN, O_WATER_1);
if (is_space_dir(cave, x, y, GD_MV_UP))
case O_V_EXPANDING_WALL:
case O_H_EXPANDING_STEEL_WALL:
case O_V_EXPANDING_STEEL_WALL:
- /* checks first if direction is changed. */
+ // checks first if direction is changed.
if (((get(cave, x, y) == O_H_EXPANDING_WALL ||
get(cave, x, y) == O_H_EXPANDING_STEEL_WALL) &&
!cave->expanding_wall_changed) ||
case O_EXPANDING_WALL:
case O_EXPANDING_STEEL_WALL:
- /* the wall which grows in all four directions. */
+ // the wall which grows in all four directions.
if (is_space_dir(cave, x, y, GD_MV_LEFT))
{
store_dir(cave, x, y, GD_MV_LEFT, get(cave, x, y));
#if 1
; // to make compilers happy ...
#else
- Info("Step[%03d]", cave->frame); /* XXX */
+ Info("Step[%03d]", cave->frame); // XXX
#endif
int rrr = gd_cave_c64_random(cave);
#if 1
GdDirection grav = cave->gravity;
GdDirection oppos = opposite[cave->gravity];
- /* space under the slime? elements may pass from top to bottom then. */
+ // space under the slime? elements may pass from top to bottom then.
if (is_space_dir(cave, x, y, grav))
{
if (get_dir(cave, x, y, oppos) == cave->slime_eats_1)
{
- /* output a falling xy under */
+ // output a falling xy under
store_dir(cave, x, y, grav, cave->slime_converts_1);
store_dir(cave, x, y, oppos, O_SPACE);
}
else if (get_dir(cave, x, y, oppos) == O_WAITING_STONE)
{
- /* waiting stones pass without awakening */
+ // waiting stones pass without awakening
store_dir(cave, x, y, grav, O_WAITING_STONE);
store_dir(cave, x, y, oppos, O_SPACE);
play_sound_of_element(cave, O_SLIME, x, y);
}
else if (get_dir(cave, x, y, oppos) == O_CHASING_STONE)
{
- /* chasing stones pass */
+ // chasing stones pass
store_dir(cave, x, y, grav, O_CHASING_STONE);
store_dir(cave, x, y, oppos, O_SPACE);
play_sound_of_element(cave, O_SLIME, x, y);
}
}
else
- /* or space over the slime? elements may pass from bottom to up then. */
+ // or space over the slime? elements may pass from bottom to up then.
if (is_space_dir(cave, x, y, oppos))
{
if (get_dir(cave, x, y, grav) == O_BLADDER)
{
- /* bladders move UP the slime */
+ // bladders move UP the slime
store_dir(cave, x, y, grav, O_SPACE);
store_dir(cave, x, y, oppos, O_BLADDER_1);
play_sound_of_element(cave, O_SLIME, x, y);
case O_FALLING_WALL:
if (is_space_dir(cave, x, y, grav_compat))
{
- /* try falling if space under. */
+ // try falling if space under.
int yy;
for (yy = y + 1; yy < y + cave->h; yy++)
- /* yy < y + cave->h is to check everything OVER the wall - since caves wrap around !! */
+ // yy < y + cave->h is to check everything OVER the wall - since caves wrap around !!
if (get(cave, x, yy) != O_SPACE)
- /* stop cycle when other than space */
+ // stop cycle when other than space
break;
- /* if scanning stopped by a player... start falling! */
+ // if scanning stopped by a player... start falling!
if (get(cave, x, yy) == O_PLAYER ||
get(cave, x, yy) == O_PLAYER_GLUED ||
get(cave, x, yy) == O_PLAYER_BOMB)
{
move(cave, x, y, grav_compat, O_FALLING_WALL_F);
- /* no sound when the falling wall starts falling! */
+ // no sound when the falling wall starts falling!
}
}
break;
case O_PLAYER:
case O_PLAYER_GLUED:
case O_PLAYER_BOMB:
- /* if player under, it explodes - the falling wall, not the player! */
+ // if player under, it explodes - the falling wall, not the player!
explode(cave, x, y);
break;
case O_SPACE:
- /* continue falling */
+ // continue falling
move(cave, x, y, grav_compat, O_FALLING_WALL_F);
break;
default:
- /* stop */
+ // stop
play_sound_of_element(cave, get(cave, x, y), x, y);
store(cave, x, y, O_FALLING_WALL);
break;
}
break;
- /*
- * C O N V E Y O R B E L T S
- */
+ // ============================================================================
+ // C O N V E Y O R B E L T S
+ // ============================================================================
case O_CONVEYOR_RIGHT:
case O_CONVEYOR_LEFT:
- /* only works if gravity is up or down!!! */
- /* first, check for gravity and running belts. */
+ // only works if gravity is up or down!!!
+ // first, check for gravity and running belts.
if (!cave->gravity_disabled && cave->conveyor_belts_active)
{
const GdDirection *dir;
boolean left;
- /* decide direction */
+ // decide direction
left = get(cave, x, y) != O_CONVEYOR_RIGHT;
if (cave->conveyor_belts_direction_changed)
left = !left;
dir = left ? ccw_eighth : cw_eighth;
- /* CHECK IF IT CONVEYS THE ELEMENT ABOVE IT */
- /* if gravity is normal, and the conveyor belt has something
- ABOVE which can be moved
- OR
- the gravity is up, so anything that should float now goes
- DOWN and touches the conveyor */
+ // CHECK IF IT CONVEYS THE ELEMENT ABOVE IT
+ // if gravity is normal, and the conveyor belt has something
+ // ABOVE which can be moved
+ // OR
+ // the gravity is up, so anything that should float now goes
+ // DOWN and touches the conveyor
if ((cave->gravity == GD_MV_DOWN &&
moved_by_conveyor_top_dir(cave, x, y, GD_MV_UP)) ||
(cave->gravity == GD_MV_UP &&
if (!is_scanned_dir(cave, x, y, GD_MV_UP) &&
is_space_dir(cave, x, y, dir[GD_MV_UP]))
{
- store_dir(cave, x, y, dir[GD_MV_UP], get_dir(cave, x, y, GD_MV_UP)); /* move */
- store_dir(cave, x, y, GD_MV_UP, O_SPACE); /* and place a space. */
+ store_dir(cave, x, y, dir[GD_MV_UP], get_dir(cave, x, y, GD_MV_UP)); // move
+ store_dir(cave, x, y, GD_MV_UP, O_SPACE); // and place a space.
}
}
- /* CHECK IF IT CONVEYS THE ELEMENT BELOW IT */
+ // CHECK IF IT CONVEYS THE ELEMENT BELOW IT
if ((cave->gravity == GD_MV_UP &&
moved_by_conveyor_top_dir(cave, x, y, GD_MV_DOWN)) ||
(cave->gravity == GD_MV_DOWN &&
if (!is_scanned_dir(cave, x, y, GD_MV_DOWN) &&
is_space_dir(cave, x, y, dir[GD_MV_DOWN]))
{
- store_dir(cave, x, y, dir[GD_MV_DOWN], get_dir(cave, x, y, GD_MV_DOWN)); /* move */
- store_dir(cave, x, y, GD_MV_DOWN, O_SPACE); /* and clear. */
+ store_dir(cave, x, y, dir[GD_MV_DOWN], get_dir(cave, x, y, GD_MV_DOWN)); // move
+ store_dir(cave, x, y, GD_MV_DOWN, O_SPACE); // and clear.
}
}
}
break;
- /*
- * S I M P L E C H A N G I N G; E X P L O S I O N S
- */
+ // ============================================================================
+ // S I M P L E C H A N G I N G; E X P L O S I O N S
+ // ============================================================================
case O_EXPLODE_5:
store(cave, x, y, cave->explosion_effect);
break;
case O_PRE_OUTBOX:
- if (cave->gate_open) /* if no more diamonds needed */
- store(cave, x, y, O_OUTBOX); /* open outbox */
+ if (cave->gate_open) // if no more diamonds needed
+ store(cave, x, y, O_OUTBOX); // open outbox
break;
case O_PRE_INVIS_OUTBOX:
- if (cave->gate_open) /* if no more diamonds needed */
- store(cave, x, y, O_INVIS_OUTBOX); /* open outbox. invisible one :P */
+ if (cave->gate_open) // if no more diamonds needed
+ store(cave, x, y, O_INVIS_OUTBOX); // open outbox. invisible one :P
break;
case O_INBOX:
- if (cave->hatched && !inbox_toggle) /* if it is time of birth */
+ if (cave->hatched && !inbox_toggle) // if it is time of birth
store(cave, x, y, O_PRE_PL_1);
inbox_toggle = !inbox_toggle;
break;
case O_AMOEBA_2_EXPL_1:
case O_AMOEBA_2_EXPL_2:
case O_AMOEBA_2_EXPL_3:
- /* simply the next identifier */
+ // simply the next identifier
next(cave, x, y);
break;
case O_WATER_13:
case O_WATER_14:
case O_WATER_15:
- found_water = TRUE; /* for sound */
- /* simply the next identifier */
+ found_water = TRUE; // for sound
+ // simply the next identifier
next(cave, x, y);
break;
break;
default:
- /* other inanimate elements that do nothing */
+ // other inanimate elements that do nothing
break;
}
}
}
- /* POSTPROCESSING */
- /* another scan-like routine: */
- /* short explosions (for example, in bd1) started with explode_2. */
- /* internally we use explode_1; and change it to explode_2 if needed. */
+ // ============================================================================
+ // POSTPROCESSING
+ // ============================================================================
+
+ // another scan-like routine:
+ // short explosions (for example, in bd1) started with explode_2.
+ // internally we use explode_1; and change it to explode_2 if needed.
if (cave->short_explosions)
{
for (y = 0; y < cave->h; y++)
{
if (is_first_stage_of_explosion(cave, x, y))
{
- next(cave, x, y); /* select next frame of explosion */
+ next(cave, x, y); // select next frame of explosion
- /* forget scanned flag immediately */
+ // forget scanned flag immediately
store(cave, x, y, get(cave, x, y) & ~SCANNED);
}
}
}
}
- /* finally: forget "scanned" flags for objects. */
- /* also, check for time penalties. */
- /* these is something like an effect table, but we do not really use one. */
+ // finally: forget "scanned" flags for objects.
+ // also, check for time penalties.
+ // these is something like an effect table, but we do not really use one.
for (y = 0; y < cave->h; y++)
{
for (x = 0; x < cave->w; x++)
{
store(cave, x, y, O_GRAVESTONE);
- /* there is time penalty for destroying the voodoo */
+ // there is time penalty for destroying the voodoo
time_decrement_sec += cave->time_penalty;
}
}
}
- /* this loop finds the coordinates of the player. needed for scrolling and chasing stone.*/
- /* but we only do this, if a living player was found. if not yet, the setup
- routine coordinates are used */
+ // this loop finds the coordinates of the player. needed for scrolling and chasing stone.
+ // but we only do this, if a living player was found. if not yet, the setup
+ // routine coordinates are used
if (cave->player_state == GD_PL_LIVING)
{
if (cave->active_is_first_found)
{
- /* to be 1stb compatible, we do everything backwards. */
+ // to be 1stb compatible, we do everything backwards.
for (y = cave->h - 1; y >= 0; y--)
{
for (x = cave->w - 1; x >= 0; x--)
{
if (is_player(cave, x, y))
{
- /* here we remember the coordinates. */
+ // here we remember the coordinates.
cave->player_x = x;
cave->player_y = y;
}
}
else
{
- /* as in the original: look for the last one */
+ // as in the original: look for the last one
for (y = 0; y < cave->h; y++)
{
for (x = 0; x < cave->w; x++)
{
if (is_player(cave, x, y))
{
- /* here we remember the coordinates. */
+ // here we remember the coordinates.
cave->player_x = x;
cave->player_y = y;
}
}
}
- /* record coordinates of player for chasing stone */
+ // record coordinates of player for chasing stone
for (i = 0; i < ARRAY_SIZE(cave->px) - 1; i++)
{
cave->px[i] = cave->px[i + 1];
cave->px[ARRAY_SIZE(cave->px) - 1] = cave->player_x;
cave->py[ARRAY_SIZE(cave->py) - 1] = cave->player_y;
- /* SCHEDULING */
+ // SCHEDULING
- /* update timing calculated by iterating and counting elements */
+ // update timing calculated by iterating and counting elements
update_cave_speed(cave);
- /* cave 3 sounds. precedence is controlled by the sound_play function. */
- /* but we have to check amoeba&magic together as they had a different gritty sound when mixed */
+ // cave 3 sounds. precedence is controlled by the sound_play function.
+ // but we have to check amoeba&magic together as they had a different gritty sound when mixed
if (found_water)
gd_sound_play(cave, GD_S_WATER, O_WATER, -1, -1);
play_sound_of_element(cave, O_AMOEBA, x, y);
}
- /* pneumatic hammer sound - overrides everything. */
+ // pneumatic hammer sound - overrides everything.
if (cave->pneumatic_hammer_active_delay > 0)
gd_sound_play(cave, GD_S_PNEUMATIC_HAMMER, O_PNEUMATIC_HAMMER, -1, -1);
- /* CAVE VARIABLES */
- /* PLAYER */
+ // ============================================================================
+ // CAVE VARIABLES
+ // ============================================================================
- /* check if player is alive. */
+ // PLAYER
+
+ // check if player is alive.
if ((cave->player_state == GD_PL_LIVING && cave->player_seen_ago > 15) || cave->kill_player)
cave->player_state = GD_PL_DIED;
- /* check if any voodoo exploded, and kill players the next scan if that happended. */
+ // check if any voodoo exploded, and kill players the next scan if that happended.
if (cave->voodoo_touched)
cave->kill_player = TRUE;
- /* AMOEBA */
+ // AMOEBA
- /* check flags after evaluating. */
+ // check flags after evaluating.
if (cave->amoeba_state == GD_AM_AWAKE)
{
if (amoeba_count >= cave->amoeba_max_count)
cave->amoeba_state = GD_AM_ENCLOSED;
}
- /* amoeba can also be turned into diamond by magic wall */
+ // amoeba can also be turned into diamond by magic wall
if (cave->magic_wall_stops_amoeba && cave->magic_wall_state == GD_MW_ACTIVE)
cave->amoeba_state = GD_AM_ENCLOSED;
- /* AMOEBA 2 */
+ // AMOEBA 2
if (cave->amoeba_2_state == GD_AM_AWAKE)
{
- /* check flags after evaluating. */
+ // check flags after evaluating.
if (amoeba_2_count >= cave->amoeba_2_max_count)
cave->amoeba_2_state = GD_AM_TOO_BIG;
cave->amoeba_2_state = GD_AM_ENCLOSED;
}
- /* amoeba 2 can also be turned into diamond by magic wall */
+ // amoeba 2 can also be turned into diamond by magic wall
if (cave->magic_wall_stops_amoeba && cave->magic_wall_state == GD_MW_ACTIVE)
cave->amoeba_2_state = GD_AM_ENCLOSED;
- /* now check times. --------------------------- */
- /* decrement time if a voodoo was killed. */
+ // now check times. ---------------------------
+ // decrement time if a voodoo was killed.
cave->time -= time_decrement_sec * cave->timing_factor;
if (cave->time < 0)
cave->time = 0;
- /* only decrement time when player is already born. */
+ // only decrement time when player is already born.
if (cave->hatched)
{
int secondsbefore, secondsafter;
secondsafter = cave->time / cave->timing_factor;
if (cave->time / cave->timing_factor < 10)
- /* if less than 10 seconds, no walking sound, but play explosion sound */
+ // if less than 10 seconds, no walking sound, but play explosion sound
gd_sound_play(cave, GD_S_NONE, O_NONE, -1, -1);
if (secondsbefore != secondsafter)
gd_cave_set_seconds_sound(cave);
}
- /* a gravity switch was activated; seconds counting down */
+ // a gravity switch was activated; seconds counting down
if (cave->gravity_will_change > 0)
{
cave->gravity_will_change -= cave->speed;
if (cave->gravity_will_change == 0)
{
cave->gravity = cave->gravity_next_direction;
- gd_sound_play(cave, GD_S_GRAVITY_CHANGING, O_GRAVITY_SWITCH, -1, -1); /* takes precedence over amoeba and magic wall sound */
+ gd_sound_play(cave, GD_S_GRAVITY_CHANGING, O_GRAVITY_SWITCH, -1, -1); // takes precedence over amoeba and magic wall sound
}
}
- /* creatures direction automatically change */
+ // creatures direction automatically change
if (cave->creatures_direction_will_change > 0)
{
cave->creatures_direction_will_change -= cave->speed;
}
}
- /* magic wall; if active&wait or not wait for hatching */
+ // magic wall; if active&wait or not wait for hatching
if (cave->magic_wall_state == GD_MW_ACTIVE &&
(cave->hatched || !cave->magic_timer_wait_for_hatching))
{
cave->magic_wall_state = GD_MW_EXPIRED;
}
- /* we may wait for hatching, when starting amoeba */
+ // we may wait for hatching, when starting amoeba
if (cave->amoeba_timer_started_immediately ||
(cave->amoeba_state == GD_AM_AWAKE &&
(cave->hatched || !cave->amoeba_timer_wait_for_hatching)))
cave->amoeba_growth_prob = cave->amoeba_fast_growth_prob;
}
- /* we may wait for hatching, when starting amoeba */
+ // we may wait for hatching, when starting amoeba
if (cave->amoeba_timer_started_immediately ||
(cave->amoeba_2_state == GD_AM_AWAKE &&
(cave->hatched || !cave->amoeba_timer_wait_for_hatching)))
cave->amoeba_2_growth_prob = cave->amoeba_2_fast_growth_prob;
}
- /* check for player hatching. */
+ // check for player hatching.
start_signal = FALSE;
- /* if not the c64 scheduling, but the correct frametime is used,
- hatching delay should always be decremented. */
- /* otherwise, the if (millisecs...) condition below will set this. */
+ // if not the c64 scheduling, but the correct frametime is used,
+ // hatching delay should always be decremented.
+ // otherwise, the if (millisecs...) condition below will set this.
if (cave->scheduling == GD_SCHEDULING_MILLISECONDS)
{
- /* NON-C64 scheduling */
+ // NON-C64 scheduling
if (cave->hatching_delay_frame > 0)
{
- /* for milliseconds-based, non-c64 schedulings, hatching delay means frames. */
+ // for milliseconds-based, non-c64 schedulings, hatching delay means frames.
cave->hatching_delay_frame--;
if (cave->hatching_delay_frame == 0)
start_signal = TRUE;
}
else
{
- /* C64 scheduling */
+ // C64 scheduling
if (cave->hatching_delay_time > 0)
{
- /* for c64 schedulings, hatching delay means milliseconds. */
+ // for c64 schedulings, hatching delay means milliseconds.
cave->hatching_delay_time -= cave->speed;
if (cave->hatching_delay_time <= 0)
{
}
}
- /* if decremented hatching, and it became zero: */
+ // if decremented hatching, and it became zero:
if (start_signal)
{
- /* THIS IS THE CAVE START SIGNAL */
+ // THIS IS THE CAVE START SIGNAL
- /* record that now the cave is in its normal state */
+ // record that now the cave is in its normal state
cave->hatched = TRUE;
- /* if diamonds needed is below zero, we count the available diamonds now. */
+ // if diamonds needed is below zero, we count the available diamonds now.
gd_cave_count_diamonds(cave);
- /* setup direction auto change */
+ // setup direction auto change
if (cave->creatures_direction_auto_change_time)
{
cave->creatures_direction_will_change =
gd_sound_play(cave, GD_S_CRACKING, O_INBOX, -1, -1);
}
- /* for biters */
+ // for biters
if (cave->biters_wait_frame == 0)
cave->biters_wait_frame = cave->biter_delay_frame;
else
cave->biters_wait_frame--;
- /* replicators delay */
+ // replicators delay
if (cave->replicators_wait_frame == 0)
cave->replicators_wait_frame = cave->replicator_delay_frame;
else
cave->replicators_wait_frame--;
- /* LAST THOUGTS */
+
+ // ============================================================================
+ // LAST THOUGTS
+ // ============================================================================
#if 1
- /* check if cave failed by timeout is done in main game engine */
+ // check if cave failed by timeout is done in main game engine
#else
- /* check if cave failed by timeout */
+ // check if cave failed by timeout
if (cave->player_state == GD_PL_LIVING && cave->time == 0)
{
gd_cave_clear_sounds(cave);
}
#endif
- /* set these for drawing. */
+ // set these for drawing.
cave->last_direction = player_move;
- /* here we remember last movements for animation. this is needed here,
- as animation is in sync with the game, not the keyboard directly.
- (for example, after exiting the cave, the player was "running" in the
- original, till bonus points were counted for remaining time and so on. */
+
+ // here we remember last movements for animation. this is needed here,
+ // as animation is in sync with the game, not the keyboard directly.
+ // (for example, after exiting the cave, the player was "running" in the
+ // original, till bonus points were counted for remaining time and so on.
if (player_move == GD_MV_LEFT ||
player_move == GD_MV_UP_LEFT ||
player_move == GD_MV_DOWN_LEFT)
player_move == GD_MV_DOWN_RIGHT)
cave->last_horizontal_direction = GD_MV_RIGHT;
- cave->frame++; /* XXX */
+ cave->frame++; // XXX
}
void set_initial_cave_speed(GdCave *cave)
int ymin, ymax;
int x, y;
- /* set cave get function; to implement perfect or lineshifting borders */
+ // set cave get function; to implement perfect or lineshifting borders
if (cave->lineshift)
cave->getp = getp_shift;
else
cave->getp = getp_perfect;
- /* check whether to scan the first and last line */
+ // check whether to scan the first and last line
if (cave->border_scan_first_and_last)
{
ymin = 0;
{
for (x = 0; x < cave->w; x++)
{
- /* add the ckdelay correction value for every element seen. */
+ // add the ckdelay correction value for every element seen.
cave->ckdelay += gd_elements[get(cave, x, y)].ckdelay;
}
}
- /* update timing calculated by iterating and counting elements */
+ // update timing calculated by iterating and counting elements
update_cave_speed(cave);
}
#include "bd_cave.h"
-/* the game itself */
+// the game itself
GdDirection gd_direction_from_keypress(boolean up, boolean down, boolean left, boolean right);
void gd_cave_iterate(GdCave *cave, GdDirection player_move, boolean player_fire, boolean suicide);
void set_initial_cave_speed(GdCave *cave);
GD_OBJECT_LEVEL5
};
-/* bdcff text description of object. caller should free string. */
+// bdcff text description of object. caller should free string.
char *gd_object_get_bdcff(const GdObject *object)
{
char *str = NULL;
return getStringPrint("Rectangle=%d %d %d %d %s", object->x1, object->y1, object->x2, object->y2, gd_elements[object->element].filename);
case GD_FILLED_RECTANGLE:
- /* if elements are not the same */
+ // if elements are not the same
if (object->fill_element!=object->element)
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);
- /* they are the same */
+ // they are the same
return getStringPrint("FillRect=%d %d %d %d %s", object->x1, object->y1, object->x2, object->y2, gd_elements[object->element].filename);
case GD_RASTER:
break;
default:
- /* never reached */
+ // never reached
break;
}
case GD_RANDOM_FILL:
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);
- /* seed and initial fill */
+ // seed and initial fill
for (j = 0; j < 4; j++)
if (object->random_fill_probability[j] != 0)
appendStringPrint(&str, " %s %d", gd_elements[object->random_fill[j]].filename, object->random_fill_probability[j]);
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");
case NONE:
- /* never reached */
+ // never reached
break;
}
return NULL;
}
-/* create an INDIVIDUAL POINT CAVE OBJECT */
+// create an INDIVIDUAL POINT CAVE OBJECT
GdObject *gd_object_new_point(GdObjectLevels levels, int x, int y, GdElement elem)
{
GdObject *newobj = checked_calloc(sizeof(GdObject));
return newobj;
}
-/* create a LINE OBJECT */
+// create a LINE OBJECT
GdObject *gd_object_new_line(GdObjectLevels levels, int x1, int y1, int x2, int y2,
GdElement elem)
{
return newobj;
}
-/* create a RECTANGLE OBJECT */
+// create a RECTANGLE OBJECT
GdObject *gd_object_new_rectangle(GdObjectLevels levels, int x1, int y1, int x2, int y2,
GdElement elem)
{
return newobj;
}
-/* create a RECTANGLE OBJECT */
+// create a RECTANGLE OBJECT
GdObject *gd_object_new_filled_rectangle(GdObjectLevels levels, int x1, int y1, int x2, int y2,
GdElement elem, GdElement fill_elem)
{
return newobj;
}
-/* create a raster object */
+// create a raster object
GdObject *gd_object_new_raster(GdObjectLevels levels, int x1, int y1, int x2, int y2,
int dx, int dy, GdElement elem)
{
return newobj;
}
-/* create a raster object */
+// create a raster object
GdObject *gd_object_new_join(GdObjectLevels levels, int dx, int dy,
GdElement search, GdElement replace)
{
return newobj;
}
-/* create a new boundary fill object */
+// create a new boundary fill object
GdObject *gd_object_new_floodfill_border(GdObjectLevels levels, int x1, int y1,
GdElement fill, GdElement border)
{
return newobj;
}
-/* create new object from bdcff description.
- return new object if ok; return null if failed.
- */
+// create new object from bdcff description.
+// return new object if ok; return null if failed.
GdObject *gd_object_new_from_string(char *str)
{
char *equalsign;
if (!equalsign)
return NULL;
- /* split string by replacing the equal sign with zero */
+ // split string by replacing the equal sign with zero
*equalsign = '\0';
name = str;
param = equalsign + 1;
- /* INDIVIDUAL POINT CAVE OBJECT */
+ // INDIVIDUAL POINT CAVE OBJECT
if (strcasecmp(name, "Point") == 0)
{
object.type = GD_POINT;
return NULL;
}
- /* LINE OBJECT */
+ // LINE OBJECT
if (strcasecmp(name, "Line") == 0)
{
object.type = GD_LINE;
return NULL;
}
- /* RECTANGLE OBJECT */
+ // RECTANGLE OBJECT
if (strcasecmp(name, "Rectangle") == 0)
{
if (sscanf(param, "%d %d %d %d %s", &object.x1, &object.y1, &object.x2, &object.y2, elem0) == 5)
return NULL;
}
- /* FILLED RECTANGLE OBJECT */
+ // FILLED RECTANGLE OBJECT
if (strcasecmp(name, "FillRect") == 0)
{
int paramcount;
return NULL;
}
- /* RASTER */
+ // RASTER
if (strcasecmp(name, "Raster") == 0)
{
int nx, ny;
return NULL;
}
- /* JOIN */
+ // JOIN
if (strcasecmp(name, "Join") == 0 ||
strcasecmp(name, "Add") == 0)
{
return NULL;
}
- /* FILL TO BORDER OBJECT */
+ // FILL TO BORDER OBJECT
if (strcasecmp(name, "BoundaryFill") == 0)
{
if (sscanf(param, "%d %d %s %s", &object.x1, &object.y1, elem0, elem1) == 4)
return NULL;
}
- /* REPLACE FILL OBJECT */
+ // REPLACE FILL OBJECT
if (strcasecmp(name, "FloodFill") == 0)
{
if (sscanf(param, "%d %d %s %s", &object.x1, &object.y1, elem0, elem1) == 4)
return NULL;
}
- /* MAZE OBJECT */
- /* MAZE UNICURSAL OBJECT */
- /* BRAID MAZE OBJECT */
+ // MAZE OBJECT
+ // MAZE UNICURSAL OBJECT
+ // BRAID MAZE OBJECT
if (strcasecmp(name, "Maze") == 0)
{
char type[100] = "perfect";
return NULL;
}
- /* RANDOM FILL OBJECT */
+ // RANDOM FILL OBJECT
if (strcasecmp(name, "RandomFill") == 0 ||
strcasecmp(name, "RandomFillC64") == 0)
{
object.type = GD_RANDOM_FILL;
if (strcasecmp(name, "RandomFillC64") == 0)
- /* totally the same, but uses c64 random generator */
+ // totally the same, but uses c64 random generator
object.c64_random = TRUE;
else
object.c64_random = FALSE;
return get_memcpy(&object, sizeof (GdObject));
}
- /* COPY PASTE OBJECT */
+ // COPY PASTE OBJECT
if (strcasecmp(name, "CopyPaste") == 0)
{
char mirror[100] = "nomirror";
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)
return NULL;
- /* MIRROR PROPERTY */
+ // MIRROR PROPERTY
if (strcasecmp(mirror, "mirror") == 0)
object.mirror = TRUE;
else if (strcasecmp(mirror, "nomirror") == 0)
else
Warn("invalid setting for copypaste mirror property: %s", mirror);
- /* FLIP PROPERTY */
+ // FLIP PROPERTY
if (strcasecmp(flip, "flip") == 0)
object.flip = TRUE;
else if (strcasecmp(flip, "noflip") == 0)
return NULL;
}
-/** drawing a line, using bresenham's */
+// drawing a line, using bresenham's
static void draw_line (GdCave *cave, const GdObject *object)
{
int x, y, x1, y1, x2, y2;
static void draw_fill_replace_proc(GdCave *cave, int x, int y, const GdObject *object)
{
- /* fill with border so we do not come back */
+ // fill with border so we do not come back
gd_cave_store_rc(cave, x, y, object->fill_element, object);
if (x > 0 && gd_cave_get_rc(cave, x - 1, y) == object->element)
static void draw_fill_replace (GdCave *cave, const GdObject *object)
{
- /* check bounds */
+ // check bounds
if (object->x1 < 0 ||
object->y1 < 0 ||
object->x1 >= cave->w ||
if (object->element == object->fill_element)
return;
- /* this procedure fills the area with the object->element. */
+ // this procedure fills the area with the object->element.
draw_fill_replace_proc(cave, object->x1, object->y1, object);
}
static void draw_fill_border_proc (GdCave *cave, int x, int y, const GdObject *object)
{
- /* fill with border so we do not come back */
+ // fill with border so we do not come back
gd_cave_store_rc(cave, x, y, object->element, object);
if (x > 0 && gd_cave_get_rc(cave, x - 1, y) != object->element)
{
int x, y;
- /* check bounds */
+ // check bounds
if (object->x1 < 0 ||
object->y1 < 0 ||
object->x1 >= cave->w ||
object->y1 >= cave->h)
return;
- /* this procedure fills the area with the object->element. */
+ // this procedure fills the area with the object->element.
draw_fill_border_proc(cave, object->x1, object->y1, object);
- /* after the fill, we change all filled cells to the fill_element. */
- /* we find those by looking at the object_order[][] */
+ // after the fill, we change all filled cells to the fill_element.
+ // we find those by looking at the object_order[][]
for (y = 0; y < cave->h; y++)
for (x = 0; x < cave->w; x++)
if (cave->objects_order[y][x] == object)
cave->map[y][x] = object->fill_element;
}
-/* rectangle, frame only */
+// rectangle, frame only
static void draw_rectangle(GdCave *cave, const GdObject *object)
{
int x1, y1, x2, y2, x, y;
- /* reorder coordinates if not drawing from northwest to southeast */
+ // reorder coordinates if not drawing from northwest to southeast
x1 = object->x1;
y1 = object->y1, x2 = object->x2;
y2 = object->y2;
}
}
-/* rectangle, filled one */
+// rectangle, filled one
static void draw_filled_rectangle(GdCave *cave, const GdObject *object)
{
int x1, y1, x2, y2, x, y;
- /* reorder coordinates if not drawing from northwest to southeast */
+ // reorder coordinates if not drawing from northwest to southeast
x1 = object->x1;
y1 = object->y1, x2 = object->x2;
y2 = object->y2;
x == object->x2) ? object->element : object->fill_element, object);
}
-/* something like ordered fill, increment is dx and dy. */
+// something like ordered fill, increment is dx and dy.
static void draw_raster(GdCave *cave, const GdObject *object)
{
int x, y, x1, y1, x2, y2;
int dx, dy;
- /* reorder coordinates if not drawing from northwest to southeast */
+ // reorder coordinates if not drawing from northwest to southeast
x1 = object->x1;
y1 = object->y1;
x2 = object->x2;
gd_cave_store_rc(cave, x, y, object->element, object);
}
-/* find every object, and put fill_element next to it. relative coordinates dx,dy */
+// find every object, and put fill_element next to it. relative coordinates dx,dy
static void draw_join(GdCave *cave, const GdObject *object)
{
int x, y;
{
int nx = x + object->dx;
int ny = y + object->dy;
- /* this one implements wraparound for joins.
- it is needed by many caves in profi boulder series */
+ // this one implements wraparound for joins.
+ // it is needed by many caves in profi boulder series
while (nx >= cave->w)
nx -= cave->w, ny++;
}
}
-/* create a maze in a boolean **maze. */
-/* recursive algorithm. */
+// create a maze in a boolean **maze.
+// recursive algorithm.
static void mazegen(GdRand *rand, boolean **maze, int width, int height, int x, int y, int horiz)
{
int dirmask = 15;
{
int dir;
- /* horiz or vert */
+ // horiz or vert
dir = gd_rand_int_range(rand, 0, 100) < horiz ? 2 : 0;
- /* if no horizontal movement possible, choose vertical */
+ // if no horizontal movement possible, choose vertical
if (dir == 2 && (dirmask & 12) == 0)
dir = 0;
- else if (dir == 0 && (dirmask & 3) == 0) /* and vice versa */
+ else if (dir == 0 && (dirmask & 3) == 0) // and vice versa
dir = 2;
- dir += gd_rand_int_range(rand, 0, 2); /* dir */
+ dir += gd_rand_int_range(rand, 0, 2); // dir
if (dirmask & (1 << dir))
{
dirmask &= ~(1 << dir);
switch (dir)
{
- case 0: /* up */
+ case 0: // up
if (y >= 2 && !maze[y - 2][x])
{
maze[y - 1][x] = TRUE;
}
break;
- case 1: /* down */
+ case 1: // down
if (y < height-2 && !maze[y + 2][x]) {
maze[y + 1][x] = TRUE;
mazegen(rand, maze, width, height, x, y + 2, horiz);
}
break;
- case 2: /* left */
+ case 2: // left
if (x >= 2 && !maze[y][x - 2]) {
maze[y][x - 1] = TRUE;
mazegen(rand, maze, width, height, x - 2, y, horiz);
}
break;
- case 3: /* right */
+ case 3: // right
if (x < width - 2 && !maze[y][x + 2]) {
maze[y][x + 1] = TRUE;
mazegen(rand, maze, width, height, x + 2, y, horiz);
int closed = 0, dirs = 0;
int closed_dirs[4];
- /* if it is the edge of the map, OR no path carved, then we can't go in that direction. */
+ // if it is the edge of the map, OR no path carved, then we can't go in that direction.
if (x < 1 || !maze[y][x - 1])
{
- /* closed from this side. */
+ // closed from this side.
closed++;
- /* if not the edge, we might open this wall (carve a path) to remove a dead end */
+ // if not the edge, we might open this wall (carve a path) to remove a dead end
if (x > 0)
closed_dirs[dirs++] = GD_MV_LEFT;
}
- /* other 3 directions similar */
+ // other 3 directions similar
if (y < 1 || !maze[y - 1][x])
{
closed++;
closed_dirs[dirs++] = GD_MV_DOWN;
}
- /* if closed from 3 sides, then it is a dead end. also check dirs != 0,
- that might fail for a 1x1 maze :) */
+ // if closed from 3 sides, then it is a dead end. also check dirs != 0,
+ // that might fail for a 1x1 maze :)
if (closed == 3 && dirs != 0)
{
- /* make up a random direction, and open in that direction, so dead end is removed */
+ // make up a random direction, and open in that direction, so dead end is removed
int dir = closed_dirs[gd_rand_int_range(rand, 0, dirs)];
switch (dir)
GdRand *rand;
int i,j;
- /* change coordinates if not in correct order */
+ // change coordinates if not in correct order
if (y1 > y2)
{
y = y1;
if (path < 1)
path = 1;
- /* calculate the width and height of the maze.
- n = number of passages, path = path width, wall = wall width, maze = maze width.
- if given the number of passages, the width of the maze is:
+ /*
+ calculate the width and height of the maze.
+ n = number of passages, path = path width, wall = wall width, maze = maze width.
+ if given the number of passages, the width of the maze is:
- n * path + (n - 1) * wall = maze
- n * path + n * wall - wall = maze
- n * (path + wall) = maze + wall
- n = (maze + wall) / (path + wall)
+ n * path + (n - 1) * wall = maze
+ n * path + n * wall - wall = maze
+ n * (path + wall) = maze + wall
+ n = (maze + wall) / (path + wall)
*/
- /* number of passages for each side */
+ // number of passages for each side
w = (x2 - x1 + 1 + wall) / (path + wall);
h = (y2 - y1 + 1 + wall) / (path + wall);
- /* and we calculate the size of the internal map */
+ // and we calculate the size of the internal map
if (object->type == GD_MAZE_UNICURSAL)
{
- /* for unicursal maze, width and height must be mod2 = 0,
- and we will convert to paths & walls later */
+ // for unicursal maze, width and height must be mod2 = 0,
+ // and we will convert to paths & walls later
w = w / 2 * 2;
h = h / 2 * 2;
}
else
{
- /* for normal maze */
+ // for normal maze
w = 2 * (w - 1) + 1;
h = 2 * (h - 1) + 1;
}
- /* twodimensional boolean array to generate map in */
+ // twodimensional boolean array to generate map in
map = checked_malloc((h) * sizeof(boolean *));
for (y = 0; y < h; y++)
map[y] = checked_calloc(w * sizeof(boolean));
- /* start generation, if map is big enough.
- otherwise the application would crash, as the editor places maze objects
- during mouse click & drag that have no sense */
+ // start generation, if map is big enough.
+ // otherwise the application would crash, as the editor places maze objects
+ // during mouse click & drag that have no sense
rand = gd_rand_new_with_seed(object->seed[level] == -1 ?
gd_rand_int(cave->random) : object->seed[level]);
{
boolean **unicursal;
- /* convert to unicursal maze */
+ // convert to unicursal maze
/* original:
xxx x
x x
}
}
- /* free original map */
+ // free original map
for (y = 0; y < h; y++)
free(map[y]);
free(map);
- /* change to new map - the unicursal maze */
+ // change to new map - the unicursal maze
map = unicursal;
h = h * 2 - 1;
w = w * 2 - 1;
}
- /* copy map to cave with correct elements and size */
+ // copy map to cave with correct elements and size
/* now copy the map into the cave. the copying works like this...
pwpwp
xxxxx p
for (j = 0; j < (x % 2 == 0 ? path : wall); j++)
gd_cave_store_rc(cave, xk++, yk, map[y][x] ? object->fill_element : object->element, object);
- /* if width is smaller than requested, fill with wall */
+ // if width is smaller than requested, fill with wall
for(x = xk; x <= x2; x++)
gd_cave_store_rc(cave, x, yk, object->element, object);
}
}
- /* if height is smaller than requested, fill with wall */
+ // if height is smaller than requested, fill with wall
for (y = yk; y <= y2; y++)
for (x = x1; x <= x2; x++)
gd_cave_store_rc(cave, x, y, object->element, object);
- /* free map */
+ // free map
for (y = 0; y < h; y++)
free(map[y]);
free(map);
GdC64RandomGenerator c64_rand;
unsigned int seed;
- /* -1 means that it should be different every time played. */
+ // -1 means that it should be different every time played.
if (object->seed[level] == -1)
seed = gd_rand_int(cave->random);
else
seed = object->seed[level];
rand = gd_rand_new_with_seed(seed);
- /* for c64 random, use the 2*8 lsb. */
+ // for c64 random, use the 2*8 lsb.
gd_c64_random_set_seed(&c64_rand, seed / 256 % 256, seed % 256);
- /* change coordinates if not in correct order */
+ // change coordinates if not in correct order
if (y1 > y2)
{
y = y1;
GdElement element;
if (object->c64_random)
- /* use c64 random generator */
+ // use c64 random generator
randm = gd_c64_random(&c64_rand);
else
- /* use the much better glib random generator */
+ // use the much better glib random generator
randm = gd_rand_int_range(rand, 0, 256);
element = object->fill_element;
static void draw_copy_paste(GdCave *cave, const GdObject *object)
{
int x1 = object->x1, y1 = object->y1, x2 = object->x2, y2 = object->y2;
- int x, y; /* iterators */
+ int x, y; // iterators
int w, h;
GdElement *clipboard;
- /* reorder coordinates if not drawing from northwest to southeast */
+ // reorder coordinates if not drawing from northwest to southeast
if (x2 < x1)
{
x = x2;
clipboard = checked_malloc((w * h) * sizeof(GdElement));
- /* copy to "clipboard" */
+ // copy to "clipboard"
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
clipboard[y * w + x] = gd_cave_get_rc(cave, x + x1, y + y1);
xdest = object->mirror ? w - 1 - x : x;
- /* dx and dy are used here are "paste to" coordinates */
+ // dx and dy are used here are "paste to" coordinates
gd_cave_store_rc(cave, object->dx + xdest, object->dy + ydest,
clipboard[y * w + x], object);
}
free(clipboard);
}
-/* draw the specified game object into cave's data.
- also remember, which cell was set by which cave object. */
+// draw the specified game object into cave's data.
+// also remember, which cell was set by which cave object.
void gd_cave_draw_object(GdCave *cave, const GdObject *object, int level)
{
switch (object->type)
{
case GD_POINT:
- /* single point */
+ // single point
gd_cave_store_rc(cave, object->x1, object->y1, object->element, object);
break;
}
}
-/* load cave to play... also can be called rendering the cave elements */
+// load cave to play... also can be called rendering the cave elements
GdCave *gd_cave_new_rendered(const GdCave *data, const int level, const unsigned int seed)
{
GdCave *cave;
int x, y;
List *iter;
- /* make a copy */
+ // make a copy
cave = gd_cave_new_from_cave(data);
cave->rendered = level + 1;
cave->render_seed = seed;
cave->random = gd_rand_new_with_seed(cave->render_seed);
- /* maps needed during drawing and gameplay */
+ // maps needed during drawing and gameplay
cave->objects_order = gd_cave_map_new(cave, void *);
cave->time = data->level_time[level];
if (!cave->map)
{
- /* if we have no map, fill with predictable random generator. */
+ // if we have no map, fill with predictable random generator.
cave->map = gd_cave_map_new(cave, GdElement);
- /* IF CAVE HAS NO MAP, USE THE RANDOM NUMBER GENERATOR */
- /* init c64 randomgenerator */
+ // IF CAVE HAS NO MAP, USE THE RANDOM NUMBER GENERATOR
+ // init c64 randomgenerator
if (data->level_rand[level] < 0)
gd_cave_c64_random_set_seed(cave, gd_rand_int_range(cave->random, 0, 256),
gd_rand_int_range(cave->random, 0, 256));
else
gd_cave_c64_random_set_seed(cave, 0, data->level_rand[level]);
- /* generate random fill
- * start from row 1 (0 skipped), and fill also the borders on left and right hand side,
- * as c64 did. this way works the original random generator the right way.
- * also, do not fill last row, that is needed for the random seeds to be correct
- * after filling! predictable slime will use it. */
+ // generate random fill
+ //
+ // start from row 1 (0 skipped), and fill also the borders on left and right hand side,
+ // as c64 did. this way works the original random generator the right way.
+ // also, do not fill last row, that is needed for the random seeds to be correct
+ // after filling! predictable slime will use it.
for (y = 1; y < cave->h - 1; y++)
{
for (x = 0; x < cave->w; x++)
unsigned int randm;
if (data->level_rand[level] < 0)
- /* use the much better glib random generator */
+ // use the much better glib random generator
randm = gd_rand_int_range(cave->random, 0, 256);
else
- /* use c64 */
+ // use c64
randm = gd_cave_c64_random(cave);
element = data->initial_fill;
}
}
- /* draw initial border */
+ // draw initial border
for (y = 0; y < cave->h; y++)
{
gd_cave_store_rc(cave, 0, y, cave->initial_border, NULL);
}
else
{
- /* IF CAVE HAS A MAP, SIMPLY USE IT... no need to fill with random elements */
+ // IF CAVE HAS A MAP, SIMPLY USE IT... no need to fill with random elements
- /* initialize c64 predictable random for slime.
- the values were taken from afl bd, see docs/internals.txt */
+ // initialize c64 predictable random for slime.
+ // the values were taken from afl bd, see docs/internals.txt
gd_cave_c64_random_set_seed(cave, 0, 0x1e);
}
if (data->level_slime_seed_c64[level] != -1)
{
- /* if a specific slime seed is requested, change it now. */
+ // if a specific slime seed is requested, change it now.
gd_cave_c64_random_set_seed(cave,
data->level_slime_seed_c64[level] / 256,
data->level_slime_seed_c64[level] % 256);
}
- /* render cave objects above random data or map */
+ // render cave objects above random data or map
for (iter = data->objects; iter; iter = list_next(iter))
{
GdObject *object = (GdObject *)iter->data;
gd_cave_draw_object(cave, iter->data, level);
}
- /* check if we use c64 ckdelay or milliseconds for timing */
+ // check if we use c64 ckdelay or milliseconds for timing
if (cave->scheduling == GD_SCHEDULING_MILLISECONDS)
- cave->speed = data->level_speed[level]; /* exact timing */
+ cave->speed = data->level_speed[level]; // exact timing
else
{
- /* delay loop based timing... set something for first iteration,
- then later it will be calculated */
+ // delay loop based timing... set something for first iteration,
+ // then later it will be calculated
cave->speed = 120;
- /* this one may be used by iterate routine to calculate actual delay
- if c64scheduling is selected */
+ // this one may be used by iterate routine to calculate actual delay
+ // if c64scheduling is selected
cave->c64_timing = data->level_ckdelay[level];
}
}
/*
- render cave at specified level.
- copy result to the map; remove objects.
- the cave will be map-based.
- */
+ render cave at specified level.
+ copy result to the map; remove objects.
+ the cave will be map-based.
+*/
void gd_flatten_cave(GdCave *cave, const int level)
{
GdCave *rendered;
if (cave == NULL)
return;
- /* render cave at specified level to obtain map. seed = 0 */
+ // render cave at specified level to obtain map. seed = 0
rendered = gd_cave_new_rendered(cave, level, 0);
- /* forget old map without objects */
+ // forget old map without objects
gd_cave_map_free(cave->map);
- /* copy new map to cave */
+ // copy new map to cave
cave->map = gd_cave_map_dup(rendered, map);
gd_cave_free(rendered);
- /* forget objects */
+ // forget objects
list_foreach(cave->objects, (list_fn) free, NULL);
cave->objects = NULL;
}
typedef enum _gd_object_type
{
- NONE, /* this one to be zero. */
- GD_POINT, /* single point of object1 */
- GD_LINE, /* line from (1) to (2) of object1 */
- GD_RECTANGLE, /* rectangle with corners (1) and (2) of object1 */
- GD_FILLED_RECTANGLE, /* rectangle with corners (1) and (2) of object1, filled with object2 */
- GD_RASTER, /* aligned plots */
- GD_JOIN, /* every object1 has an object2 next to it, relative (dx,dy) */
- GD_FLOODFILL_REPLACE, /* fill by replacing */
- GD_FLOODFILL_BORDER, /* fill to another element, a border */
- GD_MAZE, /* maze */
- GD_MAZE_UNICURSAL, /* unicursal maze */
- GD_MAZE_BRAID, /* braid maze */
- GD_RANDOM_FILL, /* random fill */
- GD_COPY_PASTE, /* copy & paste with optional mirror and flip */
+ NONE, // this one to be zero.
+ GD_POINT, // single point of object1
+ GD_LINE, // line from (1) to (2) of object1
+ GD_RECTANGLE, // rectangle with corners (1) and (2) of object1
+ GD_FILLED_RECTANGLE, // rectangle with corners (1) and (2) of object1, filled with object2
+ GD_RASTER, // aligned plots
+ GD_JOIN, // every object1 has an object2 next to it, relative (dx,dy)
+ GD_FLOODFILL_REPLACE, // fill by replacing
+ GD_FLOODFILL_BORDER, // fill to another element, a border
+ GD_MAZE, // maze
+ GD_MAZE_UNICURSAL, // unicursal maze
+ GD_MAZE_BRAID, // braid maze
+ GD_RANDOM_FILL, // random fill
+ GD_COPY_PASTE, // copy & paste with optional mirror and flip
} GdObjectType;
typedef enum _gd_object_levels
typedef struct _gd_object
{
- GdObjectType type; /* type */
- GdObjectLevels levels; /* levels to show this object on */
+ GdObjectType type; // type
+ GdObjectLevels levels; // levels to show this object on
- int x1, y1; /* (first) coordinate */
- int x2, y2; /* second coordinate */
- int dx, dy; /* distance of elements for raster or join */
- GdElement element, fill_element; /* element type */
+ int x1, y1; // (first) coordinate
+ int x2, y2; // second coordinate
+ int dx, dy; // distance of elements for raster or join
+ GdElement element, fill_element; // element type
- int seed[5]; /* for maze and random fill */
- int horiz; /* for maze */
+ int seed[5]; // for maze and random fill
+ int horiz; // for maze
- boolean mirror, flip; /* for copy */
+ boolean mirror, flip; // for copy
- boolean c64_random; /* random fill objects: use c64 random generator */
+ boolean c64_random; // random fill objects: use c64 random generator
GdElement random_fill[4];
int random_fill_probability[4];
#include "main_bd.h"
-/* this stores the caves. */
+// this stores the caves.
List *gd_caveset;
-/* the data of the caveset: name, highscore, max number of lives, etc. */
+// the data of the caveset: name, highscore, max number of lives, etc.
GdCavesetData *gd_caveset_data;
-/* is set to true, when the caveset was edited since the last save. */
+// is set to true, when the caveset was edited since the last save.
boolean gd_caveset_edited;
-/* last selected-to-play cave */
+// last selected-to-play cave
int gd_caveset_last_selected;
int gd_caveset_last_selected_level;
-/* list of possible extensions which can be opened */
+// list of possible extensions which can be opened
char *gd_caveset_extensions[] =
{
"*.gds",
const GdStructDescriptor gd_caveset_properties[] =
{
- /* default data */
+ // default data
{"", GD_TAB, 0, N_("Caveset data")},
{"Name", GD_TYPE_STRING, 0, N_("Name"), CAVESET_OFFSET(name), 1, N_("Name of the game")},
{"Description", GD_TYPE_STRING, 0, N_("Description"), CAVESET_OFFSET(description), 1, N_("Some words about the game")},
static GdPropertyDefault caveset_defaults[] =
{
- /* default data */
+ // default data
{CAVESET_OFFSET(initial_lives), 3},
{CAVESET_OFFSET(maximum_lives), 9},
{CAVESET_OFFSET(bonus_life_score), 500},
{
int i;
- /* free strings */
+ // free strings
for (i = 0; gd_caveset_properties[i].identifier != NULL; i++)
if (gd_caveset_properties[i].type == GD_TYPE_LONGSTRING)
checked_free(STRUCT_MEMBER(char *, data, gd_caveset_properties[i].offset));
free(data);
}
-/******************************************************************************
- *
- * Misc caveset functions
- *
- */
+// ============================================================================
+// Misc caveset functions
+// ============================================================================
-/** Clears all caves in the caveset. also to be called at application start */
+// Clears all caves in the caveset. also to be called at application start
void gd_caveset_clear(void)
{
if (gd_caveset)
gd_caveset_data = NULL;
}
- /* always newly create this */
- /* create pseudo cave containing default values */
+ // always newly create this
+ // create pseudo cave containing default values
gd_caveset_data = gd_caveset_data_new();
gd_strcpy(gd_caveset_data->name, getCurrentLevelsetName());
}
-/* return number of caves currently in memory. */
+// return number of caves currently in memory.
int gd_caveset_count(void)
{
return list_length(gd_caveset);
}
-/* return index of first selectable cave */
+// return index of first selectable cave
static int caveset_first_selectable_cave_index(void)
{
List *iter;
Warn("no selectable cave in caveset!");
- /* and return the first one. */
+ // and return the first one.
return 0;
}
-/* return a cave identified by its index */
+// return a cave identified by its index
GdCave *gd_return_nth_cave(const int cave)
{
return list_nth_data(gd_caveset, cave);
}
-/* get a selected cave from the loaded caveset (original, unmodified cave) */
+// get a selected cave from the loaded caveset (original, unmodified cave)
GdCave *gd_get_original_cave_from_caveset(const int cave)
{
- /* get specified cave from caveset already stored in memory */
+ // get specified cave from caveset already stored in memory
GdCave *original_cave = gd_return_nth_cave(cave);
return original_cave;
}
-/* get a selected cave from the loaded caveset (cave prepared for playing) */
+// get a selected cave from the loaded caveset (cave prepared for playing)
GdCave *gd_get_prepared_cave_from_caveset(const int cave, const int level)
{
- /* get specified cave from caveset already stored in memory */
+ // get specified cave from caveset already stored in memory
GdCave *original_cave = gd_return_nth_cave(cave);
- /* get prepared cave from original cave */
+ // get prepared cave from original cave
GdCave *prepared_cave = gd_get_prepared_cave(original_cave, level);
return prepared_cave;
}
-/* get a cave prepared for playing from a given original, unmodified cave (with seed) */
+// get a cave prepared for playing from a given original, unmodified cave (with seed)
GdCave *gd_get_prepared_cave(const GdCave *original_cave, const int level)
{
- /* get rendered cave using the selected seed for playing */
+ // get rendered cave using the selected seed for playing
GdCave *prepared_cave = gd_cave_new_rendered(original_cave, level, game_bd.random_seed);
- /* initialize some cave variables (like player position) */
+ // initialize some cave variables (like player position)
gd_cave_setup_for_game(prepared_cave);
return prepared_cave;
}
-/* colors: 4: purple 3: ciklamen 2: orange 1: blue 0: green */
+// colors: 4: purple 3: ciklamen 2: orange 1: blue 0: green
static GdElement brc_import_table[] =
{
/* 0 */
int x, y;
int level;
- /* we import 100 caves, and the put them in the correct order. */
+ // we import 100 caves, and the put them in the correct order.
GdCave *imported[100];
boolean import_effect;
gd_caveset_clear();
- /* this is some kind of a version number */
+ // this is some kind of a version number
import_effect = FALSE;
switch (data[23])
{
case 0x0:
- /* nothing to do */
+ // nothing to do
break;
case 0xde:
- /* import effects */
+ // import effects
import_effect = TRUE;
break;
{
GdCave *cave;
- /* 5 levels, 20 caves, 24 bytes - max 40*2 properties for each cave */
+ // 5 levels, 20 caves, 24 bytes - max 40*2 properties for each cave
int c = 5 * 20 * 24;
int datapos = (cavenum * 5 +level) * 24 + 22;
snprintf(cave->name, sizeof(GdString), "Intermission %d/%d",
cavenum - 15, level + 1);
- /* fixed intermission caves; are smaller. */
+ // fixed intermission caves; are smaller.
if (cavenum >= 16)
{
cave->w = 20;
cave->level_amoeba_time[i] = data[5 * c + datapos];
cave->level_amoeba_threshold[i] = data[6 * c + datapos];
- /* bonus time: 100 was added, so it could also be negative */
+ // bonus time: 100 was added, so it could also be negative
cave->level_bonus_time[i] = (int)data[11 * c + datapos + 1] - 100;
cave->level_hatching_delay_frame[i] = data[10 * c + datapos];
- /* this was not set in boulder remake. */
+ // this was not set in boulder remake.
cave->level_speed[i] = 150;
}
cave->diamond_value = data[2 * c + datapos];
cave->extra_diamond_value = data[3 * c +datapos];
- /* BRC PROBABILITIES */
- /* a typical code example:
- 46:if (random(slime*4)<4) and (tab[x,y+2] = 0) then\r
- Begin tab[x,y]:=0;col[x,y+2]:=col[x,y];tab[x,y+2]:=27;mat[x,y+2]:=9;Voice4:=2;end;\r
- where slime is the byte loaded from the file as it is.
- pascal random function generates a random number between 0..limit-1, inclusive, for random(limit).
-
- so a random number between 0..limit*4-1 is generated.
- for limit=1, 0..3, which is always < 4, so P=1.
- for limit=2, 0..7, 0..7 is < 4 in P=50%.
- for limit=3, 0..11, is < 4 in P=33%.
- So the probability is exactly 100%/limit.
- just make sure we do not divide by zero for some broken input.
+ // BRC PROBABILITIES
+ /*
+ a typical code example:
+ 46:if (random(slime*4)<4) and (tab[x,y+2] = 0) then
+ Begin tab[x,y]:=0;col[x,y+2]:=col[x,y];tab[x,y+2]:=27;mat[x,y+2]:=9;Voice4:=2;end;
+ where slime is the byte loaded from the file as it is.
+ pascal random function generates a random number between 0..limit-1,
+ inclusive, for random(limit).
+
+ so a random number between 0..limit*4-1 is generated.
+ for limit=1, 0..3, which is always < 4, so P=1.
+ for limit=2, 0..7, 0..7 is < 4 in P=50%.
+ for limit=3, 0..11, is < 4 in P=33%.
+ So the probability is exactly 100%/limit.
+ just make sure we do not divide by zero for some broken input.
*/
if (data[7 * c + datapos] == 0)
Warn("amoeba growth cannot be zero, error at byte %d",
data[7 * c + datapos]);
else
- cave->amoeba_growth_prob = 1E6 / data[7 * c + datapos] + 0.5; /* 0.5 for rounding */
+ cave->amoeba_growth_prob = 1E6 / data[7 * c + datapos] + 0.5; // 0.5 for rounding
if (data[8 * c + datapos] == 0)
Warn("amoeba growth cannot be zero, error at byte %d",
data[8 * c + datapos]);
else
- cave->amoeba_fast_growth_prob = 1E6 / data[8 * c + datapos] + 0.5; /* 0.5 for rounding */
+ cave->amoeba_fast_growth_prob = 1E6 / data[8 * c + datapos] + 0.5; // 0.5 for rounding
cave->slime_predictable = FALSE;
for (i = 0; i < 5; i++)
- cave->level_slime_permeability[i] = 1E6 / data[9 * c + datapos] + 0.5; /* 0.5 for rounding */
+ cave->level_slime_permeability[i] = 1E6 / data[9 * c + datapos] + 0.5; // 0.5 for rounding
- /* probability -> *1E6 */
+ // probability -> *1E6
cave->acid_spread_ratio = 1E6 / data[10 * c + datapos] + 0.5;
- /* br only allowed values 1..8 in here, but works the same way. prob -> *1E6 */
+ // br only allowed values 1..8 in here, but works the same way. prob -> *1E6
cave->pushing_stone_prob = 1E6 / data[11 * c + datapos] + 0.5;
cave->magic_wall_stops_amoeba = (data[12 * c + datapos + 1] != 0);
cave->intermission = (cavenum >= 16 || data[14 * c + datapos + 1] != 0);
- /* colors */
+ // colors
colind = data[31 * c + datapos] % ARRAY_SIZE(brc_color_table);
- cave->colorb = 0x000000; /* fixed rgb black */
- cave->color0 = 0x000000; /* fixed rgb black */
+ cave->colorb = 0x000000; // fixed rgb black
+ cave->color0 = 0x000000; // fixed rgb black
cave->color1 = brc_color_table[colind];
- cave->color2 = brc_color_table_comp[colind]; /* complement */
- cave->color3 = 0xffffff; /* white for brick */
- cave->color4 = 0xe5ad23; /* fixed for amoeba */
- cave->color5 = 0x8af713; /* fixed for slime */
+ cave->color2 = brc_color_table_comp[colind]; // complement
+ cave->color3 = 0xffffff; // white for brick
+ cave->color4 = 0xe5ad23; // fixed for amoeba
+ cave->color5 = 0x8af713; // fixed for slime
if (import_effect)
{
cave->explosion_effect = brc_effect(data[16 * c + datapos + 1]);
cave->bomb_explosion_effect = brc_effect(data[17 * c + datapos + 1]);
- /* 18 solid bomb explode to */
+ // 18 solid bomb explode to
cave->diamond_birth_effect = brc_effect(data[19 * c + datapos + 1]);
cave->stone_bouncing_effect = brc_effect(data[20 * c + datapos + 1]);
cave->diamond_bouncing_effect = brc_effect(data[21 * c + datapos + 1]);
cave->magic_diamond_to = brc_effect(data[22 * c + datapos + 1]);
cave->acid_eats_this = brc_effect(data[23 * c + datapos + 1]);
- /* slime eats:
- (diamond,boulder,bomb),
- (diamond,boulder),
- (diamond,bomb),
- (boulder,bomb) */
+ /*
+ slime eats:
+ (diamond,boulder,bomb),
+ (diamond,boulder),
+ (diamond,bomb),
+ (boulder,bomb)
+ */
cave->amoeba_enclosed_effect = brc_effect(data[14 * c + datapos + 1]);
}
}
}
- /* put them in the caveset - take correct order into consideration. */
+ // put them in the caveset - take correct order into consideration.
for (level = 0; level < 5; level++)
{
int cavenum;
boolean only_dirt;
int x, y;
- /* check if cave contains only dirt.
- that is an empty cave, and do not import. */
+ // check if cave contains only dirt.
+ // that is an empty cave, and do not import.
only_dirt = TRUE;
for (y = 1; y < cave->h - 1 && only_dirt; y++)
if (cave->map[y][x] != O_DIRT)
only_dirt = FALSE;
- /* append to caveset or forget it. */
+ // append to caveset or forget it.
if (!only_dirt)
gd_caveset = list_append(gd_caveset, cave);
else
char *name;
char *c;
- /* make up a caveset name from the filename. */
+ // make up a caveset name from the filename.
name = getBaseName(filename);
gd_strcpy(gd_caveset_data->name, name);
free(name);
- /* convert underscores to spaces */
+ // convert underscores to spaces
while ((c = strchr (gd_caveset_data->name, '_')) != NULL)
*c = ' ';
- /* remove extension */
+ // remove extension
if ((c = strrchr (gd_caveset_data->name, '.')) != NULL)
*c = 0;
}
-/* Load caveset from file.
- Loads the caveset from a file.
+/*
+ Load caveset from file.
+ Loads the caveset from a file.
- File type is autodetected by extension.
- param filename: Name of file.
- result: FALSE if failed
+ File type is autodetected by extension.
+ param filename: Name of file.
+ result: FALSE if failed
*/
boolean gd_caveset_load_from_file(char *filename)
{
if (strSuffix(filename, ".brc") ||
strSuffix(filename, ".BRC"))
{
- /* loading a boulder remake file */
+ // loading a boulder remake file
if (length != 96000)
{
Warn("BRC files must be 96000 bytes long");
strSuffix(filename, ".BRC"))
{
brc_import((byte *) buf);
- gd_caveset_edited = FALSE; /* newly loaded cave is not edited */
+ gd_caveset_edited = FALSE; // newly loaded cave is not edited
gd_caveset_last_selected = caveset_first_selectable_cave_index();
gd_caveset_last_selected_level = 0;
free(buf);
return TRUE;
}
- /* BDCFF */
+ // BDCFF
if (gd_caveset_imported_get_format((byte *) buf) == GD_FORMAT_UNKNOWN)
{
- /* try to load as bdcff */
+ // try to load as bdcff
boolean result;
- /* bdcff: start another function */
+ // bdcff: start another function
result = gd_caveset_load_from_bdcff(buf);
- /* newly loaded file is not edited. */
+ // newly loaded file is not edited.
gd_caveset_edited = FALSE;
gd_caveset_last_selected = caveset_first_selectable_cave_index();
return result;
}
- /* try to load as a binary file, as we know the format */
+ // try to load as a binary file, as we know the format
new_caveset = gd_caveset_import_from_buffer ((byte *) buf, length);
free(buf);
- /* if unable to load, exit here. error was reported by import_from_buffer() */
+ // if unable to load, exit here. error was reported by import_from_buffer()
if (!new_caveset)
return FALSE;
- /* no serious error :) */
+ // no serious error :)
- /* only clear caveset here. if file read was unsuccessful, caveset remains in memory. */
+ // only clear caveset here. if file read was unsuccessful, caveset remains in memory.
gd_caveset_clear();
gd_caveset = new_caveset;
- /* newly loaded cave is not edited */
+ // newly loaded cave is not edited
gd_caveset_edited = FALSE;
gd_caveset_last_selected = caveset_first_selectable_cave_index();
closeFile(file);
- /* remember that it is saved */
+ // remember that it is saved
gd_caveset_edited = FALSE;
success = TRUE;
replay->wrong_checksum = FALSE;
- /* count wrong ones... the checksum might be changed later to "repair" */
+ // count wrong ones... the checksum might be changed later to "repair"
if (replay->checksum != 0 && checksum != replay->checksum)
wrong++;
if (replay->checksum == 0 || repair)
{
- /* if no checksum found, add one. or if repair requested, overwrite old one. */
+ // if no checksum found, add one. or if repair requested, overwrite old one.
replay->checksum = checksum;
}
else
{
- /* if has a checksum, compare with this one. */
+ // if has a checksum, compare with this one.
if (replay->checksum != checksum)
{
replay->wrong_checksum = TRUE;
if (remove)
{
- /* may remove */
+ // may remove
cave->replays = list_remove_link(cave->replays, riter);
gd_replay_free(replay);
}
}
}
- /* advance to next list item which we remembered. the current one might have been deleted */
+ // advance to next list item which we remembered. the current one might have been deleted
riter = next;
}
{
List *citer;
- /* for all caves */
+ // for all caves
for (citer = gd_caveset; citer != NULL; citer = citer->next)
{
GdCave *cave = (GdCave *)citer->data;
return TRUE;
}
- /* if neither of the caves had a replay, */
+ // if neither of the caves had a replay,
return FALSE;
}
typedef struct _gd_caveset_data
{
- GdString name; /* Name of caveset */
- GdString description; /* Some words about the caveset */
- GdString author; /* Author */
- GdString difficulty; /* difficulty of the caveset, for info purposes */
- GdString www; /* link to author's webpage */
- GdString date; /* date of creation */
-
- char *story; /* story for the caves */
- char *remark; /* notes about the game */
+ GdString name; // Name of caveset
+ GdString description; // Some words about the caveset
+ GdString author; // Author
+ GdString difficulty; // difficulty of the caveset, for info purposes
+ GdString www; // link to author's webpage
+ GdString date; // date of creation
+
+ char *story; // story for the caves
+ char *remark; // notes about the game
- char *title_screen; /* base64-encoded title screen image */
- char *title_screen_scroll; /* scrolling background for title screen image */
+ char *title_screen; // base64-encoded title screen image
+ char *title_screen_scroll; // scrolling background for title screen image
- GdString charset; /* these are not used by gdash */
+ GdString charset; // these are not used by gdash
GdString fontset;
- /* these are only for a game. */
- int initial_lives; /* initial lives at game start */
- int maximum_lives; /* maximum lives */
- int bonus_life_score; /* bonus life / number of points */
+ // these are only for a game.
+ int initial_lives; // initial lives at game start
+ int maximum_lives; // maximum lives
+ int bonus_life_score; // bonus life / number of points
- /* and this one the highscores */
+ // and this one the highscores
GdHighScore highscore[GD_HIGHSCORE_NUM];
} GdCavesetData;
extern char *gd_caveset_extensions[];
-/* #included cavesets; configdir passed to look for .hsc file */
+// #included cavesets; configdir passed to look for .hsc file
boolean gd_caveset_load_from_internal(int caveset, const char *configdir);
const char **gd_caveset_get_internal_game_names(void);
-/* caveset load from file */
+// caveset load from file
boolean gd_caveset_load_from_file(char *filename);
-/* caveset save to bdcff file */
+// caveset save to bdcff file
boolean gd_caveset_save_to_file(const char *filename);
-/* misc caveset functions */
+// misc caveset functions
int gd_caveset_count(void);
void gd_caveset_clear(void);
GdCave *gd_return_nth_cave(const int cave);
GdCave *gd_get_prepared_cave_from_caveset(const int cave, const int level);
GdCave *gd_get_prepared_cave(const GdCave *cave, const int level);
-/* highscore in config directory */
+// highscore in config directory
void gd_save_highscore(const char* directory);
boolean gd_load_highscore(const char *directory);
GdCavesetData *gd_caveset_data_new(void);
void gd_caveset_data_free(GdCavesetData *data);
-/* check replays and optionally remove */
+// check replays and optionally remove
int gd_cave_check_replays(GdCave *cave, boolean report, boolean remove, boolean repair);
boolean gd_caveset_has_replays(void);
"Gray3",
};
-/* return c64 color with index. */
+// return c64 color with index.
GdColor gd_c64_color(int index)
{
return (GD_COLOR_TYPE_C64 << 24) + index;
}
-/* return atari color with index. */
+// return atari color with index.
GdColor gd_atari_color(int index)
{
return (GD_COLOR_TYPE_ATARI << 24) + index;
}
-/* return c64dtv color with index. */
+// return c64dtv color with index.
GdColor gd_c64dtv_color(int index)
{
return (GD_COLOR_TYPE_C64DTV << 24) + index;
}
-/* return "unknown color" */
+// return "unknown color"
static GdColor unknown_color(void)
{
return (GD_COLOR_TYPE_UNKNOWN << 24);
}
-/* make up GdColor from r,g,b values. */
+// make up GdColor from r,g,b values.
GdColor gd_color_get_from_rgb(int r, int g, int b)
{
return (GD_COLOR_TYPE_RGB << 24) + (r << 16) + (g << 8) + b;
if (strEqualCase(color, c64_color_names[i]))
return gd_c64_color(i);
- /* we do not use sscanf(color, "atari..." as may be lowercase */
+ // we do not use sscanf(color, "atari..." as may be lowercase
if (strEqualCaseN(color, "Atari", strlen("Atari")))
{
const char *b = color + strlen("Atari");
return unknown_color();
}
- /* we do not use sscanf(color, "c64dtv..." as may be lowercase */
+ // we do not use sscanf(color, "c64dtv..." as may be lowercase
if (strEqualCaseN(color, "C64DTV", strlen("C64DTV")))
{
const char *b = color + strlen("C64DTV");
return unknown_color();
}
- /* may or may not have a # */
+ // may or may not have a #
if (color[0] == '#')
color++;
GdColor gd_gdash_color(int c)
{
- /* these values are taken from the title screen, drawn by cws. */
- /* so menus and everything else will look nice! */
- /* the 16 colors that can be used are the same as on c64. */
- /* "Black", "White", "Red", "Cyan", "Purple", "Green", "Blue", "Yellow", */
- /* "Orange", "Brown", "LightRed", "Gray1", "Gray2", "LightGreen", "LightBlue", "Gray3", */
- /* not in the png: cyan, purple. gray3 is darker in the png. */
- /* 17th color is the player's leg in the png. i not connected it to any c64 */
- /* color, but it is used for theme images for example. */
+ // these values are taken from the title screen, drawn by cws.
+ // so menus and everything else will look nice!
+ // the 16 colors that can be used are the same as on c64.
+ // "Black", "White", "Red", "Cyan", "Purple", "Green", "Blue", "Yellow",
+ // "Orange", "Brown", "LightRed", "Gray1", "Gray2", "LightGreen", "LightBlue", "Gray3",
+ // not in the png: cyan, purple. gray3 is darker in the png.
+ // 17th color is the player's leg in the png. i not connected it to any c64
+ // color, but it is used for theme images for example.
const GdColor gdash_colors[] =
{
0x000000, 0xffffff, 0xe33939, 0x55aaaa, 0xaa55aa, 0x71aa55, 0x0039ff, 0xffff55,
GD_COLOR_TYPE_C64DTV = 2,
GD_COLOR_TYPE_ATARI = 3,
- GD_COLOR_TYPE_UNKNOWN /* should be the last one */
+ GD_COLOR_TYPE_UNKNOWN // should be the last one
} GdColorType;
-/* traditional c64 color indexes. */
+// traditional c64 color indexes.
#define GD_COLOR_INDEX_BLACK (0)
#define GD_COLOR_INDEX_WHITE (1)
#define GD_COLOR_INDEX_RED (2)
#define GD_COLOR_INVALID (0xFFFFFFFF)
-/* color */
+// color
GdColor gd_c64_color(int index);
GdColor gd_atari_color(int index);
GdColor gd_c64dtv_color(int index);
#define BD_ELEMENTS_H
-/* These are the objects in caves. */
+// These are the objects in caves.
typedef enum _element
{
O_SPACE,
O_NUT_EXPL_3,
O_NUT_EXPL_4,
- /* these are used internally for the pneumatic hammer, and should not be used in the editor! */
- /* (not even as an effect destination or something like that) */
+ // these are used internally for the pneumatic hammer, and should not be used in the editor!
+ // (not even as an effect destination or something like that)
O_PLAYER_PNEUMATIC_LEFT,
O_PLAYER_PNEUMATIC_RIGHT,
O_PNEUMATIC_ACTIVE_LEFT,
O_PNEUMATIC_ACTIVE_RIGHT,
- O_UNKNOWN, /* unknown element imported or read from bdcff */
- O_NONE, /* do not draw this element when creating cave; can be used,
- for example, to skip drawing a maze's path */
+ O_UNKNOWN, // unknown element imported or read from bdcff
+ O_NONE, // do not draw this element when creating cave; can be used,
+ // for example, to skip drawing a maze's path
- O_MAX, /* remembering last index: this should get an integer value
- which is 1 more than the one above. */
+ O_MAX, // remembering last index: this should get an integer value
+ // which is 1 more than the one above.
- /* fake elements to help drawing */
+ // fake elements to help drawing
O_FAKE_BONUS,
O_INBOX_CLOSED,
O_INBOX_OPEN,
COVERED = 0x200,
SKIPPED = 0x400,
- /* binary AND this to elements to get rid of properties above. */
+ // binary AND this to elements to get rid of properties above.
O_MASK = ~(SCANNED | COVERED | SKIPPED)
} GdElement;
GD_S_FALLING_WALL_IMPACT,
GD_S_EXPANDING_WALL,
GD_S_WALL_REAPPEARING,
- GD_S_DIAMOND_FALLING_RANDOM, /* randomly select a diamond falling sound */
+ GD_S_DIAMOND_FALLING_RANDOM, // randomly select a diamond falling sound
GD_S_DIAMOND_FALLING_1,
GD_S_DIAMOND_FALLING_2,
GD_S_DIAMOND_FALLING_3,
GD_S_DIAMOND_FALLING_6,
GD_S_DIAMOND_FALLING_7,
GD_S_DIAMOND_FALLING_8,
- GD_S_DIAMOND_IMPACT_RANDOM, /* randomly select a diamond impact sound */
+ GD_S_DIAMOND_IMPACT_RANDOM, // randomly select a diamond impact sound
GD_S_DIAMOND_IMPACT_1,
GD_S_DIAMOND_IMPACT_2,
GD_S_DIAMOND_IMPACT_3,
GD_S_DIAMOND_IMPACT_6,
GD_S_DIAMOND_IMPACT_7,
GD_S_DIAMOND_IMPACT_8,
- GD_S_FLYING_DIAMOND_FALLING_RANDOM, /* randomly select a flying diamond falling sound */
+ GD_S_FLYING_DIAMOND_FALLING_RANDOM, // randomly select a flying diamond falling sound
GD_S_FLYING_DIAMOND_FALLING_1,
GD_S_FLYING_DIAMOND_FALLING_2,
GD_S_FLYING_DIAMOND_FALLING_3,
GD_S_FLYING_DIAMOND_FALLING_6,
GD_S_FLYING_DIAMOND_FALLING_7,
GD_S_FLYING_DIAMOND_FALLING_8,
- GD_S_FLYING_DIAMOND_IMPACT_RANDOM, /* randomly select a flying diamond impact sound */
+ GD_S_FLYING_DIAMOND_IMPACT_RANDOM, // randomly select a flying diamond impact sound
GD_S_FLYING_DIAMOND_IMPACT_1,
GD_S_FLYING_DIAMOND_IMPACT_2,
GD_S_FLYING_DIAMOND_IMPACT_3,
GD_S_VOODOO_EXPLODING,
GD_S_NITRO_PACK_EXPLODING,
GD_S_BOMB_PLACING,
- GD_S_FINISHED, /* loop */
+ GD_S_FINISHED, // loop
GD_S_SWITCH_BITER,
GD_S_SWITCH_CREATURES,
GD_S_SWITCH_GRAVITY,
GD_S_SWITCH_CONVEYOR,
GD_S_SWITCH_REPLICATOR,
- GD_S_AMOEBA, /* loop */
- GD_S_AMOEBA_MAGIC, /* loop */
- GD_S_MAGIC_WALL, /* loop */
- GD_S_COVERING, /* loop */
- GD_S_PNEUMATIC_HAMMER, /* loop */
- GD_S_WATER, /* loop */
+ GD_S_AMOEBA, // loop
+ GD_S_AMOEBA_MAGIC, // loop
+ GD_S_MAGIC_WALL, // loop
+ GD_S_COVERING, // loop
+ GD_S_PNEUMATIC_HAMMER, // loop
+ GD_S_WATER, // loop
GD_S_CRACKING,
GD_S_GRAVITY_CHANGING,
#include "main_bd.h"
-/* universal settings */
+// universal settings
static boolean gd_no_invisible_outbox = FALSE;
void gd_game_free(GdGame *game)
{
- /* stop sounds */
+ // stop sounds
gd_sound_off();
if (game->element_buffer)
free(game);
}
-/* add bonus life. if sound enabled, play sound, too. */
+// add bonus life. if sound enabled, play sound, too.
static void add_bonus_life(GdGame *game, boolean inform_user)
{
if (inform_user)
game->bonus_life_flash = 100;
}
- /* really increment number of lifes? only in a real game, nowhere else. */
+ // really increment number of lifes? only in a real game, nowhere else.
if (game->player_lives &&
game->player_lives < gd_caveset_data->maximum_lives)
{
- /* only add a life, if lives is > 0.
- lives == 0 is a test run or a snapshot, no bonus life then. */
- /* also, obey max number of bonus lives. */
+ // only add a life, if lives is > 0.
+ // lives == 0 is a test run or a snapshot, no bonus life then.
+ // also, obey max number of bonus lives.
game->player_lives++;
}
}
-/* increment score of player.
- flash screen if bonus life
-*/
+// increment score of player.
+// flash screen if bonus life
static void increment_score(GdGame *game, int increment)
{
int i;
game->player_score += increment;
game->cave_score += increment;
- /* if score crossed bonus_life_score point boundary, player won a bonus life */
+ // if score crossed bonus_life_score point boundary, player won a bonus life
if (game->player_score / gd_caveset_data->bonus_life_score > i)
add_bonus_life(game, TRUE);
}
-/* do the things associated with loading a new cave. function creates gfx buffer and the like. */
+// do the things associated with loading a new cave. function creates gfx buffer and the like.
static void load_cave(GdGame *game)
{
int x, y;
- /* delete element buffer */
+ // delete element buffer
if (game->element_buffer)
gd_cave_map_free(game->element_buffer);
game->element_buffer = NULL;
- /* delete last element buffer */
+ // delete last element buffer
if (game->last_element_buffer)
gd_cave_map_free(game->last_element_buffer);
game->last_element_buffer = NULL;
- /* delete direction buffer */
+ // delete direction buffer
if (game->dir_buffer)
gd_cave_map_free(game->dir_buffer);
game->dir_buffer = NULL;
- /* delete gfx buffer */
+ // delete gfx buffer
if (game->gfx_buffer)
gd_cave_map_free(game->gfx_buffer);
game->gfx_buffer = NULL;
- /* load the cave */
+ // load the cave
game->cave_score = 0;
- /* delete previous cave */
+ // delete previous cave
gd_cave_free(game->cave);
if (native_bd_level.loaded_from_caveset)
add_bonus_life(game, FALSE);
game->milliseconds_anim = 0;
- game->milliseconds_game = 0; /* set game timer to zero, too */
+ game->milliseconds_game = 0; // set game timer to zero, too
- /* create new element buffer */
+ // create new element buffer
game->element_buffer = gd_cave_map_new(game->cave, int);
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
game->element_buffer[y][x] = O_NONE;
- /* create new last element buffer */
+ // create new last element buffer
game->last_element_buffer = gd_cave_map_new(game->cave, int);
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
game->last_element_buffer[y][x] = O_NONE;
- /* create new direction buffer */
+ // create new direction buffer
game->dir_buffer = gd_cave_map_new(game->cave, int);
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
game->dir_buffer[y][x] = GD_MV_STILL;
- /* create new gfx buffer */
+ // create new gfx buffer
game->gfx_buffer = gd_cave_map_new(game->cave, int);
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
- game->gfx_buffer[y][x] = -1; /* fill with "invalid" */
+ game->gfx_buffer[y][x] = -1; // fill with "invalid"
}
GdCave *gd_create_snapshot(GdGame *game)
if (game->cave == NULL)
return NULL;
- /* make an exact copy */
+ // make an exact copy
snapshot = gd_cave_new_from_cave(game->cave);
return snapshot;
}
-/* this starts a new game */
+// this starts a new game
GdGame *gd_game_new(const int cave, const int level)
{
GdGame *game;
{
boolean suicide = FALSE;
- /* ANYTHING EXCEPT A TIMEOUT, WE ITERATE THE CAVE */
+ // ANYTHING EXCEPT A TIMEOUT, WE ITERATE THE CAVE
if (game->cave->player_state != GD_PL_TIMEOUT)
{
if (TapeIsPlaying_ReplayBD())
}
}
- /* iterate cave */
+ // iterate cave
gd_cave_iterate(game->cave, player_move, fire, suicide);
if (game->cave->score)
game->cave->intermission_rewardlife &&
game->player_lives != 0)
{
- /* one life extra for completing intermission */
+ // one life extra for completing intermission
add_bonus_life(game, FALSE);
}
- /* start adding points for remaining time */
+ // start adding points for remaining time
game->state_counter = GAME_INT_CHECK_BONUS_TIME;
gd_cave_clear_sounds(game->cave);
- /* play cave finished sound */
+ // play cave finished sound
gd_sound_play(game->cave, GD_S_FINISHED, O_NONE, -1, -1);
gd_sound_play_cave(game->cave);
}
static GdGameState gd_game_main_int(GdGame *game, boolean allow_iterate, boolean fast_forward)
{
int millisecs_elapsed = 20;
- boolean frame; /* set to true, if this will be an animation frame */
+ boolean frame; // set to true, if this will be an animation frame
GdGameState return_state;
int counter_next;
int x, y;
counter_next = GAME_INT_INVALID;
return_state = GD_GAME_INVALID_STATE;
- game->milliseconds_anim += millisecs_elapsed; /* keep track of time */
- frame = FALSE; /* set to true, if this will be an animation frame */
+ game->milliseconds_anim += millisecs_elapsed; // keep track of time
+ frame = FALSE; // set to true, if this will be an animation frame
if (game->milliseconds_anim >= 40)
{
game->milliseconds_anim -= 40;
}
- /* cannot be less than uncover start. */
+ // cannot be less than uncover start.
if (game->state_counter < GAME_INT_LOAD_CAVE)
{
;
}
else if (game->state_counter == GAME_INT_LOAD_CAVE)
{
- /* do the things associated with loading a new cave. function creates gfx buffer and the like. */
+ // do the things associated with loading a new cave. function creates gfx buffer and the like.
load_cave(game);
return_state = GD_GAME_NOTHING;
}
else if (game->state_counter == GAME_INT_SHOW_STORY)
{
- /* for normal game, every cave can have a long string of description/story. show that. */
+ // for normal game, every cave can have a long string of description/story. show that.
- /* if we have a story... */
+ // if we have a story...
#if 0
if (game->show_story && game->original_cave && game->original_cave->story != NULL)
Info("Cave Story: %s", game->original_cave->story);
}
else if (game->state_counter == GAME_INT_START_UNCOVER)
{
- /* the very beginning. */
+ // the very beginning.
- /* cover all cells of cave */
+ // cover all cells of cave
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
game->cave->map[y][x] |= COVERED;
counter_next = game->state_counter + 1;
- /* very important: tell the caller that we loaded a new cave. */
- /* size of the cave might be new, colors might be new, and so on. */
+ // very important: tell the caller that we loaded a new cave.
+ // size of the cave might be new, colors might be new, and so on.
return_state = GD_GAME_CAVE_LOADED;
}
else if (game->state_counter < GAME_INT_UNCOVER_ALL)
{
- /* uncover animation */
+ // uncover animation
- /* to play cover sound */
+ // to play cover sound
gd_sound_play(game->cave, GD_S_COVERING, O_COVERED, -1, -1);
gd_sound_play_cave(game->cave);
{
int j;
- /* original game uncovered one cell per line each frame.
- * we have different cave sizes, so uncover width * height / 40 random
- * cells each frame. (original was width = 40).
- * this way the uncovering is the same speed also for intermissions. */
+ // original game uncovered one cell per line each frame.
+ // we have different cave sizes, so uncover width * height / 40 random
+ // cells each frame. (original was width = 40).
+ // this way the uncovering is the same speed also for intermissions.
for (j = 0; j < game->cave->w * game->cave->h / 40; j++)
{
y = gd_random_int_range(0, game->cave->h);
game->cave->map[y][x] &= ~COVERED;
}
- counter_next++; /* as we did something, advance the counter. */
+ counter_next++; // as we did something, advance the counter.
}
return_state = GD_GAME_NOTHING;
}
else if (game->state_counter == GAME_INT_UNCOVER_ALL)
{
- /* time to uncover the whole cave. */
+ // time to uncover the whole cave.
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
game->cave->map[y][x] &= ~COVERED;
- /* to stop uncover sound. */
+ // to stop uncover sound.
gd_cave_clear_sounds(game->cave);
gd_sound_play_cave(game->cave);
}
else if (game->state_counter == GAME_INT_CAVE_RUNNING)
{
- /* normal. */
+ // normal.
int cavespeed;
if (!fast_forward)
- cavespeed = game->cave->speed; /* cave speed in ms, like 175ms/frame */
+ cavespeed = game->cave->speed; // cave speed in ms, like 175ms/frame
else
- cavespeed = 40; /* if fast forward, ignore cave speed, and go as 25 iterations/sec */
+ cavespeed = 40; // if fast forward, ignore cave speed, and go as 25 iterations/sec
- /* ITERATION - cave is running. */
+ // ITERATION - cave is running.
- /* normally nothing happes. but if we iterate, this might change. */
+ // normally nothing happes. but if we iterate, this might change.
return_state = GD_GAME_NOTHING;
- /* if allowing cave movements, add elapsed time to timer. and then we can check what to do. */
+ // if allowing cave movements, add elapsed time to timer. and then we can check what to do.
if (allow_iterate)
game->milliseconds_game += millisecs_elapsed;
- /* increment cycle (frame) counter for the current cave iteration */
+ // increment cycle (frame) counter for the current cave iteration
game->itercycle++;
if (game->milliseconds_game >= cavespeed)
game->milliseconds_game -= cavespeed;
pl = game->cave->player_state;
- /* initialize buffers for last cave element and direction for next iteration */
+ // initialize buffers for last cave element and direction for next iteration
for (y = 0; y < game->cave->h; y++)
{
for (x = 0; x < game->cave->w; x++)
}
}
- /* store last maximum number of cycles (to force redraw if changed) */
+ // store last maximum number of cycles (to force redraw if changed)
game->itermax_last = game->itermax;
- /* update maximum number of cycles (frame) per cave iteration */
+ // update maximum number of cycles (frame) per cave iteration
game->itermax = game->itercycle;
- /* reset cycle (frame) counter for the next cave iteration */
+ // reset cycle (frame) counter for the next cave iteration
game->itercycle = 0;
iterate_cave(game, game->player_move, game->player_fire);
game->player_move = GD_MV_STILL;
}
- /* as we iterated, the score and the like could have been changed. */
+ // as we iterated, the score and the like could have been changed.
return_state = GD_GAME_LABELS_CHANGED;
- /* and if the cave timeouted at this moment, that is a special case. */
+ // and if the cave timeouted at this moment, that is a special case.
if (pl != GD_PL_TIMEOUT && game->cave->player_state == GD_PL_TIMEOUT)
return_state = GD_GAME_TIMEOUT_NOW;
}
- /* do not change counter state, as it is set by iterate_cave() */
+ // do not change counter state, as it is set by iterate_cave()
counter_next = game->state_counter;
}
else if (game->state_counter == GAME_INT_CHECK_BONUS_TIME)
{
- /* before covering, we check for time bonus score */
+ // before covering, we check for time bonus score
if (frame)
{
- /* if time remaining, bonus points are added. do not start animation yet. */
+ // if time remaining, bonus points are added. do not start animation yet.
if (game->cave->time > 0)
{
- /* subtract number of "milliseconds" - nothing to do with gameplay->millisecs! */
+ // subtract number of "milliseconds" - nothing to do with gameplay->millisecs!
game->cave->time -= game->cave->timing_factor;
- /* higher levels get more bonus points per second remained */
+ // higher levels get more bonus points per second remained
increment_score(game, game->cave->timevalue);
- /* if much time (> 60s) remained, fast counter :) */
+ // if much time (> 60s) remained, fast counter :)
if (game->cave->time > 60 * game->cave->timing_factor)
{
- /* decrement by nine each frame, so it also looks like a fast counter. 9 is 8 + 1! */
+ // decrement by nine each frame, so it also looks like a fast counter. 9 is 8 + 1!
game->cave->time -= 8 * game->cave->timing_factor;
increment_score(game, game->cave->timevalue * 8);
}
- /* just to be neat */
+ // just to be neat
if (game->cave->time < 0)
game->cave->time = 0;
- counter_next = game->state_counter; /* do not change yet */
+ counter_next = game->state_counter; // do not change yet
}
else
{
game_bd.level_solved = TRUE;
game_bd.cover_screen = TRUE;
- /* if no more points, start waiting a bit, and later start covering. */
+ // if no more points, start waiting a bit, and later start covering.
counter_next = GAME_INT_WAIT_BEFORE_COVER;
}
if (game->cave->time / game->cave->timing_factor > 8)
- gd_sound_play(game->cave, GD_S_FINISHED, O_NONE, -1, -1); /* play cave finished sound */
+ gd_sound_play(game->cave, GD_S_FINISHED, O_NONE, -1, -1); // play cave finished sound
- /* play bonus sound */
+ // play bonus sound
gd_cave_set_seconds_sound(game->cave);
gd_sound_play_cave(game->cave);
{
return_state = GD_GAME_NOTHING;
- /* do not change counter state, as it is set by iterate_cave() */
+ // do not change counter state, as it is set by iterate_cave()
counter_next = game->state_counter;
}
}
else if (game->state_counter == GAME_INT_WAIT_BEFORE_COVER)
{
- /* after adding bonus points, we wait some time before starting to cover.
- this is the FIRST frame... so we check for game over and maybe jump there */
- /* if no more lives, game is over. */
+ // after adding bonus points, we wait some time before starting to cover.
+ // this is the FIRST frame... so we check for game over and maybe jump there
+ // if no more lives, game is over.
counter_next = game->state_counter;
if (game->player_lives == 0)
else if (game->state_counter > GAME_INT_WAIT_BEFORE_COVER &&
game->state_counter < GAME_INT_COVER_START)
{
- /* after adding bonus points, we wait some time before starting to cover.
- ... and the other frames. */
+ // after adding bonus points, we wait some time before starting to cover.
+ // ... and the other frames.
counter_next = game->state_counter;
if (frame)
- counter_next++; /* 40 ms elapsed, advance counter */
+ counter_next++; // 40 ms elapsed, advance counter
return_state = GD_GAME_NOTHING;
}
else if (game->state_counter == GAME_INT_COVER_START)
{
- /* starting to cover. start cover sound. */
+ // starting to cover. start cover sound.
gd_cave_clear_sounds(game->cave);
gd_sound_play(game->cave, GD_S_COVERING, O_COVERED, -1, -1);
- /* to play cover sound */
+ // to play cover sound
gd_sound_play_cave(game->cave);
counter_next = game->state_counter + 1;
else if (game->state_counter > GAME_INT_COVER_START &&
game->state_counter < GAME_INT_COVER_ALL)
{
- /* covering. */
+ // covering.
gd_sound_play(game->cave, GD_S_COVERING, O_COVERED, -1, -1);
counter_next = game->state_counter;
{
int j;
- counter_next++; /* 40 ms elapsed, doing cover: advance counter */
+ counter_next++; // 40 ms elapsed, doing cover: advance counter
- /* covering eight times faster than uncovering. */
+ // covering eight times faster than uncovering.
for (j = 0; j < game->cave->w * game->cave->h * 8 / 40; j++)
game->cave->map[gd_random_int_range(0, game->cave->h)][gd_random_int_range (0, game->cave->w)] |= COVERED;
}
}
else if (game->state_counter == GAME_INT_COVER_ALL)
{
- /* cover all */
+ // cover all
for (y = 0; y < game->cave->h; y++)
for (x = 0; x < game->cave->w; x++)
game->cave->map[y][x] |= COVERED;
counter_next = game->state_counter + 1;
return_state = GD_GAME_NOTHING;
- /* to stop uncover sound. */
+ // to stop uncover sound.
gd_cave_clear_sounds(game->cave);
gd_sound_play_cave(game->cave);
}
else
{
- /* cover all + 1 */
+ // cover all + 1
if (game->player_lives != 0)
- return_state = GD_GAME_NOTHING; /* and go to next level */
+ return_state = GD_GAME_NOTHING; // and go to next level
else
return_state = GD_GAME_GAME_OVER;
}
- /* draw the cave */
+ // draw the cave
if (frame)
{
- if (game->bonus_life_flash) /* bonus life - frames */
+ if (game->bonus_life_flash) // bonus life - frames
game->bonus_life_flash--;
game->animcycle = (game->animcycle + 1) % 8;
}
- /* always render the cave to the gfx buffer;
- however it may do nothing if animcycle was not changed. */
+ // always render the cave to the gfx buffer;
+ // however it may do nothing if animcycle was not changed.
if (game->element_buffer && game->gfx_buffer)
gd_drawcave_game(game->cave, game->element_buffer, game->gfx_buffer,
game->bonus_life_flash != 0, game->animcycle, gd_no_invisible_outbox);
if (game->player_move_stick || move_up || move_down || move_left || move_right) // no "fire"!
{
- /* get movement */
+ // get movement
game->player_move = gd_direction_from_keypress(move_up, move_down, move_left, move_right);
- /* when storing last action, only update fire action with direction */
- /* (prevents clearing direction if snapping stopped before action is performed) */
+ // when storing last action, only update fire action with direction
+ // (prevents clearing direction if snapping stopped before action is performed)
game->player_fire = fire;
}
- /* if no direction was stored before, allow setting fire to current state */
+ // if no direction was stored before, allow setting fire to current state
if (game->player_move == GD_MV_STILL)
game->player_fire = fire;
- /* tell the interrupt "20ms has passed" */
+ // tell the interrupt "20ms has passed"
state = gd_game_main_int(game, !game->out_of_window, gd_keystate[SDL_SCANCODE_F]);
- /* state of game, returned by gd_game_main_int */
+ // state of game, returned by gd_game_main_int
switch (state)
{
case GD_GAME_CAVE_LOADED:
- /* select colors, prepare drawing etc. */
+ // select colors, prepare drawing etc.
gd_scroll_to_origin();
- /* fill whole screen with black - cave might be smaller than previous! */
+ // fill whole screen with black - cave might be smaller than previous!
FillRectangle(gd_screen_bitmap, 0, 0, SXSIZE, SYSIZE, BLACK_PIXEL);
break;
break;
}
- /* for the sdl version, it seems nicer if we first scroll, and then draw. */
- /* scrolling for the sdl version will merely invalidate the whole gfx buffer. */
- /* if drawcave was before scrolling, it would draw, scroll would invalidate,
- and then it should be drawn again */
- /* only do the drawing if the cave already exists. */
+ // for the sdl version, it seems nicer if we first scroll, and then draw.
+ // scrolling for the sdl version will merely invalidate the whole gfx buffer.
+ // if drawcave was before scrolling, it would draw, scroll would invalidate,
+ // and then it should be drawn again
+ // only do the drawing if the cave already exists.
if (game->cave && game->element_buffer && game->gfx_buffer)
{
- /* if fine scrolling, scroll at 50hz. if not, only scroll at every second call, so 25hz. */
- /* do the scrolling. scroll exactly, if player is not yet alive */
+ // if fine scrolling, scroll at 50hz. if not, only scroll at every second call, so 25hz.
+ // do the scrolling. scroll exactly, if player is not yet alive
game->out_of_window = gd_scroll(game, game->cave->player_state == GD_PL_NOT_YET, FALSE);
}
}
#define GAME_INT_INVALID -100
-/* prepare cave, gfx buffer */
+// prepare cave, gfx buffer
#define GAME_INT_LOAD_CAVE -73
-/* show description/note of cave. */
+// show description/note of cave.
#define GAME_INT_SHOW_STORY -72
-/* waiting fire button after showing the story. */
+// waiting fire button after showing the story.
#define GAME_INT_SHOW_STORY_WAIT -71
-/* start uncovering */
+// start uncovering
#define GAME_INT_START_UNCOVER -70
-/* ...70 frames until full uncover... */
+// ...70 frames until full uncover...
#define GAME_INT_UNCOVER_ALL -1
-/* normal running state. */
+// normal running state.
#define GAME_INT_CAVE_RUNNING 0
-/* add points for remaining time */
+// add points for remaining time
#define GAME_INT_CHECK_BONUS_TIME 1
-/* ...2..99 = wait and do nothing, after adding time */
+// ...2..99 = wait and do nothing, after adding time
#define GAME_INT_WAIT_BEFORE_COVER 2
-/* start covering */
+// start covering
#define GAME_INT_COVER_START 100
-/* ... 8 frames of cover animation */
+// ... 8 frames of cover animation
#define GAME_INT_COVER_ALL 108
typedef struct _gd_game
{
- GdString player_name; /* Name of player */
- int player_score; /* Score of player */
- int player_lives; /* Remaining lives of player */
+ GdString player_name; // Name of player
+ int player_score; // Score of player
+ int player_lives; // Remaining lives of player
GdDirection player_move;
boolean player_move_stick;
boolean player_fire;
- GdCave *cave; /* Copy of the cave. This is the iterated, changed (ruined...) one */
- GdCave *original_cave; /* original cave from caveset. used to record highscore */
+ GdCave *cave; // Copy of the cave. This is the iterated, changed (ruined...) one
+ GdCave *original_cave; // original cave from caveset. used to record highscore
- boolean out_of_window; /* will be set to true, if player is not visible in the window, and we have to wait for scrolling */
+ boolean out_of_window; // will be set to true, if player is not visible in the window,
+ // and we have to wait for scrolling
- int cave_num; /* actual playing cave number */
- int cave_score; /* score collected in this cave */
- int level_num; /* actual playing level */
- int bonus_life_flash; /* different kind of flashing, for bonus life */
+ int cave_num; // actual playing cave number
+ int cave_score; // score collected in this cave
+ int level_num; // actual playing level
+ int bonus_life_flash; // different kind of flashing, for bonus life
- int state_counter; /* counter used to control the game flow, rendering of caves */
+ int state_counter; // counter used to control the game flow, rendering of caves
int **element_buffer;
int **last_element_buffer;
int **dir_buffer;
- int **gfx_buffer; /* contains the indexes to the cells; created by *start_level, deleted by *stop_game */
+ int **gfx_buffer; // contains the indexes to the cells;
+ // created by *start_level, deleted by *stop_game
int itercycle;
int itermax;
int itermax_last;
int milliseconds_anim;
int replay_no_more_movements;
- boolean show_story; /* variable to remember that the story for a particular cave was already shown. */
+ boolean show_story; // to remember that story for a particular cave was already shown.
} GdGame;
typedef enum _gd_game_state
GD_GAME_CAVE_LOADED,
GD_GAME_NOTHING,
GD_GAME_LABELS_CHANGED,
- GD_GAME_TIMEOUT_NOW, /* this signals the moment of time out */
+ GD_GAME_TIMEOUT_NOW, // this signals the moment of time out
GD_GAME_NO_MORE_LIVES,
GD_GAME_STOP,
GD_GAME_GAME_OVER,
// !!! (can be removed later) !!!
#define DO_GFX_SANITY_CHECK TRUE
-/* distance to screen edge in cells when scrolling the screen */
+// distance to screen edge in cells when scrolling the screen
#define SCROLL_EDGE_DISTANCE 4
-/* these can't be larger than 31, or they mess up utf8 coding or are the same
- as some ascii letter */
+// these can't be larger than 31, or they mess up utf8 coding or are the same as some ascii letter
#define GD_DOWN_CHAR 1
#define GD_LEFT_CHAR 2
#define GD_UP_CHAR 3
#define GD_KEY_CHAR 12
#define GD_COMMENT_CHAR 13
-/* screen area */
+// screen area
Bitmap *gd_screen_bitmap = NULL;
static int play_area_w = 0;
static int scroll_x, scroll_y;
-/* quit, global variable which is set to true if the application should quit */
+// quit, global variable which is set to true if the application should quit
boolean gd_quit = FALSE;
const byte *gd_keystate;
static int cell_size = 0;
-/* graphic info for game objects/frames and players/actions/frames */
+// graphic info for game objects/frames and players/actions/frames
struct GraphicInfo_BD graphic_info_bd_object[O_MAX_ALL][8];
void set_cell_size(int s)
int cell_size = TILESIZE_VAR;
boolean changed = FALSE;
- /* start scrolling when player reaches certain distance to screen edge */
+ // start scrolling when player reaches certain distance to screen edge
int start = physical_size / 2 - cell_size * edge_distance;
- /* scroll so that the player is at the center; the allowed difference is this */
+ // scroll so that the player is at the center; the allowed difference is this
int to = cell_size;
- /* if cave size smaller than the screen, no scrolling req'd */
+ // if cave size smaller than the screen, no scrolling req'd
if (logical_size < physical_size)
{
*desired = 0;
if (logical_size <= physical_size + cell_size)
{
- /* if cave size is only a slightly larger than the screen, also no scrolling */
- /* scroll to the middle of the cell */
+ // if cave size is only a slightly larger than the screen, also no scrolling
+ // scroll to the middle of the cell
*desired = max / 2;
}
else
{
if (exact)
{
- /* if exact scrolling, just go exactly to the center. */
+ // if exact scrolling, just go exactly to the center.
*desired = center;
}
else
{
- /* hystheresis function.
- * when scrolling left, always go a bit less left than player being at the middle.
- * when scrolling right, always go a bit less to the right. */
+ // hystheresis function.
+ // when scrolling left, always go a bit less left than player being at the middle.
+ // when scrolling right, always go a bit less to the right.
if (*current < center - start)
*desired = center - to;
if (*current > center + start)
return changed;
}
-/* just set current viewport to upper left. */
+// just set current viewport to upper left.
void gd_scroll_to_origin(void)
{
scroll_x = 0;
return play_area_h / cell_size;
}
-/* SCROLLING
- *
- * scrolls to the player during game play.
- * called by drawcave
- * returns true, if player is not visible-ie it is out of the visible size in the drawing area.
- */
+/*
+ SCROLLING
+
+ scrolls to the player during game play.
+ called by drawcave
+ returns true, if player is not visible-ie it is out of the visible size in the drawing area.
+*/
boolean gd_scroll(GdGame *game, boolean exact_scroll, boolean immediate)
{
static int scroll_desired_x = 0, scroll_desired_y = 0;
int player_x, player_y, visible_x, visible_y;
boolean changed;
- /* max scrolling speed depends on the speed of the cave. */
- /* game moves cell_size_game * 1s / cave time pixels in a second. */
- /* scrolling moves scroll speed * 1s / scroll_time in a second. */
- /* these should be almost equal; scrolling speed a little slower. */
- /* that way, the player might reach the border with a small probability, */
- /* but the scrolling will not "oscillate", ie. turn on for little intervals as it has */
- /* caught up with the desired position. smaller is better. */
+ // max scrolling speed depends on the speed of the cave.
+ // game moves cell_size_game * 1s / cave time pixels in a second.
+ // scrolling moves scroll speed * 1s / scroll_time in a second.
+ // these should be almost equal; scrolling speed a little slower.
+ // that way, the player might reach the border with a small probability,
+ // but the scrolling will not "oscillate", ie. turn on for little intervals as it has
+ // caught up with the desired position. smaller is better.
int scroll_speed = cell_size * 20 / game->cave->speed;
if (!setup.bd_scroll_delay)
if (immediate)
scroll_speed = cell_size * MAX(game->cave->w, game->cave->h);
- player_x = game->cave->player_x - game->cave->x1; /* cell coordinates of player */
+ player_x = game->cave->player_x - game->cave->x1; // cell coordinates of player
player_y = game->cave->player_y - game->cave->y1;
- /* pixel size of visible part of the cave (may be smaller in intermissions) */
+ // pixel size of visible part of the cave (may be smaller in intermissions)
visible_x = (game->cave->x2 - game->cave->x1 + 1) * cell_size;
visible_y = (game->cave->y2 - game->cave->y1 + 1) * cell_size;
- /* cell_size contains the scaled size, but we need the original. */
+ // cell_size contains the scaled size, but we need the original.
changed = FALSE;
if (cave_scroll(visible_x, play_area_w, player_x * cell_size + cell_size / 2 - play_area_w / 2,
exact_scroll, &scroll_y, &scroll_desired_y, scroll_speed))
changed = TRUE;
- /* if scrolling, we should update entire screen. */
+ // if scrolling, we should update entire screen.
if (changed)
{
int x, y;
game->gfx_buffer[y][x] |= GD_REDRAW;
}
- /* check if active player is visible at the moment. */
+ // check if active player is visible at the moment.
out_of_window = FALSE;
- /* check if active player is outside drawing area. if yes, we should wait for scrolling */
+ // check if active player is outside drawing area. if yes, we should wait for scrolling
if ((player_x * cell_size) < scroll_x ||
(player_x * cell_size + cell_size - 1) > scroll_x + play_area_w)
{
- /* but only do the wait, if the player SHOULD BE visible, ie. he is inside
- the defined visible area of the cave */
+ // but only do the wait, if the player SHOULD BE visible, ie. he is inside
+ // the defined visible area of the cave
if (game->cave->player_x >= game->cave->x1 &&
game->cave->player_x <= game->cave->x2)
out_of_window = TRUE;
if ((player_y * cell_size) < scroll_y ||
(player_y * cell_size + cell_size - 1) > scroll_y + play_area_h)
- /* but only do the wait, if the player SHOULD BE visible, ie. he is inside
- the defined visible area of the cave */
+ // but only do the wait, if the player SHOULD BE visible, ie. he is inside
+ // the defined visible area of the cave
if (game->cave->player_y >= game->cave->y1 &&
game->cave->player_y <= game->cave->y2)
out_of_window = TRUE;
- /* if not yet born, we treat as visible. so cave will run.
- the user is unable to control an unborn player, so this is the right behaviour. */
+ // if not yet born, we treat as visible. so cave will run.
+ // the user is unable to control an unborn player, so this is the right behaviour.
if (game->cave->player_state == GD_PL_NOT_YET)
return FALSE;
}
#if DO_GFX_SANITY_CHECK
-/* workaround to prevent variable name scope problem */
+// workaround to prevent variable name scope problem
static boolean use_native_bd_graphics_engine(void)
{
return game.use_native_bd_graphics_engine;
}
#endif
-/* returns true if the element is a player */
+// returns true if the element is a player
static inline boolean is_player(const int element)
{
return (gd_elements[element & O_MASK].properties & P_PLAYER) != 0;
}
-/* returns true if the element is collectible */
+// returns true if the element is collectible
static inline boolean is_collectible(const int element)
{
return (gd_elements[element & O_MASK].properties & P_COLLECTIBLE) != 0;
}
-/* returns true if the element is exploding */
+// returns true if the element is exploding
static inline boolean is_explosion(const int element)
{
return (gd_elements[element & O_MASK].properties & P_EXPLOSION) != 0;
}
#endif
- /* if game element not moving (or no smooth movements requested), simply draw tile */
+ // if game element not moving (or no smooth movements requested), simply draw tile
if (dir == GD_MV_STILL || !use_smooth_movements)
{
blit_bitmap(g->bitmap, dest, g->src_x, g->src_y, cell_size, cell_size, sx, sy);
return;
}
- /* draw smooth animation for game element moving between two cave tiles */
+ // draw smooth animation for game element moving between two cave tiles
if (!(game->last_element_buffer[y][x] & SKIPPED))
{
- /* redraw previous game element on the cave field the new element is moving to */
+ // redraw previous game element on the cave field the new element is moving to
int tile_last = game->last_element_buffer[y][x];
- /* only redraw previous game element if it is not collectible (like dirt etc.) */
+ // only redraw previous game element if it is not collectible (like dirt etc.)
if (is_collectible(tile_last))
tile_last = O_SPACE;
blit_bitmap(g_old->bitmap, dest, g_old->src_x, g_old->src_y, cell_size, cell_size, sx, sy);
}
- /* get cave field position the game element is moving from */
+ // get cave field position the game element is moving from
int dx = (dir == GD_MV_LEFT ? +1 : dir == GD_MV_RIGHT ? -1 : 0);
int dy = (dir == GD_MV_UP ? +1 : dir == GD_MV_DOWN ? -1 : 0);
int old_x = cave->getx(cave, x + dx, y + dy);
{
if (!old_is_moving && !old_is_player)
{
- /* redraw game element on the cave field the element is moving from */
+ // redraw game element on the cave field the element is moving from
blit_bitmap(g_from->bitmap, dest, g_from->src_x, g_from->src_y, cell_size, cell_size,
sx + dx * cell_size, sy + dy * cell_size);
}
else
{
- /* if old tile also moving (like pushing player), do not redraw tile background */
+ // if old tile also moving (like pushing player), do not redraw tile background
game->last_element_buffer[old_y][old_x] |= SKIPPED;
}
}
- /* get shifted position between cave fields the game element is moving from/to */
+ // get shifted position between cave fields the game element is moving from/to
int itercycle = MIN(MAX(0, game->itermax - game->itercycle - 1), game->itermax);
int shift = cell_size * itercycle / game->itermax;
blit_bitmap(g->bitmap, dest, g->src_x, g->src_y, cell_size, cell_size,
sx + dx * shift, sy + dy * shift);
- /* special case: redraw player snapping a game element */
+ // special case: redraw player snapping a game element
if (old_is_visible && old_is_player && !old_is_moving)
{
- /* redraw game element on the cave field the element is moving from */
+ // redraw game element on the cave field the element is moving from
blit_bitmap(g_from->bitmap, dest, g_from->src_x, g_from->src_y, cell_size, cell_size,
sx + dx * cell_size, sy + dy * cell_size);
}
boolean redraw_all = force_redraw;
int x, y;
- /* force redraw if maximum number of cycles has changed (to redraw moving elements) */
+ // force redraw if maximum number of cycles has changed (to redraw moving elements)
if (game->itermax != game->itermax_last)
redraw_all = TRUE;
redraw_all = TRUE;
}
- /* here we draw all cells to be redrawn. we do not take scrolling area into
- consideration - sdl will do the clipping. */
+ // here we draw all cells to be redrawn. we do not take scrolling area into
+ // consideration - sdl will do the clipping.
for (y = cave->y1; y <= cave->y2; y++)
{
for (x = cave->x1; x <= cave->x2; x++)
game->gfx_buffer[y][x] & GD_REDRAW ||
game->dir_buffer[y][x] != GD_MV_STILL)
{
- /* skip redrawing already drawn element with movement */
+ // skip redrawing already drawn element with movement
if (game->element_buffer[y][x] & SKIPPED)
continue;
- /* now we have drawn it */
+ // now we have drawn it
game->gfx_buffer[y][x] = game->gfx_buffer[y][x] & ~GD_REDRAW;
gd_drawcave_tile(dest, game, x, y, draw_masked);
#include <time.h>
#if defined(PLATFORM_WINDOWS)
-#include <process.h> /* for getpid() */
+#include <process.h> // for getpid()
#endif
#include "main_bd.h"
* accessed through the gd_rand_* functions.
**/
-/* Period parameters */
+// Period parameters
#define N 624
#define M 397
-#define MATRIX_A 0x9908b0df /* constant vector a */
-#define UPPER_MASK 0x80000000 /* most significant w-r bits */
-#define LOWER_MASK 0x7fffffff /* least significant r bits */
+#define MATRIX_A 0x9908b0df // constant vector a
+#define UPPER_MASK 0x80000000 // most significant w-r bits
+#define LOWER_MASK 0x7fffffff // least significant r bits
-/* Tempering parameters */
+// Tempering parameters
#define TEMPERING_MASK_B 0x9d2c5680
#define TEMPERING_MASK_C 0xefc60000
#define TEMPERING_SHIFT_U(y) (y >> 11)
struct _GdRand
{
- unsigned int mt[N]; /* the array for the state vector */
+ unsigned int mt[N]; // the array for the state vector
unsigned int mti;
};
seed[2] = getpid ();
seed[3] = getppid ();
}
-#else /* PLATFORM_WINDOWS */
+#else // PLATFORM_WINDOWS
/* rand_s() is only available since Visual Studio 2005 and
* MinGW-w64 has a wrapper that will emulate rand_s() if it's not in msvcrt
*/
if (rand == NULL)
return;
- /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
- /* In the previous version (see above), MSBs of the */
- /* seed affect only MSBs of the array mt[]. */
+ // See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
+ // In the previous version (see above), MSBs of the
+ // seed affect only MSBs of the array mt[].
rand->mt[0] = seed;
for (rand->mti = 1; rand->mti < N; rand->mti++)
for (; k; k--)
{
rand->mt[i] = ((rand->mt[i] ^ ((rand->mt[i - 1] ^ (rand->mt[i - 1] >> 30)) * 1664525UL))
- + seed[j] + j); /* non linear */
- rand->mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+ + seed[j] + j); // non linear
+ rand->mt[i] &= 0xffffffffUL; // for WORDSIZE > 32 machines
i++;
j++;
for (k = N - 1; k; k--)
{
rand->mt[i] = ((rand->mt[i] ^ ((rand->mt[i - 1] ^ (rand->mt[i - 1] >> 30)) * 1566083941UL))
- - i); /* non linear */
- rand->mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+ - i); // non linear
+ rand->mt[i] &= 0xffffffffUL; // for WORDSIZE > 32 machines
i++;
if (i >= N)
}
}
- rand->mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
+ rand->mt[0] = 0x80000000UL; // MSB is 1; assuring non-zero initial array
}
/**
{
unsigned int y;
static const unsigned int mag01[2] = { 0x0, MATRIX_A };
- /* mag01[x] = x * MATRIX_A for x=0,1 */
+ // mag01[x] = x * MATRIX_A for x=0,1
if (rand == NULL)
return 0;
if (rand->mti >= N)
{
- /* generate N words at one time */
+ // generate N words at one time
int kk;
for (kk = 0; kk < N - M; kk++)
* multiple of dist less or equal 2^32.
*/
unsigned int maxvalue;
- if (dist <= 0x80000000u) /* 2^31 */
+ if (dist <= 0x80000000u) // 2^31
{
- /* maxvalue = 2^32 - 1 - (2^32 % dist) */
+ // maxvalue = 2^32 - 1 - (2^32 % dist)
unsigned int leftover = (0x80000000u % dist) * 2;
if (leftover >= dist) leftover -= dist;
maxvalue = 0xffffffffu - leftover;
{
static GdRand *global_random;
- /* called while locked */
+ // called while locked
if (!global_random)
global_random = gd_rand_new();
typedef enum _sound_flag
{
GD_SP_LOOPED = 1 << 0,
- GD_SP_FORCE = 1 << 1, /* force restart, regardless of precedence level */
+ GD_SP_FORCE = 1 << 1, // force restart, regardless of precedence level
} GdSoundFlag;
typedef struct _sound_property
{
GdSound sound;
- int channel; /* channel this sound is played on. */
- int precedence; /* greater numbers will have precedence. */
+ int channel; // channel this sound is played on.
+ int precedence; // greater numbers will have precedence.
int flags;
} SoundProperty;
static SoundProperty sound_flags[] =
{
- { 0, GD_S_NONE, 0, 0 },
-
- /* channel 1 sounds. */
- /* CHANNEL 1 SOUNDS ARE ALWAYS RESTARTED, so no need for GD_SP_FORCE flag. */
- { GD_S_STONE_PUSHING, 1, 10 },
- { GD_S_STONE_FALLING, 1, 10 },
- { GD_S_STONE_IMPACT, 1, 10 },
- { GD_S_MEGA_STONE_PUSHING, 1, 10 },
- { GD_S_MEGA_STONE_FALLING, 1, 10 },
- { GD_S_MEGA_STONE_IMPACT, 1, 10 },
- { GD_S_FLYING_STONE_PUSHING, 1, 10 },
- { GD_S_FLYING_STONE_FALLING, 1, 10 },
- { GD_S_FLYING_STONE_IMPACT, 1, 10 },
- { GD_S_WAITING_STONE_PUSHING, 1, 10 },
- { GD_S_CHASING_STONE_PUSHING, 1, 10 },
- /* nut falling is relatively silent, so low precedence. */
- { GD_S_NUT_PUSHING, 1, 8 },
- { GD_S_NUT_FALLING, 1, 8 },
- { GD_S_NUT_IMPACT, 1, 8 },
- /* higher precedence than a stone bouncing. */
- { GD_S_NUT_CRACKING, 1, 12 },
- /* sligthly lower precedence, as stones and diamonds should be "louder" */
- { GD_S_DIRT_BALL_FALLING, 1, 8 },
- { GD_S_DIRT_BALL_IMPACT, 1, 8 },
- { GD_S_DIRT_LOOSE_FALLING, 1, 8 },
- { GD_S_DIRT_LOOSE_IMPACT, 1, 8 },
- { GD_S_NITRO_PACK_PUSHING, 1, 10 },
- { GD_S_NITRO_PACK_FALLING, 1, 10 },
- { GD_S_NITRO_PACK_IMPACT, 1, 10 },
- { GD_S_FALLING_WALL_FALLING, 1, 10 },
- { GD_S_FALLING_WALL_IMPACT, 1, 10 },
- { GD_S_EXPANDING_WALL, 1, 10 },
- { GD_S_WALL_REAPPEARING, 1, 9 },
- { GD_S_DIAMOND_FALLING_RANDOM, 1, 10 },
- { GD_S_DIAMOND_FALLING_1, 1, 10 },
- { GD_S_DIAMOND_FALLING_2, 1, 10 },
- { GD_S_DIAMOND_FALLING_3, 1, 10 },
- { GD_S_DIAMOND_FALLING_4, 1, 10 },
- { GD_S_DIAMOND_FALLING_5, 1, 10 },
- { GD_S_DIAMOND_FALLING_6, 1, 10 },
- { GD_S_DIAMOND_FALLING_7, 1, 10 },
- { GD_S_DIAMOND_FALLING_8, 1, 10 },
- { GD_S_DIAMOND_IMPACT_RANDOM, 1, 10 },
- { GD_S_DIAMOND_IMPACT_1, 1, 10 },
- { GD_S_DIAMOND_IMPACT_2, 1, 10 },
- { GD_S_DIAMOND_IMPACT_3, 1, 10 },
- { GD_S_DIAMOND_IMPACT_4, 1, 10 },
- { GD_S_DIAMOND_IMPACT_5, 1, 10 },
- { GD_S_DIAMOND_IMPACT_6, 1, 10 },
- { GD_S_DIAMOND_IMPACT_7, 1, 10 },
- { GD_S_DIAMOND_IMPACT_8, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_RANDOM, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_1, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_2, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_3, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_4, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_5, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_6, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_7, 1, 10 },
- { GD_S_FLYING_DIAMOND_FALLING_8, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_RANDOM, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_1, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_2, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_3, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_4, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_5, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_6, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_7, 1, 10 },
- { GD_S_FLYING_DIAMOND_IMPACT_8, 1, 10 },
- /* diamond collect sound has precedence over everything. */
- { GD_S_DIAMOND_COLLECTING, 1, 100 },
- { GD_S_FLYING_DIAMOND_COLLECTING, 1, 100 },
-
- /* collect sounds have higher precedence than falling sounds and the like. */
- { GD_S_SKELETON_COLLECTING, 1, 100 },
- { GD_S_PNEUMATIC_COLLECTING, 1, 50 },
- { GD_S_BOMB_COLLECTING, 1, 50 },
- { GD_S_CLOCK_COLLECTING, 1, 50 },
- { GD_S_SWEET_COLLECTING, 1, 50 },
- { GD_S_KEY_COLLECTING, 1, 50 },
- { GD_S_DIAMOND_KEY_COLLECTING, 1, 50 },
- { GD_S_SLIME, 1, 5 }, /* slime has lower precedence than diamond and stone falling sounds. */
- { GD_S_LAVA, 1, 5 }, /* lava has low precedence, too. */
- { GD_S_REPLICATOR, 1, 5 },
- { GD_S_ACID_SPREADING, 1, 3 }, /* same for acid, even lower. */
- { GD_S_BLADDER_MOVING, 1, 5 }, /* same for bladder. */
- { GD_S_BLADDER_PUSHING, 1, 5 },
- { GD_S_BLADDER_CONVERTING, 1, 8 },
- { GD_S_BLADDER_SPENDER, 1, 8 },
- { GD_S_BITER_EATING, 1, 3 }, /* very low precedence. biters tend to produce too much sound. */
-
- /* channel2 sounds. */
- { GD_S_DOOR_OPENING, 2, 10 },
- { GD_S_DIRT_WALKING, 2, 10 },
- { GD_S_EMPTY_WALKING, 2, 10 },
- { GD_S_STIRRING, 2, 10 },
- { GD_S_BOX_PUSHING, 2, 10 },
- { GD_S_TELEPORTER, 2, 10 },
- { GD_S_TIMEOUT_10, 2, 20 }, /* timeout sounds have increasing precedence so they are always started */
- { GD_S_TIMEOUT_9, 2, 21 }, /* timeout sounds are examples which do not need "force restart" flag. */
- { GD_S_TIMEOUT_8, 2, 22 },
- { GD_S_TIMEOUT_7, 2, 23 },
- { GD_S_TIMEOUT_6, 2, 24 },
- { GD_S_TIMEOUT_5, 2, 25 },
- { GD_S_TIMEOUT_4, 2, 26 },
- { GD_S_TIMEOUT_3, 2, 27 },
- { GD_S_TIMEOUT_2, 2, 28 },
- { GD_S_TIMEOUT_1, 2, 29 },
- { GD_S_TIMEOUT_0, 2, 150, GD_SP_FORCE },
- { GD_S_EXPLODING, 2, 100, GD_SP_FORCE },
- { GD_S_BOMB_EXPLODING, 2, 100, GD_SP_FORCE },
- { GD_S_GHOST_EXPLODING, 2, 100, GD_SP_FORCE },
- { GD_S_VOODOO_EXPLODING, 2, 100, GD_SP_FORCE },
- { GD_S_NITRO_PACK_EXPLODING, 2, 100, GD_SP_FORCE },
- { GD_S_BOMB_PLACING, 2, 10 },
- { GD_S_FINISHED, 2, 15, GD_SP_FORCE | GD_SP_LOOPED }, /* precedence larger than normal, but smaller than timeout sounds */
- { GD_S_SWITCH_BITER, 2, 10 },
- { GD_S_SWITCH_CREATURES, 2, 10 },
- { GD_S_SWITCH_GRAVITY, 2, 10 },
- { GD_S_SWITCH_EXPANDING, 2, 10 },
- { GD_S_SWITCH_CONVEYOR, 2, 10 },
- { GD_S_SWITCH_REPLICATOR, 2, 10 },
-
- /* channel 3 sounds. */
- { GD_S_AMOEBA, 3, 30, GD_SP_LOOPED },
- { GD_S_AMOEBA_MAGIC, 3, 40, GD_SP_LOOPED },
- { GD_S_MAGIC_WALL, 3, 35, GD_SP_LOOPED },
- { GD_S_COVERING, 3, 100, GD_SP_LOOPED },
- { GD_S_PNEUMATIC_HAMMER, 3, 50, GD_SP_LOOPED },
- { GD_S_WATER, 3, 20, GD_SP_LOOPED },
- { GD_S_CRACKING, 3, 150 },
- { GD_S_GRAVITY_CHANGING, 3, 60 },
-
- /* other sounds */
- /* the bonus life sound has nothing to do with the cave. */
- /* playing on channel 4. */
- { GD_S_BONUS_LIFE, 4, 0 },
+ { 0, GD_S_NONE, 0, 0 },
+
+ // channel 1 sounds.
+ // CHANNEL 1 SOUNDS ARE ALWAYS RESTARTED, so no need for GD_SP_FORCE flag.
+ { GD_S_STONE_PUSHING, 1, 10 },
+ { GD_S_STONE_FALLING, 1, 10 },
+ { GD_S_STONE_IMPACT, 1, 10 },
+ { GD_S_MEGA_STONE_PUSHING, 1, 10 },
+ { GD_S_MEGA_STONE_FALLING, 1, 10 },
+ { GD_S_MEGA_STONE_IMPACT, 1, 10 },
+ { GD_S_FLYING_STONE_PUSHING, 1, 10 },
+ { GD_S_FLYING_STONE_FALLING, 1, 10 },
+ { GD_S_FLYING_STONE_IMPACT, 1, 10 },
+ { GD_S_WAITING_STONE_PUSHING, 1, 10 },
+ { GD_S_CHASING_STONE_PUSHING, 1, 10 },
+ // nut falling is relatively silent, so low precedence.
+ { GD_S_NUT_PUSHING, 1, 8 },
+ { GD_S_NUT_FALLING, 1, 8 },
+ { GD_S_NUT_IMPACT, 1, 8 },
+ // higher precedence than a stone bouncing.
+ { GD_S_NUT_CRACKING, 1, 12 },
+ // sligthly lower precedence, as stones and diamonds should be "louder"
+ { GD_S_DIRT_BALL_FALLING, 1, 8 },
+ { GD_S_DIRT_BALL_IMPACT, 1, 8 },
+ { GD_S_DIRT_LOOSE_FALLING, 1, 8 },
+ { GD_S_DIRT_LOOSE_IMPACT, 1, 8 },
+ { GD_S_NITRO_PACK_PUSHING, 1, 10 },
+ { GD_S_NITRO_PACK_FALLING, 1, 10 },
+ { GD_S_NITRO_PACK_IMPACT, 1, 10 },
+ { GD_S_FALLING_WALL_FALLING, 1, 10 },
+ { GD_S_FALLING_WALL_IMPACT, 1, 10 },
+ { GD_S_EXPANDING_WALL, 1, 10 },
+ { GD_S_WALL_REAPPEARING, 1, 9 },
+ { GD_S_DIAMOND_FALLING_RANDOM, 1, 10 },
+ { GD_S_DIAMOND_FALLING_1, 1, 10 },
+ { GD_S_DIAMOND_FALLING_2, 1, 10 },
+ { GD_S_DIAMOND_FALLING_3, 1, 10 },
+ { GD_S_DIAMOND_FALLING_4, 1, 10 },
+ { GD_S_DIAMOND_FALLING_5, 1, 10 },
+ { GD_S_DIAMOND_FALLING_6, 1, 10 },
+ { GD_S_DIAMOND_FALLING_7, 1, 10 },
+ { GD_S_DIAMOND_FALLING_8, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_RANDOM, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_1, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_2, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_3, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_4, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_5, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_6, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_7, 1, 10 },
+ { GD_S_DIAMOND_IMPACT_8, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_RANDOM, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_1, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_2, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_3, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_4, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_5, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_6, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_7, 1, 10 },
+ { GD_S_FLYING_DIAMOND_FALLING_8, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_RANDOM, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_1, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_2, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_3, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_4, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_5, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_6, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_7, 1, 10 },
+ { GD_S_FLYING_DIAMOND_IMPACT_8, 1, 10 },
+ // diamond collect sound has precedence over everything.
+ { GD_S_DIAMOND_COLLECTING, 1, 100 },
+ { GD_S_FLYING_DIAMOND_COLLECTING, 1, 100 },
+
+ // collect sounds have higher precedence than falling sounds and the like.
+ { GD_S_SKELETON_COLLECTING, 1, 100 },
+ { GD_S_PNEUMATIC_COLLECTING, 1, 50 },
+ { GD_S_BOMB_COLLECTING, 1, 50 },
+ { GD_S_CLOCK_COLLECTING, 1, 50 },
+ { GD_S_SWEET_COLLECTING, 1, 50 },
+ { GD_S_KEY_COLLECTING, 1, 50 },
+ { GD_S_DIAMOND_KEY_COLLECTING, 1, 50 },
+ // slime has lower precedence than diamond and stone falling sounds.
+ { GD_S_SLIME, 1, 5 },
+ // lava has low precedence, too.
+ { GD_S_LAVA, 1, 5 },
+ { GD_S_REPLICATOR, 1, 5 },
+ // same for acid, even lower.
+ { GD_S_ACID_SPREADING, 1, 3 },
+ // same for bladder.
+ { GD_S_BLADDER_MOVING, 1, 5 },
+ { GD_S_BLADDER_PUSHING, 1, 5 },
+ { GD_S_BLADDER_CONVERTING, 1, 8 },
+ { GD_S_BLADDER_SPENDER, 1, 8 },
+ // very low precedence. biters tend to produce too much sound.
+ { GD_S_BITER_EATING, 1, 3 },
+
+ // channel2 sounds.
+ { GD_S_DOOR_OPENING, 2, 10 },
+ { GD_S_DIRT_WALKING, 2, 10 },
+ { GD_S_EMPTY_WALKING, 2, 10 },
+ { GD_S_STIRRING, 2, 10 },
+ { GD_S_BOX_PUSHING, 2, 10 },
+ { GD_S_TELEPORTER, 2, 10 },
+ // timeout sounds have increasing precedence so they are always started
+ { GD_S_TIMEOUT_10, 2, 20 },
+ // timeout sounds are examples which do not need "force restart" flag.
+ { GD_S_TIMEOUT_9, 2, 21 },
+ { GD_S_TIMEOUT_8, 2, 22 },
+ { GD_S_TIMEOUT_7, 2, 23 },
+ { GD_S_TIMEOUT_6, 2, 24 },
+ { GD_S_TIMEOUT_5, 2, 25 },
+ { GD_S_TIMEOUT_4, 2, 26 },
+ { GD_S_TIMEOUT_3, 2, 27 },
+ { GD_S_TIMEOUT_2, 2, 28 },
+ { GD_S_TIMEOUT_1, 2, 29 },
+ { GD_S_TIMEOUT_0, 2, 150, GD_SP_FORCE },
+ { GD_S_EXPLODING, 2, 100, GD_SP_FORCE },
+ { GD_S_BOMB_EXPLODING, 2, 100, GD_SP_FORCE },
+ { GD_S_GHOST_EXPLODING, 2, 100, GD_SP_FORCE },
+ { GD_S_VOODOO_EXPLODING, 2, 100, GD_SP_FORCE },
+ { GD_S_NITRO_PACK_EXPLODING, 2, 100, GD_SP_FORCE },
+ { GD_S_BOMB_PLACING, 2, 10 },
+ // precedence larger than normal, but smaller than timeout sounds
+ { GD_S_FINISHED, 2, 15, GD_SP_FORCE | GD_SP_LOOPED },
+ { GD_S_SWITCH_BITER, 2, 10 },
+ { GD_S_SWITCH_CREATURES, 2, 10 },
+ { GD_S_SWITCH_GRAVITY, 2, 10 },
+ { GD_S_SWITCH_EXPANDING, 2, 10 },
+ { GD_S_SWITCH_CONVEYOR, 2, 10 },
+ { GD_S_SWITCH_REPLICATOR, 2, 10 },
+
+ // channel 3 sounds.
+ { GD_S_AMOEBA, 3, 30, GD_SP_LOOPED },
+ { GD_S_AMOEBA_MAGIC, 3, 40, GD_SP_LOOPED },
+ { GD_S_MAGIC_WALL, 3, 35, GD_SP_LOOPED },
+ { GD_S_COVERING, 3, 100, GD_SP_LOOPED },
+ { GD_S_PNEUMATIC_HAMMER, 3, 50, GD_SP_LOOPED },
+ { GD_S_WATER, 3, 20, GD_SP_LOOPED },
+ { GD_S_CRACKING, 3, 150 },
+ { GD_S_GRAVITY_CHANGING, 3, 60 },
+
+ // other sounds
+ // the bonus life sound has nothing to do with the cave.
+ // playing on channel 4.
+ { GD_S_BONUS_LIFE, 4, 0 },
};
struct GdSoundInfo
static void play_sound(int channel, GdSound sound)
{
- /* channel 1 and channel 4 are used alternating */
- /* channel 2 and channel 5 are used alternating */
+ // channel 1 and channel 4 are used alternating
+ // channel 2 and channel 5 are used alternating
static const GdSound diamond_falling_sounds[] =
{
GD_S_DIAMOND_FALLING_1,
if (sound == GD_S_NONE)
return;
- /* change diamond falling random to a selected diamond falling sound. */
+ // change diamond falling random to a selected diamond falling sound.
if (sound == GD_S_DIAMOND_FALLING_RANDOM)
sound = diamond_falling_sounds[gd_random_int_range(0, 8)];
else if (sound == GD_S_DIAMOND_IMPACT_RANDOM)
else if (sound == GD_S_FLYING_DIAMOND_IMPACT_RANDOM)
sound = flying_diamond_impact_sounds[gd_random_int_range(0, 8)];
- /* channel 1 may have been changed to channel 4 above. */
+ // channel 1 may have been changed to channel 4 above.
if (!gd_sound_is_looped(sound))
halt_channel(channel);
{
int i;
- /* stop all sounds. */
+ // stop all sounds.
for (i = 0; i < ARRAY_SIZE(snd_playing); i++)
halt_channel(i);
}
static void play_sounds(GdSound sound1, GdSound sound2, GdSound sound3)
{
- /* CHANNEL 1 is for small sounds */
+ // CHANNEL 1 is for small sounds
if (sound1 != GD_S_NONE)
{
- /* start new sound if higher or same precedence than the one currently playing */
+ // start new sound if higher or same precedence than the one currently playing
if (gd_sound_get_precedence(sound1) >= gd_sound_get_precedence(sound_playing(1)))
play_sound(1, sound1);
}
else
{
- /* only interrupt looped sounds. non-looped sounds will go away automatically. */
+ // only interrupt looped sounds. non-looped sounds will go away automatically.
if (gd_sound_is_looped(sound_playing(1)))
halt_channel(1);
}
- /* CHANNEL 2 is for walking, explosions */
- /* if no sound requested, do nothing. */
+ // CHANNEL 2 is for walking, explosions
+ // if no sound requested, do nothing.
if (sound2 != GD_S_NONE)
{
boolean play = FALSE;
- /* always start if not currently playing a sound. */
+ // always start if not currently playing a sound.
if (sound_playing(2) == GD_S_NONE ||
gd_sound_force_start(sound2) ||
gd_sound_get_precedence(sound2) > gd_sound_get_precedence(sound_playing(2)))
play = TRUE;
- /* if figured out to play: do it. */
- /* (if the requested sound is looped, this is required to continue playing it) */
+ // if figured out to play: do it.
+ // (if the requested sound is looped, this is required to continue playing it)
if (play)
play_sound(2, sound2);
}
else
{
- /* only interrupt looped sounds. non-looped sounds will go away automatically. */
+ // only interrupt looped sounds. non-looped sounds will go away automatically.
if (gd_sound_is_looped(sound_playing(2)))
halt_channel(2);
}
- /* CHANNEL 3 is for crack sound, amoeba and magic wall. */
+ // CHANNEL 3 is for crack sound, amoeba and magic wall.
if (sound3 != GD_S_NONE)
{
boolean play = TRUE;
- /* if requests a non-looped sound, play that immediately.
- that can be a crack sound, gravity change, new life, ... */
- /* do not interrupt the previous sound, if it is non-looped.
- later calls of this function will probably contain the same sound3,
- and then it will be set. */
+ // if requests a non-looped sound, play that immediately.
+ // that can be a crack sound, gravity change, new life, ...
+
+ // do not interrupt the previous sound, if it is non-looped.
+ // later calls of this function will probably contain the same sound3,
+ // and then it will be set.
if (!gd_sound_is_looped(sound_playing(3)) &&
gd_sound_is_looped(sound3) &&
sound_playing(3) != GD_S_NONE)
play = FALSE;
- /* if figured out to play: do it. */
+ // if figured out to play: do it.
if (play)
play_sound(3, sound3);
}
else
{
- /* sound3 = none, so interrupt sound requested. */
- /* only interrupt looped sounds. non-looped sounds will go away automatically. */
+ // sound3 = none, so interrupt sound requested.
+ // only interrupt looped sounds. non-looped sounds will go away automatically.
if (gd_sound_is_looped(sound_playing(3)))
halt_channel(3);
}
si->sound = sound;
}
-/* plays sound in a cave */
+// plays sound in a cave
void gd_sound_play(GdCave *cave, GdSound sound, GdElement element, int x, int y)
{
if (sound == GD_S_NONE)
// constant definitions
// ----------------------------------------------------------------------------
-/* screen sizes and positions for BD engine */
+// screen sizes and positions for BD engine
#define TILESIZE 32
extern int SCR_FIELDX, SCR_FIELDY;
-/* often used screen positions */
+// often used screen positions
extern int SX, SY;
#define SXSIZE (SCR_FIELDX * TILEX)
#define SYSIZE (SCR_FIELDY * TILEY)
-/* compatibility macros */
+// compatibility macros
#define gettext(String) (String)
#define N_(String) (String)
projects / rocksndiamonds.git / commitdiff