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
  11 PlayerLayer *create_player_layer(Vec position, Color color)
  12 {
  13     Lt *lt = create_lt();
  14
  15     PlayerLayer *player_layer = PUSH_LT(lt, nth_calloc(1, sizeof(PlayerLayer)), free);
  16     player_layer->lt = lt;
  17
  18     player_layer->position = position;
  19     player_layer->color_picker.color = color;
  20
  21     return player_layer;
  22 }
  23
  24 PlayerLayer *create_player_layer_from_line_stream(LineStream *line_stream)
  25 {
  26     trace_assert(line_stream);
  27
  28     PlayerLayer *player_layer = create_player_layer(
  29         vec(0.0f, 0.0f), COLOR_BLACK);
  30
  31     const char *line = line_stream_next(line_stream);
  32     if (line == NULL) {
  33         log_fail("Could not read Player Layer\n");
  34         RETURN_LT(player_layer->lt, NULL);
  35     }
  36
  37     char colorstr[7];
  38     Point position;
  39     if (sscanf(line,
  40                "%f%f%6s",
  41                &position.x,
  42                &position.y,
  43                colorstr) == EOF) {
  44         log_fail("Could not read Player Layer\n");
  45         RETURN_LT(player_layer->lt, NULL);
  46     }
  47
  48     return create_player_layer(position, hexstr(colorstr));
  49 }
  50
  51 void destroy_player_layer(PlayerLayer *player_layer)
  52 {
  53     trace_assert(player_layer);
  54     destroy_lt(player_layer->lt);
  55 }
  56
  57 LayerPtr player_layer_as_layer(PlayerLayer *player_layer)
  58 {
  59     LayerPtr layer = {
  60         .type = LAYER_PLAYER,
  61         .ptr = player_layer
  62     };
  63     return layer;
  64 }
  65
  66 int player_layer_render(const PlayerLayer *player_layer,
  67                         Camera *camera,
  68                         int active)
  69 {
  70     trace_assert(player_layer);
  71     trace_assert(camera);
  72
  73     if (camera_fill_rect(
  74             camera,
  75             rect_from_vecs(
  76                 player_layer->position,
  77                 vec(25.0f, 25.0f)),
  78             color_scale(
  79                 player_layer->color_picker.color,
  80                 rgba(1.0f, 1.0f, 1.0f, active ? 1.0f : 0.0f))) < 0) {
  81         return -1;
  82     }
  83
  84     return 0;
  85 }
  86
  87
  88 int player_layer_event(PlayerLayer *player_layer,
  89                        const SDL_Event *event,
  90                        const Camera *camera)
  91 {
  92     trace_assert(player_layer);
  93     trace_assert(event);
  94     trace_assert(camera);
  95
  96     switch (event->type) {
  97     case SDL_MOUSEBUTTONDOWN:
  98     case SDL_MOUSEBUTTONUP: {
  99         bool selected = false;
 100         if (color_picker_mouse_button(
 101                 &player_layer->color_picker,
 102                 &event->button,
 103                 &selected) < 0) {
 104             return -1;
 105         }
 106
 107         if (!selected &&
 108             event->type == SDL_MOUSEBUTTONUP &&
 109             event->button.button == SDL_BUTTON_LEFT) {
 110             player_layer->position =
 111                 camera_map_screen(camera,
 112                                   event->button.x,
 113                                   event->button.y);
 114         }
 115     } break;
 116     }
 117
 118     return 0;
 119 }
 120
 121 int player_layer_dump_stream(const PlayerLayer *player_layer,
 122                              FILE *filedump)
 123 {
 124     trace_assert(player_layer);
 125     trace_assert(filedump);
 126
 127     fprintf(filedump, "%f %f ", player_layer->position.x, player_layer->position.y);
 128     color_hex_to_stream(player_layer->color_picker.color, filedump);
 129     fprintf(filedump, "\n");
 130
 131     return 0;
 132 }