From 21bad5438f8956c3011c0d69de1d554f3fcc0729 Mon Sep 17 00:00:00 2001 From: xolatile Date: Fri, 24 Nov 2023 09:00:46 -0500 Subject: [PATCH] Added unused sprites... --- chapter/chapter_0.c | 120 +++++++++++++++++++++++++++------------------------- chapter/chapter_0.h | 18 ++++---- chapter/chapter_5.c | 77 ++++++++++++++++----------------- chapter/chapter_5.h | 34 +++++++++++---- chapter/chapter_6.c | 62 +++++++++++++++------------ 5 files changed, 166 insertions(+), 145 deletions(-) diff --git a/chapter/chapter_0.c b/chapter/chapter_0.c index 73dab53..c55565c 100644 --- a/chapter/chapter_0.c +++ b/chapter/chapter_0.c @@ -172,51 +172,51 @@ use it to interate the strings, while in "unlimited" versions, we iterate on poi same results, you can use any of them. */ -int string_compare (char * string_0, char * string_1) { - fatal_failure (string_0 == NULL, "string_compare: Destination string is null pointer."); // This will be seen in next 5 functions too, we don't want NULL here. - fatal_failure (string_1 == NULL, "string_compare: Source string is null pointer."); +int string_compare (char * destination, char * source) { + fatal_failure (destination == NULL, "string_compare: Destination string is null pointer."); // This will be seen in next 5 functions too, we don't want NULL here. + fatal_failure (source == NULL, "string_compare: Source string is null pointer."); - for (; (* string_0 != CHARACTER_NULL) && (* string_1 != CHARACTER_NULL); ++string_0, ++string_1) { // We iterate until either string reaches the null character. - if (* string_0 != * string_1) { // In case that characters at the same offset are different: - return (FALSE); // > We return FALSE, 0, since strings aren't the same... + for (; (* destination != CHARACTER_NULL) && (* source != CHARACTER_NULL); ++destination, ++source) { // We iterate until either string reaches the null character. + if (* destination != * source) { // In case that characters at the same offset are different: + return (FALSE); // > We return FALSE, 0, since strings aren't the same... } } - if (* string_0 != * string_1) { // Now, we'll do one last termination check. + if (* destination != * source) { // Now, we'll do one last termination check. return (FALSE); } - return (TRUE); // Otherwise, strings are same, we return TRUE, 1. + return (TRUE); // Otherwise, strings are same, we return TRUE, 1. } -char * string_copy (char * string_0, char * string_1) { - char * result = string_0; // We need to save pointer to destination string before changing it. +char * string_copy (char * destination, char * source) { + char * result = destination; // We need to save pointer to destination string before changing it. - fatal_failure (string_0 == NULL, "string_copy: Destination string is null pointer."); - fatal_failure (string_1 == NULL, "string_copy: Source string is null pointer."); + fatal_failure (destination == NULL, "string_copy: Destination string is null pointer."); + fatal_failure (source == NULL, "string_copy: Source string is null pointer."); - for (; * string_1 != CHARACTER_NULL; ++string_0, ++string_1) { // This time and in next function, we iterate only source string. - * string_0 = * string_1; // And we assign character at the same offset to destination string (aka copy it). + for (; * source != CHARACTER_NULL; ++destination, ++source) { // This time and in next function, we iterate only source string. + * destination = * source; // And we assign character at the same offset to destination string (aka copy it). } - * string_0 = CHARACTER_NULL; // Copying null termination, since the loop stopped on that condition. + * destination = CHARACTER_NULL; // Copying null termination, since the loop stopped on that condition. - return (result); // Lastly, we return the destination string, in order to be able to bind functions. + return (result); // Lastly we return the destination string, in order to be able to bind functions. } -char * string_concatenate (char * string_0, char * string_1) { - char * result = string_0; +char * string_concatenate (char * destination, char * source) { + char * result = destination; - fatal_failure (string_0 == NULL, "string_concatenate: Destination string is null pointer."); - fatal_failure (string_1 == NULL, "string_concatenate: Source string is null pointer."); + fatal_failure (destination == NULL, "string_concatenate: Destination string is null pointer."); + fatal_failure (source == NULL, "string_concatenate: Source string is null pointer."); - string_0 += string_length (string_0); // We'll first offset destination string to the end of it. - // Because we want to start copying from the end, aka concatenate it. - for (; * string_1 != CHARACTER_NULL; ++string_0, ++string_1) { // The rest of the function is same as string_copy, so: - * string_0 = * string_1; // We could even use it here, but that defies the purpose of learning now. + destination += string_length (destination); // We'll first offset destination string to the end of it. + // Because we want to start copying from the end, aka concatenate it. + for (; * source != CHARACTER_NULL; ++destination, ++source) { // The rest of the function is same as string_copy, so: + * destination = * source; // We could even use it here, but that defies the purpose of learning now. } - * string_0 = CHARACTER_NULL; // Again, assign null termination. + * destination = CHARACTER_NULL; // Again, assign null termination. return (result); } @@ -232,56 +232,54 @@ write comments for 'string_copy_limit', 'string_concatenate_limit' and 'string_r current knowledge of C language. */ -int string_compare_limit (char * string_0, char * string_1, int limit) { +int string_compare_limit (char * destination, char * source, int limit) { int offset; - fatal_failure (string_0 == NULL, "string_compare_limit: Destination string is null pointer."); // This is the new trend, check for unimportant things. - fatal_failure (string_1 == NULL, "string_compare_limit: Source string is null pointer."); // At least this isn't too verbose. I hope... + fatal_failure (destination == NULL, "string_compare_limit: Destination string is null pointer."); // This is the new trend, check for unimportant things. + fatal_failure (source == NULL, "string_compare_limit: Source string is null pointer."); // At least this isn't too verbose. I hope... - for (offset = 0; offset < limit; ++offset) { // Now, we'll iterate until 'limit' is reached, but it can overrun. - if (string_0 [offset] != string_1 [offset]) { // All said here applies to next two functions as well... - return (FALSE); // As soon as 2 characters mismatch, they're not same, we return FALSE. + for (offset = 0; offset < limit; ++offset) { // Now, we'll iterate until 'limit' is reached, but it can overrun. + if (destination [offset] != source [offset]) { // All said here applies to next two functions as well... + return (FALSE); // As soon as 2 characters mismatch, they're not same, we return FALSE. } } - return (TRUE); // Otherwise, we're reached the end, they're same, we return TRUE. + return (TRUE); // Otherwise, we're reached the end, they're same, we return TRUE. } -char * string_copy_limit (char * string_0, char * string_1, int limit) { +char * string_copy_limit (char * destination, char * source, int limit) { int offset; - fatal_failure (string_0 == NULL, "string_copy_limit: Destination string is null pointer."); - fatal_failure (string_1 == NULL, "string_copy_limit: Source string is null pointer."); + fatal_failure (destination == NULL, "string_copy_limit: Destination string is null pointer."); - if ((limit <= 0) || (string_1 == NULL)) { - return (string_0); + if ((limit <= 0) || (source == NULL)) { + return (destination); } for (offset = 0; offset < limit; ++offset) { - string_0 [offset] = string_1 [offset]; + destination [offset] = source [offset]; } - return (string_0); + return (destination); } -char * string_concatenate_limit (char * string_0, char * string_1, int limit) { - int offset, length_0, length_1; +char * string_concatenate_limit (char * destination, char * source, int limit) { + int offset, destination_length, source_length; - fatal_failure (string_0 == NULL, "string_concatenate_limit: Destination string is null pointer."); - fatal_failure (string_1 == NULL, "string_concatenate_limit: Source string is null pointer."); + fatal_failure (destination == NULL, "string_concatenate_limit: Destination string is null pointer."); - if ((limit <= 0) || (string_1 == NULL)) { - return (string_0); + if ((limit <= 0) || (source == NULL)) { + return (destination); } - length_0 = string_length (string_0); - length_1 = string_length (string_1); + destination_length = string_length (destination); + source_length = string_length (source); - for (offset = 0; (offset < length_1) && (offset < limit); ++offset) { - string_0 [length_0 + offset] = string_1 [offset]; + for (offset = 0; (offset < source_length) && (offset < limit); ++offset) { + destination [destination_length + offset] = source [offset]; } - return (string_0); + return (destination); } char * string_reverse_limit (char * string, int limit) { @@ -349,14 +347,17 @@ char * string_realign (char * string, int amount, char character) { // Ignore what next two functions do, it's about memory management that we'll cover in later chapters. */ -int memory_compare (void * memory, void * source, int length) { +int memory_compare (void * destination, void * source, int length) { int offset; - char * cast_0 = (char *) memory; + char * cast_0 = (char *) destination; char * cast_1 = (char *) source; - fatal_failure (memory == NULL, "memory_compare: Memory is null pointer."); - fatal_failure (source == NULL, "memory_compare: Source is null pointer."); + fatal_failure (destination == NULL, "memory_compare: Memory is null pointer."); + + if (source == NULL) { + return (FALSE); + } for (offset = 0; offset != length; ++offset) { if (cast_0 [offset] != cast_1 [offset]) { @@ -367,14 +368,17 @@ int memory_compare (void * memory, void * source, int length) { return (TRUE); } -void memory_copy (void * memory, void * source, int length) { +void memory_copy (void * destination, void * source, int length) { int offset; - char * cast_0 = (char *) memory; + char * cast_0 = (char *) destination; char * cast_1 = (char *) source; - fatal_failure (memory == NULL, "memory_copy: Memory is null pointer."); - fatal_failure (source == NULL, "memory_copy: Source is null pointer."); + fatal_failure (destination == NULL, "memory_copy: Memory is null pointer."); + + if (source == NULL) { + return; + } for (offset = 0; offset != length; ++offset) { cast_0 [offset] = cast_1 [offset]; diff --git a/chapter/chapter_0.h b/chapter/chapter_0.h index 39eed16..520e035 100644 --- a/chapter/chapter_0.h +++ b/chapter/chapter_0.h @@ -207,15 +207,15 @@ extern void * deallocate (void * data ); extern int string_length (char * string); // We deal with strings a lot in this program, so string functions will be more important than character functions from chapter one. -extern int string_compare (char * string_0, char * string_1); // See how nicely they align, right? -extern char * string_copy (char * string_0, char * string_1); -extern char * string_concatenate (char * string_0, char * string_1); -extern char * string_reverse (char * string); // Notice last function, we didn't align ');'... - -extern int string_compare_limit (char * string_0, char * string_1, int limit); // These ones too, it's beautiful (in my opinion), tho some consider it useless. -extern char * string_copy_limit (char * string_0, char * string_1, int limit); -extern char * string_concatenate_limit (char * string_0, char * string_1, int limit); -extern char * string_reverse_limit (char * string, int limit); // And we align the last argument in this case, use whatever you prefer. +extern int string_compare (char * destination, char * source); // See how nicely they align, right? +extern char * string_copy (char * destination, char * source); +extern char * string_concatenate (char * destination, char * source); +extern char * string_reverse (char * string); // Notice last function, we didn't align ');'... + +extern int string_compare_limit (char * destination, char * source, int limit); // These ones too, it's beautiful (in my opinion), tho some consider it useless. +extern char * string_copy_limit (char * destination, char * source, int limit); +extern char * string_concatenate_limit (char * destination, char * source, int limit); +extern char * string_reverse_limit (char * string, int limit); // And we align the last argument in this case, use whatever you prefer. extern char * string_realign (char * string, int amount, char character); // This is a simple function that realigns a string to right, we'll use it way later ahead. diff --git a/chapter/chapter_5.c b/chapter/chapter_5.c index 8ae8f37..88dfceb 100644 --- a/chapter/chapter_5.c +++ b/chapter/chapter_5.c @@ -37,7 +37,7 @@ procedure_t game_clean_up (procedure_t) { } number_t randomize (number_t lower, number_t upper) { - return ((number_t) rand () % (upper - lower) + lower); + return ((number_t) rand () % (upper - lower + 1) + lower); } bundle_t * game_bundle (number_t minimum, number_t maximum, number_t current) { @@ -64,6 +64,18 @@ symbol_t * game_symbol (number_t character, number_t colour, number_t effect) { return (symbol); } +sprite_t * game_sprite (number_t width, number_t height, memory_t data) { + sprite_t * sprite = allocate ((number_t) sizeof (* sprite)); + + sprite->width = width; + sprite->height = height; + sprite->data = data; + + game_free_memory (sprite); + + return (sprite); +} + generator_t * game_generator (generate_t function) { generator_t * generator = allocate ((number_t) sizeof (* generator)); @@ -141,7 +153,7 @@ skill_t * game_skill (string_t name, bundle_t * points, ...) { return (skill); } -bot_t * game_bot (string_t name, symbol_t * symbol, bundle_t * health, bundle_t * mana, bundle_t * stamina) { +bot_t * game_bot (string_t name, symbol_t * symbol, sprite_t * sprite, bundle_t * health, bundle_t * mana, bundle_t * stamina) { bot_t * bot = allocate ((number_t) sizeof (* bot)); string_copy ((bot->name = allocate (string_length (name) + 1)), name); @@ -150,12 +162,14 @@ bot_t * game_bot (string_t name, symbol_t * symbol, bundle_t * health, bundle_t bot->y = 0; memory_copy ((bot->symbol = allocate ((number_t) sizeof (* bot->symbol))), symbol, (number_t) sizeof (* symbol)); + memory_copy ((bot->sprite = allocate ((number_t) sizeof (* bot->sprite))), sprite, (number_t) sizeof (* sprite)); memory_copy ((bot->health = allocate ((number_t) sizeof (* bot->health))), health, (number_t) sizeof (* health)); memory_copy ((bot->mana = allocate ((number_t) sizeof (* bot->mana))), mana, (number_t) sizeof (* mana)); memory_copy ((bot->stamina = allocate ((number_t) sizeof (* bot->stamina))), stamina, (number_t) sizeof (* stamina)); game_free_memory (bot->name); game_free_memory (bot->symbol); + game_free_memory (bot->sprite); game_free_memory (bot->health); game_free_memory (bot->mana); game_free_memory (bot->stamina); @@ -164,7 +178,7 @@ bot_t * game_bot (string_t name, symbol_t * symbol, bundle_t * health, bundle_t return (bot); } -player_t * game_player (string_t name, symbol_t * symbol, bundle_t * health, bundle_t * mana, bundle_t * stamina, ...) { +player_t * game_player (string_t name, symbol_t * symbol, sprite_t * sprite, bundle_t * health, bundle_t * mana, bundle_t * stamina, ...) { va_list list; player_t * player = allocate ((number_t) sizeof (* player)); @@ -175,6 +189,7 @@ player_t * game_player (string_t name, symbol_t * symbol, bundle_t * health, bun player->y = 3; memory_copy ((player->symbol = allocate ((number_t) sizeof (* player->symbol))), symbol, (number_t) sizeof (* symbol)); + memory_copy ((player->sprite = allocate ((number_t) sizeof (* player->sprite))), sprite, (number_t) sizeof (* sprite)); memory_copy ((player->health = allocate ((number_t) sizeof (* player->health))), health, (number_t) sizeof (* health)); memory_copy ((player->mana = allocate ((number_t) sizeof (* player->mana))), mana, (number_t) sizeof (* mana)); memory_copy ((player->stamina = allocate ((number_t) sizeof (* player->stamina))), stamina, (number_t) sizeof (* stamina)); @@ -208,6 +223,7 @@ player_t * game_player (string_t name, symbol_t * symbol, bundle_t * health, bun game_free_memory (player->name); game_free_memory (player->symbol); + game_free_memory (player->sprite); game_free_memory (player->health); game_free_memory (player->mana); game_free_memory (player->stamina); @@ -218,18 +234,20 @@ player_t * game_player (string_t name, symbol_t * symbol, bundle_t * health, bun return (player); } -block_t * game_block (string_t name, symbol_t * symbol, number_t collision, number_t override) { +block_t * game_block (string_t name, symbol_t * symbol, sprite_t * sprite, number_t collision, number_t override) { block_t * block = allocate ((number_t) sizeof (* block)); string_copy ((block->name = allocate (string_length (name) + 1)), name); memory_copy ((block->symbol = allocate ((number_t) sizeof (* block->symbol))), symbol, (number_t) sizeof (* symbol)); + memory_copy ((block->sprite = allocate ((number_t) sizeof (* block->sprite))), sprite, (number_t) sizeof (* sprite)); block->collision = collision; block->override = override; game_free_memory (block->name); game_free_memory (block->symbol); + game_free_memory (block->sprite); game_free_memory (block); return (block); @@ -269,46 +287,23 @@ world_t * game_world (number_t width, number_t height, ...) { return (world); } -procedure_t game_render_attribute (number_t x, number_t y, ...) { - va_list list; - - va_start (list, y); - - for (;; ++y) { - attribute_t * attribute = (attribute_t *) va_arg (list, void *); - - if (attribute != NULL) { - curses_render_string (attribute->name, COLOUR_CYAN, EFFECT_NORMAL, x + 0, y); - curses_render_string ("[ ", COLOUR_GREY, EFFECT_BOLD, x + 18, y); - curses_render_string (format_to_string (attribute->points->minimum, 0, 10, 4, ' '), COLOUR_RED, EFFECT_NORMAL, x + 20, y); - curses_render_string (format_to_string (attribute->points->current, 0, 10, 4, ' '), COLOUR_WHITE, EFFECT_NORMAL, x + 24, y); - curses_render_string (format_to_string (attribute->points->maximum, 0, 10, 4, ' '), COLOUR_GREEN, EFFECT_NORMAL, x + 28, y); - curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x + 32, y); - } else break; - } - - va_end (list); +procedure_t game_render_attribute (attribute_t * attribute, number_t x, number_t y) { + curses_render_string (attribute->name, COLOUR_CYAN, EFFECT_NORMAL, x + 0, y); + curses_render_string ("[ ", COLOUR_GREY, EFFECT_BOLD, x + 18, y); + curses_render_string (format_to_string (attribute->points->minimum, 0, 10, 4, ' '), COLOUR_RED, EFFECT_NORMAL, x + 20, y); + curses_render_string (format_to_string (attribute->points->current, 0, 10, 4, ' '), COLOUR_WHITE, EFFECT_NORMAL, x + 24, y); + curses_render_string (format_to_string (attribute->points->maximum, 0, 10, 4, ' '), COLOUR_GREEN, EFFECT_NORMAL, x + 28, y); + curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x + 32, y); } -procedure_t game_render_skill (number_t x, number_t y, ...) { - va_list list; - - va_start (list, y); - - for (;; ++y) { - skill_t * skill = (skill_t *) va_arg (list, void *); - - if (skill != NULL) { - curses_render_string (skill->name, COLOUR_CYAN, EFFECT_NORMAL, x + 0, y); - curses_render_string ("[ ", COLOUR_GREY, EFFECT_BOLD, x + 18, y); - curses_render_string (format_to_string (skill->points->minimum, 0, 10, 4, ' '), COLOUR_RED, EFFECT_NORMAL, x + 20, y); - curses_render_string (format_to_string (skill->points->current, 0, 10, 4, ' '), COLOUR_WHITE, EFFECT_NORMAL, x + 24, y); - curses_render_string (format_to_string (skill->points->maximum, 0, 10, 4, ' '), COLOUR_GREEN, EFFECT_NORMAL, x + 28, y); - curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x + 32, y); - } else break; - } +procedure_t game_render_skill (skill_t * skill, number_t x, number_t y) { + curses_render_string (skill->name, COLOUR_CYAN, EFFECT_NORMAL, x + 0, y); + curses_render_string ("[ ", COLOUR_GREY, EFFECT_BOLD, x + 18, y); + curses_render_string (format_to_string (skill->points->minimum, 0, 10, 4, ' '), COLOUR_RED, EFFECT_NORMAL, x + 20, y); + curses_render_string (format_to_string (skill->points->current, 0, 10, 4, ' '), COLOUR_WHITE, EFFECT_NORMAL, x + 24, y); + curses_render_string (format_to_string (skill->points->maximum, 0, 10, 4, ' '), COLOUR_GREEN, EFFECT_NORMAL, x + 28, y); + curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x + 32, y); - va_end (list); } procedure_t game_render_bot (bot_t * bot) { diff --git a/chapter/chapter_5.h b/chapter/chapter_5.h index d55fd86..713bd22 100644 --- a/chapter/chapter_5.h +++ b/chapter/chapter_5.h @@ -39,13 +39,23 @@ typedef enum action_t { } action_t; typedef struct bundle_t { - number_t minimum, maximum, current; + number_t minimum; + number_t maximum; + number_t current; } bundle_t; typedef struct symbol_t { - number_t character, colour, effect; + number_t character; + number_t colour; + number_t effect; } symbol_t; +typedef struct sprite_t { + number_t width; + number_t height; + memory_t data; +} sprite_t; + typedef struct attribute_t { string_t name; number_t positive_count; @@ -68,6 +78,7 @@ typedef struct bot_t { number_t x; number_t y; symbol_t * symbol; + sprite_t * sprite; bundle_t * health; bundle_t * mana; bundle_t * stamina; @@ -78,6 +89,7 @@ typedef struct player_t { number_t x; number_t y; symbol_t * symbol; + sprite_t * sprite; bundle_t * health; bundle_t * mana; bundle_t * stamina; @@ -92,6 +104,7 @@ typedef struct block_t { number_t collision; number_t override; symbol_t * symbol; + sprite_t * sprite; } block_t; typedef struct world_t { @@ -110,27 +123,30 @@ extern procedure_t game_clean_up (procedure_t); extern number_t randomize (number_t lower, number_t upper); -extern bundle_t * game_bundle (number_t minimum, number_t maximum, number_t current); -extern symbol_t * game_symbol (number_t character, number_t colour, number_t effect); +extern bundle_t * game_bundle (number_t minimum, number_t maximum, number_t current); +extern symbol_t * game_symbol (number_t character, number_t colour, number_t effect); +extern sprite_t * game_sprite (number_t width, number_t height, memory_t data); extern generator_t * game_generator (generate_t generator); extern attribute_t * game_attribute (string_t name, bundle_t * points, ...); extern skill_t * game_skill (string_t name, bundle_t * points, ...); -extern bot_t * game_bot (string_t name, symbol_t * symbol, bundle_t * health, bundle_t * mana, bundle_t * stamina); -extern player_t * game_player (string_t name, symbol_t * symbol, bundle_t * health, bundle_t * mana, bundle_t * stamina, ...); +extern bot_t * game_bot (string_t name, symbol_t * symbol, sprite_t * sprite, bundle_t * health, bundle_t * mana, bundle_t * stamina); +extern player_t * game_player (string_t name, symbol_t * symbol, sprite_t * sprite, bundle_t * health, bundle_t * mana, bundle_t * stamina, ...); + +extern block_t * game_block (string_t name, symbol_t * symbol, sprite_t * sprite, number_t collision, number_t override); -extern block_t * game_block (string_t name, symbol_t * symbol, number_t collision, number_t override); extern world_t * game_world (number_t width, number_t height, ...); -extern procedure_t game_render_attribute (number_t x, number_t y, ...); -extern procedure_t game_render_skill (number_t x, number_t y, ...); +extern procedure_t game_render_attribute (attribute_t * attribute, number_t x, number_t y); +extern procedure_t game_render_skill (skill_t * skill, number_t x, number_t y); extern procedure_t game_render_bot (bot_t * bot); extern procedure_t game_render_player (player_t * player); extern procedure_t game_render_block (block_t * block, number_t x, number_t y); + extern procedure_t game_render_world (world_t * world, number_t x, number_t y, number_t width, number_t height); #endif diff --git a/chapter/chapter_6.c b/chapter/chapter_6.c index 590d920..90c973c 100644 --- a/chapter/chapter_6.c +++ b/chapter/chapter_6.c @@ -51,37 +51,30 @@ procedure_t play_game (procedure_t) { generator_t * rectangle_fill = game_generator (generate_rectangle_fill_function); generator_t * rectangle_line = game_generator (generate_rectangle_line_function); - //~attribute_t * strength = game_attribute ("Strength", game_bundle (1, 12, 0), GAME_ACTION_SWING_BLADE, GAME_ACTION_SWING_AXE, -GAME_ACTION_CAMP, 0); - //~attribute_t * edurance = game_attribute ("Edurance", game_bundle (1, 12, 0), GAME_ACTION_WALK, GAME_ACTION_CAMP, -GAME_ACTION_REST, 0); - //~attribute_t * wisdom = game_attribute ("Wisdom", game_bundle (1, 12, 0), GAME_ACTION_CITE_RUNE, GAME_ACTION_CAST_CHARM, -GAME_ACTION_WALK, 0); - //~attribute_t * agility = game_attribute ("Agility", game_bundle (1, 12, 0), GAME_ACTION_SHOOT_ARROW, GAME_ACTION_THROW_SPEAR, -GAME_ACTION_WAIT, 0); - - skill_t * blades = game_skill ("Blades", game_bundle (10, 120, 0), GAME_ACTION_SWING_BLADE, 0); - skill_t * axes = game_skill ("Axes", game_bundle (10, 120, 0), GAME_ACTION_SWING_AXE, 0); - skill_t * bows = game_skill ("Bows", game_bundle (10, 120, 0), GAME_ACTION_SHOOT_ARROW, 0); - skill_t * spears = game_skill ("Spears", game_bundle (10, 120, 0), GAME_ACTION_THROW_SPEAR, 0); - skill_t * puppet_magic = game_skill ("Puppet Magic", game_bundle (10, 120, 0), GAME_ACTION_SUMMON_PUPPET, 0); - skill_t * nature_magic = game_skill ("Nature Magic", game_bundle (10, 120, 0), GAME_ACTION_CALL_NATURE, 0); - skill_t * rune_magic = game_skill ("Rune Magic", game_bundle (10, 120, 0), GAME_ACTION_CITE_RUNE, 0); - skill_t * charm_magic = game_skill ("Charm Magic", game_bundle (10, 120, 0), GAME_ACTION_CAST_CHARM, 0); - - bot_t * goblin = game_bot ("Goblin", game_symbol ('g', COLOUR_RED, EFFECT_NORMAL), game_bundle (0, 11, 11), game_bundle (0, 3, 3), game_bundle (0, 23, 23)); - bot_t * hob_goblin = game_bot ("Hob Goblin", game_symbol ('g', COLOUR_RED, EFFECT_BOLD), game_bundle (0, 17, 17), game_bundle (0, 7, 7), game_bundle (0, 31, 31)); - bot_t * orc = game_bot ("Orc", game_symbol ('G', COLOUR_RED, EFFECT_NORMAL), game_bundle (0, 23, 23), game_bundle (0, 5, 5), game_bundle (0, 47, 47)); - bot_t * ogre = game_bot ("Ogre", game_symbol ('G', COLOUR_RED, EFFECT_BOLD), game_bundle (0, 37, 37), game_bundle (0, 2, 2), game_bundle (0, 83, 83)); - - player_t * player = game_player ("Riri", game_symbol ('@', COLOUR_CYAN, EFFECT_BOLD), game_bundle (0, 29, 29), game_bundle (0, 3, 3), game_bundle (0, 37, 37), - //~strength, edurance, wisdom, agility, NULL, + bot_t * goblin = game_bot ("Goblin", game_symbol ('g', COLOUR_RED, EFFECT_NORMAL), NULL, game_bundle (0, 11, 11), game_bundle (0, 3, 3), game_bundle (0, 23, 23)); + bot_t * hob_goblin = game_bot ("Hob Goblin", game_symbol ('g', COLOUR_RED, EFFECT_BOLD), NULL, game_bundle (0, 17, 17), game_bundle (0, 7, 7), game_bundle (0, 31, 31)); + bot_t * orc = game_bot ("Orc", game_symbol ('G', COLOUR_RED, EFFECT_NORMAL), NULL, game_bundle (0, 23, 23), game_bundle (0, 5, 5), game_bundle (0, 47, 47)); + bot_t * ogre = game_bot ("Ogre", game_symbol ('G', COLOUR_RED, EFFECT_BOLD), NULL, game_bundle (0, 37, 37), game_bundle (0, 2, 2), game_bundle (0, 83, 83)); + + player_t * player = game_player ("Riri", game_symbol ('@', COLOUR_CYAN, EFFECT_BOLD), NULL, game_bundle (0, 29, 29), game_bundle (0, 3, 3), game_bundle (0, 37, 37), game_attribute ("Strength", game_bundle (1, 12, 0), GAME_ACTION_SWING_BLADE, GAME_ACTION_SWING_AXE, -GAME_ACTION_CAMP, 0), game_attribute ("Edurance", game_bundle (1, 12, 0), GAME_ACTION_WALK, GAME_ACTION_CAMP, -GAME_ACTION_REST, 0), game_attribute ("Wisdom", game_bundle (1, 12, 0), GAME_ACTION_CITE_RUNE, GAME_ACTION_CAST_CHARM, -GAME_ACTION_WALK, 0), game_attribute ("Agility", game_bundle (1, 12, 0), GAME_ACTION_SHOOT_ARROW, GAME_ACTION_THROW_SPEAR, -GAME_ACTION_WAIT, 0), NULL, - blades, axes, bows, spears, puppet_magic, nature_magic, rune_magic, charm_magic, NULL); - - block_t * grass = game_block ("Grass", game_symbol (',', COLOUR_GREEN, EFFECT_BOLD), FALSE, FALSE); - block_t * stone_floor = game_block ("Stone Floor", game_symbol ('.', COLOUR_GREY, EFFECT_BOLD), FALSE, FALSE); - block_t * stone_wall = game_block ("Stone Wall", game_symbol ('#', COLOUR_GREY, EFFECT_BOLD), TRUE, FALSE); + game_skill ("Blades", game_bundle (10, 120, 0), GAME_ACTION_SWING_BLADE, 0), + game_skill ("Axes", game_bundle (10, 120, 0), GAME_ACTION_SWING_AXE, 0), + game_skill ("Bows", game_bundle (10, 120, 0), GAME_ACTION_SHOOT_ARROW, 0), + game_skill ("Spears", game_bundle (10, 120, 0), GAME_ACTION_THROW_SPEAR, 0), + game_skill ("Puppet Magic", game_bundle (10, 120, 0), GAME_ACTION_SUMMON_PUPPET, 0), + game_skill ("Nature Magic", game_bundle (10, 120, 0), GAME_ACTION_CALL_NATURE, 0), + game_skill ("Rune Magic", game_bundle (10, 120, 0), GAME_ACTION_CITE_RUNE, 0), + game_skill ("Charm Magic", game_bundle (10, 120, 0), GAME_ACTION_CAST_CHARM, 0), + NULL); + + block_t * grass = game_block ("Grass", game_symbol (',', COLOUR_GREEN, EFFECT_BOLD), NULL, FALSE, FALSE); + block_t * stone_floor = game_block ("Stone Floor", game_symbol ('.', COLOUR_GREY, EFFECT_BOLD), NULL, FALSE, FALSE); + block_t * stone_wall = game_block ("Stone Wall", game_symbol ('#', COLOUR_GREY, EFFECT_BOLD), NULL, TRUE, FALSE); world_t * world = game_world (300, 100, full_fill, 0, 0, 0, 0, grass, rectangle_fill, 5, 9, 2, 4, stone_floor, @@ -93,6 +86,15 @@ procedure_t play_game (procedure_t) { player->attributes [2]->points->current = 5; player->attributes [3]->points->current = 3; + player->skills [0]->points->current = randomize (1, 10); + player->skills [1]->points->current = randomize (1, 10); + player->skills [2]->points->current = randomize (1, 10); + player->skills [3]->points->current = randomize (1, 10); + player->skills [4]->points->current = randomize (1, 10); + player->skills [5]->points->current = randomize (1, 10); + player->skills [6]->points->current = randomize (1, 10); + player->skills [7]->points->current = randomize (1, 10); + curses_configure (); terminal_show_cursor (FALSE); @@ -108,9 +110,13 @@ procedure_t play_game (procedure_t) { game_render_player (player); - game_render_attribute (game_screen_offset, 1, player->attributes [0], player->attributes [1], player->attributes [2], player->attributes [3], NULL); + for (number_t attribute = 0; attribute < player->attribute_count; ++attribute) { + game_render_attribute (player->attributes [attribute], game_screen_offset, 1 + attribute); + } - game_render_skill (game_screen_offset, 6, blades, axes, bows, spears, puppet_magic, nature_magic, rune_magic, charm_magic, NULL); + for (number_t skill = 0; skill < player->skill_count; ++skill) { + game_render_skill (player->skills [skill], game_screen_offset, 6 + skill); + } switch (curses_character) { case SIGNAL_ARROW_UP: player->y -= 1; limit (& player->y, 0, world->height - 1); break;