1

     2

#include "Graphics.hh"

     3

#include "GameState.hh"

     4

#include <cmath>

     6

     7

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

     8

    CL_DisplayWindow(GRAPHICS_WINDOW_TITLE, GRAPHICS_RESOLUTION_WIDTH, GRAPHICS_RESOLUTION_HEIGHT),

     9

    engine(engine), 

    10

    state(state), 

    11

    resolution(GRAPHICS_RESOLUTION_WIDTH, GRAPHICS_RESOLUTION_HEIGHT),

    12

    update_timer(GRAPHICS_UPDATE_INTERVAL_MS),

    13

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

    14

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

    15

{

    16

    17

    // connect timer signal

    18

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

    19

    20

    // enable

    21

    update_timer.start();

    22

}

    23

    24

void Graphics::check_input (void) {

    25

    LocalPlayer *player;

    26

    PlayerInput input_mask;

    27

    TimeMS input_dt;

    28

    29

    // update gui flags

    30

    this->flags = input.readGuiInput();

    31

    32

    // quit?

    33

    if (flags & GUI_INPUT_QUIT) {

    34

        engine.stop();

    35

    36

        return;

    37

    }

    38

    39

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

    40

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

    41

        return;

    42

    43

    // dump debug info on stderr

    44

    if (flags & GUI_INPUT_DEBUG_PLAYER)

    45

        player->printDebugInfo();

    46

    47

    // build input_mask

    48

    input.readPlayerInput(input_mask, input_dt);

    49

    50

    // apply input if there was any

    51

    if (input_mask)

    52

        player->handleInput(input_mask, input_dt);

    53

}

    54

    55

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

    56

    if (high < low)

    57

        return (high + low) / 2;

    58

    59

    else if (value < low)

    60

        return low;

    61

    62

    else if (value > high)

    63

        return high;

    64

    65

    else

    66

        return value;

    67

}

    68

    69

void Graphics::do_redraw (void) {

    70

    CL_GraphicContext *gc = get_gc();

    71

    LocalPlayer *player;

    72

    73

    // calculate camera

    74

    PixelCoordinate camera(0, 0);

    75

    76

    // ...to track our local player

    77

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

    78

        PixelCoordinate target = player->getCoordinate() - PixelCoordinate(resolution.x / 2, (resolution.y - 100) / 2);

    79

        PixelCoordinate max = state.world.getDimensions() - resolution + PixelCoordinate(0, 100);

    80

    81

        // keep the terrain in view

    82

        camera = PixelCoordinate(

    83

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

    84

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

    85

        );

    86

    }

    87

    88

    // Black background

    89

    gc->clear(CL_Color::black);

    90

    91

    // Draw the game

    92

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

    93

    94

    // Draw box for player information

    95

    if (player != NULL) {

    96

        draw_player_info(gc, (Player*)player);

    97

    }

    98

    99

    // Flip window buffer, sync

   100

    flip(1);

   101

}

   102

   103

void Graphics::on_update (TimeMS tick_length) {

   104

    (void) tick_length;

   105

   106

    // check keyboard input

   107

    check_input();

   108

   109

    // redraw display

   110

    do_redraw();

   111

}

   112

   113

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

   114

    int box_top = GRAPHICS_RESOLUTION_HEIGHT - 100;

   115

    int box_left = 0;

   116

    int box_right = GRAPHICS_RESOLUTION_WIDTH;

   117

    int box_bottom = GRAPHICS_RESOLUTION_HEIGHT;

   118

    int bar_length = 3; // *100

   119

   120

    // draw status info at bottom of display

   121

    gc->fill_rect(

   122

        CL_Rect(

   123

            box_left,

   124

            box_top,

   125

            box_right,

   126

            box_bottom

   127

        ),

   128

        CL_Gradient(

   131

            CL_Color(50, 50, 50, 150),

   132

            CL_Color(100, 100, 100, 200)

   133

        )

   134

    );

   135

   136

    // Lifebar

   137

    gc->draw_rect(

   138

        CL_Rect(

   139

            box_left + 9,

   140

            box_top + 9,

   141

            box_left + 11 + 100 * bar_length,

   142

            box_top + 31

   143

        ),

   144

        CL_Color(150, 150, 150)

   145

    );

   146

   147

    gc->fill_rect(

   148

        CL_Rect(

   149

            box_left + 10,

   150

            box_top + 10,

   151

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

   152

            box_top + 30

   153

        ),

   154

        CL_Gradient(

   155

            CL_Color(200, 0, 0),

   156

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

   157

            CL_Color(200, 0, 0),

   158

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

   159

        )

   160

    );

   179

   180

    // Ammobar

   181

    gc->draw_rect(

   182

        CL_Rect(

   183

            box_left + 9,

   185

            box_left + 11 + 100 * bar_length,

   187

        ),

   188

        CL_Color(150, 150, 150)

   189

    );

   190

   191

    gc->fill_rect(

   192

        CL_Rect(

   193

            box_left + 10,

   195

            box_left + 10 + (int) (p->getCurrentWeapon()->getReloadTimer() * 100 / p->getCurrentWeapon()->getReloadTime() * bar_length),

   197

        ),

   198

        CL_Gradient(

   199

            CL_Color(100, 100, 0),

   200

            CL_Color(100, 100, 0),

   201

            CL_Color(100, 100, 0),

   202

            CL_Color(100, 100, 100)

   203

        )

   204

    );

   212

}

   213