From 82238afbdc7c73ca430e1d9ad58149c3d3767439 Mon Sep 17 00:00:00 2001 From: xolatile Date: Fri, 24 Nov 2023 13:22:09 -0500 Subject: [PATCH] Changed chapter numbers... --- chapter/chapter_5.c | 320 ------------------------------------------------- chapter/chapter_5.h | 140 +--------------------- chapter/chapter_6.c | 149 ----------------------- chapter/chapter_6.h | 3 +- chapter/chapter_x.c | 334 ++++++++++++++++++++++++++++++++++++++++++++++++++++ chapter/chapter_x.h | 156 ++++++++++++++++++++++++ chapter/chapter_y.c | 152 ++++++++++++++++++++++++ chapter/chapter_y.h | 20 ++++ xhartae.c | 5 +- 9 files changed, 666 insertions(+), 613 deletions(-) create mode 100644 chapter/chapter_x.c create mode 100644 chapter/chapter_x.h create mode 100644 chapter/chapter_y.c create mode 100644 chapter/chapter_y.h diff --git a/chapter/chapter_5.c b/chapter/chapter_5.c index a49f426..e8fc8e6 100644 --- a/chapter/chapter_5.c +++ b/chapter/chapter_5.c @@ -11,324 +11,4 @@ It is distributed in the hope that it will be useful or harmful, it really depen #include "chapter_5.h" -/* -So, what are actually getters and setters, and why you should never use them? Lets explain. -*/ - -#define MEMORY_LIMIT (1024 * 1024) - -static number_t game_memory_length = 0; -static memory_t * game_memory = NULL; - -static procedure_t game_free_memory (memory_t memory) { - ++game_memory_length; - - game_memory = reallocate (game_memory, game_memory_length * (number_t) sizeof (* game_memory)); - - game_memory [game_memory_length - 1] = memory; -} - -procedure_t game_clean_up (procedure_t) { - for (number_t pointer = 0; pointer < game_memory_length; ++pointer) { - game_memory [pointer] = deallocate (game_memory [pointer]); - } - - game_memory = deallocate (game_memory); -} - -number_t randomize (number_t lower, number_t upper) { - return ((number_t) rand () % (upper - lower + 1) + lower); -} - -bundle_t * game_bundle (number_t minimum, number_t maximum, number_t current) { - bundle_t * bundle = allocate ((number_t) sizeof (* bundle)); - - bundle->minimum = minimum; - bundle->maximum = maximum; - bundle->current = current; - - game_free_memory (bundle); - - return (bundle); -} - -symbol_t * game_symbol (number_t character, number_t colour, number_t effect) { - symbol_t * symbol = allocate ((number_t) sizeof (* symbol)); - - symbol->character = character; - symbol->colour = colour; - symbol->effect = effect; - - game_free_memory (symbol); - - 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)); - - generator->generate = function; - - game_free_memory (generator); - - return (generator); -} - -attribute_t * game_attribute (string_t name, bundle_t * points, ...) { - va_list list; - - attribute_t * attribute = allocate ((number_t) sizeof (* attribute)); - - string_copy ((attribute->name = allocate (string_length (name) + 1)), name); - - memory_copy ((attribute->points = allocate ((number_t) sizeof (* attribute->points))), points, (number_t) sizeof (* points)); - - va_start (list, points); - - for (;;) { - number_t action = (number_t) va_arg (list, int); - - if (action > 0) { - attribute->positive_count += 1; - attribute->positive = reallocate (attribute->positive, attribute->positive_count * (number_t) sizeof (action)); - attribute->positive [attribute->positive_count - 1] = (action_t) action; - } else if (action < 0) { - attribute->negative_count += 1; - attribute->negative = reallocate (attribute->negative, attribute->negative_count * (number_t) sizeof (action)); - attribute->negative [attribute->negative_count - 1] = (action_t) -action; - } else break; - } - - va_end (list); - - game_free_memory (attribute->name); - game_free_memory (attribute->points); - game_free_memory (attribute->positive); - game_free_memory (attribute->negative); - game_free_memory (attribute); - - return (attribute); -} - -skill_t * game_skill (string_t name, bundle_t * points, ...) { - va_list list; - - skill_t * skill = allocate ((number_t) sizeof (* skill)); - - string_copy ((skill->name = allocate (string_length (name) + 1)), name); - - memory_copy ((skill->points = allocate ((number_t) sizeof (* skill->points))), points, (number_t) sizeof (* points)); - - va_start (list, points); - - for (;;) { - action_t action = (action_t) va_arg (list, int); - - if (action > 0) { - skill->positive_count += 1; - skill->positive = reallocate (skill->positive, skill->positive_count * (number_t) sizeof (action)); - skill->positive [skill->positive_count - 1] = action; - } else break; - } - - va_end (list); - - game_free_memory (skill->name); - game_free_memory (skill->points); - game_free_memory (skill->positive); - game_free_memory (skill); - - return (skill); -} - -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); - - bot->x = 0; - 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); - game_free_memory (bot); - - return (bot); -} - -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)); - - string_copy ((player->name = allocate (string_length (name) + 1)), name); - - player->x = 3; - 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)); - - player->attribute_count = 0; - player->skill_count = 0; - - va_start (list, stamina); - - for (;;) { - attribute_t * attribute = (attribute_t *) va_arg (list, void *); - - if (attribute != NULL) { - player->attribute_count += 1; - player->attributes = reallocate (player->attributes, player->attribute_count * (number_t) sizeof (* player->attributes)); - player->attributes [player->attribute_count - 1] = attribute; - } else break; - } - - for (;;) { - skill_t * skill = (skill_t *) va_arg (list, void *); - - if (skill != NULL) { - player->skill_count += 1; - player->skills = reallocate (player->skills, player->skill_count * (number_t) sizeof (* player->skills)); - player->skills [player->skill_count - 1] = skill; - } else break; - } - - va_end (list); - - 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); - game_free_memory (player->attributes); - game_free_memory (player->skills); - game_free_memory (player); - - return (player); -} - -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); -} - -world_t * game_world (number_t width, number_t height, ...) { - va_list list; - - world_t * world = allocate ((number_t) sizeof (* world)); - - world->width = width; - world->height = height; - - world->block = allocate (width * height * (number_t) sizeof (* world->block)); - - va_start (list, height); - - for (;;) { - generator_t * generator = (generator_t *) va_arg (list, void *); - - if (generator != NULL) { - memory_t data = (memory_t) va_arg (list, void *); - number_t w = (number_t) va_arg (list, int); - number_t h = (number_t) va_arg (list, int); - number_t x = (number_t) va_arg (list, int); - number_t y = (number_t) va_arg (list, int); - - generator->generate (world, data, w, h, x, y); - } else break; - } - - va_end (list); - - game_free_memory (world->bots); - game_free_memory (world->block); - game_free_memory (world); - - return (world); -} - -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 (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); - -} - -procedure_t game_render_bot (bot_t * bot) { - curses_render_character ((char) bot->symbol->character, bot->symbol->colour, bot->symbol->effect, bot->x, bot->y); -} - -procedure_t game_render_player (player_t * player) { - curses_render_character ((char) player->symbol->character, player->symbol->colour, player->symbol->effect, player->x, player->y); -} - -procedure_t game_render_block (block_t * block, number_t x, number_t y) { - curses_render_character ((char) block->symbol->character, block->symbol->colour, block->symbol->effect, x, y); -} - -procedure_t game_render_world (world_t * world, number_t x, number_t y, number_t width, number_t height) { - for (number_t j = 0; (j < height) && (j < world->height); ++j) { - for (number_t i = 0; (i < width) && (i < world->width); ++i) { - game_render_block (world->block [j * world->width + i], i + x, j + y); - } - } - - for (number_t index = 0; index < world->bot_count; ++index) { - game_render_bot (& world->bots [index]); - } -} - #endif diff --git a/chapter/chapter_5.h b/chapter/chapter_5.h index 6d5f366..3ba2c72 100644 --- a/chapter/chapter_5.h +++ b/chapter/chapter_5.h @@ -13,144 +13,6 @@ It is distributed in the hope that it will be useful or harmful, it really depen #include "chapter_1.h" #include "chapter_2.h" #include "chapter_3.h" - -/* -Okay, we're finally on chapter five, and now we'll write something fun, not serious and boring. Before the Great Flood, when our ancestors were riding dinosaurs, building -pyramids, killing African men and mating with Asian women, people didn't have dedicated nor integrated graphical processing units, called GPUs. They only had their terminals, -built inside some of their spaceships. And what did they do with them? They played terminal rogue-like games, similar to those that archeologists discovered in ancient Egypt, -Syria, Sumeria, Greece and Atlantis. They were reconstructed around 50 years ago by some guy that made the game Rogue. So, all those myths, sagas and legends about Anubis, -Gilgamesh, Achilles, Inana, Gaea, they were just playable characters or main characters in those games, with different statistics, skills, attributes and back-story. Now, lets -make a simple terminal rogue-like game using what we wrote in previous chapters. - -First of all, lets talk briefly about keyword 'typedef' and why I hate to use it. -*/ - -typedef int number_t; -typedef void procedure_t; -typedef char * string_t; -typedef void * memory_t; - -typedef enum action_t { - GAME_ACTION_NONE, - GAME_ACTION_WAIT, GAME_ACTION_WALK, GAME_ACTION_REST, GAME_ACTION_CAMP, - GAME_ACTION_SWING_BLADE, GAME_ACTION_SWING_AXE, GAME_ACTION_SHOOT_ARROW, GAME_ACTION_THROW_SPEAR, - GAME_ACTION_SUMMON_PUPPET, GAME_ACTION_CALL_NATURE, GAME_ACTION_CITE_RUNE, GAME_ACTION_CAST_CHARM, - GAME_ACTION_COUNT -} action_t; - -typedef struct bundle_t { - number_t minimum; - number_t maximum; - number_t current; -} bundle_t; - -typedef struct symbol_t { - 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; - number_t negative_count; - bundle_t * points; - action_t * positive; - action_t * negative; -} attribute_t; - -typedef struct skill_t { - string_t name; - number_t positive_count; - number_t learning_rate; - bundle_t * points; - action_t * positive; -} skill_t; - -typedef struct bot_t { - string_t name; - number_t x; - number_t y; - symbol_t * symbol; - sprite_t * sprite; - bundle_t * health; - bundle_t * mana; - bundle_t * stamina; -} bot_t; - -typedef struct player_t { - string_t name; - number_t x; - number_t y; - symbol_t * symbol; - sprite_t * sprite; - bundle_t * health; - bundle_t * mana; - bundle_t * stamina; - number_t attribute_count; - number_t skill_count; - attribute_t * * attributes; - skill_t * * skills; -} player_t; - -typedef struct block_t { - string_t name; - number_t collision; - number_t override; - symbol_t * symbol; - sprite_t * sprite; -} block_t; - -typedef struct world_t { - number_t width; - number_t height; - number_t item_count; - number_t bot_count; - block_t * * block; - bot_t * bots; - player_t * player; -} world_t; - -typedef procedure_t (* generate_t) (world_t *, memory_t, number_t, number_t, number_t, number_t); - -typedef struct generator_t { - generate_t generate; -} generator_t; - -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 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, 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 world_t * game_world (number_t width, number_t height, ...); - -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); +#include "chapter_4.h" #endif diff --git a/chapter/chapter_6.c b/chapter/chapter_6.c index 63af338..e2cae3a 100644 --- a/chapter/chapter_6.c +++ b/chapter/chapter_6.c @@ -11,153 +11,4 @@ It is distributed in the hope that it will be useful or harmful, it really depen #include "chapter_6.h" -#define UNUSED(variable) (void) variable - -static procedure_t generate_full_fill_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { - UNUSED (width); UNUSED (height); UNUSED (x); UNUSED (y); - - for (number_t j = 0; j < world->height; ++j) { - for (number_t i = 0; i < world->width; ++i) { - world->block [j * world->width + i] = (block_t *) data; - } - } -} - -static procedure_t generate_rectangle_fill_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { - for (number_t j = 0; j < height; ++j) { - for (number_t i = 0; i < width; ++i) { - world->block [(j + y) * world->width + (i + x)] = (block_t *) data; - } - } -} - -static procedure_t generate_rectangle_line_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { - for (number_t offset = 0; offset < width; ++offset) { - world->block [world->width * y + offset + x] = (block_t *) data; - world->block [world->width * (height - 1 + y) + offset + x] = (block_t *) data; - } - - for (number_t offset = 0; offset < height; ++offset) { - world->block [world->width * (y + offset) + x] = (block_t *) data; - world->block [world->width * (y + offset) + width - 1 + x] = (block_t *) data; - } -} - -static procedure_t generate_create_bots_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { - UNUSED (height); UNUSED (x); UNUSED (y); - - bot_t * bot = (bot_t *) data; - number_t count = width; - - for (number_t index = 0; index < count; ++index) { - world->bot_count += 1; - world->bots = reallocate (world->bots, world->bot_count * (number_t) sizeof (* world->bots)); - memory_copy (& world->bots [world->bot_count - 1], game_bot (bot->name, bot->symbol, NULL, bot->health, bot->mana, bot->stamina), (number_t) sizeof (* world->bots)); - world->bots [world->bot_count - 1].x = randomize (1, 40); - world->bots [world->bot_count - 1].y = randomize (1, 40); - } -} - -procedure_t play_game (procedure_t) { - generator_t * full_fill = game_generator (generate_full_fill_function); - generator_t * rectangle_fill = game_generator (generate_rectangle_fill_function); - generator_t * rectangle_line = game_generator (generate_rectangle_line_function); - generator_t * create_bots = game_generator (generate_create_bots_function); - - 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, - 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, game_block ("Grass", game_symbol (',', COLOUR_GREEN, EFFECT_BOLD), NULL, FALSE, FALSE), 0, 0, 0, 0, - //~rectangle_fill, game_block ("Stone Floor", game_symbol ('.', COLOUR_GREY, EFFECT_BOLD), NULL, FALSE, FALSE), 5, 9, 2, 4, - //~rectangle_line, game_block ("Stone Wall", game_symbol ('#', COLOUR_GREY, EFFECT_BOLD), NULL, TRUE, FALSE), 5, 9, 2, 4, - //~create_bots, 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)), 3, 0, 0, 0, - //~create_bots, 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)), 3, 0, 0, 0, - //~create_bots, 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)), 3, 0, 0, 0, - //~create_bots, 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)), 3, 0, 0, 0, - //~NULL - //~); - - world_t * world = game_world (300, 100, full_fill, grass, 0, 0, 0, 0, - rectangle_fill, stone_floor, 5, 9, 2, 4, - rectangle_line, stone_wall, 5, 9, 2, 4, - create_bots, goblin, 3, 0, 0, 0, - create_bots, hob_goblin, 3, 0, 0, 0, - create_bots, orc, 3, 0, 0, 0, - create_bots, ogre, 3, 0, 0, 0, - NULL); - - player->attributes [0]->points->current = 7; - player->attributes [1]->points->current = 3; - 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); - - while (curses_active) { - number_t game_screen_offset = curses_screen_width - 40; - - curses_render_background (' ', COLOUR_WHITE, EFFECT_NORMAL); - - game_render_world (world, 0, 0, game_screen_offset, curses_screen_height); - - game_render_player (player); - - for (number_t attribute = 0; attribute < player->attribute_count; ++attribute) { - game_render_attribute (player->attributes [attribute], game_screen_offset, 1 + attribute); - } - - 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; - case SIGNAL_ARROW_DOWN: player->y += 1; limit (& player->y, 0, world->height - 1); break; - case SIGNAL_ARROW_LEFT: player->x -= 1; limit (& player->x, 0, world->width - 1); break; - case SIGNAL_ARROW_RIGHT: player->x += 1; limit (& player->x, 0, world->width - 1); break; - default: break; - } - - curses_synchronize (); - } - - terminal_show_cursor (TRUE); - - game_clean_up (); -} - #endif diff --git a/chapter/chapter_6.h b/chapter/chapter_6.h index a18252d..ecf98af 100644 --- a/chapter/chapter_6.h +++ b/chapter/chapter_6.h @@ -13,8 +13,7 @@ It is distributed in the hope that it will be useful or harmful, it really depen #include "chapter_1.h" #include "chapter_2.h" #include "chapter_3.h" +#include "chapter_4.h" #include "chapter_5.h" -extern procedure_t play_game (procedure_t); - #endif diff --git a/chapter/chapter_x.c b/chapter/chapter_x.c new file mode 100644 index 0000000..a49f426 --- /dev/null +++ b/chapter/chapter_x.c @@ -0,0 +1,334 @@ +/* +Copyright (c) 2023 : Ognjen 'xolatile' Milan Robovic + +Xhartae is free software! You will redistribute it or modify it under the terms of the GNU General Public License by Free Software Foundation. +And when you do redistribute it or modify it, it will use either version 3 of the License, or (at yours truly opinion) any later version. +It is distributed in the hope that it will be useful or harmful, it really depends... But no warranty what so ever, seriously. See GNU/GPLv3. +*/ + +#ifndef CHAPTER_5_SOURCE +#define CHAPTER_5_SOURCE + +#include "chapter_5.h" + +/* +So, what are actually getters and setters, and why you should never use them? Lets explain. +*/ + +#define MEMORY_LIMIT (1024 * 1024) + +static number_t game_memory_length = 0; +static memory_t * game_memory = NULL; + +static procedure_t game_free_memory (memory_t memory) { + ++game_memory_length; + + game_memory = reallocate (game_memory, game_memory_length * (number_t) sizeof (* game_memory)); + + game_memory [game_memory_length - 1] = memory; +} + +procedure_t game_clean_up (procedure_t) { + for (number_t pointer = 0; pointer < game_memory_length; ++pointer) { + game_memory [pointer] = deallocate (game_memory [pointer]); + } + + game_memory = deallocate (game_memory); +} + +number_t randomize (number_t lower, number_t upper) { + return ((number_t) rand () % (upper - lower + 1) + lower); +} + +bundle_t * game_bundle (number_t minimum, number_t maximum, number_t current) { + bundle_t * bundle = allocate ((number_t) sizeof (* bundle)); + + bundle->minimum = minimum; + bundle->maximum = maximum; + bundle->current = current; + + game_free_memory (bundle); + + return (bundle); +} + +symbol_t * game_symbol (number_t character, number_t colour, number_t effect) { + symbol_t * symbol = allocate ((number_t) sizeof (* symbol)); + + symbol->character = character; + symbol->colour = colour; + symbol->effect = effect; + + game_free_memory (symbol); + + 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)); + + generator->generate = function; + + game_free_memory (generator); + + return (generator); +} + +attribute_t * game_attribute (string_t name, bundle_t * points, ...) { + va_list list; + + attribute_t * attribute = allocate ((number_t) sizeof (* attribute)); + + string_copy ((attribute->name = allocate (string_length (name) + 1)), name); + + memory_copy ((attribute->points = allocate ((number_t) sizeof (* attribute->points))), points, (number_t) sizeof (* points)); + + va_start (list, points); + + for (;;) { + number_t action = (number_t) va_arg (list, int); + + if (action > 0) { + attribute->positive_count += 1; + attribute->positive = reallocate (attribute->positive, attribute->positive_count * (number_t) sizeof (action)); + attribute->positive [attribute->positive_count - 1] = (action_t) action; + } else if (action < 0) { + attribute->negative_count += 1; + attribute->negative = reallocate (attribute->negative, attribute->negative_count * (number_t) sizeof (action)); + attribute->negative [attribute->negative_count - 1] = (action_t) -action; + } else break; + } + + va_end (list); + + game_free_memory (attribute->name); + game_free_memory (attribute->points); + game_free_memory (attribute->positive); + game_free_memory (attribute->negative); + game_free_memory (attribute); + + return (attribute); +} + +skill_t * game_skill (string_t name, bundle_t * points, ...) { + va_list list; + + skill_t * skill = allocate ((number_t) sizeof (* skill)); + + string_copy ((skill->name = allocate (string_length (name) + 1)), name); + + memory_copy ((skill->points = allocate ((number_t) sizeof (* skill->points))), points, (number_t) sizeof (* points)); + + va_start (list, points); + + for (;;) { + action_t action = (action_t) va_arg (list, int); + + if (action > 0) { + skill->positive_count += 1; + skill->positive = reallocate (skill->positive, skill->positive_count * (number_t) sizeof (action)); + skill->positive [skill->positive_count - 1] = action; + } else break; + } + + va_end (list); + + game_free_memory (skill->name); + game_free_memory (skill->points); + game_free_memory (skill->positive); + game_free_memory (skill); + + return (skill); +} + +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); + + bot->x = 0; + 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); + game_free_memory (bot); + + return (bot); +} + +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)); + + string_copy ((player->name = allocate (string_length (name) + 1)), name); + + player->x = 3; + 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)); + + player->attribute_count = 0; + player->skill_count = 0; + + va_start (list, stamina); + + for (;;) { + attribute_t * attribute = (attribute_t *) va_arg (list, void *); + + if (attribute != NULL) { + player->attribute_count += 1; + player->attributes = reallocate (player->attributes, player->attribute_count * (number_t) sizeof (* player->attributes)); + player->attributes [player->attribute_count - 1] = attribute; + } else break; + } + + for (;;) { + skill_t * skill = (skill_t *) va_arg (list, void *); + + if (skill != NULL) { + player->skill_count += 1; + player->skills = reallocate (player->skills, player->skill_count * (number_t) sizeof (* player->skills)); + player->skills [player->skill_count - 1] = skill; + } else break; + } + + va_end (list); + + 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); + game_free_memory (player->attributes); + game_free_memory (player->skills); + game_free_memory (player); + + return (player); +} + +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); +} + +world_t * game_world (number_t width, number_t height, ...) { + va_list list; + + world_t * world = allocate ((number_t) sizeof (* world)); + + world->width = width; + world->height = height; + + world->block = allocate (width * height * (number_t) sizeof (* world->block)); + + va_start (list, height); + + for (;;) { + generator_t * generator = (generator_t *) va_arg (list, void *); + + if (generator != NULL) { + memory_t data = (memory_t) va_arg (list, void *); + number_t w = (number_t) va_arg (list, int); + number_t h = (number_t) va_arg (list, int); + number_t x = (number_t) va_arg (list, int); + number_t y = (number_t) va_arg (list, int); + + generator->generate (world, data, w, h, x, y); + } else break; + } + + va_end (list); + + game_free_memory (world->bots); + game_free_memory (world->block); + game_free_memory (world); + + return (world); +} + +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 (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); + +} + +procedure_t game_render_bot (bot_t * bot) { + curses_render_character ((char) bot->symbol->character, bot->symbol->colour, bot->symbol->effect, bot->x, bot->y); +} + +procedure_t game_render_player (player_t * player) { + curses_render_character ((char) player->symbol->character, player->symbol->colour, player->symbol->effect, player->x, player->y); +} + +procedure_t game_render_block (block_t * block, number_t x, number_t y) { + curses_render_character ((char) block->symbol->character, block->symbol->colour, block->symbol->effect, x, y); +} + +procedure_t game_render_world (world_t * world, number_t x, number_t y, number_t width, number_t height) { + for (number_t j = 0; (j < height) && (j < world->height); ++j) { + for (number_t i = 0; (i < width) && (i < world->width); ++i) { + game_render_block (world->block [j * world->width + i], i + x, j + y); + } + } + + for (number_t index = 0; index < world->bot_count; ++index) { + game_render_bot (& world->bots [index]); + } +} + +#endif diff --git a/chapter/chapter_x.h b/chapter/chapter_x.h new file mode 100644 index 0000000..6d5f366 --- /dev/null +++ b/chapter/chapter_x.h @@ -0,0 +1,156 @@ +/* +Copyright (c) 2023 : Ognjen 'xolatile' Milan Robovic + +Xhartae is free software! You will redistribute it or modify it under the terms of the GNU General Public License by Free Software Foundation. +And when you do redistribute it or modify it, it will use either version 3 of the License, or (at yours truly opinion) any later version. +It is distributed in the hope that it will be useful or harmful, it really depends... But no warranty what so ever, seriously. See GNU/GPLv3. +*/ + +#ifndef CHAPTER_5_HEADER +#define CHAPTER_5_HEADER + +#include "chapter_0.h" +#include "chapter_1.h" +#include "chapter_2.h" +#include "chapter_3.h" + +/* +Okay, we're finally on chapter five, and now we'll write something fun, not serious and boring. Before the Great Flood, when our ancestors were riding dinosaurs, building +pyramids, killing African men and mating with Asian women, people didn't have dedicated nor integrated graphical processing units, called GPUs. They only had their terminals, +built inside some of their spaceships. And what did they do with them? They played terminal rogue-like games, similar to those that archeologists discovered in ancient Egypt, +Syria, Sumeria, Greece and Atlantis. They were reconstructed around 50 years ago by some guy that made the game Rogue. So, all those myths, sagas and legends about Anubis, +Gilgamesh, Achilles, Inana, Gaea, they were just playable characters or main characters in those games, with different statistics, skills, attributes and back-story. Now, lets +make a simple terminal rogue-like game using what we wrote in previous chapters. + +First of all, lets talk briefly about keyword 'typedef' and why I hate to use it. +*/ + +typedef int number_t; +typedef void procedure_t; +typedef char * string_t; +typedef void * memory_t; + +typedef enum action_t { + GAME_ACTION_NONE, + GAME_ACTION_WAIT, GAME_ACTION_WALK, GAME_ACTION_REST, GAME_ACTION_CAMP, + GAME_ACTION_SWING_BLADE, GAME_ACTION_SWING_AXE, GAME_ACTION_SHOOT_ARROW, GAME_ACTION_THROW_SPEAR, + GAME_ACTION_SUMMON_PUPPET, GAME_ACTION_CALL_NATURE, GAME_ACTION_CITE_RUNE, GAME_ACTION_CAST_CHARM, + GAME_ACTION_COUNT +} action_t; + +typedef struct bundle_t { + number_t minimum; + number_t maximum; + number_t current; +} bundle_t; + +typedef struct symbol_t { + 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; + number_t negative_count; + bundle_t * points; + action_t * positive; + action_t * negative; +} attribute_t; + +typedef struct skill_t { + string_t name; + number_t positive_count; + number_t learning_rate; + bundle_t * points; + action_t * positive; +} skill_t; + +typedef struct bot_t { + string_t name; + number_t x; + number_t y; + symbol_t * symbol; + sprite_t * sprite; + bundle_t * health; + bundle_t * mana; + bundle_t * stamina; +} bot_t; + +typedef struct player_t { + string_t name; + number_t x; + number_t y; + symbol_t * symbol; + sprite_t * sprite; + bundle_t * health; + bundle_t * mana; + bundle_t * stamina; + number_t attribute_count; + number_t skill_count; + attribute_t * * attributes; + skill_t * * skills; +} player_t; + +typedef struct block_t { + string_t name; + number_t collision; + number_t override; + symbol_t * symbol; + sprite_t * sprite; +} block_t; + +typedef struct world_t { + number_t width; + number_t height; + number_t item_count; + number_t bot_count; + block_t * * block; + bot_t * bots; + player_t * player; +} world_t; + +typedef procedure_t (* generate_t) (world_t *, memory_t, number_t, number_t, number_t, number_t); + +typedef struct generator_t { + generate_t generate; +} generator_t; + +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 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, 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 world_t * game_world (number_t width, number_t height, ...); + +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_y.c b/chapter/chapter_y.c new file mode 100644 index 0000000..3a643e1 --- /dev/null +++ b/chapter/chapter_y.c @@ -0,0 +1,152 @@ +/* +Copyright (c) 2023 : Ognjen 'xolatile' Milan Robovic + +Xhartae is free software! You will redistribute it or modify it under the terms of the GNU General Public License by Free Software Foundation. +And when you do redistribute it or modify it, it will use either version 3 of the License, or (at yours truly opinion) any later version. +It is distributed in the hope that it will be useful or harmful, it really depends... But no warranty what so ever, seriously. See GNU/GPLv3. +*/ + +#ifndef CHAPTER_6_SOURCE +#define CHAPTER_6_SOURCE + +#include "chapter_6.h" + +#define UNUSED(variable) (void) variable + +static procedure_t generate_full_fill_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { + UNUSED (width); UNUSED (height); UNUSED (x); UNUSED (y); + + for (number_t j = 0; j < world->height; ++j) { + for (number_t i = 0; i < world->width; ++i) { + world->block [j * world->width + i] = (block_t *) data; + } + } +} + +static procedure_t generate_rectangle_fill_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { + for (number_t j = 0; j < height; ++j) { + for (number_t i = 0; i < width; ++i) { + world->block [(j + y) * world->width + (i + x)] = (block_t *) data; + } + } +} + +static procedure_t generate_rectangle_line_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { + for (number_t offset = 0; offset < width; ++offset) { + world->block [world->width * y + offset + x] = (block_t *) data; + world->block [world->width * (height - 1 + y) + offset + x] = (block_t *) data; + } + + for (number_t offset = 0; offset < height; ++offset) { + world->block [world->width * (y + offset) + x] = (block_t *) data; + world->block [world->width * (y + offset) + width - 1 + x] = (block_t *) data; + } +} + +static procedure_t generate_create_bots_function (world_t * world, memory_t data, number_t width, number_t height, number_t x, number_t y) { + UNUSED (height); UNUSED (x); UNUSED (y); + + bot_t * bot = (bot_t *) data; + number_t count = width; + + for (number_t index = 0; index < count; ++index) { + world->bot_count += 1; + world->bots = reallocate (world->bots, world->bot_count * (number_t) sizeof (* world->bots)); + memory_copy (& world->bots [world->bot_count - 1], game_bot (bot->name, bot->symbol, NULL, bot->health, bot->mana, bot->stamina), (number_t) sizeof (* world->bots)); + world->bots [world->bot_count - 1].x = randomize (1, 40); + world->bots [world->bot_count - 1].y = randomize (1, 40); + } +} + +procedure_t play_game (procedure_t) { + generator_t * full_fill = game_generator (generate_full_fill_function); + generator_t * rectangle_fill = game_generator (generate_rectangle_fill_function); + generator_t * rectangle_line = game_generator (generate_rectangle_line_function); + generator_t * create_bots = game_generator (generate_create_bots_function); + + 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, + 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, grass, 0, 0, 0, 0, + rectangle_fill, stone_floor, 5, 9, 2, 4, + rectangle_line, stone_wall, 5, 9, 2, 4, + create_bots, goblin, 3, 0, 0, 0, + create_bots, hob_goblin, 3, 0, 0, 0, + create_bots, orc, 3, 0, 0, 0, + create_bots, ogre, 3, 0, 0, 0, + NULL); + + player->attributes [0]->points->current = 7; + player->attributes [1]->points->current = 3; + 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); + + while (curses_active) { + number_t game_screen_offset = curses_screen_width - 40; + + curses_render_background (' ', COLOUR_WHITE, EFFECT_NORMAL); + + game_render_world (world, 0, 0, game_screen_offset, curses_screen_height); + + game_render_player (player); + + for (number_t attribute = 0; attribute < player->attribute_count; ++attribute) { + game_render_attribute (player->attributes [attribute], game_screen_offset, 1 + attribute); + } + + 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; + case SIGNAL_ARROW_DOWN: player->y += 1; limit (& player->y, 0, world->height - 1); break; + case SIGNAL_ARROW_LEFT: player->x -= 1; limit (& player->x, 0, world->width - 1); break; + case SIGNAL_ARROW_RIGHT: player->x += 1; limit (& player->x, 0, world->width - 1); break; + default: break; + } + + curses_synchronize (); + } + + terminal_show_cursor (TRUE); + + game_clean_up (); +} + +#endif diff --git a/chapter/chapter_y.h b/chapter/chapter_y.h new file mode 100644 index 0000000..a18252d --- /dev/null +++ b/chapter/chapter_y.h @@ -0,0 +1,20 @@ +/* +Copyright (c) 2023 : Ognjen 'xolatile' Milan Robovic + +Xhartae is free software! You will redistribute it or modify it under the terms of the GNU General Public License by Free Software Foundation. +And when you do redistribute it or modify it, it will use either version 3 of the License, or (at yours truly opinion) any later version. +It is distributed in the hope that it will be useful or harmful, it really depends... But no warranty what so ever, seriously. See GNU/GPLv3. +*/ + +#ifndef CHAPTER_6_HEADER +#define CHAPTER_6_HEADER + +#include "chapter_0.h" +#include "chapter_1.h" +#include "chapter_2.h" +#include "chapter_3.h" +#include "chapter_5.h" + +extern procedure_t play_game (procedure_t); + +#endif diff --git a/xhartae.c b/xhartae.c index 1069683..3bad453 100644 --- a/xhartae.c +++ b/xhartae.c @@ -132,9 +132,8 @@ int main (int argc, char * * argv) { (void) argc; (void) argv; - preview_c_file ("program/example.c", 5, 1); - - play_game (); + //~preview_c_file ("program/example.c", 5, 1); + preview_c_file ("chapter/chapter_0.c", 0, 0); return (EXIT_SUCCESS); }