1

     2

#include "Graphics.hh"

     3

#include "GameState.hh"

     4

#include <cmath>

     5

     6

Graphics::Graphics (Engine &engine, GameState &state) :

     7

    CL_DisplayWindow(GRAPHICS_WINDOW_TITLE, GRAPHICS_RESOLUTION_WIDTH, GRAPHICS_RESOLUTION_HEIGHT),

     8

    engine(engine), 

     9

    state(state), 

    10

    resolution(GRAPHICS_RESOLUTION_WIDTH, GRAPHICS_RESOLUTION_HEIGHT),

    11

    update_timer(GRAPHICS_UPDATE_INTERVAL_MS),

    12

    input(get_ic()->get_keyboard()),

    13

    simple_font("Font2", engine.getResourceManager()) 

    14

{

    15

    16

    // connect timer signal

    17

    slots.connect(update_timer.sig_tick(), this, &Graphics::on_update);

    18

    19

    // enable

    20

    update_timer.start();

    21

}

    22

    23

void Graphics::check_input (void) {

    24

    LocalPlayer *player;

    25

    PlayerInput input_mask;

    26

    TimeMS input_dt;

    27

    28

    // update gui flags

    29

    this->flags = input.readGuiInput();

    30

    31

    // quit?

    32

    if (flags & GUI_INPUT_QUIT) {

    33

        engine.stop();

    34

    35

        return;

    36

    }

    37

    38

    // stop here if we don't have a local player

    39

    if ((player = state.getLocalPlayer()) == NULL)

    40

        return;

    41

    42

    // dump debug info on stderr

    43

    if (flags & GUI_INPUT_DEBUG_PLAYER)

    44

        player->printDebugInfo();

    45

    46

    // build input_mask

    47

    input.readPlayerInput(input_mask, input_dt);

    48

    49

    // apply input if there was any

    50

    if (input_mask)

    51

        player->handleInput(input_mask, input_dt);

    52

}

    53

    54

static PixelDimension value_between (PixelDimension low, PixelDimension value, PixelDimension high) {

    59

        return low;

    60

    61

    else if (value > high)

    62

        return high;

    63

    64

    else

    65

        return value;

    66

}

    67

    68

void Graphics::do_redraw (void) {

    69

    CL_GraphicContext *gc = get_gc();

    70

    LocalPlayer *player;

    71

    72

    // calculate camera

    73

    PixelCoordinate camera(0, 0);

    74

    75

    // ...to track our local player

    76

    if ((player = state.getLocalPlayer()) != NULL) {

    77

        PixelCoordinate target = player->getCoordinate() - resolution / 2;

    78

        PixelCoordinate max = state.world.getDimensions() - resolution;

    79

    80

        // keep the terrain in view

    81

        camera = PixelCoordinate(

    82

            value_between(0, target.x, max.x),

    83

            value_between(0, target.y, max.y)

    84

        );

    85

    }

    86

    87

    // Black background

    88

    gc->clear(CL_Color::black);

    89

    90

    // Draw the game

    91

    state.draw(this, camera, flags & GUI_INPUT_DISPLAY_WEAPON);

    92

    93

    // Draw box for player information

    94

    if (player != NULL) {

    95

        draw_player_info(gc, (Player*)player);

    96

    }

    97

    98

    // Flip window buffer, sync

    99

    flip(1);

   100

}

   101

   102

void Graphics::on_update (TimeMS tick_length) {

   103

    (void) tick_length;

   104

   105

    // check keyboard input

   106

    check_input();

   107

   108

    // redraw display

   109

    do_redraw();

   110

}

   111

   112

void Graphics::draw_player_info(CL_GraphicContext *gc, Player *p) {

   113

    int box_top = GRAPHICS_RESOLUTION_HEIGHT - 100;

   114

    int box_left = 0;

   115

    int box_right = GRAPHICS_RESOLUTION_WIDTH;

   116

    int box_bottom = GRAPHICS_RESOLUTION_HEIGHT;

   117

    int life_bar_length = 3; // *100

   118

   119

    // draw status info at bottom of display

   120

    gc->fill_rect(

   121

        CL_Rect(

   122

            box_left,

   123

            box_top,

   124

            box_right,

   125

            box_bottom

   126

        ),

   127

        CL_Gradient(

   128

            CL_Color(0, 0, 0, 100),

   129

            CL_Color(50, 50, 50, 150),

   130

            CL_Color(50, 50, 50, 150),

   131

            CL_Color(100, 100, 100, 200)

   132

        )

   133

    );

   134

   135

    gc->draw_rect(

   136

        CL_Rect(

   137

            box_left + 9,

   138

            box_top + 9,

   139

            box_left + 11 + 100 * life_bar_length,

   140

            box_top + 31

   141

        ),

   142

        CL_Color(150, 150, 150)

   143

    );

   144

   145

    gc->fill_rect(

   146

        CL_Rect(

   147

            box_left + 10,

   148

            box_top + 10,

   149

            box_left + 10 + (int) (p->getHealthPercent() * life_bar_length),

   150

            box_top + 30

   151

        ),

   152

        CL_Gradient(

   153

            CL_Color(200, 0, 0),

   154

            CL_Color(200 - (int)(p->getHealthPercent() * 2), (int)(p->getHealthPercent() * 2), 0),

   155

            CL_Color(200, 0, 0),

   156

            CL_Color(200 - (int)(p->getHealthPercent() * 2), (int)(p->getHealthPercent() * 2), 0)

   157

        )

   158

    );

   159

}

   160