-#include <SDL2/SDL.h>
-#include <assert.h>
+#include <stdio.h>
#include <math.h>
+#include <SDL.h>
+
+#include "game/level/level_editor/point_layer.h"
#include "goals.h"
#include "math/pi.h"
#include "math/triangle.h"
-#include "str.h"
-#include "system/error.h"
#include "system/line_stream.h"
+#include "system/log.h"
#include "system/lt.h"
#include "system/nth_alloc.h"
+#include "system/stacktrace.h"
+#include "system/str.h"
#define GOAL_RADIUS 10.0f
-#define GOAL_MAX_ID_SIZE 36
static int goals_is_goal_hidden(const Goals *goals, size_t i);
struct Goals {
Lt *lt;
char **ids;
- Point *points;
- /* TODO(#493): replace Goals.regions with the Regions entity */
- Rect *regions;
+ Vec2f *positions;
Color *colors;
- /* TODO(#494): it is not clear how to maintain Cue_state from the scripting language */
Cue_state *cue_states;
+ bool *visible;
size_t count;
- Rect player_hitbox;
float angle;
};
Goals *create_goals_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
- Lt *const lt = create_lt();
- if (lt == NULL) {
- return NULL;
- }
+ Lt *lt = create_lt();
- Goals *const goals = PUSH_LT(lt, nth_alloc(sizeof(Goals)), free);
+ Goals *const goals = PUSH_LT(lt, nth_calloc(1, sizeof(Goals)), free);
if (goals == NULL) {
- throw_error(ERROR_TYPE_LIBC);
RETURN_LT(lt, NULL);
}
goals->count = 0;
if (sscanf(
line_stream_next(line_stream),
- "%lu",
+ "%zu",
&goals->count) == EOF) {
- throw_error(ERROR_TYPE_LIBC);
+ log_fail("Could not read amount of goals\n");
RETURN_LT(lt, NULL);
}
goals->ids = PUSH_LT(
lt,
- nth_alloc(sizeof(char*) * goals->count),
+ nth_calloc(1, sizeof(char*) * goals->count),
free);
if (goals->ids == NULL) {
- throw_error(ERROR_TYPE_LIBC);
RETURN_LT(lt, NULL);
}
for (size_t i = 0; i < goals->count; ++i) {
- goals->ids[i] = PUSH_LT(lt, nth_alloc(sizeof(char) * GOAL_MAX_ID_SIZE), free);
+ goals->ids[i] = PUSH_LT(lt, nth_calloc(1, sizeof(char) * ENTITY_MAX_ID_SIZE), free);
if (goals->ids[i] == NULL) {
- throw_error(ERROR_TYPE_LIBC);
RETURN_LT(lt, NULL);
}
}
- goals->points = PUSH_LT(lt, nth_alloc(sizeof(Point) * goals->count), free);
- if (goals->points == NULL) {
- throw_error(ERROR_TYPE_LIBC);
+ goals->positions = PUSH_LT(lt, nth_calloc(1, sizeof(Vec2f) * goals->count), free);
+ if (goals->positions == NULL) {
RETURN_LT(lt, NULL);
}
- goals->regions = PUSH_LT(lt, nth_alloc(sizeof(Rect) * goals->count), free);
- if (goals->regions == NULL) {
- throw_error(ERROR_TYPE_LIBC);
+ goals->colors = PUSH_LT(lt, nth_calloc(1, sizeof(Color) * goals->count), free);
+ if (goals->colors == NULL) {
RETURN_LT(lt, NULL);
}
- goals->colors = PUSH_LT(lt, nth_alloc(sizeof(Color) * goals->count), free);
- if (goals->colors == NULL) {
- throw_error(ERROR_TYPE_LIBC);
+ goals->cue_states = PUSH_LT(lt, nth_calloc(1, sizeof(int) * goals->count), free);
+ if (goals->cue_states == NULL) {
RETURN_LT(lt, NULL);
}
- goals->cue_states = PUSH_LT(lt, nth_alloc(sizeof(int) * goals->count), free);
- if (goals->cue_states == NULL) {
- throw_error(ERROR_TYPE_LIBC);
+ goals->visible = PUSH_LT(lt, nth_calloc(1, sizeof(bool) * goals->count), free);
+ if (goals->visible == NULL) {
RETURN_LT(lt, NULL);
}
for (size_t i = 0; i < goals->count; ++i) {
if (sscanf(
line_stream_next(line_stream),
- "%" STRINGIFY(GOAL_MAX_ID_SIZE) "s%f%f%f%f%f%f%6s",
+ "%" STRINGIFY(ENTITY_MAX_ID_SIZE) "s%f%f%6s",
goals->ids[i],
- &goals->points[i].x,
- &goals->points[i].y,
- &goals->regions[i].x,
- &goals->regions[i].y,
- &goals->regions[i].w,
- &goals->regions[i].h,
+ &goals->positions[i].x,
+ &goals->positions[i].y,
color) < 0) {
- throw_error(ERROR_TYPE_LIBC);
+ log_fail("Could not read %dth goal\n", i);
RETURN_LT(lt, NULL);
}
- goals->colors[i] = color_from_hexstr(color);
+ goals->colors[i] = hexstr(color);
+ goals->cue_states[i] = CUE_STATE_VIRGIN;
+ goals->visible[i] = true;
+ }
+
+ goals->lt = lt;
+ goals->angle = 0.0f;
+
+ return goals;
+}
+
+Goals *create_goals_from_point_layer(const PointLayer *point_layer)
+{
+ trace_assert(point_layer);
+
+ Lt *lt = create_lt();
+
+ Goals *const goals = PUSH_LT(lt, nth_calloc(1, sizeof(Goals)), free);
+ if (goals == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+
+ goals->count = point_layer_count(point_layer);
+
+ goals->ids = PUSH_LT(
+ lt,
+ nth_calloc(1, sizeof(char*) * goals->count),
+ free);
+ if (goals->ids == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+ for (size_t i = 0; i < goals->count; ++i) {
+ goals->ids[i] = PUSH_LT(lt, nth_calloc(1, sizeof(char) * ENTITY_MAX_ID_SIZE), free);
+ if (goals->ids[i] == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+ }
+
+ goals->positions = PUSH_LT(lt, nth_calloc(1, sizeof(Vec2f) * goals->count), free);
+ if (goals->positions == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+
+ goals->colors = PUSH_LT(lt, nth_calloc(1, sizeof(Color) * goals->count), free);
+ if (goals->colors == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+
+ goals->cue_states = PUSH_LT(lt, nth_calloc(1, sizeof(int) * goals->count), free);
+ if (goals->cue_states == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+
+ goals->visible = PUSH_LT(lt, nth_calloc(1, sizeof(bool) * goals->count), free);
+ if (goals->visible == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+
+ const Vec2f *positions = point_layer_positions(point_layer);
+ const Color *colors = point_layer_colors(point_layer);
+ const char *ids = point_layer_ids(point_layer);
+
+ // TODO(#835): we could use memcpy in create_goals_from_point_layer
+ for (size_t i = 0; i < goals->count; ++i) {
+ goals->positions[i] = positions[i];
+ goals->colors[i] = colors[i];
+ memcpy(goals->ids[i], ids + ID_MAX_SIZE * i, ID_MAX_SIZE);
goals->cue_states[i] = CUE_STATE_VIRGIN;
+ goals->visible[i] = true;
}
goals->lt = lt;
void destroy_goals(Goals *goals)
{
- assert(goals);
+ trace_assert(goals);
RETURN_LT0(goals->lt);
}
static int goals_render_core(const Goals *goals,
size_t goal_index,
- Camera *camera)
+ const Camera *camera)
{
- assert(goals);
- assert(camera);
+ trace_assert(goals);
+ trace_assert(camera);
- const Point position = vec_sum(
- goals->points[goal_index],
+ const Vec2f position = vec_sum(
+ goals->positions[goal_index],
vec(0.0f, sinf(goals->angle) * 10.0f));
if (camera_fill_triangle(
return 0;
}
-/* TODO(#448): goals do not render their ids in debug mode */
int goals_render(const Goals *goals,
- Camera *camera)
+ const Camera *camera)
{
- assert(goals);
- assert(camera);
+ trace_assert(goals);
+ trace_assert(camera);
for (size_t i = 0; i < goals->count; ++i) {
if (!goals_is_goal_hidden(goals, i)) {
return -1;
}
}
-
- if (camera_render_debug_rect(
- camera,
- goals->regions[i],
- goals->colors[i]) < 0) {
- return -1;
- }
}
return 0;
void goals_update(Goals *goals,
float delta_time)
{
- assert(goals);
- assert(delta_time > 0.0f);
+ trace_assert(goals);
+ trace_assert(delta_time > 0.0f);
goals->angle = fmodf(goals->angle + 2.0f * delta_time, 2.0f * PI);
}
-void goals_hide_from_player(Goals *goals,
- Rect player_hitbox)
-{
- goals->player_hitbox = player_hitbox;
-
-}
-
int goals_sound(Goals *goals,
Sound_samples *sound_samples)
{
for (size_t i = 0; i < goals->count; ++i) {
switch (goals->cue_states[i]) {
case CUE_STATE_HIT_NOTHING:
- sound_samples_play_sound(sound_samples, 0, 0);
+ sound_samples_play_sound(sound_samples, 0);
goals->cue_states[i] = CUE_STATE_SEEN_NOTHING;
break;
for (size_t i = 0; i < goals->count; ++i) {
switch (goals->cue_states[i]) {
case CUE_STATE_VIRGIN:
- if (goals_is_goal_hidden(goals, i) && camera_is_point_visible(camera, goals->points[i])) {
+ if (goals_is_goal_hidden(goals, i) && camera_is_point_visible(camera, goals->positions[i])) {
goals->cue_states[i] = CUE_STATE_HIT_NOTHING;
}
break;
case CUE_STATE_SEEN_NOTHING:
- if (!goals_is_goal_hidden(goals, i) && camera_is_point_visible(camera, goals->points[i])) {
+ if (!goals_is_goal_hidden(goals, i) && camera_is_point_visible(camera, goals->positions[i])) {
goals->cue_states[i] = CUE_STATE_VIRGIN;
}
break;
void goals_checkpoint(const Goals *goals,
Player *player)
{
- assert(goals);
- assert(player);
+ trace_assert(goals);
+ trace_assert(player);
for (size_t i = 0; i < goals->count; ++i) {
if (goals->cue_states[i] == CUE_STATE_HIT_NOTHING) {
- player_checkpoint(player, goals->points[i]);
+ player_checkpoint(player, goals->positions[i]);
}
}
}
-void goals_hide(Goals *goals, const char *id)
+/* Private Functions */
+
+static int goals_is_goal_hidden(const Goals *goals, size_t i)
{
- assert(goals);
- assert(id);
- /* TODO(#495): goals_hide is not implemented */
+ return !goals->visible[i];
}
-void goals_show(Goals *goals, const char *id)
+void goals_hide(Goals *goals, char goal_id[ENTITY_MAX_ID_SIZE])
{
- assert(goals);
- assert(id);
- /* TODO(#496): goals_show is not implemented */
-}
+ trace_assert(goals);
+ trace_assert(goal_id);
-/* Private Functions */
+ for (size_t i = 0; i < goals->count; ++i) {
+ if (strncmp(goal_id, goals->ids[i], ENTITY_MAX_ID_SIZE) == 0) {
+ goals->visible[i] = false;
+ }
+ }
+}
-static int goals_is_goal_hidden(const Goals *goals, size_t i)
+void goals_show(Goals *goals, char goal_id[ENTITY_MAX_ID_SIZE])
{
- return rects_overlap(goals->regions[i], goals->player_hitbox);
+ trace_assert(goals);
+ trace_assert(goal_id);
+ for (size_t i = 0; i < goals->count; ++i) {
+ if (strncmp(goal_id, goals->ids[i], ENTITY_MAX_ID_SIZE) == 0) {
+ goals->visible[i] = true;
+ }
+ }
}
projects / nothing.git / blobdiff