1

     2

#include "Graphics.hh"

     3

#include "GameState.hh"

     4

#include <cmath>

     5

#include <sstream>

     6

    19

Graphics::Graphics (Engine &engine, GameState &state, PixelCoordinate resolution, bool fullscreen) :

    20

    CL_DisplayWindow(GRAPHICS_WINDOW_TITLE, resolution.x, resolution.y, fullscreen),

    21

    engine(engine), 

    22

    state(state), 

    23

    resolution(resolution),

    24

    update_timer(GRAPHICS_UPDATE_INTERVAL_MS),

    25

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

    28

{

    29

    30

    // connect timer signal

    31

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

    32

    33

    // enable

    34

    update_timer.start();

    41

}

    42

    43

const std::vector<CL_DisplayMode> & Graphics::getDisplayModes (void) {

    44

    return CL_DisplayMode::get_display_modes();

    45

}

    46

    47

const CL_DisplayMode Graphics::getBestMode (void) {

    48

    const std::vector<CL_DisplayMode> &modes = Graphics::getDisplayModes();

    49

    50

    const CL_DisplayMode *best_mode = NULL;

    51

    52

    for (std::vector<CL_DisplayMode>::const_iterator it = modes.begin(); it != modes.end(); it++)

    53

        if (best_mode == NULL || (

    54

                it->get_resolution().width * it->get_resolution().height > 

    55

                best_mode->get_resolution().width * best_mode->get_resolution().height    

    56

        ))

    57

            best_mode = &*it;

    58

    59

    if (best_mode == NULL)

    60

        throw Error("No available video modes!");

    61

    62

    return *best_mode;

    63

}

    64

    65

void Graphics::check_input (void) {

    66

    LocalPlayer *player;

    67

    PlayerInput input_mask;

    68

    TimeMS input_dt;

    69

    70

    // update gui flags

    71

    handle_input(input.readGuiInput());

    72

    73

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

    74

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

    75

        return;

    76

    77

    // build input_mask

    78

    input.readPlayerInput(input_mask, input_dt);

    79

    80

    // apply input if there was any

    81

    if (input_mask)

    82

        player->handleInput(input_mask, input_dt);

    83

}

    84

    85

void Graphics::handle_input (GuiInput flags) {

    86

    // update flags

    87

    this->flags = flags;

    88

    89

    // quit?

    90

    if (flags & GUI_INPUT_QUIT) {

    91

        engine.stop();

    92

    93

        return;

    94

    }

    95

    96

    // dump player debug info on stderr

    98

        state.getLocalPlayer()->printDebugInfo();

   102

   103

    // toggle fullscreen?

   104

    if (flags & GUI_INPUT_TOGGLE_FULLSCREEN) {

   105

        if (is_fullscreen())

   106

            set_windowed();

   107

        else

   108

            set_fullscreen();

   109

    }

   110

}

   111

   112

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

   113

    if (high < low)

   114

        return (high + low) / 2;

   115

   116

    else if (value < low)

   117

        return low;

   118

   119

    else if (value > high)

   120

        return high;

   121

   122

    else

   123

        return value;

   124

}

   125

   126

void Graphics::do_redraw (void) {

   127

    CL_GraphicContext *gc = get_gc();

   128

    LocalPlayer *player;

   129

   130

    // calculate camera

   131

    PixelCoordinate camera(0, 0);

   132

   133

    // ...to track our local player

   134

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

   135

        // try and center the screen on the player

   136

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

   137

   138

        // ...but keep the world in view

   139

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

   140

   141

        // ...by limiting the value to 0...max

   142

        camera = PixelCoordinate(

   143

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

   144

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

   145

        );

   146

    }

   147

   148

    // Black background

   149

    gc->clear(CL_Color::black);

   150

   151

    // Draw the game

   152

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

   155

    if (player != NULL) {

   156

        draw_player_info(gc, player);

   157

    }

   161

   162

    // Flip window buffer, sync

   163

    flip(1);

   164

}

   165

   166

void Graphics::on_update (TimeMS tick_length) {

   167

    (void) tick_length;

   168

   169

    // check keyboard input

   170

    check_input();

   171

   172

    // redraw display

   173

    do_redraw();

   174

}

   175

   176

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

   177

    int box_top = resolution.y - 100;

   178

    int box_left = 0;

   179

    int box_right = resolution.x;

   180

    int box_bottom = resolution.y;

   181

    int bar_length = 3; // *100

   182

   183

    // draw status info at bottom of display

   184

    gc->fill_rect(

   185

        CL_Rect(

   186

            box_left,

   187

            box_top,

   188

            box_right,

   189

            box_bottom

   190

        ),

   191

        CL_Gradient(

   192

            CL_Color(0, 0, 0),

   193

            CL_Color(50, 50, 50),

   194

            CL_Color(50, 50, 50, 150),

   195

            CL_Color(100, 100, 100, 200)

   196

        )

   197

    );

   198

   199

    // Health

   200

    gc->draw_rect(

   201

        CL_Rect(

   202

            box_left + 9,

   203

            box_top + 9,

   204

            box_left + 11 + 100 * bar_length,

   205

            box_top + 31

   206

        ),

   207

        CL_Color(150, 150, 150)

   208

    );

   209

   210

    gc->fill_rect(

   211

        CL_Rect(

   212

            box_left + 10,

   213

            box_top + 10,

   214

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

   215

            box_top + 30

   216

        ),

   217

        CL_Gradient(

   218

            CL_Color(200, 0, 0),

   219

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

   220

            CL_Color(200, 0, 0),

   221

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

   222

        )

   223

    );

   224

   225

    // stats - kills

   226

    std::stringstream sskills;

   227

    sskills << "Kills:  " << p->getKills();

   228

    getSimpleFont().draw(

   229

        box_left + 20 + 100 * bar_length,

   230

        box_top + 10,

   231

        sskills.str(),

   232

        get_gc()

   233

    );

   234

   235

    // stats - deaths

   236

    std::stringstream ssdeaths;

   237

    ssdeaths << "Deaths:  " << p->getDeaths();

   238

    getSimpleFont().draw(

   239

        box_left + 20 + 100 * bar_length,

   240

        box_top + 30,

   241

        ssdeaths.str(),

   242

        get_gc()

   243

    );

   244

   245

    // stats - ratio

   246

    std::stringstream ssratio;

   247

    ssratio << "Ratio:  " << (p->getKills()+1) / (p->getDeaths()+1);

   248

    getSimpleFont().draw(

   249

        box_left + 20 + 100 * bar_length,

   250

        box_top + 50,

   251

        ssratio.str(),

   252

        get_gc()

   253

    );

   254

   255

   256

    // Weapon clip / reloading

   257

    gc->draw_rect(

   258

        CL_Rect(

   259

            box_left + 9,

   260

            box_top + 69,

   261

            box_left + 11 + 100 * bar_length,

   262

            box_top + 91

   263

        ),

   264

        CL_Color(150, 150, 150)

   265

    );

   266

   267

    gc->fill_rect(

   268

        CL_Rect(

   269

            box_left + 10,

   270

            box_top + 70,

   271

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

   272

            box_top + 90

   273

        ),

   274

        CL_Gradient(

   275

            CL_Color(100, 100, 0),

   276

            CL_Color(100, 100, 0),

   277

            CL_Color(100, 100, 0),

   278

            CL_Color(100, 100, 100)

   279

        )

   280

    );

   281

   282

    // current weapon name

   283

    getSimpleFont().draw(

   284

        box_left + 20 + 100 * bar_length,

   285

        box_top + 70,

   286

        p->getCurrentWeapon()->getName(),

   287

        get_gc()

   288

    );

   290

}

   291