creikey
/
flight
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix build warnings and remove V2 functions

Browse Source
main
Cameron Murphy Reikes 1 year ago
parent ba27f9b72f
commit af2bf08607
9 changed files with 179 additions and 291 deletions
Show Stats Download Patch File Download Diff File

4
.vscode/settings.json vendored
Unescape Escape View File

@ -52,6 +52,8 @@
"xtr1common": "c",
"xtree": "c",
"stdint.h": "c",
"ipsettings.h": "c"
"ipsettings.h": "c",
"cpvect.h": "c",
"miniaudio.h": "c"
}
}

1
Flight.vcxproj
Unescape Escape View File

@ -144,6 +144,7 @@
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>$(ProjectDir)\thirdparty\enet\include;$(ProjectDir)\thirdparty\Chipmunk2D\include\chipmunk;$(ProjectDir)\thirdparty;$(ProjectDir)\thirdparty\Chipmunk2D\include;$(ProjectDir)\thirdparty\minilzo;$(ProjectDir)\thirdparty\opus\include</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>

3
Flight.vcxproj.user
Unescape Escape View File

@ -4,8 +4,7 @@
<ShowAllFiles>false</ShowAllFiles>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LocalDebuggerCommandArguments>
</LocalDebuggerCommandArguments>
<LocalDebuggerCommandArguments>--host</LocalDebuggerCommandArguments>
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug No Host|x64'">

7
build_msvc.bat
Unescape Escape View File

@ -3,10 +3,11 @@
@REM what all the compile flags mean: https://learn.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-by-category?view=msvc-170
set OPUSLIB=%~dp0\thirdparty\opus\win32\VS2015\x64\Release\opus.lib
set OPUSLIB=%~dp0thirdparty\opus\win32\VS2015\x64\Release\opus.lib
WHERE %OPUSLIB%
IF %ERRORLEVEL% NEQ 0 ECHO ERROR Couldn't find %OPUSLIB% compile opus by opening the visual studio project in win32\VS2015 and building the release setting
if not exist %OPUSLIB% (
ECHO ERROR Couldn't find %OPUSLIB% compile opus by opening the visual studio project in win32\VS2015 and building the release setting
)
setlocal enabledelayedexpansion enableextensions
pushd thirdparty\Chipmunk2D\src

2
debugdraw.c
Unescape Escape View File

@ -48,7 +48,7 @@ void dbg_drawall()
case rect:
{
V2 center = commands[i].center;
V2 upper_left = V2add(center, (V2){.x = -size / 2.0, .y = -size / 2.0});
V2 upper_left = cpvadd(center, (V2){.x = -size / 2.0, .y = -size / 2.0});
sgp_draw_filled_rect((float)upper_left.x, (float)upper_left.y, (float)size, (float)size);
break;
}

239
gamestate.c
Unescape Escape View File

@ -30,16 +30,6 @@ void __flight_assert(bool cond, const char *file, int line, const char *cond_str
}
}
static V2 cp_to_v2(cpVect v)
{
return (V2){.x = (float)v.x, .y = (float)v.y};
}
static cpVect v2_to_cp(V2 v)
{
return cpv(v.x, v.y);
}
bool is_burning(Entity *missile)
{
assert(missile->is_missile);
@ -212,7 +202,7 @@ V2 entity_vel(GameState *gs, Entity *e)
if (e->is_player)
return player_vel(gs, e);
if (e->body != NULL)
return cp_to_v2(cpBodyGetVelocity(e->body));
return (cpBodyGetVelocity(e->body));
if (e->is_explosion)
return e->explosion_vel;
assert(false);
@ -229,29 +219,29 @@ static void on_missile_shape(cpShape *shape, cpContactPointSet *points, void *da
GameState *gs = entitys_gamestate(launcher);
assert(other->is_box || other->is_player || other->is_missile);
V2 to = V2sub(entity_pos(other), entity_pos(launcher));
V2 to = cpvsub(entity_pos(other), entity_pos(launcher));
bool should_attack = true;
if (other->is_box && box_grid(other) == box_grid(launcher))
should_attack = false;
if (other->owning_squad == launcher->owning_squad)
should_attack = false;
if (should_attack && V2length(to) < nearest_dist)
if (should_attack && cpvlength(to) < nearest_dist)
{
target_found = true;
nearest_dist = V2length(to);
nearest_dist = cpvlength(to);
// lookahead by their velocity
V2 rel_velocity = V2sub(entity_vel(gs, other), entity_vel(gs, launcher));
double dist = V2dist(entity_pos(other), entity_pos(launcher));
V2 rel_velocity = cpvsub(entity_vel(gs, other), entity_vel(gs, launcher));
double dist = cpvdist(entity_pos(other), entity_pos(launcher));
double time_of_travel = sqrt((2.0 * dist) / (MISSILE_BURN_FORCE / MISSILE_MASS));
V2 other_future_pos = V2add(entity_pos(other), V2scale(rel_velocity, time_of_travel));
V2 other_future_pos = cpvadd(entity_pos(other), cpvmult(rel_velocity, time_of_travel));
V2 adjusted_to = V2sub(other_future_pos, entity_pos(launcher));
V2 adjusted_to = cpvsub(other_future_pos, entity_pos(launcher));
to_face = V2angle(adjusted_to);
to_face = cpvangle(adjusted_to);
}
}
@ -259,7 +249,7 @@ LauncherTarget missile_launcher_target(GameState *gs, Entity *launcher)
{
to_face = 0.0;
cpBody *tmp = cpBodyNew(0.0, 0.0);
cpBodySetPosition(tmp, v2_to_cp(entity_pos(launcher)));
cpBodySetPosition(tmp, (entity_pos(launcher)));
cpShape *circle = cpCircleShapeNew(tmp, MISSILE_RANGE, cpv(0, 0));
nearest_dist = INFINITY;
@ -389,10 +379,10 @@ V2 player_vel(GameState *gs, Entity *player)
{
if (potential_seat != NULL)
{
return cp_to_v2(cpBodyGetVelocity(get_entity(gs, potential_seat->shape_parent_entity)->body));
return (cpBodyGetVelocity(get_entity(gs, potential_seat->shape_parent_entity)->body));
}
}
return cp_to_v2(cpBodyGetVelocity(player->body));
return (cpBodyGetVelocity(player->body));
}
void grid_create(GameState *gs, Entity *e)
@ -401,6 +391,7 @@ void grid_create(GameState *gs, Entity *e)
create_body(gs, e);
}
void entity_set_rotation(Entity *e, double rot)
{
assert(e->body != NULL);
@ -411,7 +402,7 @@ void entity_set_pos(Entity *e, V2 pos)
{
assert(e->is_grid);
assert(e->body != NULL);
cpBodySetPosition(e->body, v2_to_cp(pos));
cpBodySetPosition(e->body, (pos));
}
// size is (1/2 the width, 1/2 the height)
@ -462,7 +453,7 @@ void create_player(Player *player)
void create_missile(GameState *gs, Entity *e)
{
create_body(gs, e);
create_rectangle_shape(gs, e, e, (V2){0}, V2scale(MISSILE_COLLIDER_SIZE, 0.5), PLAYER_MASS);
create_rectangle_shape(gs, e, e, (V2){0}, cpvmult(MISSILE_COLLIDER_SIZE, 0.5), PLAYER_MASS);
e->is_missile = true;
}
@ -471,7 +462,7 @@ void create_player_entity(GameState *gs, Entity *e)
e->is_player = true;
e->no_save_to_disk = true;
create_body(gs, e);
create_rectangle_shape(gs, e, e, (V2){0}, V2scale(PLAYER_SIZE, 0.5), PLAYER_MASS);
create_rectangle_shape(gs, e, e, (V2){0}, cpvmult(PLAYER_SIZE, 0.5), PLAYER_MASS);
cpShapeSetFilter(e->shape, PLAYER_SHAPE_FILTER);
}
@ -508,7 +499,7 @@ V2 box_compass_vector(Entity *box)
assert(box->is_box);
V2 to_return = (V2){.x = 1.0, .y = 0.0};
to_return = V2rotate(to_return, rotangle(box->compass_rotation));
to_return = cpvspin(to_return, rotangle(box->compass_rotation));
return to_return;
}
@ -593,15 +584,15 @@ static void grid_correct_for_holes(GameState *gs, struct Entity *grid)
// @Robust @Speed faster method, not O(N^2), of getting the box
// in the direction currently needed
V2 compass_vect = box_compass_vector(N);
if (N->box_type == BoxMerge && N->wants_disconnect && V2equal(compass_vect, dir, 0.01))
if (N->box_type == BoxMerge && N->wants_disconnect && cpvnear(compass_vect, dir, 0.01))
{
}
else
{
V2 wanted_local_pos = V2add(cur_local_pos, V2scale(dir, BOX_SIZE));
V2 wanted_local_pos = cpvadd(cur_local_pos, cpvmult(dir, BOX_SIZE));
BOXES_ITER(gs, cur, grid)
{
if (V2equal(entity_shape_pos(cur), wanted_local_pos, 0.01))
if (cpvnear(entity_shape_pos(cur), wanted_local_pos, 0.01))
{
box_in_direction = get_id(gs, cur);
break;
@ -611,7 +602,7 @@ static void grid_correct_for_holes(GameState *gs, struct Entity *grid)
Entity *newbox = get_entity(gs, box_in_direction);
if (newbox != NULL && newbox->box_type == BoxMerge && newbox->wants_disconnect && V2equal(V2scale(box_compass_vector(newbox), -1.0), dir, 0.01))
if (newbox != NULL && newbox->box_type == BoxMerge && newbox->wants_disconnect && cpvnear(cpvmult(box_compass_vector(newbox), -1.0), dir, 0.01))
{
newbox = NULL;
}
@ -667,7 +658,7 @@ static void grid_correct_for_holes(GameState *gs, struct Entity *grid)
cur = next;
}
cpBodySetVelocity(new_grid->body, cpBodyGetVelocityAtWorldPoint(grid->body, v2_to_cp(grid_com(new_grid))));
cpBodySetVelocity(new_grid->body, cpBodyGetVelocityAtWorldPoint(grid->body, (grid_com(new_grid))));
cpBodySetAngularVelocity(new_grid->body, entity_angular_velocity(grid));
}
}
@ -705,7 +696,7 @@ static void on_damage(cpArbiter *arb, cpSpace *space, cpDataPointer userData)
for (int i = 0; i < count; i++)
{
cpVect collision_point = getPointFunc(arb, i);
V2 local_collision_point = cp_to_v2(cpBodyWorldToLocal(missile->body, collision_point));
V2 local_collision_point = (cpBodyWorldToLocal(missile->body, collision_point));
if (local_collision_point.x > MISSILE_COLLIDER_SIZE.x * 0.2)
{
missile->damage += MISSILE_DAMAGE_THRESHOLD * 2.0;
@ -717,7 +708,7 @@ static void on_damage(cpArbiter *arb, cpSpace *space, cpDataPointer userData)
// if(entity_a->is_missile) {getPointFunc = cpArbiterGetPointA;
// if(entity_b->is_missile) getPointFunc = cpArbiterGetPointB;
double damage = V2length(cp_to_v2(cpArbiterTotalImpulse(arb))) * COLLISION_DAMAGE_SCALING;
double damage = cpvlength((cpArbiterTotalImpulse(arb))) * COLLISION_DAMAGE_SCALING;
if (entity_a->is_box && entity_a->box_type == BoxExplosive)
entity_a->damage += 2.0 * EXPLOSION_DAMAGE_THRESHOLD;
@ -772,21 +763,21 @@ void destroy(GameState *gs)
// center of mass, not the literal position
V2 grid_com(Entity *grid)
{
return cp_to_v2(cpBodyLocalToWorld(grid->body, cpBodyGetCenterOfGravity(grid->body)));
return (cpBodyLocalToWorld(grid->body, cpBodyGetCenterOfGravity(grid->body)));
}
V2 grid_vel(Entity *grid)
{
return cp_to_v2(cpBodyGetVelocity(grid->body));
return (cpBodyGetVelocity(grid->body));
}
V2 grid_world_to_local(Entity *grid, V2 world)
{
return cp_to_v2(cpBodyWorldToLocal(grid->body, v2_to_cp(world)));
return (cpBodyWorldToLocal(grid->body, (world)));
}
V2 grid_local_to_world(Entity *grid, V2 local)
{
assert(grid->is_grid);
return cp_to_v2(cpBodyLocalToWorld(grid->body, v2_to_cp(local)));
return (cpBodyLocalToWorld(grid->body, (local)));
}
// returned snapped position is in world coordinates
V2 grid_snapped_box_pos(Entity *grid, V2 world)
@ -799,7 +790,7 @@ V2 grid_snapped_box_pos(Entity *grid, V2 world)
local.x *= BOX_SIZE;
local.y *= BOX_SIZE;
return cp_to_v2(cpBodyLocalToWorld(grid->body, v2_to_cp(local)));
return (cpBodyLocalToWorld(grid->body, (local)));
}
// for boxes does not include box's compass rotation
@ -826,7 +817,7 @@ Entity *box_grid(Entity *box)
// in local space
V2 entity_shape_pos(Entity *box)
{
return cp_to_v2(cpShapeGetCenterOfGravity(box->shape));
return (cpShapeGetCenterOfGravity(box->shape));
}
double entity_shape_mass(Entity *box)
{
@ -842,7 +833,7 @@ V2 entity_pos(Entity *e)
{
if (e->is_box)
{
return V2add(entity_pos(box_grid(e)), V2rotate(entity_shape_pos(e), entity_rotation(box_grid(e))));
return cpvadd(entity_pos(box_grid(e)), cpvspin(entity_shape_pos(e), entity_rotation(box_grid(e))));
}
else if (e->is_explosion)
{
@ -855,7 +846,7 @@ V2 entity_pos(Entity *e)
else
{
assert(e->body != NULL);
return cp_to_v2(cpBodyGetPosition(e->body));
return (cpBodyGetPosition(e->body));
}
}
@ -869,16 +860,16 @@ struct BodyData
void populate(cpBody *body, struct BodyData *data)
{
data->pos = cp_to_v2(cpBodyGetPosition(body));
data->vel = cp_to_v2(cpBodyGetVelocity(body));
data->pos = (cpBodyGetPosition(body));
data->vel = (cpBodyGetVelocity(body));
data->rotation = (float)cpBodyGetAngle(body);
data->angular_velocity = (float)cpBodyGetAngularVelocity(body);
}
void update_from(cpBody *body, struct BodyData *data)
{
cpBodySetPosition(body, v2_to_cp(data->pos));
cpBodySetVelocity(body, v2_to_cp(data->vel));
cpBodySetPosition(body, (data->pos));
cpBodySetVelocity(body, (data->vel));
cpBodySetAngle(body, data->rotation);
cpBodySetAngularVelocity(body, data->angular_velocity);
}
@ -1403,7 +1394,7 @@ SerMaybeFailure ser_server_to_client(SerState *ser, ServerToClient *s)
{
bool this_box_in_range = ser->save_or_load_from_disk;
this_box_in_range |= ser->for_player == NULL;
this_box_in_range |= (ser->for_player != NULL && V2distsqr(entity_pos(ser->for_player), entity_pos(cur_box)) < VISION_RADIUS * VISION_RADIUS); // only in vision radius
this_box_in_range |= (ser->for_player != NULL && cpvdistsq(entity_pos(ser->for_player), entity_pos(cur_box)) < VISION_RADIUS * VISION_RADIUS); // only in vision radius
if (DONT_SEND_BECAUSE_CLOAKED(cur_box))
this_box_in_range = false;
if (cur_box->always_visible)
@ -1687,7 +1678,7 @@ static void closest_point_callback_func(cpShape *shape, cpContactPointSet *point
if (closest_to_point_in_radius_filter_func != NULL && !closest_to_point_in_radius_filter_func(e))
return;
double dist = V2length(cp_to_v2(cpvsub(points->points[0].pointA, points->points[0].pointB)));
double dist = cpvlength((cpvsub(points->points[0].pointA, points->points[0].pointB)));
// double dist = -points->points[0].distance;
if (dist > closest_to_point_in_radius_result_largest_dist)
{
@ -1704,7 +1695,7 @@ Entity *closest_box_to_point_in_radius(struct GameState *gs, V2 point, double ra
closest_to_point_in_radius_result_largest_dist = 0.0;
closest_to_point_in_radius_filter_func = filter_func;
cpBody *tmpbody = cpBodyNew(0.0, 0.0);
cpShape *circle = cpCircleShapeNew(tmpbody, radius, v2_to_cp(point));
cpShape *circle = cpCircleShapeNew(tmpbody, radius, (point));
cpSpaceShapeQuery(gs->space, circle, closest_point_callback_func, NULL);
cpShapeFree(circle);
@ -1738,16 +1729,16 @@ static void explosion_callback_func(cpShape *shape, cpContactPointSet *points, v
cp_shape_entity(shape)->damage += cur_explosion_damage;
Entity *parent = get_entity(gs, cp_shape_entity(shape)->shape_parent_entity);
V2 from_pos = entity_pos(cp_shape_entity(shape));
V2 impulse = V2scale(V2normalize(V2sub(from_pos, explosion_origin)), explosion_push_strength);
V2 impulse = cpvmult(cpvnormalize(cpvsub(from_pos, explosion_origin)), explosion_push_strength);
assert(parent->body != NULL);
cpBodyApplyImpulseAtWorldPoint(parent->body, v2_to_cp(impulse), v2_to_cp(from_pos));
cpBodyApplyImpulseAtWorldPoint(parent->body, (impulse), (from_pos));
}
static void do_explosion(GameState *gs, Entity *explosion, double dt)
{
cpBody *tmpbody = cpBodyNew(0.0, 0.0);
cpShape *circle = cpCircleShapeNew(tmpbody, explosion->explosion_radius, v2_to_cp(explosion_origin));
cpShape *circle = cpCircleShapeNew(tmpbody, explosion->explosion_radius, (explosion_origin));
cur_explosion_damage = dt * EXPLOSION_DAMAGE_PER_SEC;
explosion_origin = explosion->explosion_pos;
@ -1764,7 +1755,7 @@ V2 box_facing_vector(Entity *box)
V2 to_return = (V2){.x = 1.0, .y = 0.0};
to_return = box_compass_vector(box);
to_return = V2rotate(to_return, box_rotation(box));
to_return = cpvspin(to_return, box_rotation(box));
return to_return;
}
@ -1774,10 +1765,10 @@ enum CompassRotation facing_vector_to_compass(Entity *grid_to_transplant_to, Ent
assert(grid_to_transplant_to->body != NULL);
assert(grid_to_transplant_to->is_grid);
V2 local_to_from = grid_world_to_local(grid_facing_vector_from, V2add(entity_pos(grid_facing_vector_from), facing_vector));
V2 local_to_from = grid_world_to_local(grid_facing_vector_from, cpvadd(entity_pos(grid_facing_vector_from), facing_vector));
Log("local %f %f\n", local_to_from.x, local_to_from.y);
V2 from_target = V2add(entity_pos(grid_to_transplant_to), facing_vector);
V2 from_target = cpvadd(entity_pos(grid_to_transplant_to), facing_vector);
V2 local_target = grid_world_to_local(grid_to_transplant_to, from_target);
V2 local_facing = local_target;
@ -1791,8 +1782,8 @@ enum CompassRotation facing_vector_to_compass(Entity *grid_to_transplant_to, Ent
double smallest_dist = INFINITY;
for (int i = 0; i < ARRLEN(dirs); i++)
{
V2 point = V2rotate((V2){.x = 1.0}, rotangle(dirs[i]));
double dist = V2dist(point, local_facing);
V2 point = cpvspin((V2){.x = 1.0}, rotangle(dirs[i]));
double dist = cpvdist(point, local_facing);
if (dist < smallest_dist)
{
smallest_dist = dist;
@ -1805,7 +1796,7 @@ enum CompassRotation facing_vector_to_compass(Entity *grid_to_transplant_to, Ent
V2 thruster_force(Entity *box)
{
return V2scale(box_facing_vector(box), -box->thrust * THRUSTER_FORCE);
return cpvmult(box_facing_vector(box), -box->thrust * THRUSTER_FORCE);
}
uint64_t tick(GameState *gs)
@ -1830,7 +1821,7 @@ V2 potentially_snap_hand_pos(GameState *gs, V2 world_hand_pos)
V2 get_world_hand_pos(GameState *gs, InputFrame *input, Entity *player)
{
return potentially_snap_hand_pos(gs, V2add(entity_pos(player), input->hand_pos));
return potentially_snap_hand_pos(gs, cpvadd(entity_pos(player), input->hand_pos));
}
bool batteries_have_capacity_for(GameState *gs, Entity *grid, double *energy_left_over, double energy_to_use)
@ -1903,12 +1894,12 @@ V2 sun_gravity_accel_for_entity(Entity *entity_with_gravity, Entity *sun)
return (V2){0};
#else
if (V2length(V2sub(entity_pos(entity_with_gravity), entity_pos(sun))) > sun_dist_no_gravity(sun))
if (cpvlength(cpvsub(entity_pos(entity_with_gravity), entity_pos(sun))) > sun_dist_no_gravity(sun))
return (V2){0};
V2 rel_vector = V2sub(entity_pos(entity_with_gravity), entity_pos(sun));
V2 rel_vector = cpvsub(entity_pos(entity_with_gravity), entity_pos(sun));
double mass = entity_mass(entity_with_gravity);
assert(mass != 0.0);
double distance_sqr = V2lengthsqr(rel_vector);
double distance_sqr = cpvlengthsq(rel_vector);
// return (GRAVITY_CONSTANT * (SUN_MASS * mass / (distance * distance))) / mass;
// the mass divides out
@ -1920,15 +1911,15 @@ V2 sun_gravity_accel_for_entity(Entity *entity_with_gravity, Entity *sun)
if (distance_sqr <= sun->sun_radius * 0.25)
accel_magnitude = 0.0;
}
V2 towards_sun = V2normalize(V2scale(rel_vector, -1.0));
return V2scale(towards_sun, accel_magnitude);
V2 towards_sun = cpvnormalize(cpvmult(rel_vector, -1.0));
return cpvmult(towards_sun, accel_magnitude);
#endif // NO_GRAVITY
}
void entity_set_velocity(Entity *e, V2 vel)
{
if (e->body != NULL)
cpBodySetVelocity(e->body, v2_to_cp(vel));
cpBodySetVelocity(e->body, (vel));
else if (e->is_sun)
e->sun_vel = vel;
else
@ -1941,20 +1932,20 @@ void entity_ensure_in_orbit(GameState *gs, Entity *e)
SUNS_ITER(gs)
{
V2 gravity_accel = sun_gravity_accel_for_entity(e, i.sun);
if (V2length(gravity_accel) > 0.0)
if (cpvlength(gravity_accel) > 0.0)
{
double dist = V2length(V2sub(entity_pos(e), entity_pos(i.sun)));
V2 orthogonal_to_gravity = V2normalize(V2rotate(gravity_accel, PI / 2.0));
V2 wanted_vel = V2scale(orthogonal_to_gravity, sqrt(V2length(gravity_accel) * dist));
double dist = cpvlength(cpvsub(entity_pos(e), entity_pos(i.sun)));
V2 orthogonal_to_gravity = cpvnormalize(cpvspin(gravity_accel, PI / 2.0));
V2 wanted_vel = cpvmult(orthogonal_to_gravity, sqrt(cpvlength(gravity_accel) * dist));
total_new_vel = cpvadd(total_new_vel, v2_to_cp(wanted_vel));
total_new_vel = cpvadd(total_new_vel, (wanted_vel));
}
}
entity_set_velocity(e, cp_to_v2(total_new_vel));
entity_set_velocity(e, (total_new_vel));
// cpVect pos = v2_to_cp(V2sub(entity_pos(e), SUN_POS));
// cpVect pos = (cpvsub(entity_pos(e), SUN_POS));
// cpFloat r = cpvlength(pos);
// cpFloat v = cpfsqrt(sun_gravity_accel_at_point(cp_to_v2(pos), e) / r) / r;
// cpFloat v = cpfsqrt(sun_gravity_accel_at_point((pos), e) / r) / r;
// cpBodySetVelocity(e->body, cpvmult(cpvperp(pos), v));
}
@ -1962,7 +1953,7 @@ V2 box_vel(Entity *box)
{
assert(box->is_box);
Entity *grid = box_grid(box);
return cp_to_v2(cpBodyGetVelocityAtWorldPoint(grid->body, v2_to_cp(entity_pos(box))));
return (cpBodyGetVelocityAtWorldPoint(grid->body, (entity_pos(box))));
}
void create_bomb_station(GameState *gs, V2 pos, enum BoxType platonic_type)
@ -2078,7 +2069,7 @@ void create_initial_world(GameState *gs)
Entity *grid = new_entity(gs);
grid_create(gs, grid);
entity_set_pos(grid, V2add(from, V2rotate((V2){.x = -BOX_SIZE * 9.0}, theta)));
entity_set_pos(grid, cpvadd(from, cpvspin((V2){.x = -BOX_SIZE * 9.0}, theta)));
cpBodySetAngle(grid->body, theta + PI);
rot = Left;
BOX_AT_TYPE(grid, ((V2){0.0, 0.0}), BoxMerge);
@ -2098,7 +2089,7 @@ void create_initial_world(GameState *gs)
BOX_AT_TYPE(grid, ((V2){0.0, 0.0}), BoxMerge);
rot = Up;
BOX_AT_TYPE(grid, ((V2){0.0, BOX_SIZE}), BoxMerge);
cpBodySetVelocity(grid->body, v2_to_cp(V2rotate((V2){-0.4, 0.0}, theta)));
cpBodySetVelocity(grid->body, (cpvspin((V2){-0.4, 0.0}, theta)));
entity_ensure_in_orbit(gs, grid);
}
@ -2113,9 +2104,9 @@ void create_initial_world(GameState *gs)
void exit_seat(GameState *gs, Entity *seat_in, Entity *p)
{
V2 pilot_seat_exit_spot = V2add(entity_pos(seat_in), V2scale(box_facing_vector(seat_in), BOX_SIZE));
cpBodySetPosition(p->body, v2_to_cp(pilot_seat_exit_spot));
// cpBodySetVelocity(p->body, v2_to_cp(player_vel(gs, p)));
V2 pilot_seat_exit_spot = cpvadd(entity_pos(seat_in), cpvmult(box_facing_vector(seat_in), BOX_SIZE));
cpBodySetPosition(p->body, (pilot_seat_exit_spot));
// cpBodySetVelocity(p->body, (player_vel(gs, p)));
cpBodySetVelocity(p->body, cpBodyGetVelocity(box_grid(seat_in)->body));
}
@ -2140,17 +2131,17 @@ void process(GameState *gs, double dt)
Entity *other_sun = i.sun;
if (other_sun != from_sun)
{
accel = V2add(accel, sun_gravity_accel_for_entity(from_sun, other_sun));
accel = cpvadd(accel, sun_gravity_accel_for_entity(from_sun, other_sun));
}
}
#ifndef NO_GRAVITY
from_sun->sun_vel = V2add(from_sun->sun_vel, V2scale(accel, dt));
from_sun->sun_pos = V2add(from_sun->sun_pos, V2scale(from_sun->sun_vel, dt));
from_sun->sun_vel = cpvadd(from_sun->sun_vel, cpvmult(accel, dt));
from_sun->sun_pos = cpvadd(from_sun->sun_pos, cpvmult(from_sun->sun_vel, dt));
if (V2length(from_sun->sun_pos) >= INSTANT_DEATH_DISTANCE_FROM_CENTER)
if (cpvlength(from_sun->sun_pos) >= INSTANT_DEATH_DISTANCE_FROM_CENTER)
{
from_sun->sun_vel = V2scale(from_sun->sun_vel, -0.8);
from_sun->sun_pos = V2scale(V2normalize(from_sun->sun_pos), INSTANT_DEATH_DISTANCE_FROM_CENTER);
from_sun->sun_vel = cpvmult(from_sun->sun_vel, -0.8);
from_sun->sun_pos = cpvmult(cpvnormalize(from_sun->sun_pos), INSTANT_DEATH_DISTANCE_FROM_CENTER);
}
#endif
}
@ -2226,7 +2217,7 @@ void process(GameState *gs, double dt)
p->damage = 0.0;
#endif
// update gold win condition
if (V2length(V2sub(cp_to_v2(cpBodyGetPosition(p->body)), gs->goldpos)) < GOLD_COLLECT_RADIUS)
if (cpvlength(cpvsub((cpBodyGetPosition(p->body)), gs->goldpos)) < GOLD_COLLECT_RADIUS)
{
p->goldness += 0.1;
p->damage = 0.0;
@ -2241,7 +2232,7 @@ void process(GameState *gs, double dt)
if (seat_maybe_in == NULL) // not in any seat
{
cpPointQueryInfo query_info = {0};
cpShape *result = cpSpacePointQueryNearest(gs->space, v2_to_cp(world_hand_pos), 0.1, cpShapeFilterNew(CP_NO_GROUP, CP_ALL_CATEGORIES, BOXES), &query_info);
cpShape *result = cpSpacePointQueryNearest(gs->space, (world_hand_pos), 0.1, cpShapeFilterNew(CP_NO_GROUP, CP_ALL_CATEGORIES, BOXES), &query_info);
if (result != NULL)
{
Entity *potential_seat = cp_shape_entity(result);
@ -2290,9 +2281,9 @@ void process(GameState *gs, double dt)
// no cheating by making movement bigger than length 1
V2 movement_this_tick = (V2){0};
double rotation_this_tick = 0.0;
if (V2length(player->input.movement) > 0.0)
if (cpvlength(player->input.movement) > 0.0)
{
movement_this_tick = V2scale(V2normalize(player->input.movement), clamp(V2length(player->input.movement), 0.0, 1.0));
movement_this_tick = cpvmult(cpvnormalize(player->input.movement), clamp(cpvlength(player->input.movement), 0.0, 1.0));
player->input.movement = (V2){0};
}
if (fabs(player->input.rotation) > 0.0)
@ -2318,17 +2309,17 @@ void process(GameState *gs, double dt)
if (seat_inside_of == NULL)
{
cpShapeSetFilter(p->shape, PLAYER_SHAPE_FILTER);
cpBodyApplyForceAtWorldPoint(p->body, v2_to_cp(V2scale(movement_this_tick, PLAYER_JETPACK_FORCE)), cpBodyGetPosition(p->body));
cpBodyApplyForceAtWorldPoint(p->body, (cpvmult(movement_this_tick, PLAYER_JETPACK_FORCE)), cpBodyGetPosition(p->body));
cpBodySetTorque(p->body, rotation_this_tick * PLAYER_JETPACK_TORQUE);
p->damage += V2length(movement_this_tick) * dt * PLAYER_JETPACK_SPICE_PER_SECOND;
p->damage += cpvlength(movement_this_tick) * dt * PLAYER_JETPACK_SPICE_PER_SECOND;
p->damage += fabs(rotation_this_tick) * dt * PLAYER_JETPACK_ROTATION_ENERGY_PER_SECOND;
}
else
{
assert(seat_inside_of->is_box);
cpShapeSetFilter(p->shape, CP_SHAPE_FILTER_NONE); // no collisions while in a seat
cpBodySetPosition(p->body, v2_to_cp(entity_pos(seat_inside_of)));
cpBodySetVelocity(p->body, v2_to_cp(box_vel(seat_inside_of)));
cpBodySetPosition(p->body, (entity_pos(seat_inside_of)));
cpBodySetVelocity(p->body, (box_vel(seat_inside_of)));
// share cloaking with box
p->time_was_last_cloaked = seat_inside_of->time_was_last_cloaked;
@ -2340,16 +2331,16 @@ void process(GameState *gs, double dt)
Entity *g = get_entity(gs, seat_inside_of->shape_parent_entity);
V2 target_direction = {0};
if (V2length(movement_this_tick) > 0.0)
if (cpvlength(movement_this_tick) > 0.0)
{
target_direction = V2normalize(movement_this_tick);
target_direction = cpvnormalize(movement_this_tick);
}
BOXES_ITER(gs, cur, g)
{
if (cur->box_type == BoxThruster)
{
double wanted_thrust = -V2dot(target_direction, box_facing_vector(cur));
double wanted_thrust = -cpvdot(target_direction, box_facing_vector(cur));
wanted_thrust = clamp01(wanted_thrust);
cur->wanted_thrust = wanted_thrust;
}
@ -2372,7 +2363,7 @@ void process(GameState *gs, double dt)
// @Robust sanitize this input so player can't build on any grid in the world
Entity *target_grid = grid_to_build_on(gs, world_hand_pos);
cpShape *maybe_box_to_destroy = cpSpacePointQueryNearest(gs->space, v2_to_cp(world_build), 0.01, cpShapeFilterNew(CP_NO_GROUP, CP_ALL_CATEGORIES, BOXES), &info);
cpShape *maybe_box_to_destroy = cpSpacePointQueryNearest(gs->space, (world_build), 0.01, cpShapeFilterNew(CP_NO_GROUP, CP_ALL_CATEGORIES, BOXES), &info);
if (maybe_box_to_destroy != NULL)
{
Entity *cur_box = cp_shape_entity(maybe_box_to_destroy);
@ -2395,7 +2386,7 @@ void process(GameState *gs, double dt)
Entity *new_grid = new_entity(gs);
grid_create(gs, new_grid);
entity_set_pos(new_grid, world_build);
cpBodySetVelocity(new_grid->body, v2_to_cp(player_vel(gs, p)));
cpBodySetVelocity(new_grid->body, (player_vel(gs, p)));
target_grid = new_grid;
created_box_position = (V2){0};
}
@ -2435,7 +2426,7 @@ void process(GameState *gs, double dt)
// instant death
{
cpFloat dist_from_center = cpvlengthsq(v2_to_cp(entity_pos(e)));
cpFloat dist_from_center = cpvlengthsq((entity_pos(e)));
if (e->body != NULL && dist_from_center > (INSTANT_DEATH_DISTANCE_FROM_CENTER * INSTANT_DEATH_DISTANCE_FROM_CENTER))
{
bool platonic_found = false;
@ -2469,11 +2460,11 @@ void process(GameState *gs, double dt)
{
SUNS_ITER(gs)
{
cpVect pos_rel_sun = v2_to_cp(V2sub(entity_pos(e), (entity_pos(i.sun))));
cpVect pos_rel_sun = (cpvsub(entity_pos(e), (entity_pos(i.sun))));
cpFloat sqdist = cpvlengthsq(pos_rel_sun);
if (!e->is_grid) // grids aren't damaged (this edge case sucks!)
{
sqdist = cpvlengthsq(cpvsub(v2_to_cp(entity_pos(e)), v2_to_cp(entity_pos(i.sun))));
sqdist = cpvlengthsq(cpvsub((entity_pos(e)), (entity_pos(i.sun))));
if (sqdist < (i.sun->sun_radius * i.sun->sun_radius))
{
e->damage += 10.0 * dt;
@ -2484,8 +2475,8 @@ void process(GameState *gs, double dt)
{
V2 accel = sun_gravity_accel_for_entity(e, i.sun);
V2 new_vel = entity_vel(gs, e);
new_vel = V2add(new_vel, V2scale(accel, dt));
cpBodySetVelocity(e->body, v2_to_cp(new_vel));
new_vel = cpvadd(new_vel, cpvmult(accel, dt));
cpBodySetVelocity(e->body, (new_vel));
}
}
}
@ -2493,7 +2484,7 @@ void process(GameState *gs, double dt)
if (e->is_explosion)
{
e->explosion_progress += dt;
e->explosion_pos = V2add(e->explosion_pos, V2scale(e->explosion_vel, dt));
e->explosion_pos = cpvadd(e->explosion_pos, cpvmult(e->explosion_vel, dt));
do_explosion(gs, e, dt);
if (e->explosion_progress >= EXPLOSION_TIME)
{
@ -2506,14 +2497,14 @@ void process(GameState *gs, double dt)
if (is_burning(e))
{
e->time_burned_for += dt;
cpBodyApplyForceAtWorldPoint(e->body, v2_to_cp(V2rotate((V2){.x = MISSILE_BURN_FORCE, .y = 0.0}, entity_rotation(e))), v2_to_cp(entity_pos(e)));
cpBodyApplyForceAtWorldPoint(e->body, (cpvspin((V2){.x = MISSILE_BURN_FORCE, .y = 0.0}, entity_rotation(e))), (entity_pos(e)));
}
if (e->damage >= MISSILE_DAMAGE_THRESHOLD && e->time_burned_for >= MISSILE_ARM_TIME)
{
Entity *explosion = new_entity(gs);
explosion->is_explosion = true;
explosion->explosion_pos = entity_pos(e);
explosion->explosion_vel = cp_to_v2(cpBodyGetVelocity(e->body));
explosion->explosion_vel = (cpBodyGetVelocity(e->body));
explosion->explosion_push_strength = MISSILE_EXPLOSION_PUSH;
explosion->explosion_radius = MISSILE_EXPLOSION_RADIUS;
entity_destroy(gs, e);
@ -2557,29 +2548,29 @@ void process(GameState *gs, double dt)
Entity *other_grid = box_grid(other_merge);
// the merges are near eachother, but are they facing eachother...
bool from_facing_other = V2dot(box_facing_vector(from_merge), V2normalize(V2sub(entity_pos(other_merge), entity_pos(from_merge)))) > 0.8;
bool other_facing_from = V2dot(box_facing_vector(other_merge), V2normalize(V2sub(entity_pos(from_merge), entity_pos(other_merge)))) > 0.8;
bool from_facing_other = cpvdot(box_facing_vector(from_merge), cpvnormalize(cpvsub(entity_pos(other_merge), entity_pos(from_merge)))) > 0.8;
bool other_facing_from = cpvdot(box_facing_vector(other_merge), cpvnormalize(cpvsub(entity_pos(from_merge), entity_pos(other_merge)))) > 0.8;
// using this stuff to detect if when the other grid's boxes are snapped, they'll be snapped
// to be next to the from merge box
V2 actual_new_pos = grid_snapped_box_pos(from_grid, entity_pos(other_merge));
V2 needed_new_pos = V2add(entity_pos(from_merge), V2scale(box_facing_vector(from_merge), BOX_SIZE));
if (from_facing_other && other_facing_from && V2equal(needed_new_pos, actual_new_pos, 0.01))
V2 needed_new_pos = cpvadd(entity_pos(from_merge), cpvmult(box_facing_vector(from_merge), BOX_SIZE));
if (from_facing_other && other_facing_from && cpvnear(needed_new_pos, actual_new_pos, 0.01))
{
// do the merge
V2 facing_vector_needed = V2scale(box_facing_vector(from_merge), -1.0);
V2 facing_vector_needed = cpvmult(box_facing_vector(from_merge), -1.0);
V2 current_facing_vector = box_facing_vector(other_merge);
double angle_diff = V2anglediff(current_facing_vector, facing_vector_needed);
double angle_diff = cpvanglediff(current_facing_vector, facing_vector_needed);
if (angle_diff == FLT_MIN)
angle_diff = 0.0;
assert(!isnan(angle_diff));
cpBodySetAngle(other_grid->body, cpBodyGetAngle(other_grid->body) + angle_diff);
V2 moved_because_angle_change = V2sub(needed_new_pos, entity_pos(other_merge));
cpBodySetPosition(other_grid->body, v2_to_cp(V2add(entity_pos(other_grid), moved_because_angle_change)));
V2 moved_because_angle_change = cpvsub(needed_new_pos, entity_pos(other_merge));
cpBodySetPosition(other_grid->body, (cpvadd(entity_pos(other_grid), moved_because_angle_change)));
// V2 snap_movement_vect = V2sub(actual_new_pos, entity_pos(other_merge));
// V2 snap_movement_vect = cpvsub(actual_new_pos, entity_pos(other_merge));
V2 snap_movement_vect = (V2){0};
Entity *cur = get_entity(gs, other_grid->boxes);
@ -2591,7 +2582,7 @@ void process(GameState *gs, double dt)
V2 world = entity_pos(cur);
enum CompassRotation new_rotation = facing_vector_to_compass(from_grid, other_grid, box_facing_vector(cur));
cur->compass_rotation = new_rotation;
V2 new_cur_pos = grid_snapped_box_pos(from_grid, V2add(snap_movement_vect, world));
V2 new_cur_pos = grid_snapped_box_pos(from_grid, cpvadd(snap_movement_vect, world));
box_create(gs, cur, from_grid, grid_world_to_local(from_grid, new_cur_pos)); // destroys next/prev fields on cur
assert(box_grid(cur) == box_grid(from_merge));
cur = next;
@ -2617,10 +2608,10 @@ void process(GameState *gs, double dt)
cur_box->sun_amount = 0.0;
SUNS_ITER(gs)
{
double new_sun = clamp01(fabs(V2dot(box_facing_vector(cur_box), V2normalize(V2sub(entity_pos(i.sun), entity_pos(cur_box))))));
double new_sun = clamp01(fabs(cpvdot(box_facing_vector(cur_box), cpvnormalize(cpvsub(entity_pos(i.sun), entity_pos(cur_box))))));
// less sun the farther away you are!
new_sun *= lerp(1.0, 0.0, clamp01(V2length(V2sub(entity_pos(cur_box), entity_pos(i.sun))) / sun_dist_no_gravity(i.sun)));
new_sun *= lerp(1.0, 0.0, clamp01(cpvlength(cpvsub(entity_pos(cur_box), entity_pos(i.sun))) / sun_dist_no_gravity(i.sun)));
cur_box->sun_amount += new_sun;
}
energy_to_add += cur_box->sun_amount * SOLAR_ENERGY_PER_SECOND * dt;
@ -2657,7 +2648,7 @@ void process(GameState *gs, double dt)
double energy_unconsumed = batteries_use_energy(gs, grid, &non_battery_energy_left_over, energy_to_consume);
cur_box->thrust = (1.0 - energy_unconsumed / energy_to_consume) * cur_box->wanted_thrust;
if (cur_box->thrust >= 0.0)
cpBodyApplyForceAtWorldPoint(grid->body, v2_to_cp(thruster_force(cur_box)), v2_to_cp(entity_pos(cur_box)));
cpBodyApplyForceAtWorldPoint(grid->body, (thruster_force(cur_box)), (entity_pos(cur_box)));
}
}
if (cur_box->box_type == BoxGyroscope)
@ -2696,7 +2687,7 @@ void process(GameState *gs, double dt)
{
cur_box->cloaking_power = lerp(cur_box->cloaking_power, 1.0, dt * 3.0);
cpBody *tmp = cpBodyNew(0.0, 0.0);
cpBodySetPosition(tmp, v2_to_cp(entity_pos(cur_box)));
cpBodySetPosition(tmp, (entity_pos(cur_box)));
cpBodySetAngle(tmp, entity_rotation(cur_box));
// subtract a little from the panel size so that boxes just at the boundary of the panel
// aren't (sometimes cloaked)/(sometimes not) from floating point imprecision
@ -2724,9 +2715,9 @@ void process(GameState *gs, double dt)
create_missile(gs, new_missile);
new_missile->owning_squad = cur_box->owning_squad; // missiles have teams and attack eachother!
double missile_spawn_dist = sqrt((BOX_SIZE / 2.0) * (BOX_SIZE / 2.0) * 2.0) + MISSILE_COLLIDER_SIZE.x / 2.0 + 0.1;
cpBodySetPosition(new_missile->body, v2_to_cp(V2add(entity_pos(cur_box), V2rotate((V2){.x = missile_spawn_dist, 0.0}, target.facing_angle))));
cpBodySetPosition(new_missile->body, (cpvadd(entity_pos(cur_box), cpvspin((V2){.x = missile_spawn_dist, 0.0}, target.facing_angle))));
cpBodySetAngle(new_missile->body, target.facing_angle);
cpBodySetVelocity(new_missile->body, v2_to_cp(box_vel(cur_box)));
cpBodySetVelocity(new_missile->body, (box_vel(cur_box)));
}
}
if (cur_box->box_type == BoxScanner)
@ -2748,9 +2739,9 @@ void process(GameState *gs, double dt)
for (int i = 0; i < MAX_BOX_TYPES; i++)
{
V2 cur_pos = gs->platonic_positions[i];
if (V2length(cur_pos) > 0.0) // zero is uninitialized, the platonic solid doesn't exist (probably) @Robust do better
if (cpvlength(cur_pos) > 0.0) // zero is uninitialized, the platonic solid doesn't exist (probably) @Robust do better
{
double length_to_cur = V2dist(from_pos, cur_pos);
double length_to_cur = cpvdist(from_pos, cur_pos);
if (length_to_cur < nearest_dist)
{
nearest_dist = length_to_cur;
@ -2760,7 +2751,7 @@ void process(GameState *gs, double dt)
}
if (nearest_dist < INFINITY)
{
cur_box->platonic_nearest_direction = V2normalize(V2sub(nearest, from_pos));
cur_box->platonic_nearest_direction = cpvnormalize(cpvsub(nearest, from_pos));
cur_box->platonic_detection_strength = fmax(0.1, 1.0 - fmin(1.0, nearest_dist / 100.0));
}
else

62
main.c
Unescape Escape View File

@ -709,7 +709,7 @@ static void draw_color_rect_centered(V2 center, double size)
static void draw_texture_rectangle_centered(V2 center, V2 width_height)
{
V2 halfsize = V2scale(width_height, 0.5);
V2 halfsize = cpvmult(width_height, 0.5);
draw_textured_rect(center.x - halfsize.x, center.y - halfsize.y, width_height.x, width_height.y);
}
static void draw_texture_centered(V2 center, double size)
@ -739,8 +739,8 @@ static void draw_circle(V2 point, double radius)
.y = sin(progress * 2.0 * PI) * radius});
lines[i].b = V2point((V2){.x = cos(next_progress * 2.0 * PI) * radius,
.y = sin(next_progress * 2.0 * PI) * radius});
lines[i].a = V2point(V2add(pointV2(lines[i].a), point));
lines[i].b = V2point(V2add(pointV2(lines[i].b), point));
lines[i].a = V2point(cpvadd(pointV2(lines[i].a), point));
lines[i].b = V2point(cpvadd(pointV2(lines[i].b), point));
}
sgp_draw_lines(lines, POINTS);
}
@ -768,20 +768,20 @@ static void setup_hueshift(enum Squad squad)
static V2 screen_to_world(double width, double height, V2 screen)
{
V2 world = screen;
world = V2sub(world, (V2){.x = width / 2.0, .y = height / 2.0});
world = cpvsub(world, (V2){.x = width / 2.0, .y = height / 2.0});
world.x /= zoom;
world.y /= -zoom;
world = V2add(world, camera_pos);
world = cpvadd(world, camera_pos);
return world;
}
static V2 world_to_screen(double width, double height, V2 world)
{
V2 screen = world;
screen = V2sub(screen, camera_pos);
screen = cpvsub(screen, camera_pos);
screen.x *= zoom;
screen.y *= -zoom;
screen = V2add(screen, (V2){.x = width / 2.0, .y = height / 2.0});
screen = cpvadd(screen, (V2){.x = width / 2.0, .y = height / 2.0});
return screen;
}
@ -918,9 +918,9 @@ static void ui(bool draw, double dt, double width, double height)
double buttons_y = invite_y + size / 2.0;
bool yes_hovered =
invited && V2dist(mouse_pos, (V2){yes_x, buttons_y}) < yes_size / 2.0;
invited && cpvdist(mouse_pos, (V2){yes_x, buttons_y}) < yes_size / 2.0;
bool no_hovered =
invited && V2dist(mouse_pos, (V2){no_x, buttons_y}) < no_size / 2.0;
invited && cpvdist(mouse_pos, (V2){no_x, buttons_y}) < no_size / 2.0;
yes_size = lerp(yes_size, yes_hovered ? 75.0 : 50.0, dt * 9.0);
no_size = lerp(no_size, no_hovered ? 75.0 : 50.0, dt * 9.0);
@ -991,14 +991,14 @@ static void ui(bool draw, double dt, double width, double height)
{
V2 top_of_head = world_to_screen(
width, height,
V2add(entity_pos(inviting),
cpvadd(entity_pos(inviting),
(V2){.y = player_scaling * PLAYER_SIZE.y / 2.0}));
V2 pos = V2add(top_of_head, (V2){.y = -30.0});
V2 to_mouse = V2sub(mouse_pos,
V2 pos = cpvadd(top_of_head, (V2){.y = -30.0});
V2 to_mouse = cpvsub(mouse_pos,
world_to_screen(width, height, entity_pos(inviting)));
bool selecting_to_invite =
V2dot(V2normalize(to_mouse), (V2){0.0, -1.0}) > 0.5 &&
V2length(to_mouse) > 15.0;
cpvdot(cpvnormalize(to_mouse), (V2){0.0, -1.0}) > 0.5 &&
cpvlength(to_mouse) > 15.0;
if (!mousedown[SAPP_MOUSEBUTTON_RIGHT])
{
if (selecting_to_invite)
@ -1061,7 +1061,7 @@ static void ui(bool draw, double dt, double width, double height)
target_pos.y = 200.0;
target_rot = lerp(-PI / 3.0, PI / 3.0, flag_progress) + PI / 2.0;
}
flag_pos[i] = V2lerp(flag_pos[i], target_pos, dt * 5.0);
flag_pos[i] = cpvlerp(flag_pos[i], target_pos, dt * 5.0);
flag_rot[i] = lerp_angle(flag_rot[i], target_rot, dt * 5.0);
}
@ -1108,7 +1108,7 @@ static void ui(bool draw, double dt, double width, double height)
double size = 128.0;
bool hovering =
V2dist(mouse_pos, flag_pos[i]) < size * 0.25 && this_squad_available;
cpvdist(mouse_pos, flag_pos[i]) < size * 0.25 && this_squad_available;
if (!choosing_flags && hovering && build_pressed)
{
@ -1354,7 +1354,7 @@ static void draw_dots(V2 camera_pos, double gap)
V2 star = (V2){(float)x * gap, (float)y * gap};
star.x += hash11(star.x * 100.0 + star.y * 67.0) * gap;
star.y += hash11(star.y * 93.0 + star.x * 53.0) * gap;
if (V2lengthsqr(V2sub(star, camera_pos)) > VISION_RADIUS * VISION_RADIUS)
if (cpvlengthsq(cpvsub(star, camera_pos)) > VISION_RADIUS * VISION_RADIUS)
continue;
sgp_draw_point((float)star.x, (float)star.y);
@ -1367,8 +1367,8 @@ static V2 get_global_hand_pos(V2 world_mouse_pos, bool *hand_at_arms_length)
if (myentity() == NULL)
return (V2){0};
V2 global_hand_pos = V2sub(world_mouse_pos, entity_pos(myentity()));
double hand_len = V2length(global_hand_pos);
V2 global_hand_pos = cpvsub(world_mouse_pos, entity_pos(myentity()));
double hand_len = cpvlength(global_hand_pos);
if (hand_len > MAX_HAND_REACH)
{
*hand_at_arms_length = true;
@ -1378,8 +1378,8 @@ static V2 get_global_hand_pos(V2 world_mouse_pos, bool *hand_at_arms_length)
{
*hand_at_arms_length = false;
}
global_hand_pos = V2scale(V2normalize(global_hand_pos), hand_len);
global_hand_pos = V2add(global_hand_pos, entity_pos(myentity()));
global_hand_pos = cpvmult(cpvnormalize(global_hand_pos), hand_len);
global_hand_pos = cpvadd(global_hand_pos, entity_pos(myentity()));
return global_hand_pos;
}
static void frame(void)
@ -1562,7 +1562,7 @@ static void frame(void)
if (myentity() != NULL)
{
local_hand_pos = V2sub(global_hand_pos, entity_pos(myentity()));
local_hand_pos = cpvsub(global_hand_pos, entity_pos(myentity()));
}
// process player interaction (squad invites)
@ -1570,7 +1570,7 @@ static void frame(void)
ENTITIES_ITER(cur)
{
if (cur != myentity() && cur->is_player &&
has_point(centered_at(entity_pos(cur), V2scale(PLAYER_SIZE, player_scaling)), world_mouse_pos))
has_point(centered_at(entity_pos(cur), cpvmult(PLAYER_SIZE, player_scaling)), world_mouse_pos))
{
maybe_inviting_this_player = get_id(&gs, cur);
interact_pressed = false;
@ -1591,8 +1591,8 @@ static void frame(void)
.x = (float)keydown[SAPP_KEYCODE_D] - (float)keydown[SAPP_KEYCODE_A],
.y = (float)keydown[SAPP_KEYCODE_W] - (float)keydown[SAPP_KEYCODE_S],
};
if (V2length(input) > 0.0)
input = V2normalize(input);
if (cpvlength(input) > 0.0)
input = cpvnormalize(input);
cur_input_frame.movement = input;
cur_input_frame.rotation = (float)keydown[SAPP_KEYCODE_E] - (float)keydown[SAPP_KEYCODE_Q];
@ -1745,7 +1745,7 @@ static void frame(void)
#if 1 // space background
transform_scope
{
V2 scaled_camera_pos = V2scale(
V2 scaled_camera_pos = cpvmult(
camera_pos, 0.0005); // this is how strong/weak the parallax is
translate(-scaled_camera_pos.x, -scaled_camera_pos.y);
set_color(WHITE);
@ -1762,7 +1762,7 @@ static void frame(void)
}
transform_scope
{
V2 scaled_camera_pos = V2scale(
V2 scaled_camera_pos = cpvmult(
camera_pos, 0.005); // this is how strong/weak the parallax is
translate(-scaled_camera_pos.x, -scaled_camera_pos.y);
set_color(WHITE);
@ -1782,14 +1782,14 @@ static void frame(void)
#if 1 // parallaxed dots
transform_scope
{
V2 scaled_camera_pos = V2scale(camera_pos, 0.25);
V2 scaled_camera_pos = cpvmult(camera_pos, 0.25);
translate(-scaled_camera_pos.x, -scaled_camera_pos.y);
set_color(WHITE);
draw_dots(scaled_camera_pos, 3.0);
}
transform_scope
{
V2 scaled_camera_pos = V2scale(camera_pos, 0.5);
V2 scaled_camera_pos = cpvmult(camera_pos, 0.5);
translate(-scaled_camera_pos.x, -scaled_camera_pos.y);
set_color(WHITE);
draw_dots(scaled_camera_pos, 2.0);
@ -1998,7 +1998,7 @@ static void frame(void)
if (b->platonic_detection_strength > 0.0)
{
set_color(colhexcode(0xf2d75c));
V2 to = V2add(entity_pos(b), V2scale(b->platonic_nearest_direction, b->platonic_detection_strength));
V2 to = cpvadd(entity_pos(b), cpvmult(b->platonic_nearest_direction, b->platonic_detection_strength));
dbg_rect(to);
dbg_rect(entity_pos(b));
draw_line(entity_pos(b).x, entity_pos(b).y, to.x, to.y);
@ -2043,7 +2043,7 @@ static void frame(void)
setup_hueshift(e->owning_squad);
sgp_set_image(0, image_player);
draw_texture_rectangle_centered(
entity_pos(e), V2scale(PLAYER_SIZE, player_scaling));
entity_pos(e), cpvmult(PLAYER_SIZE, player_scaling));
sgp_reset_image(0);
}
}

2
server.c
Unescape Escape View File

@ -467,7 +467,7 @@ void server(void *info_raw)
Entity *other_player_entity = get_entity(&gs, gs.players[other_player_index].entity);
if (other_player_entity != NULL)
{
double dist = V2dist(entity_pos(this_player_entity), entity_pos(other_player_entity));
double dist = cpvdist(entity_pos(this_player_entity), entity_pos(other_player_entity));
double volume = lerp(1.0, 0.0, clamp01(dist / VOIP_DISTANCE_WHEN_CANT_HEAR));
if (volume > 0.01)
{

150
types.h
Unescape Escape View File

@ -100,27 +100,25 @@
#include "ipsettings.h" // don't leak IP!
#include "miniaudio.h" // @Robust BAD. using miniaudio mutex construct for server thread synchronization. AWFUL!
#include "cpVect.h" // offers vector functions and types for the structs
// @Robust remove this include somehow, needed for sqrt and cos
#include <math.h>
#include <stdint.h> // tick is unsigned integer
#include <stdio.h> // logging on errors for functions
// defined in gamestate.c. Janky
#ifndef assert
#define assert(condition) __flight_assert(condition, __FILE__, __LINE__, #condition)
#endif
// including headers from headers bad
#ifndef CHIPMUNK_H
typedef void cpSpace;
typedef void cpBody;
typedef void cpShape;
typedef struct cpVect
{
double x, y;
} cpVect;
#endif
#include "queue.h"
@ -492,7 +490,7 @@ typedef struct AABB
double x, y, width, height;
} AABB;
static AABB centered_at(V2 point, V2 size)
static inline AABB centered_at(V2 point, V2 size)
{
return (AABB){
.x = point.x - size.x / 2.0f,
@ -502,59 +500,19 @@ static AABB centered_at(V2 point, V2 size)
};
}
static bool has_point(AABB aabb, V2 point)
static inline bool has_point(AABB aabb, V2 point)
{
return point.x > aabb.x && point.x < aabb.x + aabb.width && point.y > aabb.y && point.y < aabb.y + aabb.height;
}
static V2 V2add(V2 a, V2 b)
{
return (V2){
.x = a.x + b.x,
.y = a.y + b.y,
};
}
static V2 V2scale(V2 a, double f)
{
return (V2){
.x = a.x * f,
.y = a.y * f,
};
}
static double V2lengthsqr(V2 v)
{
return v.x * v.x + v.y * v.y;
}
static double V2length(V2 v)
{
return sqrt(V2lengthsqr(v));
}
static V2 V2normalize(V2 v)
{
return V2scale(v, 1.0f / V2length(v));
}
static double V2dot(V2 a, V2 b)
{
return a.x * b.x + a.y * b.y;
}
static double V2projectvalue(V2 vec, V2 onto)
{
double length_onto = V2length(onto);
return V2dot(vec, onto) / (length_onto * length_onto);
}
static V2 V2project(V2 vec, V2 onto)
static inline double cpvprojectval(V2 vec, V2 onto)
{
return V2scale(onto, V2projectvalue(vec, onto));
double length_onto = cpvlength(onto);
return cpvdot(vec, onto) / (length_onto * length_onto);
}
static V2 V2rotate(V2 vec, double theta)
// spins around by theta
static inline V2 cpvspin(V2 vec, double theta)
{
return (V2){
.x = vec.x * cos(theta) - vec.y * sin(theta),
@ -563,19 +521,11 @@ static V2 V2rotate(V2 vec, double theta)
}
// also known as atan2
static double V2angle(V2 vec)
static inline double cpvangle(V2 vec)
{
return atan2(vec.y, vec.x);
}
static V2 V2sub(V2 a, V2 b)
{
return (V2){
.x = a.x - b.x,
.y = a.y - b.y,
};
}
static double sign(double f)
{
if (f >= 0.0f)
@ -584,26 +534,11 @@ static double sign(double f)
return -1.0f;
}
static bool V2equal(V2 a, V2 b, double eps)
{
return V2length(V2sub(a, b)) < eps;
}
static inline double clamp01(double f)
{
return fmax(0.0f, fmin(f, 1.0f));
}
static double V2distsqr(V2 from, V2 to)
{
return V2lengthsqr(V2sub(to, from));
}
static double V2dist(V2 from, V2 to)
{
return sqrt(V2distsqr(from, to));
}
static inline double clamp(double f, double minimum, double maximum)
{
if (f < minimum)
@ -613,92 +548,51 @@ static inline double clamp(double f, double minimum, double maximum)
return f;
}
static double V2anglediff(V2 a, V2 b)
static inline double cpvanglediff(V2 a, V2 b)
{
double acos_input = V2dot(a, b) / (V2length(a) * V2length(b));
double acos_input = cpvdot(a, b) / (cpvlength(a) * cpvlength(b));
acos_input = clamp(acos_input, -1.0f, 1.0f);
assert(acos_input >= -1.0f && acos_input <= 1.0f);
return acos(acos_input) * sign(V2dot(a, b));
return acos(acos_input) * sign(cpvdot(a, b));
}
static double fract(double f)
static inline double fract(double f)
{
return f - floor(f);
}
static double lerp(double a, double b, double f)
static inline double lerp(double a, double b, double f)
{
return a * (1.0f - f) + (b * f);
}
static double lerp_angle(double p_from, double p_to, double p_weight)
static inline double lerp_angle(double p_from, double p_to, double p_weight)
{
double difference = fmod(p_to - p_from, (float)TAU);
double distance = fmod(2.0f * difference, (float)TAU) - difference;
return p_from + distance * p_weight;
}
static V2 V2floor(V2 p)
static inline V2 cpvfloor(V2 p)
{
return (V2){floor(p.x), floor(p.y)};
}
static V2 V2fract(V2 p)
static inline V2 cpvfract(V2 p)
{
return (V2){fract(p.x), fract(p.y)};
}
/*
double noise(V2 p)
{
V2 id = V2floor(p);
V2 f = V2fract(p);
V2 u = V2dot(f, f) * (3.0f - 2.0f * f);
return mix(mix(random(id + V2(0.0, 0.0)),
random(id + V2(1.0, 0.0)), u.x),
mix(random(id + V2(0.0, 1.0)),
random(id + V2(1.0, 1.0)), u.x),
u.y);
}
double fbm(V2 p)
{
double f = 0.0;
double gat = 0.0;
for (double octave = 0.; octave < 5.; ++octave)
{
double la = pow(2.0, octave);
double ga = pow(0.5, octave + 1.);
f += ga * noise(la * p);
gat += ga;
}
f = f / gat;
return f;
}
*/
static V2 V2lerp(V2 a, V2 b, double factor)
{
V2 to_return = {0};
to_return.x = lerp(a.x, b.x, factor);
to_return.y = lerp(a.y, b.y, factor);
return to_return;
}
// for random generation
static double hash11(double p)
static inline double hash11(double p)
{
p = fract(p * .1031f);
p *= p + 33.33f;
p *= p + p;
return fract(p);
}
static double deg2rad(double deg)
static inline double deg2rad(double deg)
{
return (deg / 360.0f) * 2.0f * PI;
}

Write Preview
Loading…
Cancel
Save