falsycat/LEFTONE
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[RELEASE] u22-v04

Browse Source 
This version is submitted for U22 final presentation. (squashed 158 commits)
This commit is contained in:
falsycat
2020-10-09 00:00:00 +00:00
parent 84c3a02b9a
commit 80b3b82332
277 changed files with 12154 additions and 13836 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
core/loworld/CMakeLists.txt
View File

@@ -7,21 +7,27 @@ add_library(loworld
template.c
view.c
)
target_benum_sources(loworld
chunk.h
)
target_link_libraries(loworld
msgpackc
chaos
container
flasy
jukebox
math
memory
mpkutil
lobullet
locharacter
lochara
locommon
loentity
loground
loparticle
loplayer
loresource
loshader
)

30
core/loworld/chunk.c
View File

@@ -29,36 +29,6 @@ static void loworld_chunk_pack_entities_(
}
}
const char* loworld_chunk_biome_stringify(loworld_chunk_biome_t biome) {
# define each_(NAME, name) \
if (biome == LOWORLD_CHUNK_BIOME_##NAME) return #name;
LOWORLD_CHUNK_BIOME_EACH_(each_);
assert(false);
return NULL;
# undef each_
}
bool loworld_chunk_biome_unstringify(
loworld_chunk_biome_t* biome, const char* str, size_t len) {
assert(biome != NULL);
assert(str != NULL || len == 0);
# define each_(NAME, name) do { \
if (strncmp(str, #name, len) == 0 && #name[len] == 0) { \
*biome = LOWORLD_CHUNK_BIOME_##NAME; \
return true; \
} \
} while (0)
LOWORLD_CHUNK_BIOME_EACH_(each_);
return false;
# undef each_
}
void loworld_chunk_initialize(loworld_chunk_t* chunk) {
assert(chunk != NULL);

25
core/loworld/chunk.h
View File

@@ -14,24 +14,19 @@
#define LOWORLD_CHUNK_FILENAME_MAX 64
/* dont forget to change EACH macro */
typedef enum {
/* BENUM BEGIN loworld_chunk_biome */
LOWORLD_CHUNK_BIOME_METAPHYSICAL_GATE,
LOWORLD_CHUNK_BIOME_CAVIAS_CAMP,
LOWORLD_CHUNK_BIOME_LABORATORY,
LOWORLD_CHUNK_BIOME_BOSS_THEISTS_CHILD,
LOWORLD_CHUNK_BIOME_BOSS_BIG_WARDER,
LOWORLD_CHUNK_BIOME_BOSS_GREEDY_SCIENTIST,
/* BENUM END */
} loworld_chunk_biome_t;
#define LOWORLD_CHUNK_BIOME_EACH_(PROC) do { \
PROC(METAPHYSICAL_GATE, metaphysical-gate); \
PROC(CAVIAS_CAMP, cavias-camp); \
PROC(LABORATORY, laboratory); \
PROC(BOSS_THEISTS_CHILD, boss-theists-child); \
PROC(BOSS_BIG_WARDER, boss-big-warder); \
PROC(BOSS_GREEDY_SCIENTIST, boss-greedy-scientist); \
} while (0)
/* generated enum utility */
#include "core/loworld/benum/chunk.h"
typedef struct {
struct {
@@ -44,18 +39,6 @@ typedef struct {
CONTAINER_ARRAY loentity_t** entities;
} loworld_chunk_t;
const char*
loworld_chunk_biome_stringify(
loworld_chunk_biome_t biome
);
bool
loworld_chunk_biome_unstringify(
loworld_chunk_biome_t* biome,
const char* str,
size_t len
);
void
loworld_chunk_initialize(
loworld_chunk_t* chunk

129
core/loworld/environment.c
View File

@@ -10,7 +10,6 @@
#include "core/locommon/easing.h"
#include "core/locommon/ticker.h"
#include "core/loplayer/event.h"
#include "core/loplayer/player.h"
#include "core/loresource/music.h"
#include "core/loresource/set.h"
@@ -21,25 +20,8 @@
#include "./view.h"
static const char* loworld_environment_get_chunk_name_(
loresource_language_t lang, loworld_chunk_biome_t b) {
switch (b) {
case LOWORLD_CHUNK_BIOME_METAPHYSICAL_GATE:
return loresource_text_get(lang, "biome_metaphysical_gate");
case LOWORLD_CHUNK_BIOME_CAVIAS_CAMP:
return loresource_text_get(lang, "biome_cavias_camp");
case LOWORLD_CHUNK_BIOME_LABORATORY:
return loresource_text_get(lang, "biome_laboratory");
case LOWORLD_CHUNK_BIOME_BOSS_THEISTS_CHILD:
return loresource_text_get(lang, "biome_boss_theists_child");
case LOWORLD_CHUNK_BIOME_BOSS_BIG_WARDER:
return loresource_text_get(lang, "biome_boss_big_warder");
case LOWORLD_CHUNK_BIOME_BOSS_GREEDY_SCIENTIST:
return loresource_text_get(lang, "biome_boss_greedy_scientist");
}
assert(false);
return "unknown biome";
}
#define MUSIC_FADE_DURATION_ rational(1, 1)
#define MUSIC_EVENT_FADE_DURATION_ rational(1, 2)
static loshader_backwall_type_t loworld_environment_get_backwall_type_(
loworld_chunk_biome_t b) {
@@ -57,8 +39,7 @@ static loshader_backwall_type_t loworld_environment_get_backwall_type_(
case LOWORLD_CHUNK_BIOME_BOSS_GREEDY_SCIENTIST:
return LOSHADER_BACKWALL_TYPE_INFINITE_BOXES;
}
assert(false);
return LOSHADER_BACKWALL_TYPE_WHITE;
__builtin_unreachable();
}
static loshader_fog_type_t loworld_environment_get_fog_type_(
@@ -72,47 +53,37 @@ static loshader_fog_type_t loworld_environment_get_fog_type_(
case LOWORLD_CHUNK_BIOME_BOSS_GREEDY_SCIENTIST:
return LOSHADER_FOG_TYPE_WHITE_CLOUD;
}
assert(false);
return LOSHADER_FOG_TYPE_NONE;
__builtin_unreachable();
}
static loresource_music_player_t* loworld_environment_get_music_(
loworld_chunk_biome_t b, loresource_music_t* m) {
static loresource_music_id_t loworld_environment_get_music_id_(
loworld_chunk_biome_t b) {
switch (b) {
case LOWORLD_CHUNK_BIOME_METAPHYSICAL_GATE:
return &m->biome_metaphysical_gate;
return LORESOURCE_MUSIC_ID_BIOME_METAPHYSICAL_GATE;
case LOWORLD_CHUNK_BIOME_CAVIAS_CAMP:
return &m->biome_cavias_camp;
return LORESOURCE_MUSIC_ID_BIOME_CAVIAS_CAMP;
case LOWORLD_CHUNK_BIOME_LABORATORY:
return &m->biome_laboratory;
return LORESOURCE_MUSIC_ID_BIOME_LABORATORY;
case LOWORLD_CHUNK_BIOME_BOSS_THEISTS_CHILD:
case LOWORLD_CHUNK_BIOME_BOSS_BIG_WARDER:
case LOWORLD_CHUNK_BIOME_BOSS_GREEDY_SCIENTIST:
return &m->biome_boss;
return LORESOURCE_MUSIC_ID_BIOME_BOSS;
}
assert(false);
return NULL;
__builtin_unreachable();
}
static void loworld_environment_stop_music_(loworld_environment_t* env) {
static void loworld_environment_stop_music_(
loworld_environment_t* env, const rational_t* after) {
assert(env != NULL);
if (env->music != NULL && env->music_control) {
jukebox_amp_change_volume(&env->music->amp, 0, &rational(1, 1));
jukebox_decoder_stop_after(env->music->decoder, &rational(1, 1));
if (env->music != NULL) {
jukebox_amp_change_volume(&env->music->amp, 0, after);
jukebox_decoder_stop_after(env->music->decoder, after);
}
env->music = NULL;
}
static void loworld_environment_update_hud_(loworld_environment_t* env) {
assert(env != NULL);
if (env->transition > 0) return;
loplayer_hud_set_biome_text(
env->player->hud,
loworld_environment_get_chunk_name_(env->res->lang, env->biome));
}
static void loworld_environment_update_backwall_(loworld_environment_t* env) {
assert(env != NULL);
@@ -142,12 +113,11 @@ static void loworld_environment_update_fog_(loworld_environment_t* env) {
env->fog.transition = env->transition;
/* ---- bounds fog ---- */
const loplayer_event_param_t* e =
loplayer_event_get_param(env->player->event);
if (e != NULL && vec2_pow_length(&e->area_size) > 0) {
env->fog.bounds_pos = e->area_pos;
env->fog.bounds_size = e->area_size;
const locommon_position_t* pos = &env->player->event.ctx.area.pos;
const vec2_t* size = &env->player->event.ctx.area.size;
if (size->x > 0 && size->y > 0) {
env->fog.bounds_pos = *pos;
env->fog.bounds_size = *size;
locommon_easing_smooth_float(
&env->fog.bounds_fog, 1, env->ticker->delta_f);
} else {
@@ -159,39 +129,29 @@ static void loworld_environment_update_fog_(loworld_environment_t* env) {
static void loworld_environment_update_music_(loworld_environment_t* env) {
assert(env != NULL);
bool control = true;
loresource_music_player_t* music =
loworld_environment_get_music_(env->biome, &env->res->music);
const loplayer_event_context_t* ev = &env->player->event.ctx;
const loplayer_event_param_t* e =
loplayer_event_get_param(env->player->event);
if (e != NULL) {
music = e->music;
control = false;
loresource_music_t* music = env->music;
if (ev->music.enable) {
music = loresource_music_set_get(&env->res->music, ev->music.id);
if (music != env->music) {
loworld_environment_stop_music_(env, &MUSIC_EVENT_FADE_DURATION_);
jukebox_amp_change_volume(&music->amp, .9f, &MUSIC_EVENT_FADE_DURATION_);
if (!env->sound_attenuation) {
loresource_sound_change_master_volume(
env->res->sound, .2f, &rational(1, 1));
env->sound_attenuation = true;
const uint64_t t = env->ticker->time - ev->music.since;
jukebox_decoder_play(music->decoder, &rational(t, 1000), true);
}
} else {
if (env->sound_attenuation) {
loresource_sound_change_master_volume(
env->res->sound, 1, &rational(1, 1));
env->sound_attenuation = false;
}
}
music = loresource_music_set_get(
&env->res->music, loworld_environment_get_music_id_(env->biome));
if (music != env->music) {
loworld_environment_stop_music_(env, &MUSIC_FADE_DURATION_);
jukebox_amp_change_volume(&music->amp, .6f, &MUSIC_FADE_DURATION_);
if (music != env->music) {
loworld_environment_stop_music_(env);
env->music = music;
env->music_control = control;
if (env->music != NULL && env->music_control) {
jukebox_amp_change_volume(&env->music->amp, .6f, &rational(1, 1));
jukebox_decoder_resume(env->music->decoder, true);
jukebox_decoder_resume(music->decoder, true);
}
}
env->music = music;
}
void loworld_environment_initialize(
@@ -199,23 +159,23 @@ void loworld_environment_initialize(
loresource_set_t* res,
loshader_set_t* shaders,
const locommon_ticker_t* ticker,
const loplayer_t* player,
const loworld_view_t* view,
loplayer_t* player,
const loworld_environment_config_t* config) {
assert(env != NULL);
assert(res != NULL);
assert(shaders != NULL);
assert(ticker != NULL);
assert(view != NULL);
assert(player != NULL);
assert(view != NULL);
assert(config != NULL);
*env = (typeof(*env)) {
.res = res,
.shaders = shaders,
.ticker = ticker,
.view = view,
.player = player,
.view = view,
.config = *config,
};
@@ -224,7 +184,7 @@ void loworld_environment_initialize(
void loworld_environment_deinitialize(loworld_environment_t* env) {
assert(env != NULL);
loworld_environment_stop_music_(env);
loworld_environment_stop_music_(env, &rational(1, 10));
}
void loworld_environment_update(loworld_environment_t* env) {
@@ -236,7 +196,6 @@ void loworld_environment_update(loworld_environment_t* env) {
env->biome = chunk->biome;
env->transition = 0;
}
loworld_environment_update_hud_(env);
loworld_environment_update_backwall_(env);
loworld_environment_update_fog_(env);
loworld_environment_update_music_(env);
@@ -248,7 +207,7 @@ void loworld_environment_draw(const loworld_environment_t* env) {
assert(env != NULL);
loshader_backwall_drawer_set_param(
env->shaders->drawer.backwall, &env->backwall);
&env->shaders->drawer.backwall, &env->backwall);
loshader_fog_drawer_set_param(
env->shaders->drawer.fog, &env->fog);
&env->shaders->drawer.fog, &env->fog);
}

8
core/loworld/environment.h
View File

@@ -21,8 +21,8 @@ typedef struct {
loresource_set_t* res;
loshader_set_t* shaders;
const locommon_ticker_t* ticker;
const loplayer_t* player;
const loworld_view_t* view;
loplayer_t* player;
/* immutable params */
loworld_environment_config_t config;
@@ -31,9 +31,7 @@ typedef struct {
float transition;
loworld_chunk_biome_t biome;
loresource_music_player_t* music;
bool music_control;
bool sound_attenuation;
loresource_music_t* music;
loshader_backwall_drawer_param_t backwall;
loshader_fog_drawer_param_t fog;
@@ -45,8 +43,8 @@ loworld_environment_initialize(
loresource_set_t* res,
loshader_set_t* shaders,
const locommon_ticker_t* ticker,
const loplayer_t* player,
const loworld_view_t* view,
loplayer_t* player,
const loworld_environment_config_t* config
);

85
core/loworld/poolset.c
View File

@@ -7,10 +7,80 @@
#include <msgpack/sbuffer.h>
#include "core/lobullet/pool.h"
#include "core/locharacter/pool.h"
#include "core/lochara/pool.h"
#include "core/locommon/counter.h"
#include "core/locommon/ticker.h"
#include "core/loentity/store.h"
#include "core/loground/pool.h"
#include "core/loparticle/pool.h"
#include "core/loplayer/player.h"
#include "core/loresource/set.h"
#include "core/loshader/set.h"
#include "./test.h"
#define GROUNDS_PER_CHUNK_ 16
#define PARTICLES_PER_CHUNK_ 16
#define BULLETS_PER_CHUNK_ 64
#define CHARACTERS_PER_CHUNK_ 16
void loworld_poolset_initialize(
loworld_poolset_t* pools,
loresource_set_t* res,
loshader_set_t* shaders,
locommon_counter_t* idgen,
const locommon_ticker_t* ticker,
loentity_store_t* entities,
loplayer_t* player,
size_t max_chunks) {
assert(pools != NULL);
assert(res != NULL);
assert(shaders != NULL);
assert(idgen != NULL);
assert(ticker != NULL);
assert(entities != NULL);
assert(player != NULL);
assert(max_chunks > 0);
*pools = (typeof(*pools)) {0};
pools->ground = loground_pool_new(
&shaders->drawer.ground,
idgen,
max_chunks*GROUNDS_PER_CHUNK_);
pools->particle = loparticle_pool_new(
&shaders->drawer.particle,
idgen,
ticker,
entities,
max_chunks*PARTICLES_PER_CHUNK_);
pools->bullet = lobullet_pool_new(
res,
shaders,
idgen,
ticker,
entities,
max_chunks*BULLETS_PER_CHUNK_);
pools->chara = lochara_pool_new(
res,
shaders,
idgen,
ticker,
entities,
player,
pools->bullet,
max_chunks*CHARACTERS_PER_CHUNK_);
}
void loworld_poolset_deinitialize(loworld_poolset_t* pools) {
assert(pools != NULL);
lochara_pool_delete(pools->chara);
lobullet_pool_delete(pools->bullet);
loparticle_pool_delete(pools->particle);
loground_pool_delete(pools->ground);
}
loentity_t* loworld_poolset_unpack_entity(
const loworld_poolset_t* pools, const msgpack_object* obj) {
@@ -22,17 +92,14 @@ loentity_t* loworld_poolset_unpack_entity(
e = (typeof(e)) loground_pool_unpack_item(pools->ground, obj);
if (e != NULL) return e;
e = (typeof(e)) loparticle_pool_unpack_item(pools->particle, obj);
if (e != NULL) return e;
e = (typeof(e)) lobullet_pool_unpack_item(pools->bullet, obj);
if (e != NULL) return e;
e = (typeof(e)) locharacter_pool_unpack_item(pools->character, obj);
e = (typeof(e)) lochara_pool_unpack_item(pools->chara, obj);
if (e != NULL) return e;
return NULL;
}
void loworld_poolset_test_packing(const loworld_poolset_t* pools) {
assert(pools != NULL);
loworld_test_packing(pools);
}

35
core/loworld/poolset.h
View File

@@ -5,25 +5,42 @@
#include <msgpack.h>
#include "core/lobullet/pool.h"
#include "core/locharacter/pool.h"
#include "core/lochara/pool.h"
#include "core/locommon/counter.h"
#include "core/locommon/ticker.h"
#include "core/loentity/store.h"
#include "core/loground/pool.h"
#include "core/loparticle/pool.h"
#include "core/loplayer/player.h"
#include "core/loresource/set.h"
#include "core/loshader/set.h"
typedef struct {
loground_pool_t* ground;
loparticle_pool_t* particle;
lobullet_pool_t* bullet;
locharacter_pool_t* character;
lochara_pool_t* chara;
} loworld_poolset_t;
/* Initialize and Deinitialize each member manually
* because of a dependency issue. */
void
loworld_poolset_initialize(
loworld_poolset_t* pools,
loresource_set_t* res,
loshader_set_t* shaders,
locommon_counter_t* idgen,
const locommon_ticker_t* ticker,
loentity_store_t* entities,
loplayer_t* player,
size_t max_chunks
);
void
loworld_poolset_deinitialize(
loworld_poolset_t* pools
);
loentity_t* /* NULLABLE/OWNERSHIP */
loworld_poolset_unpack_entity(
const loworld_poolset_t* pools,
const msgpack_object* obj
);
void
loworld_poolset_test_packing(
const loworld_poolset_t* pools
);

9
core/loworld/store.c
View File

@@ -12,6 +12,7 @@
#include <msgpack.h>
#include <msgpack/fbuffer.h>
#include "util/flasy/flasy.h"
#include "util/memory/memory.h"
#include "util/mpkutil/file.h"
@@ -35,6 +36,7 @@ struct loworld_store_t {
char path[LOWORLD_STORE_PATH_MAX_LENGTH+LOWORLD_CHUNK_FILENAME_MAX];
size_t basepath_length;
flasy_t* flasy;
const loworld_poolset_t* pools;
const loworld_generator_t* generator;
@@ -135,7 +137,7 @@ static bool loworld_store_save_chunk_to_file_(
loworld_store_build_chunk_filename_(store, chunk);
FILE* fp = fopen(store->path, "wb");
FILE* fp = flasy_open_file(store->flasy, store->path, true);
if (fp == NULL) return false;
msgpack_packer packer;
@@ -144,16 +146,18 @@ static bool loworld_store_save_chunk_to_file_(
loworld_chunk_pack(chunk, &packer);
const bool success = (ferror(fp) == 0);
fclose(fp);
flasy_close_file(store->flasy, fp);
return success;
}
loworld_store_t* loworld_store_new(
flasy_t* flasy,
const loworld_poolset_t* pools,
const loworld_generator_t* generator,
size_t chunks_length,
const char* basepath,
size_t basepath_length) {
assert(flasy != NULL);
assert(pools != NULL);
assert(generator != NULL);
assert(chunks_length > 0);
@@ -167,6 +171,7 @@ loworld_store_t* loworld_store_new(
sizeof(*store) + (chunks_length-1)*sizeof(store->chunks[0]));
*store = (typeof(*store)) {
.basepath_length = basepath_length,
.flasy = flasy,
.pools = pools,
.generator = generator,
.chunks_length = chunks_length,

3
core/loworld/store.h
View File

@@ -4,6 +4,8 @@
#include <stddef.h>
#include <stdint.h>
#include "util/flasy/flasy.h"
#include "./chunk.h"
#include "./generator.h"
#include "./poolset.h"
@@ -14,6 +16,7 @@ typedef struct loworld_store_t loworld_store_t;
/* TODO(catfoot): make it possible to specify a path to chunk dir */
loworld_store_t* /* OWNERSHIP */
loworld_store_new(
flasy_t* flasy,
const loworld_poolset_t* pools,
const loworld_generator_t* gen,
size_t chunks_length,

178
core/loworld/template.c
View File

@@ -8,23 +8,22 @@
#include "util/math/algorithm.h"
#include "util/math/vector.h"
#include "core/locharacter/base.h"
#include "core/locharacter/big_warder.h"
#include "core/locharacter/cavia.h"
#include "core/locharacter/encephalon.h"
#include "core/locharacter/scientist.h"
#include "core/locharacter/greedy_scientist.h"
#include "core/locharacter/theists_child.h"
#include "core/locharacter/warder.h"
#include "core/lochara/base.h"
#include "core/lochara/big_warder.h"
#include "core/lochara/cavia.h"
#include "core/lochara/encephalon.h"
#include "core/lochara/theists_child.h"
#include "core/lochara/warder.h"
#include "core/locommon/position.h"
#include "core/loentity/entity.h"
#include "core/loentity/ground.h"
#include "core/loground/base.h"
#include "core/loground/island.h"
#include "./chunk.h"
#include "./poolset.h"
static loentity_id_t loworld_template_add_ground_island_(
static loentity_ground_t* loworld_template_add_ground_island_(
const loworld_template_building_param_t* param,
const vec2_t* pos,
const vec2_t* sz) {
@@ -39,46 +38,30 @@ static loentity_id_t loworld_template_add_ground_island_(
loground_base_t* island = loground_pool_create(param->pools->ground);
loground_island_build(island, &p, sz);
loworld_chunk_add_entity(param->target, &island->super.super);
return island->super.super.id;
return &island->super;
}
static loentity_id_t loworld_template_add_character_random_enemy_(
static void loworld_template_add_random_enemy_(
const loworld_template_building_param_t* param,
uint64_t seed,
loentity_id_t ground,
const loentity_ground_t* gnd,
float pos) {
assert(param != NULL);
assert(loworld_template_building_param_valid(param));
assert(gnd != NULL);
assert(MATH_FLOAT_VALID(pos));
locharacter_base_t* base = locharacter_pool_create(param->pools->character);
static void (*const builders[])(
lochara_base_t*, const loentity_ground_t*, float) = {
lochara_cavia_build,
lochara_warder_build,
};
lochara_base_t* base = lochara_pool_create(param->pools->chara);
const size_t i = chaos_xorshift(seed)%(sizeof(builders)/sizeof(builders[0]));
builders[i](base, gnd, pos);
bool built = false;
const uint64_t type = (seed = chaos_xorshift(seed))%3;
switch (type) {
case 1:
locharacter_warder_build(base, &(locharacter_warder_param_t) {
.ground = ground,
.pos = pos,
});
built = true;
break;
case 2:
locharacter_scientist_build(base, &(locharacter_scientist_param_t) {
.ground = ground,
.pos = pos,
.direction = (seed = chaos_xorshift(seed))%2? 1: -1,
});
built = true;
break;
}
if (!built) {
locharacter_cavia_build(base, &(locharacter_cavia_param_t) {
.ground = ground,
.pos = pos,
.direction = (seed = chaos_xorshift(seed))%2? 1: -1,
});
}
loworld_chunk_add_entity(param->target, &base->super.super);
return base->super.super.id;
}
bool loworld_template_building_param_valid(
@@ -93,15 +76,13 @@ void loworld_template_metaphysical_gate_build_chunk(
const loworld_template_building_param_t* param) {
assert(loworld_template_building_param_valid(param));
loworld_template_add_ground_island_(
param, &vec2(.5f, .2f), &vec2(.5f, .1f));
loworld_template_add_ground_island_(param, &vec2(.5f, .2f), &vec2(.5f, .1f));
const loentity_id_t ground = loworld_template_add_ground_island_(
const loentity_ground_t* platform = loworld_template_add_ground_island_(
param, &vec2(.5f, .45f), &vec2(.2f, .02f));
locharacter_base_t* encephalon =
locharacter_pool_create(param->pools->character);
locharacter_encephalon_build(encephalon, ground);
lochara_base_t* encephalon = lochara_pool_create(param->pools->chara);
lochara_encephalon_build(encephalon, platform);
loworld_chunk_add_entity(param->target, &encephalon->super.super);
}
@@ -113,12 +94,12 @@ void loworld_template_open_space_build_chunk(
const size_t enemy_count = (s = chaos_xorshift(s))%3+1;
const loentity_id_t ground = loworld_template_add_ground_island_(
const loentity_ground_t* gnd = loworld_template_add_ground_island_(
param, &vec2(.5f, .2f), &vec2(.47f, .01f));
for (size_t i = 0; i < enemy_count; ++i) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), ground, (2.0f/enemy_count*i - 1)*.75f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), gnd, .1f+.8f/enemy_count*i);
}
}
@@ -128,18 +109,18 @@ void loworld_template_broken_open_space_build_chunk(
uint64_t s = param->seed;
const loentity_id_t floor1 = loworld_template_add_ground_island_(
const loentity_ground_t* floor1 = loworld_template_add_ground_island_(
param, &vec2(.2f, .2f), &vec2(.18f, .01f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor1, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor1, .5f);
}
const loentity_id_t floor2 = loworld_template_add_ground_island_(
const loentity_ground_t* floor2 = loworld_template_add_ground_island_(
param, &vec2(.8f, .2f), &vec2(.18f, .01f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor2, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor2, .5f);
}
loworld_template_add_ground_island_(
@@ -152,18 +133,18 @@ void loworld_template_passage_build_chunk(
uint64_t s = param->seed;
const loentity_id_t floor = loworld_template_add_ground_island_(
const loentity_ground_t* floor = loworld_template_add_ground_island_(
param, &vec2(.5f, .25f), &vec2(.5f, .01f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor, .5f);
}
const loentity_id_t ceiling = loworld_template_add_ground_island_(
const loentity_ground_t* ceiling = loworld_template_add_ground_island_(
param, &vec2(.55f, .4f), &vec2(.3f, .007f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), ceiling, .2f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), ceiling, .5f);
}
}
@@ -173,42 +154,42 @@ void loworld_template_broken_passage_build_chunk(
uint64_t s = param->seed;
const loentity_id_t floor1 = loworld_template_add_ground_island_(
const loentity_ground_t* floor1 = loworld_template_add_ground_island_(
param, &vec2(.15f, .25f), &vec2(.15f, .01f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor1, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor1, .5f);
}
const loentity_id_t floor2 = loworld_template_add_ground_island_(
const loentity_ground_t* floor2 = loworld_template_add_ground_island_(
param, &vec2(.45f, .25f), &vec2(.1f, .01f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor2, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor2, .5f);
}
const loentity_id_t floor3 = loworld_template_add_ground_island_(
const loentity_ground_t* floor3 = loworld_template_add_ground_island_(
param, &vec2(.85f, .25f), &vec2(.15f, .01f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor3, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor3, .5f);
}
const uint64_t layout = (s = chaos_xorshift(s))%3;
if (layout == 0 || layout == 1) {
const loentity_id_t ceiling = loworld_template_add_ground_island_(
const loentity_ground_t* ceiling = loworld_template_add_ground_island_(
param, &vec2(.2f, .4f), &vec2(.15f, .007f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), ceiling, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), ceiling, .5f);
}
}
if (layout == 0 || layout == 2) {
const loentity_id_t ceiling = loworld_template_add_ground_island_(
const loentity_ground_t* ceiling = loworld_template_add_ground_island_(
param, &vec2(.7f, .38f), &vec2(.12f, .007f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), ceiling, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), ceiling, .5f);
}
}
}
@@ -219,34 +200,34 @@ void loworld_template_stairs_build_chunk(
uint64_t s = param->seed;
const loentity_id_t floor1 = loworld_template_add_ground_island_(
const loentity_ground_t* floor1 = loworld_template_add_ground_island_(
param, &vec2(.5f, .3f), &vec2(.5f, .015f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor1, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor1, .5f);
}
bool layout = (s = chaos_xorshift(s))%2;
const loentity_id_t floor2 = loworld_template_add_ground_island_(
const loentity_ground_t* floor2 = loworld_template_add_ground_island_(
param, &vec2(layout? .3f: .6f, .5f), &vec2(.2f, .015f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor2, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor2, .5f);
}
layout = !layout;
const loentity_id_t floor3 = loworld_template_add_ground_island_(
const loentity_ground_t* floor3 = loworld_template_add_ground_island_(
param, &vec2(layout? .2f: .8f, .7f), &vec2(.18f, .007f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor3, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor3, .5f);
}
const loentity_id_t floor4 = loworld_template_add_ground_island_(
const loentity_ground_t* floor4 = loworld_template_add_ground_island_(
param, &vec2(.5f, .9f), &vec2(.32f, .007f));
if ((s = chaos_xorshift(s))%2) {
loworld_template_add_character_random_enemy_(
param, (s = chaos_xorshift(s)), floor4, .5f);
loworld_template_add_random_enemy_(
param, s = chaos_xorshift(s), floor4, .5f);
}
}
@@ -254,11 +235,11 @@ void loworld_template_boss_theists_child_build_chunk(
const loworld_template_building_param_t* param) {
assert(loworld_template_building_param_valid(param));
const loentity_id_t ground = loworld_template_add_ground_island_(
loentity_ground_t* gnd = loworld_template_add_ground_island_(
param, &vec2(.5f, .1f), &vec2(.5f, .05f));
locharacter_base_t* boss = locharacter_pool_create(param->pools->character);
locharacter_theists_child_build(boss, ground);
lochara_base_t* boss = lochara_pool_create(param->pools->chara);
lochara_theists_child_build(boss, gnd);
loworld_chunk_add_entity(param->target, &boss->super.super);
}
@@ -266,11 +247,11 @@ void loworld_template_boss_big_warder_build_chunk(
const loworld_template_building_param_t* param) {
assert(loworld_template_building_param_valid(param));
const loentity_id_t ground = loworld_template_add_ground_island_(
loentity_ground_t* gnd = loworld_template_add_ground_island_(
param, &vec2(.5f, .1f), &vec2(.5f, .05f));
locharacter_base_t* boss = locharacter_pool_create(param->pools->character);
locharacter_big_warder_build(boss, ground);
lochara_base_t* boss = lochara_pool_create(param->pools->chara);
lochara_big_warder_build(boss, gnd);
loworld_chunk_add_entity(param->target, &boss->super.super);
}
@@ -278,10 +259,7 @@ void loworld_template_boss_greedy_scientist_build_chunk(
const loworld_template_building_param_t* param) {
assert(loworld_template_building_param_valid(param));
const loentity_id_t ground = loworld_template_add_ground_island_(
const loentity_ground_t* ground = loworld_template_add_ground_island_(
param, &vec2(.5f, .1f), &vec2(.5f, .05f));
locharacter_base_t* boss = locharacter_pool_create(param->pools->character);
locharacter_greedy_scientist_build(boss, ground);
loworld_chunk_add_entity(param->target, &boss->super.super);
(void) ground;
}

146
core/loworld/test.h
View File

@@ -1,146 +0,0 @@
#pragma once
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <msgpack.h>
#include <msgpack/sbuffer.h>
#include "core/lobullet/base.h"
#include "core/lobullet/bomb.h"
#include "core/lobullet/linear.h"
#include "core/locharacter/base.h"
#include "core/locharacter/big_warder.h"
#include "core/locharacter/cavia.h"
#include "core/locharacter/encephalon.h"
#include "core/locharacter/greedy_scientist.h"
#include "core/locharacter/theists_child.h"
#include "core/locharacter/scientist.h"
#include "core/locharacter/warder.h"
#include "core/locharacter/pool.h"
#include "core/loentity/entity.h"
#include "core/loground/base.h"
#include "core/loground/island.h"
#include "core/loground/pool.h"
#include "./poolset.h"
# define pack_and_unpack_(type, name) do { \
msgpack_sbuffer_clear(buf); \
loentity_pack(&base->super.super, &packer); \
loentity_delete(&base->super.super); \
\
size_t offset = 0; \
const msgpack_unpack_return r = \
msgpack_unpack_next(upk, buf->data, buf->size, &offset); \
if (r != MSGPACK_UNPACK_SUCCESS) { \
fprintf(stderr, #type"_"#name": invalid msgpack format\n"); \
abort(); \
} \
if (!type##_base_unpack(base, &upk->data)) { \
fprintf(stderr, #type"_"#name": failed to unpack\n"); \
abort(); \
} \
loentity_delete(&base->super.super); \
printf(#type"_"#name": pack test passed\n"); \
} while (0)
static inline void loworld_test_packing_grounds(
loground_base_t* base, msgpack_sbuffer* buf, msgpack_unpacked* upk) {
assert(base != NULL);
assert(buf != NULL);
assert(upk != NULL);
msgpack_packer packer;
msgpack_packer_init(&packer, buf, msgpack_sbuffer_write);
loground_island_build(
base, &locommon_position(0, 0, vec2(0, 0)), &vec2(1, 1));
pack_and_unpack_(loground, island);
}
static inline void loworld_test_packing_bullets(
lobullet_base_t* base, msgpack_sbuffer* buf, msgpack_unpacked* upk) {
assert(base != NULL);
assert(buf != NULL);
assert(upk != NULL);
msgpack_packer packer;
msgpack_packer_init(&packer, buf, msgpack_sbuffer_write);
lobullet_bomb_square_build(
base, &((lobullet_bomb_param_t) { .step = 1, }));
pack_and_unpack_(lobullet, bomb);
lobullet_bomb_triangle_build(
base, &((lobullet_bomb_param_t) { .step = 1, }));
pack_and_unpack_(lobullet, bomb);
lobullet_linear_light_build(
base, &((lobullet_linear_param_t) { .duration = 1, }));
pack_and_unpack_(lobullet, linear);
lobullet_linear_triangle_build(
base, &((lobullet_linear_param_t) { .duration = 1, }));
pack_and_unpack_(lobullet, linear);
}
static inline void loworld_test_packing_characters(
locharacter_base_t* base, msgpack_sbuffer* buf, msgpack_unpacked* upk) {
assert(base != NULL);
assert(buf != NULL);
assert(upk != NULL);
msgpack_packer packer;
msgpack_packer_init(&packer, buf, msgpack_sbuffer_write);
locharacter_big_warder_build(base, 0);
pack_and_unpack_(locharacter, big_warder);
locharacter_cavia_build(
base, &((locharacter_cavia_param_t) { .direction = 1, }));
pack_and_unpack_(locharacter, cavia);
locharacter_encephalon_build(base, 0);
pack_and_unpack_(locharacter, encephalon);
locharacter_theists_child_build(base, 0);
pack_and_unpack_(locharacter, theists_child);
locharacter_greedy_scientist_build(base, 0);
pack_and_unpack_(locharacter, greedy_scientist);
locharacter_scientist_build(base, &((locharacter_scientist_param_t) {0}));
pack_and_unpack_(locharacter, scientist);
locharacter_warder_build(base, &((locharacter_warder_param_t) {0}));
pack_and_unpack_(locharacter, warder);
}
# undef pack_and_unpack_
static inline void loworld_test_packing(const loworld_poolset_t* pools) {
assert(pools != NULL);
msgpack_sbuffer buf;
msgpack_sbuffer_init(&buf);
msgpack_unpacked upk;
msgpack_unpacked_init(&upk);
loground_base_t* ground = loground_pool_create(pools->ground);
loworld_test_packing_grounds(ground, &buf, &upk);
loentity_delete(&ground->super.super);
lobullet_base_t* bullet = lobullet_pool_create(pools->bullet);
loworld_test_packing_bullets(bullet, &buf, &upk);
loentity_delete(&bullet->super.super);
locharacter_base_t* chara = locharacter_pool_create(pools->character);
loworld_test_packing_characters(chara, &buf, &upk);
loentity_delete(&chara->super.super);
msgpack_unpacked_destroy(&upk);
msgpack_sbuffer_destroy(&buf);
}