xolatile
/
xhartae
1
1
Forka 1
Codice Problemi 1 Pull Requests 0 Rilasci 0 Wiki Attività
Sfoglia il codice sorgente

World map and more rendering...

master
Ognjen Milan Robovic 5 mesi fa
parent
f0f98e1b7a
commit
f446a47e84
2 ha cambiato i file con 170 aggiunte e 96 eliminazioni
Visualizzazione separata
Diff Options
Show Stats Download Patch File Download Diff File
  1. +141
    -76
      chapter/chapter_5.c
  2. +29
    -20
      chapter/chapter_5.h

+ 141
- 76
chapter/chapter_5.c Vedi File

@@ -24,7 +24,7 @@ static number_t game_set_screen_height (game_t * game, number_t height) { return

#define MEMORY_LIMIT (1024 * 1024)

static memory_t memorize (number_t size) {
memory_t memorize (number_t size) {
static string_t memory_store [MEMORY_LIMIT] = { 0 };
static number_t memory_count = 0;

@@ -35,7 +35,19 @@ static memory_t memorize (number_t size) {
return ((memory_t) ((string_t) memory_store + memory_count - size));
}

static symbol_t * format_symbol (number_t character, number_t colour, number_t effect) {
bundle_t * format_bundle (number_t minimum, number_t maximum, number_t current) {
bundle_t * bundle;

bundle = memorize ((number_t) sizeof (* bundle));

bundle->minimum = minimum;
bundle->maximum = maximum;
bundle->current = current;

return (bundle);
}

symbol_t * format_symbol (number_t character, number_t colour, number_t effect) {
symbol_t * symbol;

symbol = memorize ((number_t) sizeof (* symbol));
@@ -47,33 +59,6 @@ static symbol_t * format_symbol (number_t character, number_t colour, number_t e
return (symbol);
}

skill_t * game_skill (string_t name, bundle_t * points, ...) {
skill_t * skill;
va_list list;
number_t action;

va_start (list, points);

skill = memorize ((number_t) sizeof (* skill));

string_copy ((skill->name = memorize (string_length (name) + 1)), name);
memory_copy ((skill->points = memorize ((number_t) sizeof (* skill->points))), points, (number_t) sizeof (* points));

for (;;) {
action = (number_t) va_arg (list, int);

if (action > 0) {
skill->positive_count += 1;
skill->positive = memorize ((number_t) sizeof (action));
skill->positive [skill->positive_count - 1] = (action_t) action;
} else break;
}

va_end (list);

return (skill);
}

attribute_t * game_attribute (string_t name, bundle_t * points, ...) {
attribute_t * attribute;
va_list list;
@@ -83,7 +68,8 @@ attribute_t * game_attribute (string_t name, bundle_t * points, ...) {

attribute = memorize ((number_t) sizeof (* attribute));

string_copy ((attribute->name = memorize (string_length (name) + 1)), name);
string_copy ((attribute->name = memorize (string_length (name) + 1)), name);

memory_copy ((attribute->points = memorize ((number_t) sizeof (* attribute->points))), points, (number_t) sizeof (* points));

for (;;) {
@@ -105,23 +91,41 @@ attribute_t * game_attribute (string_t name, bundle_t * points, ...) {
return (attribute);
}

//~block_t * game_block (string_t name, symbol_t * symbol) {
//~block_t * block;
skill_t * game_skill (string_t name, bundle_t * points, ...) {
skill_t * skill;
va_list list;
number_t action;

//~block = memorize ((number_t) sizeof (* block));
va_start (list, points);

//~string_copy ((block->name = memorize (string_length (name) + 1)), name);
//~memory_copy ((block->symbol = memorize ((number_t) sizeof (* block->symbol))), symbol, (number_t) sizeof (* symbol));
skill = memorize ((number_t) sizeof (* skill));

//~return (block);
//~}
string_copy ((skill->name = memorize (string_length (name) + 1)), name);

memory_copy ((skill->points = memorize ((number_t) sizeof (* skill->points))), points, (number_t) sizeof (* points));

for (;;) {
action = (number_t) va_arg (list, int);

if (action > 0) {
skill->positive_count += 1;
skill->positive = memorize ((number_t) sizeof (action));
skill->positive [skill->positive_count - 1] = (action_t) action;
} else break;
}

va_end (list);

return (skill);
}

player_t * game_player (string_t name, symbol_t * symbol) {
player_t * player;

player = memorize ((number_t) sizeof (* player));

string_copy ((player->name = memorize (string_length (name) + 1)), name);
string_copy ((player->name = memorize (string_length (name) + 1)), name);

memory_copy ((player->symbol = memorize ((number_t) sizeof (* player->symbol))), symbol, (number_t) sizeof (* symbol));

player->x = 3;
@@ -130,14 +134,42 @@ player_t * game_player (string_t name, symbol_t * symbol) {
return (player);
}

void game_render_skill (skill_t * skill, number_t x, number_t y) {
curses_render_string (skill->name, COLOUR_CYAN, EFFECT_NORMAL, x, y);
block_t * game_block (string_t name, symbol_t * symbol, number_t collision, number_t override) {
block_t * block;

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 = 22, y);
curses_render_string (format_to_string (skill->points->current, 0, 10, 4, ' '), COLOUR_WHITE, EFFECT_NORMAL, x = 26, y);
curses_render_string (format_to_string (skill->points->maximum, 0, 10, 4, ' '), COLOUR_GREEN, EFFECT_NORMAL, x = 30, y);
curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x = 34, y);
block = memorize ((number_t) sizeof (* block));

string_copy ((block->name = memorize (string_length (name) + 1)), name);

memory_copy ((block->symbol = memorize ((number_t) sizeof (* block->symbol))), symbol, (number_t) sizeof (* symbol));

block->collision = collision;
block->override = override;

return (block);
}

world_t * game_world (number_t width, number_t height, block_t * floor, block_t * wall) {
world_t * world;

number_t x, y;

world = memorize ((number_t) sizeof (* world));

world->width = width;
world->height = height;

world->block = memorize (width * height * (number_t) sizeof (* world->block));

for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
world->block [y * width + x] = floor;
}
}

world->block [6] = wall;

return (world);
}

void game_render_attribute (attribute_t * attribute, number_t x, number_t y) {
@@ -150,56 +182,89 @@ void game_render_attribute (attribute_t * attribute, number_t x, number_t y) {
curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x = 34, y);
}

void play_game (void) {
bundle_t skill_points = { 10, 120, 0 };
bundle_t attribute_points = { 1, 12, 0 };
void game_render_skill (skill_t * skill, number_t x, number_t y) {
curses_render_string (skill->name, COLOUR_CYAN, EFFECT_NORMAL, x, 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 = 22, y);
curses_render_string (format_to_string (skill->points->current, 0, 10, 4, ' '), COLOUR_WHITE, EFFECT_NORMAL, x = 26, y);
curses_render_string (format_to_string (skill->points->maximum, 0, 10, 4, ' '), COLOUR_GREEN, EFFECT_NORMAL, x = 30, y);
curses_render_string (" ]", COLOUR_GREY, EFFECT_BOLD, x = 34, y);
}

void game_render_player (player_t * player) {
curses_render_character ((char) player->symbol->character, player->symbol->colour, player->symbol->effect, player->x, player->y);
}

void 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);
}

void game_render_world (world_t * world, number_t x, number_t y, number_t width, number_t height) {
number_t i, j;

for (j = 0; (j < height) && (j < world->height); ++j) {
for (i = 0; (i < width) && (i < world->width); ++i) {
game_render_block (world->block [(j + y) * world->width + (i + x)], i, j);
}
}
}

void play_game (void) {
player_t * player;
//~world_t * world;
block_t * floor, * wall;
world_t * world;

skill_t * blades, * axes, * bows, * spears, * puppet_magic, * nature_magic, * rune_magic, * charm_magic;
attribute_t * strength, * edurance, * wisdom, * agility;

strength = game_attribute ("Strength", & attribute_points, GAME_ACTION_SWING_BLADE, GAME_ACTION_SWING_AXE, -GAME_ACTION_CAMP, 0);
edurance = game_attribute ("Edurance", & attribute_points, GAME_ACTION_WALK, GAME_ACTION_CAMP, -GAME_ACTION_REST, 0);
wisdom = game_attribute ("Wisdom", & attribute_points, GAME_ACTION_CITE_RUNE, GAME_ACTION_CAST_CHARM, -GAME_ACTION_WALK, 0);
agility = game_attribute ("Agility", & attribute_points, GAME_ACTION_SHOOT_ARROW, GAME_ACTION_THROW_SPEAR, -GAME_ACTION_WAIT, 0);
strength = game_attribute ("Strength", format_bundle (1, 12, 0), GAME_ACTION_SWING_BLADE, GAME_ACTION_SWING_AXE, -GAME_ACTION_CAMP, 0);
edurance = game_attribute ("Edurance", format_bundle (1, 12, 0), GAME_ACTION_WALK, GAME_ACTION_CAMP, -GAME_ACTION_REST, 0);
wisdom = game_attribute ("Wisdom", format_bundle (1, 12, 0), GAME_ACTION_CITE_RUNE, GAME_ACTION_CAST_CHARM, -GAME_ACTION_WALK, 0);
agility = game_attribute ("Agility", format_bundle (1, 12, 0), GAME_ACTION_SHOOT_ARROW, GAME_ACTION_THROW_SPEAR, -GAME_ACTION_WAIT, 0);

blades = game_skill ("Blades", & skill_points, GAME_ACTION_SWING_BLADE, 0);
axes = game_skill ("Axes", & skill_points, GAME_ACTION_SWING_AXE, 0);
bows = game_skill ("Bows", & skill_points, GAME_ACTION_SHOOT_ARROW, 0);
spears = game_skill ("Spears", & skill_points, GAME_ACTION_THROW_SPEAR, 0);
puppet_magic = game_skill ("Puppet Magic", & skill_points, GAME_ACTION_SUMMON_PUPPET, 0);
nature_magic = game_skill ("Nature Magic", & skill_points, GAME_ACTION_CALL_NATURE, 0);
rune_magic = game_skill ("Rune Magic", & skill_points, GAME_ACTION_CITE_RUNE, 0);
charm_magic = game_skill ("Charm Magic", & skill_points, GAME_ACTION_CAST_CHARM, 0);
blades = game_skill ("Blades", format_bundle (10, 120, 0), GAME_ACTION_SWING_BLADE, 0);
axes = game_skill ("Axes", format_bundle (10, 120, 0), GAME_ACTION_SWING_AXE, 0);
bows = game_skill ("Bows", format_bundle (10, 120, 0), GAME_ACTION_SHOOT_ARROW, 0);
spears = game_skill ("Spears", format_bundle (10, 120, 0), GAME_ACTION_THROW_SPEAR, 0);
puppet_magic = game_skill ("Puppet Magic", format_bundle (10, 120, 0), GAME_ACTION_SUMMON_PUPPET, 0);
nature_magic = game_skill ("Nature Magic", format_bundle (10, 120, 0), GAME_ACTION_CALL_NATURE, 0);
rune_magic = game_skill ("Rune Magic", format_bundle (10, 120, 0), GAME_ACTION_CITE_RUNE, 0);
charm_magic = game_skill ("Charm Magic", format_bundle (10, 120, 0), GAME_ACTION_CAST_CHARM, 0);

player = game_player ("Riri", format_symbol ('@', COLOUR_CYAN, EFFECT_BOLD));

floor = game_block ("Floor", format_symbol ('.', COLOUR_GREY, EFFECT_BOLD), FALSE, FALSE);
wall = game_block ("Wall", format_symbol ('#', COLOUR_GREY, EFFECT_BOLD), TRUE, FALSE);

world = game_world (80, 24, floor, wall);

curses_configure ();

while (curses_active) {
curses_render_background (' ', COLOUR_WHITE, EFFECT_NORMAL);

curses_render_string ("Attributes:", COLOUR_WHITE, EFFECT_BOLD, 0, 0);
//~curses_render_string ("Attributes:", COLOUR_WHITE, EFFECT_BOLD, 0, 0);

//~game_render_attribute (strength, 2, 1);
//~game_render_attribute (edurance, 2, 2);
//~game_render_attribute (wisdom, 2, 3);
//~game_render_attribute (agility, 2, 4);

game_render_attribute (strength, 2, 1);
game_render_attribute (edurance, 2, 2);
game_render_attribute (wisdom, 2, 3);
game_render_attribute (agility, 2, 4);
//~curses_render_string ("Skills:", COLOUR_WHITE, EFFECT_BOLD, 0, 5);

curses_render_string ("Skills:", COLOUR_WHITE, EFFECT_BOLD, 0, 5);
//~game_render_skill (blades, 2, 6);
//~game_render_skill (axes, 2, 7);
//~game_render_skill (bows, 2, 8);
//~game_render_skill (spears, 2, 9);
//~game_render_skill (puppet_magic, 2, 10);
//~game_render_skill (nature_magic, 2, 11);
//~game_render_skill (rune_magic, 2, 12);
//~game_render_skill (charm_magic, 2, 13);

game_render_skill (blades, 2, 6);
game_render_skill (axes, 2, 7);
game_render_skill (bows, 2, 8);
game_render_skill (spears, 2, 9);
game_render_skill (puppet_magic, 2, 10);
game_render_skill (nature_magic, 2, 11);
game_render_skill (rune_magic, 2, 12);
game_render_skill (charm_magic, 2, 13);
game_render_world (world, 0, 0, curses_screen_width, curses_screen_height);

curses_render_character ('@', COLOUR_CYAN, EFFECT_BOLD, player->x, player->y);
game_render_player (player);

switch (curses_character) {
case 'w': player->y -= 1; break;


+ 29
- 20
chapter/chapter_5.h Vedi File

@@ -45,14 +45,6 @@ typedef struct bundle_t {
number_t minimum, maximum, current;
} bundle_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 attribute_t {
string_t name;
number_t positive_count, negative_count;
@@ -60,11 +52,12 @@ typedef struct attribute_t {
action_t * positive, * negative;
} attribute_t;

//~typedef struct block_t {
//~string_t name;
//~symbol_t * symbol;
//~number_t collision;
//~} block_t;
typedef struct skill_t {
string_t name;
number_t positive_count, learning_rate;
bundle_t * points;
action_t * positive;
} skill_t;

typedef struct player_t {
string_t name;
@@ -76,18 +69,34 @@ typedef struct player_t {
//~skill_t puppet_magic, nature_magic, rune_magic, charm_magic;
} player_t;

//~typedef struct world_t {
//~number_t width, height;
//~block_t * block;
//~} world_t;
typedef struct block_t {
string_t name;
symbol_t * symbol;
number_t collision;
number_t override;
} block_t;

typedef struct world_t {
number_t width, height;
block_t * * block;
} world_t;

extern memory_t memorize (number_t size);

extern bundle_t * format_bundle (number_t minimum, number_t maximum, number_t current);
extern symbol_t * format_symbol (number_t character, number_t colour, number_t effect);

extern skill_t * game_skill (string_t name, bundle_t * points, ...);
extern attribute_t * game_attribute (string_t name, bundle_t * points, ...);
//~extern block_t * game_block (string_t name, symbol_t * symbol);
extern skill_t * game_skill (string_t name, bundle_t * points, ...);
extern player_t * game_player (string_t name, symbol_t * symbol);
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, block_t * floor, block_t * wall);

extern void game_render_skill (skill_t * skill, number_t x, number_t y);
extern void game_render_attribute (attribute_t * attribute, number_t x, number_t y);
extern void game_render_skill (skill_t * skill, number_t x, number_t y);
extern void game_render_player (player_t * player);
extern void game_render_block (block_t * block, number_t x, number_t y);
extern void game_render_world (world_t * world, number_t x, number_t y, number_t width, number_t height);

extern void play_game (void);



Write Preview
Loading…
Annulla
Salva