1

     2

#include "Graphics.hh"

     3

#include "Physics.hh"

     4

#include "GameState.hh"

     5

#include <cmath>

     6

     7

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

     8

    engine(engine), 

     9

    state(state), 

    10

    update_timer(GRAPHICS_UPDATE_INTERVAL_MS),

    11

    win(GRAPHICS_WINDOW_TITLE, GRAPHICS_RESOLUTION_WIDTH, GRAPHICS_RESOLUTION_HEIGHT),

    12

    keyboard(win.get_ic()->get_keyboard()) {

    13

    14

    Vector tmp;

    15

    CL_Color color;

    16

    CL_PixelBuffer terr(MAP_WIDTH, MAP_HEIGHT, 4*MAP_WIDTH, CL_PixelFormat::rgba8888);

    17

    18

    19

    for (tmp.x = 0; tmp.x < MAP_WIDTH; tmp.x++) {

    20

        for (tmp.y = 0; tmp.y < MAP_HEIGHT; tmp.y++) {

    21

            if (state.getType(tmp) == EMPTY) {

    22

                color = CL_Color(86, 41, 0);

    23

            } else if (state.getType(tmp) == DIRT) {

    24

                color = CL_Color(144, 82, 23);

    25

            } else if (state.getType(tmp) == ROCK) {

    26

                color = CL_Color(132, 136, 135);

    27

            } else {

    28

                // Fale

    29

            }

    30

            terr.draw_pixel(tmp.x, tmp.y, color);

    31

     	}

    32

    }

    33

    terrain = CL_Surface(terr);

    34

    35

    // connect timer signal

    36

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

    37

    38

    // enable

    39

    update_timer.enable();

    40

}

    41

    42

void Graphics::check_input (void) {

    43

    LocalPlayer *player;

    44

    PlayerInput_Move input_move = 0;

    45

    46

    // stop on escape

    47

    if (keyboard.get_keycode(CL_KEY_ESCAPE)) {

    48

        engine.stop();

    49

    50

        return;

    51

    }

    52

    53

    // ignore if we don't have a local player

    54

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

    55

        return;

    56

    57

    // handle movement

    58

    if (keyboard.get_keycode(CL_KEY_LEFT))

    59

        input_move |= INPUT_MOVE_LEFT;

    60

    61

    if (keyboard.get_keycode(CL_KEY_RIGHT))

    62

        input_move |= INPUT_MOVE_RIGHT;

    63

    64

    if (keyboard.get_keycode(CL_KEY_UP))

    65

        input_move |= INPUT_MOVE_UP;

    66

    67

    if (keyboard.get_keycode(CL_KEY_DOWN))

    68

        input_move |= INPUT_MOVE_DOWN;

    69

    70

    if (keyboard.get_keycode(CL_KEY_RSHIFT))

    71

        input_move |= INPUT_MOVE_JUMP;

    72

    73

    if (keyboard.get_keycode(CL_KEY_I))

    74

        player->debugInfo();

    75

    76

    if (keyboard.get_keycode(CL_KEY_M))

    77

        input_move |= INPUT_MOVE_DIG;

    78

    79

    // apply movement if applicable

    80

    if (input_move)

    81

        player->handleMove(input_move);

    82

}

    83

    84

void Graphics::do_redraw (void) {

    85

    CL_GraphicContext *gc = win.get_gc();

    86

    87

    // white background

    88

    gc->clear(CL_Color::white);

    89

    90

    const float factorX = GRAPHICS_RESOLUTION_WIDTH / MAP_WIDTH;

    91

    const float factorY = GRAPHICS_RESOLUTION_HEIGHT / MAP_HEIGHT;

    92

    93

    // draw terrain

    94

    terrain.draw(0,0, gc);

    95

   117

    // draw players

   118

    for (std::list<Player*>::iterator it = state.player_list.begin(); it != state.player_list.end(); it++) {

   119

        Player *p = *it;

   120

   121

        Vector loc = p->getPosition();

   122

        bool right = p->getFacing();

   123

        float aim = p->getAim();

   124

        std::vector<Vector> &shape = p->getShape();

   125

        // draw quad

   126

        gc->fill_quad(

   127

                      CL_Quad(

   128

                              (loc.x+shape[0].x) * factorX, (loc.y+shape[0].y) * factorY,

   129

                              (loc.x+shape[1].x) * factorX, (loc.y+shape[1].y) * factorY,

   130

                              (loc.x+shape[2].x) * factorX, (loc.y+shape[2].y) * factorY,

   131

                              (loc.x+shape[3].x) * factorX, (loc.y+shape[3].y) * factorY

   132

                              ), CL_Color::green

   133

                      );

   134

   135

        // Draw crosshair

   136

        if (right) {

   137

            gc->draw_line(loc.x, loc.y, loc.x + std::cos(aim)*5, loc.y - std::sin(aim)*5, CL_Color::black);

   138

        } else {

   139

            gc->draw_line(loc.x, loc.y, loc.x - std::cos(aim)*5, loc.y - std::sin(aim)*5, CL_Color::black);

   140

        }

   141

    }

   142

   143

    // flip window buffer, LIEK NAO

   144

    win.flip(0);

   145

}

   146

   147

void Graphics::on_update (void) {

   148

    // check keyboard input

   149

    check_input();

   150

   151

    // redraw display

   152

    do_redraw();

   153

}