src/game/level/level_editor/player_layer.c

   1 #include <stdio.h>
   2
   3 #include <SDL.h>
   4
   5 #include "game/camera.h"
   6 #include "system/stacktrace.h"
   7 #include "player_layer.h"
   8 #include "system/nth_alloc.h"
   9 #include "system/log.h"
  10 #include "undo_history.h"
  11
  12 PlayerLayer create_player_layer(Vec position, Color color)
  13 {
  14     return (PlayerLayer) {
  15         .position = position,
  16         .color_picker = create_color_picker_from_rgba(color)
  17     };
  18 }
  19
  20 PlayerLayer create_player_layer_from_line_stream(LineStream *line_stream)
  21 {
  22     trace_assert(line_stream);
  23
  24     const char *line = line_stream_next(line_stream);
  25     trace_assert(line);
  26
  27     char colorstr[7] = "000000";
  28     Point position = vec(0.0f, 0.0f);
  29
  30     const int bound =
  31         sscanf(line, "%f%f%6s", &position.x, &position.y, colorstr);
  32
  33 #define BOUND_EXPECTED 3
  34     if (bound != BOUND_EXPECTED) {
  35         log_fail("Could not read Player Layer properly. Parsed tokens: %d. Expected: %d\n",
  36                  bound, BOUND_EXPECTED);
  37     }
  38 #undef BOUND_EXPECTED
  39
  40     return create_player_layer(position, hexstr(colorstr));
  41 }
  42
  43 LayerPtr player_layer_as_layer(PlayerLayer *player_layer)
  44 {
  45     LayerPtr layer = {
  46         .type = LAYER_PLAYER,
  47         .ptr = player_layer
  48     };
  49     return layer;
  50 }
  51
  52 int player_layer_render(const PlayerLayer *player_layer,
  53                         Camera *camera,
  54                         int active)
  55 {
  56     trace_assert(player_layer);
  57     trace_assert(camera);
  58
  59     if (camera_fill_rect(
  60             camera,
  61             rect_from_vecs(
  62                 player_layer->position,
  63                 vec(25.0f, 25.0f)),
  64             color_scale(
  65                 color_picker_rgba(&player_layer->color_picker),
  66                 rgba(1.0f, 1.0f, 1.0f, active ? 1.0f : 0.5f))) < 0) {
  67         return -1;
  68     }
  69
  70     if (active && color_picker_render(
  71             &player_layer->color_picker,
  72             camera)) {
  73         return -1;
  74     }
  75
  76     return 0;
  77 }
  78
  79 static void player_layer_revert_position(void *layer, Context context)
  80 {
  81     trace_assert(layer);
  82
  83     PlayerLayer *player_layer = layer;
  84     player_layer->position = *((Point*)context.data);
  85 }
  86
  87 // TODO(#1013): PlayerLayer does not support undo color
  88
  89 int player_layer_event(PlayerLayer *player_layer,
  90                        const SDL_Event *event,
  91                        const Camera *camera,
  92                        UndoHistory *undo_history)
  93 {
  94     trace_assert(player_layer);
  95     trace_assert(event);
  96     trace_assert(camera);
  97     trace_assert(undo_history);
  98
  99     int selected = 0;
 100     if (color_picker_event(
 101             &player_layer->color_picker,
 102             event,
 103             camera,
 104             &selected) < 0) {
 105         return -1;
 106     }
 107
 108     if (!selected &&
 109         event->type == SDL_MOUSEBUTTONDOWN &&
 110         event->button.button == SDL_BUTTON_LEFT) {
 111         Action action = {
 112             .layer = player_layer,
 113             .revert = player_layer_revert_position
 114         };
 115         trace_assert(sizeof(player_layer->position) <= CONTEXT_SIZE);
 116         memcpy(action.context.data, &player_layer->position, sizeof(player_layer->position));
 117         undo_history_push(undo_history, action);
 118
 119         player_layer->position =
 120             camera_map_screen(camera,
 121                               event->button.x,
 122                               event->button.y);
 123     }
 124
 125     return 0;
 126 }
 127
 128 int player_layer_dump_stream(const PlayerLayer *player_layer,
 129                              FILE *filedump)
 130 {
 131     trace_assert(player_layer);
 132     trace_assert(filedump);
 133
 134     fprintf(filedump, "%f %f ", player_layer->position.x, player_layer->position.y);
 135     color_hex_to_stream(color_picker_rgba(&player_layer->color_picker), filedump);
 136     fprintf(filedump, "\n");
 137
 138     return 0;
 139 }