jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cmd_kind. fix aabb draw

Browse Source
This commit is contained in:
jacob 2025-03-01 09:39:00 -06:00
parent d16fdcd260
commit 0b92a1e8a4
8 changed files with 156 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/config.h
View File

@ -23,10 +23,10 @@
#define RESOURCES_EMBEDDED (!DEVELOPER)
#define RESOURCE_RELOADING (DEVELOPER && !RESOURCES_EMBEDDED)
#define DEFAULT_CAMERA_WIDTH (7.0)
#define DEFAULT_CAMERA_WIDTH (15.0)
#define DEFAULT_CAMERA_HEIGHT (DEFAULT_CAMERA_WIDTH / (16.0 / 9.0))
#define IMAGE_PIXELS_PER_UNIT 256.0
#define IMAGE_PIXELS_PER_UNIT 128.0
/* How many ticks back in time should the user blend between?
* <Delay> = <USER_INTERP_RATIO> * <Tick interval>

18
src/math.h
View File

@ -1154,9 +1154,9 @@ INLINE struct quad quad_from_aabb(struct aabb aabb)
{
struct quad res;
res.p0 = V2(aabb.p0.x, aabb.p0.y); /* Top left */
res.p0 = V2(aabb.p1.x, aabb.p0.y); /* Top right */
res.p0 = V2(aabb.p1.x, aabb.p1.y); /* Bottom right */
res.p0 = V2(aabb.p0.x, aabb.p1.y); /* Bottom left */
res.p1 = V2(aabb.p1.x, aabb.p0.y); /* Top right */
res.p2 = V2(aabb.p1.x, aabb.p1.y); /* Bottom right */
res.p3 = V2(aabb.p0.x, aabb.p1.y); /* Bottom left */
return res;
}
@ -1197,9 +1197,9 @@ INLINE struct quad quad_round(struct quad quad)
{
struct quad res;
res.p0 = v2_round(quad.p0);
res.p0 = v2_round(quad.p1);
res.p0 = v2_round(quad.p2);
res.p0 = v2_round(quad.p3);
res.p1 = v2_round(quad.p1);
res.p2 = v2_round(quad.p2);
res.p3 = v2_round(quad.p3);
return res;
}
@ -1207,9 +1207,9 @@ INLINE struct quad quad_floor(struct quad quad)
{
struct quad res;
res.p0 = v2_floor(quad.p0);
res.p0 = v2_floor(quad.p1);
res.p0 = v2_floor(quad.p2);
res.p0 = v2_floor(quad.p3);
res.p1 = v2_floor(quad.p1);
res.p2 = v2_floor(quad.p2);
res.p3 = v2_floor(quad.p3);
return res;
}

1
src/sim.c
View File

@ -590,7 +590,6 @@ struct sim_snapshot *sim_snapshot_alloc_from_lerp(struct sim_client *client, str
}
}
return ss;
}

7
src/sim.h
View File

@ -150,6 +150,13 @@ struct sim_control {
u32 flags;
};
enum sim_cmd_kind {
SIM_CMD_KIND_INVALID,
SIM_CMD_KIND_CONTROL,
SIM_CMD_KIND_CHAT
};
struct sim_ent_bin;
struct sim_snapshot {

2
src/sim_ent.c
View File

@ -149,7 +149,7 @@ void sim_ent_release_all_with_prop(struct sim_snapshot *ss, enum sim_ent_prop pr
* child entities will be released along with parent anyway) */
for (u64 i = 0; i < ents_to_release_count; ++i) {
struct sim_ent *ent = ents_to_release[i];
if (ent->valid && !ent->is_root && !sim_ent_has_prop(ent, SIM_ENT_PROP_CMD_CONTROL) && !sim_ent_has_prop(ent, SIM_ENT_PROP_PLAYER)) {
if (ent->valid && !ent->is_root && !sim_ent_has_prop(ent, SIM_ENT_PROP_CMD) && !sim_ent_has_prop(ent, SIM_ENT_PROP_PLAYER)) {
sim_ent_release(ent);
}
}

22
src/sim_ent.h
View File

@ -22,7 +22,7 @@ enum sim_ent_prop {
SIM_ENT_PROP_PLAYER,
SIM_ENT_PROP_PLAYER_IS_MASTER,
SIM_ENT_PROP_CMD_CONTROL,
SIM_ENT_PROP_CMD,
SIM_ENT_PROP_PHYSICAL_DYNAMIC,
SIM_ENT_PROP_PHYSICAL_KINEMATIC,
@ -125,13 +125,27 @@ struct sim_ent {
/* ====================================================================== */
/* Cmd */
/* SIM_ENT_PROP_CMD_CONTROL */
/* SIM_ENT_PROP_CMD */
enum sim_cmd_kind cmd_kind;
struct sim_ent_id cmd_player;
/* FIXME: Lerp */
struct sim_ent_id cmd_player;
/* Control cmd */
struct sim_control cmd_control;
struct sim_ent_id cmd_hovered_ent;
struct sim_ent_id cmd_control_hovered_ent;
/* Chat cmd */
//struct string cmd_chat_msg;
/* ====================================================================== */
/* Chat */
/* SIM_ENT_PROP_CHAT */
struct sim_ent_id chat_player;
//struct string chat_msg;
/* ====================================================================== */
/* Client */

163
src/sim_step.c
View File

@ -129,13 +129,13 @@ INTERNAL void spawn_test_entities(struct sim_step_ctx *ctx, struct v2 offset)
#endif
}
INTERNAL struct sim_ent *spawn_test_player(struct sim_step_ctx *ctx)
INTERNAL struct sim_ent *spawn_test_employee(struct sim_step_ctx *ctx)
{
struct sim_snapshot *world = ctx->world;
struct sim_ent *root = sim_ent_from_id(world, SIM_ENT_ROOT_ID);
/* Player */
struct sim_ent *player_ent = sim_ent_nil();
struct sim_ent *employee = sim_ent_nil();
//if (!ctx->extra_spawn) {
{
@ -165,7 +165,7 @@ INTERNAL struct sim_ent *spawn_test_player(struct sim_step_ctx *ctx)
e->local_collider.points[0] = V2(0, 0);
e->local_collider.count = 1;
e->local_collider.radius = 0.15f;
e->local_collider.radius = 0.30f;
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
//xf.bx.y = -1.f;
@ -178,20 +178,20 @@ INTERNAL struct sim_ent *spawn_test_player(struct sim_step_ctx *ctx)
e->friction = 0;
//e->control_force = 500;
e->control_force = 500;
e->control_force_max_speed = 4;
e->control_force = 1200;
e->control_force_max_speed = 8;
//e->control_torque = 5000;
e->control_torque = F32_INFINITY;
sim_ent_enable_prop(e, SIM_ENT_PROP_PHYSICAL_DYNAMIC);
player_ent = e;
employee = e;
}
/* Player weapon */
if (player_ent->valid) {
struct sim_ent *e = sim_ent_alloc_sync_src(player_ent);
if (employee->valid) {
struct sim_ent *e = sim_ent_alloc_sync_src(employee);
e->sprite = sprite_tag_from_path(LIT("res/graphics/gun.ase"));
sim_ent_enable_prop(e, SIM_ENT_PROP_ATTACHED);
@ -202,24 +202,24 @@ INTERNAL struct sim_ent *spawn_test_player(struct sim_step_ctx *ctx)
e->trigger_delay = 1.0f / 10.0f;
//e->trigger_delay = 1.0f / 100.0f;
player_ent->equipped = e->id;
employee->equipped = e->id;
}
return player_ent;
return employee;
}
INTERNAL struct sim_ent *spawn_test_player_camera(struct sim_snapshot *world, struct sim_ent *player_ent)
INTERNAL struct sim_ent *spawn_test_camera(struct sim_snapshot *world, struct sim_ent *follow)
{
struct sim_ent *root = sim_ent_from_id(world, SIM_ENT_ROOT_ID);
struct sim_ent *camera_ent = sim_ent_nil();
if (player_ent->valid) {
if (follow->valid) {
camera_ent = sim_ent_alloc_sync_src(root);
sim_ent_set_xform(camera_ent, XFORM_IDENT);
sim_ent_enable_prop(camera_ent, SIM_ENT_PROP_CAMERA);
sim_ent_enable_prop(camera_ent, SIM_ENT_PROP_CAMERA_ACTIVE);
camera_ent->camera_follow = player_ent->id;
camera_ent->camera_follow = follow->id;
f32 width = (f32)DEFAULT_CAMERA_WIDTH;
f32 height = (f32)DEFAULT_CAMERA_HEIGHT;
@ -419,7 +419,7 @@ void sim_step(struct sim_step_ctx *ctx)
/* Mark incoming cmds with correct client */
for (u64 i = 0; i < world->num_ents_reserved; ++i) {
struct sim_ent *ent = &world->ents[i];
if (ent->valid && sim_ent_has_prop(ent, SIM_ENT_PROP_CMD_CONTROL) && sim_ent_has_prop(ent, SIM_ENT_PROP_SYNC_DST)) {
if (ent->valid && sim_ent_has_prop(ent, SIM_ENT_PROP_CMD) && sim_ent_has_prop(ent, SIM_ENT_PROP_SYNC_DST)) {
ent->cmd_player = ent->owner;
}
}
@ -428,7 +428,7 @@ void sim_step(struct sim_step_ctx *ctx)
if (!is_master) {
for (u64 i = 0; i < world->num_ents_reserved; ++i) {
struct sim_ent *ent = &world->ents[i];
if (sim_ent_is_valid_and_active(ent) && sim_ent_has_prop(ent, SIM_ENT_PROP_CMD_CONTROL)) {
if (sim_ent_is_valid_and_active(ent) && sim_ent_has_prop(ent, SIM_ENT_PROP_CMD)) {
if (!sim_ent_id_is_nil(ent->cmd_player) && sim_ent_id_eq(ent->cmd_player, world->local_player)) {
sim_ent_enable_prop(ent, SIM_ENT_PROP_SYNC_SRC);
}
@ -485,64 +485,99 @@ void sim_step(struct sim_step_ctx *ctx)
struct sim_ent *cmd_ent = &world->ents[ent_index];
if (!is_master && !sim_ent_should_simulate(cmd_ent)) continue;
if (sim_ent_has_prop(cmd_ent, SIM_ENT_PROP_CMD_CONTROL)) {
if (sim_ent_has_prop(cmd_ent, SIM_ENT_PROP_CMD)) {
struct sim_ent *player = sim_ent_from_id(world, cmd_ent->cmd_player);
if (sim_ent_should_simulate(player)) {
b32 persist_cmd = false;
if (!is_master && !sim_ent_id_eq(player->id, world->local_player)) {
/* We are not the master and the command is not our own, skip processing */
continue;
}
/* Process control cmd for client */
struct sim_control old_control = player->player_control;
struct sim_control *control = &player->player_control;
*control = cmd_ent->cmd_control;
{
player->player_dbg_drag_start = false;
player->player_dbg_drag_stop = false;
if (v2_len_sq(control->move) > 1) {
/* Cap movement vector magnitude at 1 */
control->move = v2_norm(control->move);
}
/* Determine cursor pos from focus */
enum sim_cmd_kind kind = cmd_ent->cmd_kind;
switch (kind) {
case SIM_CMD_KIND_CONTROL:
{
struct sim_ent_id player_control_ent_id = player->player_control_ent;
struct sim_ent *player_control_ent = sim_ent_from_id(world, player_control_ent_id);
if (player_control_ent->valid || sim_ent_id_is_nil(player_control_ent_id)) {
/* Only update cursor pos if focus ent is valid (or nil) */
player->player_cursor_pos = v2_add(sim_ent_get_xform(player_control_ent).og, player->player_control.focus);
}
}
/* Player's will send control cmds a lot, so keep it around to prevent re-creating it each time */
persist_cmd = true;
player->player_hovered_ent = cmd_ent->cmd_hovered_ent;
/* Process control cmd for client */
struct sim_control old_control = player->player_control;
struct sim_control *control = &player->player_control;
*control = cmd_ent->cmd_control;
{
player->player_dbg_drag_start = false;
player->player_dbg_drag_stop = false;
u32 flags = control->flags;
if (flags & SIM_CONTROL_FLAG_DRAG) {
if (!(old_control.flags & SIM_CONTROL_FLAG_DRAG)) {
player->player_dbg_drag_start = true;
}
} else {
if (old_control.flags & SIM_CONTROL_FLAG_DRAG) {
player->player_dbg_drag_stop = true;
}
}
if (flags & SIM_CONTROL_FLAG_CLEAR_ALL) {
if (is_master && !(old_control.flags & SIM_CONTROL_FLAG_CLEAR_ALL)) {
test_clear_level(ctx);
}
}
if (flags & SIM_CONTROL_FLAG_SPAWN_TEST) {
if (!(old_control.flags & SIM_CONTROL_FLAG_SPAWN_TEST)) {
logf_info("Spawning (test)");
u32 count = 1;
f32 spread = 1;
for (u32 j = 0; j < count; ++j) {
spawn_test_entities(ctx, V2(0, (((f32)j / (f32)count) - 0.5) * spread));
if (v2_len_sq(control->move) > 1) {
/* Cap movement vector magnitude at 1 */
control->move = v2_norm(control->move);
}
/* Determine cursor pos from focus */
{
struct sim_ent_id player_control_ent_id = player->player_control_ent;
struct sim_ent *player_control_ent = sim_ent_from_id(world, player_control_ent_id);
if (player_control_ent->valid || sim_ent_id_is_nil(player_control_ent_id)) {
/* Only update cursor pos if focus ent is valid (or nil) */
player->player_cursor_pos = v2_add(sim_ent_get_xform(player_control_ent).og, player->player_control.focus);
}
}
player->player_hovered_ent = cmd_ent->cmd_control_hovered_ent;
u32 flags = control->flags;
if (flags & SIM_CONTROL_FLAG_DRAG) {
if (!(old_control.flags & SIM_CONTROL_FLAG_DRAG)) {
player->player_dbg_drag_start = true;
}
} else {
if (old_control.flags & SIM_CONTROL_FLAG_DRAG) {
player->player_dbg_drag_stop = true;
}
}
if (flags & SIM_CONTROL_FLAG_CLEAR_ALL) {
if (is_master && !(old_control.flags & SIM_CONTROL_FLAG_CLEAR_ALL)) {
test_clear_level(ctx);
}
}
if (flags & SIM_CONTROL_FLAG_SPAWN_TEST) {
if (!(old_control.flags & SIM_CONTROL_FLAG_SPAWN_TEST)) {
logf_info("Spawning (test)");
u32 count = 1;
f32 spread = 1;
for (u32 j = 0; j < count; ++j) {
spawn_test_entities(ctx, V2(0, (((f32)j / (f32)count) - 0.5) * spread));
}
}
}
}
}
} break;
#if 0
case SIM_CMD_KIND_CHAT:
{
struct sim_data_key msg_key = cmd_ent->cmd_chat_msg;
struct string msg = sim_data_from_key(sim_data_store, msg_key);
if (msg.len > 0) {
struct sim_ent *chat_ent = sim_ent_alloc_sync_src(root);
sim_ent_enable_prop(chat_ent, SIM_ENT_PROP_CHAT);
chat_ent->chat_player = player->id;
chat_ent->chat_msg = msg_key;
}
} break;
#endif
default:
{
/* Invalid cmd kind */
ASSERT(false);
} break;
}
/* Release cmd */
if (!persist_cmd) {
sim_ent_enable_prop(cmd_ent, SIM_ENT_PROP_RELEASE);
}
}
}
@ -560,7 +595,7 @@ void sim_step(struct sim_step_ctx *ctx)
/* FIXME: Ents never released when client disconnects */
struct sim_ent *control_ent = sim_ent_from_id(world, ent->player_control_ent);
if (!control_ent->valid) {
control_ent = spawn_test_player(ctx);
control_ent = spawn_test_employee(ctx);
control_ent->predictor = ent->id;
sim_ent_enable_prop(control_ent, SIM_ENT_PROP_CONTROLLED);
ent->player_control_ent = control_ent->id;
@ -568,7 +603,7 @@ void sim_step(struct sim_step_ctx *ctx)
}
struct sim_ent *camera_ent = sim_ent_from_id(world, ent->player_camera_ent);
if (!camera_ent->valid) {
camera_ent = spawn_test_player_camera(world, control_ent);
camera_ent = spawn_test_camera(world, control_ent);
camera_ent->predictor = ent->id;
ent->player_camera_ent = camera_ent->id;
}
@ -991,7 +1026,7 @@ void sim_step(struct sim_step_ctx *ctx)
* Create motor joints from ground friction (gravity)
* ========================== */
#if 0
#if 1
for (u64 ent_index = 0; ent_index < world->num_ents_reserved; ++ent_index) {
struct sim_ent *ent = &world->ents[ent_index];
if (!sim_ent_should_simulate(ent)) continue;

30
src/user.c
View File

@ -1851,19 +1851,29 @@ INTERNAL void generate_user_input_cmds(struct sim_client *user_input_client, u64
struct sim_snapshot *user_input_ss = sim_snapshot_alloc(user_input_client, prev_user_input_ss, tick);
struct sim_ent *user_input_root = sim_ent_from_id(user_input_ss, SIM_ENT_ROOT_ID);
/* Find / create local control cmd ent */
struct sim_ent *control_cmd_ent = sim_ent_find_first_match_one(user_input_ss, SIM_ENT_PROP_CMD_CONTROL);
if (!control_cmd_ent->valid) {
control_cmd_ent = sim_ent_alloc_sync_src(user_input_root);
control_cmd_ent->predictor = user_input_ss->local_player;
sim_ent_enable_prop(control_cmd_ent, SIM_ENT_PROP_CMD_CONTROL);
control_cmd_ent->predictor = user_input_client->player_id;
sim_ent_activate(control_cmd_ent, user_input_ss->tick);
struct sim_ent *control_cmd = sim_ent_find_first_match_one(user_input_ss, SIM_ENT_PROP_CMD);
if (!control_cmd->valid) {
control_cmd = sim_ent_alloc_sync_src(user_input_root);
control_cmd->cmd_kind = SIM_CMD_KIND_CONTROL;
control_cmd->predictor = user_input_client->player_id;
sim_ent_enable_prop(control_cmd, SIM_ENT_PROP_CMD);
sim_ent_activate(control_cmd, user_input_ss->tick);
}
/* Update local control cmd ent */
{
struct sys_lock lock = sys_mutex_lock_e(&G.user_sim_cmd_mutex);
control_cmd_ent->cmd_control = G.user_sim_cmd_control;
control_cmd_ent->cmd_hovered_ent = G.user_hovered_ent;
/* Update control cmd */
{
control_cmd->cmd_control = G.user_sim_cmd_control;
control_cmd->cmd_control_hovered_ent = G.user_hovered_ent;
}
#if 0
/* Create chat cmd */
if (G.user_sim_cmd_chat.len > 0) {
struct sim_ent *chat_cmd = sim_ent_alloc_sync_src(user_input_root);
chat_cmd->cmd_kind = SIM_CMD_KIND_CHAT;
//chat_cmd->chat_msg = ZI
}
#endif
++G.user_sim_cmd_gen;
sys_mutex_unlock(&lock);
}