567 lines
17 KiB
C
567 lines
17 KiB
C
#include <malloc.h>
|
|
#include "main.h"
|
|
#include "pilot.h"
|
|
#include "log.h"
|
|
#include "opengl.h"
|
|
#include "player.h"
|
|
|
|
#define POW2(x) ((x)*(x))
|
|
|
|
#define GFX_GUI_FRAME "../gfx/gui/frame.png"
|
|
#define GFX_GUI_TARG_PILOT "../gfx/gui/pilot.png"
|
|
#define GFX_GUI_TARG_PLANET "../gfx/gui/planet.png"
|
|
|
|
#define KEY_PRESS 1.
|
|
#define KEY_RELEASE -1.
|
|
|
|
// Keybind structure.
|
|
typedef struct {
|
|
char* name; // Keybinding name, taken from keybindNames[]
|
|
KeybindType type; // type, defined in player.h.
|
|
unsigned int key; // Key/axis/button event number.
|
|
double reverse; // 1. if normal, -1 if reversed, only useful for joystick axis.
|
|
} Keybind;
|
|
static Keybind** player_input; // Contains the players keybindings.
|
|
// Name of each keybinding.
|
|
const char* keybindNames[] = { "accel", "left", "right", "primary", "target",
|
|
"target_nearest", "mapzoomin", "mapzoomout" };
|
|
|
|
// Player stuff.
|
|
Pilot* player = NULL; // extern in pilot.h
|
|
static double player_turn = 0.; // Turn velocity from input.
|
|
static double player_acc = 0.; // Accel velocity from input.
|
|
static int player_primary = 0; // Player is shooting primary weapon.
|
|
static unsigned int player_target = PLAYER_ID; // Targetted pilot.
|
|
|
|
// Pilot stuff for GUI.
|
|
extern Pilot** pilot_stack;
|
|
extern int pilots;
|
|
|
|
// Weapon stuff for GUI.
|
|
extern void weapon_minimap(double res, double w, double h);
|
|
extern void planets_minimap(double res, double w, double h);
|
|
|
|
// GUI crap.
|
|
// Need these offsets to render properly. -- Used in opengl.c
|
|
// -- Colors.
|
|
typedef struct {
|
|
double r, g, b, a;
|
|
} Color;
|
|
#define COLOR(x) glColor4d((x).r, (x).g, (x).b, (x).a)
|
|
// Standard colors.
|
|
Color cInert = { .r = 0.6, .g = 0.6, .b = 0.6, .a = 1. };
|
|
Color cNeutral = { .r = 0.9, .g = 1.0, .b = 0.3, .a = 1. };
|
|
Color cFriend = { .r = 0.0, .g = 1.0, .b = 0.0, .a = 1. };
|
|
Color cHostile = { .r = 0.9, .g = 0.2, .b = 0.2, .a = 1. };
|
|
|
|
Color cRadar_player = { .r = 0.4, .g = 0.8, .b = 0.4, .a = 1. };
|
|
Color cRadar_targ = { .r = 0.0, .g = 0.7, .b = 1.0, .a = 1. };
|
|
Color cRadar_weap = { .r = 0.8, .g = 0.2, .b = 0.2, .a = 1. };
|
|
// Bars.
|
|
Color cShield = { .r = 0.2, .g = 0.2, .b = 0.8, .a = 1. };
|
|
Color cArmor = { .r = 0.5, .g = 0.5, .b = 0.5, .a = 1. };
|
|
Color cEnergy = { .r = 0.2, .g = 0.8, .b = 0.2, .a = 1. };
|
|
|
|
typedef enum { RADAR_RECT, RADAR_CIRCLE } RadarShape;
|
|
|
|
typedef struct {
|
|
double w,h; // Dimensions.
|
|
RadarShape shape;
|
|
double res; // Resolution.
|
|
} Radar;
|
|
|
|
// Radar res.
|
|
#define RADAR_RES_MAX 100.
|
|
#define RADAR_RES_MIN 10.
|
|
#define RADAR_RES_INTERVAL 10.
|
|
#define RADAR_RES_DEFAULT 40.
|
|
|
|
typedef struct {
|
|
double w,h;
|
|
} Rect;
|
|
|
|
typedef struct {
|
|
// Graphics.
|
|
gl_font smallFont;
|
|
gl_texture* gfx_frame;
|
|
gl_texture* gfx_targetPilot, *gfx_targetPlanet;
|
|
Radar radar;
|
|
Rect shield, armor, energy;
|
|
// Positions.
|
|
Vec2 pos_frame;
|
|
Vec2 pos_radar;
|
|
Vec2 pos_shield, pos_armor, pos_energy;
|
|
Vec2 pos_target, pos_target_health, pos_target_name, pos_target_faction;
|
|
Vec2 pos_msg;
|
|
} GUI;
|
|
|
|
GUI gui; // Le Gui!
|
|
|
|
double gui_xoff = 0.;
|
|
double gui_yoff = 0.;
|
|
|
|
// Messages.
|
|
#define MSG_SIZE_MAX 80
|
|
int msg_timeout = 5000;
|
|
int msg_max = 5; // Max messages on screen.
|
|
typedef struct {
|
|
char str[MSG_SIZE_MAX];
|
|
unsigned int t;
|
|
} Msg;
|
|
static Msg* msg_stack;
|
|
|
|
// External.
|
|
extern void pilot_render(Pilot* pilot); // Extern is in Pilot.*
|
|
// Internal.
|
|
void gui_renderPilot(Pilot* p);
|
|
void gui_renderBar(Color* c, Vec2* p, Rect* r, double w);
|
|
|
|
void player_message(const char* fmt, ...) {
|
|
va_list ap;
|
|
int i;
|
|
|
|
if(fmt == NULL) return; // Message not valid.
|
|
|
|
for(i = 1; i < msg_max; i++)
|
|
if(msg_stack[msg_max-i-1].str[0] != '\0') {
|
|
strcpy(msg_stack[msg_max-i].str, msg_stack[msg_max-i-1].str);
|
|
msg_stack[msg_max-i].t = msg_stack[msg_max-i-1].t;
|
|
}
|
|
va_start(ap, fmt);
|
|
vsprintf(msg_stack[0].str, fmt, ap);
|
|
va_end(ap);
|
|
|
|
msg_stack[0].t = SDL_GetTicks() + msg_timeout;
|
|
}
|
|
|
|
// Render the player.
|
|
void player_render(void) {
|
|
int i, j;
|
|
Pilot* p;
|
|
Vec2 v;
|
|
|
|
// Render the player target graphics.
|
|
if(player_target != PLAYER_ID) {
|
|
p = pilot_get(player_target);
|
|
|
|
vect_csetmin(&v, VX(p->solid->pos) - p->ship->gfx_space->sw * PILOT_SIZE_APROX/2.,
|
|
VY(p->solid->pos) + p->ship->gfx_space->sh * PILOT_SIZE_APROX/2.);
|
|
gl_blitSprite(gui.gfx_targetPilot, &v, 0, 0); // Top left.
|
|
VX(v) += p->ship->gfx_space->sw * PILOT_SIZE_APROX;
|
|
gl_blitSprite(gui.gfx_targetPilot, &v, 1, 0); // Top right.
|
|
VY(v) -= p->ship->gfx_space->sh * PILOT_SIZE_APROX;
|
|
gl_blitSprite(gui.gfx_targetPilot, &v, 1, 1); // Bottom right.
|
|
VX(v) -= p->ship->gfx_space->sw * PILOT_SIZE_APROX;
|
|
gl_blitSprite(gui.gfx_targetPilot, &v, 0, 1); // Bottom left.
|
|
}
|
|
|
|
// Render the player.
|
|
pilot_render(player);
|
|
|
|
// GUI!
|
|
// -- Frame.
|
|
gl_blitStatic(gui.gfx_frame, &gui.pos_frame);
|
|
// -- Radar.
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glTranslated(VX(gui.pos_radar) - gl_screen.w/2. + gui.radar.w/2.,
|
|
VY(gui.pos_radar) - gl_screen.h/2. - gui.radar.h/2., 0.);
|
|
|
|
switch(gui.radar.shape) {
|
|
case RADAR_RECT:
|
|
// Planets.
|
|
COLOR(cFriend);
|
|
planets_minimap(gui.radar.res, gui.radar.w, gui.radar.h);
|
|
|
|
// Weapons.
|
|
glBegin(GL_POINTS);
|
|
COLOR(cRadar_weap);
|
|
weapon_minimap(gui.radar.res, gui.radar.w, gui.radar.h);
|
|
glEnd(); // Put end to those points.
|
|
for(j = 0, i = 1; i < pilots; i++) {
|
|
// Skip the player.
|
|
if(pilot_stack[i]->id == player_target) j = i;
|
|
else gui_renderPilot(pilot_stack[i]);
|
|
}
|
|
// Render the targetted pilot.
|
|
if(j != 0) gui_renderPilot(pilot_stack[j]);
|
|
glBegin(GL_POINTS); // For ze player.
|
|
break;
|
|
case RADAR_CIRCLE:
|
|
glBegin(GL_POINTS);
|
|
for(i = 1; i < pilots; i++) {
|
|
p = pilot_stack[i];
|
|
COLOR(cNeutral);
|
|
glVertex2d((p->solid->pos.x - player->solid->pos.x) / gui.radar.res,
|
|
(p->solid->pos.y - player->solid->pos.y) / gui.radar.res);
|
|
}
|
|
break;
|
|
}
|
|
// Player. -- Drawn last.
|
|
COLOR(cRadar_player);
|
|
glVertex2d( 0., 2. ); // We represent the player with a small '+'
|
|
glVertex2d( 0., 1. );
|
|
glVertex2d( 0., 0. );
|
|
glVertex2d( 0., -1. );
|
|
glVertex2d( 0., -2. );
|
|
glVertex2d( 2., 0. );
|
|
glVertex2d( 1., 0. );
|
|
glVertex2d( -1., 0. );
|
|
glVertex2d( -2., 0. );
|
|
|
|
glEnd();
|
|
|
|
glPopMatrix(); // GL_PROJECTION.
|
|
|
|
// Health.
|
|
gui_renderBar(&cShield, &gui.pos_shield, &gui.shield, player->shield / player->shield_max);
|
|
gui_renderBar(&cArmor, &gui.pos_armor, &gui.armor, player->armor / player->armor_max);
|
|
gui_renderBar(&cEnergy, &gui.pos_energy, &gui.energy, player->energy / player->energy_max);
|
|
|
|
// Target.
|
|
if(player_target != PLAYER_ID) {
|
|
p = pilot_get(player_target);
|
|
|
|
gl_blitStatic(p->ship->gfx_target, &gui.pos_target);
|
|
|
|
// Target name.
|
|
gl_print(NULL, &gui.pos_target_name, "%s", p->name);
|
|
gl_print(&gui.smallFont, &gui.pos_target_faction, "%s", p->faction->name);
|
|
|
|
// Target status.
|
|
if(p->armor < p->armor_max * PILOT_DISABLED)
|
|
// Disable the pilot.
|
|
gl_print(&gui.smallFont, &gui.pos_target_health, "Disabled");
|
|
else if(p->shield > p->shield_max / 100.)
|
|
// On shields.
|
|
gl_print(&gui.smallFont, &gui.pos_target_health, "%s: %.0f%%", "Shield", p->shield/p->shield_max*100.);
|
|
else
|
|
// On armor.
|
|
gl_print(&gui.smallFont, &gui.pos_target_health, "%s: %.0f%%", "Armor", p->armor/p->armor_max*100.);
|
|
}
|
|
// Messages.
|
|
VX(v) = VX(gui.pos_msg);
|
|
VY(v) = VY(gui.pos_msg) + (double)(gl_defFont.h*msg_max)*1.2;
|
|
for(i = 0; i < msg_max; i++) {
|
|
VY(v) -= (double)gl_defFont.h*1.2;
|
|
if(msg_stack[msg_max-i-1].str[0] != '\0') {
|
|
if(msg_stack[msg_max-i-1].t < SDL_GetTicks())
|
|
msg_stack[msg_max-i-1].str[0] = '\0';
|
|
else gl_print(NULL, &v, "%s", msg_stack[msg_max-i-1].str);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Renders a pilot.
|
|
void gui_renderPilot(Pilot* p) {
|
|
int x, y, sx, sy;
|
|
|
|
x = (p->solid->pos.x - player->solid->pos.x) / gui.radar.res;
|
|
y = (p->solid->pos.y - player->solid->pos.y) / gui.radar.res;
|
|
sx = PILOT_SIZE_APROX/2. * p->ship->gfx_space->sw / gui.radar.res;
|
|
sy = PILOT_SIZE_APROX/2. * p->ship->gfx_space->sh / gui.radar.res;
|
|
if(sx < 1.) sx = 1.;
|
|
if(sy < 1.) sy = 1.;
|
|
|
|
if((ABS(x) > gui.radar.w/2+sx) || (ABS(y) > gui.radar.h/2.+sy))
|
|
return; // Pilot isn't in range.
|
|
|
|
glBegin(GL_QUADS);
|
|
// Colors.
|
|
if(p->id == player_target) COLOR(cRadar_targ);
|
|
else if(pilot_isFlag(p, PILOT_HOSTILE)) COLOR(cHostile);
|
|
else COLOR(cNeutral);
|
|
|
|
// Image.
|
|
glVertex2d(MAX(x-sx, -gui.radar.w/2.), MIN(y+sy, gui.radar.h/2)); // Top left.
|
|
glVertex2d(MIN(x+sx, gui.radar.w/2.), MIN(y+sy, gui.radar.h/2)); // Top right.
|
|
glVertex2d(MIN(x+sx, gui.radar.w/2.), MAX(y-sy, -gui.radar.h/2)); // Bottom right.
|
|
glVertex2d(MAX(x-sx, -gui.radar.w/2.), MAX(y-sy, -gui.radar.h/2)); // Bottom left.
|
|
glEnd();
|
|
}
|
|
|
|
// Render a bar.
|
|
void gui_renderBar(Color* c, Vec2* p, Rect* r, double w) {
|
|
int x, y, sx, sy;
|
|
|
|
glBegin(GL_QUADS);
|
|
COLOR(*c);
|
|
x = VX(*p) - gl_screen.w/2.;
|
|
y = VY(*p) - gl_screen.h/2.;
|
|
sx = w * r->w;
|
|
sy = r->h;
|
|
glVertex2d(x, y);
|
|
glVertex2d(x+sx, y);
|
|
glVertex2d(x+sx, y-sy);
|
|
glVertex2d(x, y-sy);
|
|
glEnd();
|
|
}
|
|
|
|
// Init GUI.
|
|
int gui_init(void) {
|
|
// Font.
|
|
gl_fontInit(&gui.smallFont, NULL, 10);
|
|
// -- Targeting.
|
|
gui.gfx_targetPilot = gl_newSprite(GFX_GUI_TARG_PILOT, 2, 2);
|
|
gui.gfx_targetPlanet = gl_newSprite(GFX_GUI_TARG_PLANET, 2, 2);
|
|
// -- Frame.
|
|
gui.gfx_frame = gl_newImage(GFX_GUI_FRAME);
|
|
vect_csetmin(&gui.pos_frame,
|
|
gl_screen.w - gui.gfx_frame->w, // x.
|
|
gl_screen.h - gui.gfx_frame->h); // y.
|
|
gui_xoff = -gui.gfx_frame->w/2.; // Offset is only horizontal and on the right side.
|
|
|
|
// -- Radar.
|
|
gui.radar.res = RADAR_RES_DEFAULT;
|
|
gui.radar.w = 128.;
|
|
gui.radar.h = 128.;
|
|
gui.radar.shape = RADAR_RECT; //RADAR_CIRCLE;
|
|
vect_csetmin(&gui.pos_radar,
|
|
VX(gui.pos_frame) + 11, // x
|
|
VY(gui.pos_frame) + gui.gfx_frame->h - 10); // y.
|
|
|
|
// -- Bars.
|
|
gui.shield.w = gui.armor.w = gui.energy.w = 129;
|
|
gui.shield.h = gui.armor.h = gui.energy.h = 10;
|
|
vect_csetmin(&gui.pos_shield,
|
|
VX(gui.pos_frame) + 10, // x
|
|
VY(gui.pos_frame) + gui.gfx_frame->h - 201); // y.
|
|
|
|
vect_csetmin(&gui.pos_armor,
|
|
VX(gui.pos_frame) + 10, // x
|
|
VY(gui.pos_frame) + gui.gfx_frame->h - 218); // y.
|
|
|
|
vect_csetmin(&gui.pos_energy,
|
|
VX(gui.pos_frame) + 10, // x
|
|
VY(gui.pos_frame) + gui.gfx_frame->h - 236); // y.
|
|
|
|
// Target.
|
|
vect_csetmin(&gui.pos_target,
|
|
VX(gui.pos_frame) + 10,
|
|
VY(gui.pos_frame) + gui.gfx_frame->h - 256 - SHIP_TARGET_H);
|
|
|
|
vect_csetmin(&gui.pos_target_name,
|
|
VX(gui.pos_target) + 10,
|
|
VY(gui.pos_target) + SHIP_TARGET_H - 10 - gl_defFont.h);
|
|
|
|
vect_csetmin(&gui.pos_target_faction,
|
|
VX(gui.pos_target_name),
|
|
VY(gui.pos_target_name) - gui.smallFont.h - 4);
|
|
|
|
vect_csetmin(&gui.pos_target_health,
|
|
VX(gui.pos_target) + 10,
|
|
VY(gui.pos_target) +10);
|
|
|
|
// Message system.
|
|
vect_csetmin(&gui.pos_msg, 20, 30);
|
|
msg_stack = calloc(msg_max, sizeof(Msg));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
// Free the GUI.
|
|
void gui_free(void) {
|
|
gl_freeFont(&gui.smallFont);
|
|
|
|
gl_freeTexture(gui.gfx_frame);
|
|
gl_freeTexture(gui.gfx_targetPilot);
|
|
gl_freeTexture(gui.gfx_targetPlanet);
|
|
|
|
free(msg_stack);
|
|
}
|
|
|
|
// Used in pilot.c
|
|
// Basically uses keyboard input instead of AI input.
|
|
void player_think(Pilot* player) {
|
|
player->solid->dir_vel = 0.;
|
|
if(player_turn)
|
|
player->solid->dir_vel -= player->ship->turn * player_turn;
|
|
|
|
if(player_primary) pilot_shoot(player, 0);
|
|
|
|
vect_pset(&player->solid->force, player->ship->thrust * player_acc, player->solid->dir);
|
|
}
|
|
|
|
// ================
|
|
// INPUT!
|
|
// ================
|
|
// Initialization/exit functions (does not assign keys).
|
|
void input_init(void) {
|
|
Keybind* tmp;
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++); // Get number of bindings.
|
|
player_input = malloc(i*sizeof(Keybind*));
|
|
|
|
// Create a null keybinding for each.
|
|
for(i = 0; keybindNames[i]; i++) {
|
|
tmp = MALLOC_L(Keybind);
|
|
tmp->name = (char*)keybindNames[i];
|
|
tmp->type = KEYBIND_NULL;
|
|
tmp->key = 0;
|
|
tmp->reverse = 1.;
|
|
player_input[i] = tmp;
|
|
}
|
|
}
|
|
|
|
void input_exit(void) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++)
|
|
free(player_input[i]);
|
|
free(player_input);
|
|
}
|
|
|
|
// Binds key of type [type] to action keybind.
|
|
void input_setKeybind(char* keybind, KeybindType type, int key, int reverse) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++) {
|
|
if(strcmp(keybind, player_input[i]->name)==0) {
|
|
player_input[i]->type = type;
|
|
player_input[i]->key = key;
|
|
player_input[i]->reverse = reverse ? -1. : 1.;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// == Run input method. ================================================
|
|
// keynum : Index of the player_input keybind.
|
|
// value : Value of keypress (defined above).
|
|
// abs : Whether or not it's an abs value (For those pesky joysticks.
|
|
// =====================================================================
|
|
static void input_key(int keynum, double value, int abs) {
|
|
if(strcmp(player_input[keynum]->name, "accel")==0) {
|
|
if(abs)player_acc = value;
|
|
else player_acc += value;
|
|
}
|
|
else if(strcmp(player_input[keynum]->name, "left")==0) {
|
|
if(abs)player_turn = -value;
|
|
else player_turn -= value;
|
|
}
|
|
else if(strcmp(player_input[keynum]->name, "right")==0) {
|
|
if(abs) player_turn = value;
|
|
else player_turn += value;
|
|
}
|
|
// Shoot primary weapon. BOOM BOOM.
|
|
else if(strcmp(player_input[keynum]->name, "primary")==0) {
|
|
if(value == KEY_PRESS) player_primary = 1;
|
|
else if(value == KEY_RELEASE) player_primary = 0;
|
|
}
|
|
// Targetting.
|
|
else if(strcmp(player_input[keynum]->name, "target")==0) {
|
|
if(value == KEY_PRESS) player_target = pilot_getNext(player_target);
|
|
}
|
|
else if(strcmp(player_input[keynum]->name, "target_nearest")==0) {
|
|
if(value == KEY_PRESS) player_target = pilot_getHostile();
|
|
}
|
|
// Zoom in.
|
|
else if(strcmp(player_input[keynum]->name, "mapzoomin")==0) {
|
|
if(value == KEY_PRESS && gui.radar.res < RADAR_RES_MAX)
|
|
gui.radar.res += RADAR_RES_INTERVAL;
|
|
}
|
|
// Zoom out.
|
|
else if(strcmp(player_input[keynum]->name, "mapzoomout")==0) {
|
|
if(value == KEY_PRESS && gui.radar.res > RADAR_RES_MIN)
|
|
gui.radar.res -= RADAR_RES_INTERVAL;
|
|
}
|
|
|
|
//Make sure values are sane.
|
|
player_acc = ABS(player_acc);
|
|
if(player_acc > 1.) player_acc = 1.;
|
|
if(player_turn > 1.) player_turn = 1.;
|
|
else if(player_turn < -1.) player_turn = -1.;
|
|
}
|
|
|
|
// --Events--
|
|
|
|
static void input_joyaxis(const unsigned int axis, const int value);
|
|
static void input_joydown(const unsigned int button);
|
|
static void input_joyup(const unsigned int button);
|
|
static void input_keydown(SDLKey key);
|
|
static void input_keyup(SDLKey key);
|
|
|
|
// Joystick.
|
|
|
|
// Axis.
|
|
static void input_joyaxis(const unsigned int axis, const int value) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++)
|
|
if(player_input[i]->type == KEYBIND_JAXIS && player_input[i]->key == axis) {
|
|
input_key(i, -(player_input[i]->reverse) * (double)value / 32767., 1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Joystick button down.
|
|
static void input_joydown(const unsigned int button) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++)
|
|
if(player_input[i]->type == KEYBIND_JBUTTON && player_input[i]->key == button) {
|
|
input_key(i, KEY_RELEASE, 0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Joystick button up.
|
|
static void input_joyup(const unsigned int button) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++)
|
|
if(player_input[i]->type == KEYBIND_JBUTTON && player_input[i]->key == button) {
|
|
input_key(i, KEY_RELEASE, 0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Keyboard.
|
|
|
|
// Key down.
|
|
static void input_keydown(SDLKey key) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++)
|
|
if(player_input[i]->type == KEYBIND_KEYBOARD && player_input[i]->key == key) {
|
|
input_key(i, KEY_PRESS, 0);
|
|
return;
|
|
}
|
|
|
|
// Fire Escape.
|
|
SDL_Event quit;
|
|
if(key == SDLK_ESCAPE) {
|
|
quit.type = SDL_QUIT;
|
|
SDL_PushEvent(&quit);
|
|
}
|
|
}
|
|
|
|
// Key up.
|
|
static void input_keyup(SDLKey key) {
|
|
int i;
|
|
for(i = 0; keybindNames[i]; i++)
|
|
if(player_input[i]->type == KEYBIND_KEYBOARD && player_input[i]->key == key) {
|
|
input_key(i, KEY_RELEASE, 0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Global input.
|
|
|
|
// Just seperates the event types.
|
|
void input_handle(SDL_Event* event) {
|
|
switch(event->type) {
|
|
case SDL_JOYAXISMOTION:
|
|
input_joyaxis(event->jaxis.axis, event->jaxis.value);
|
|
break;
|
|
case SDL_JOYBUTTONDOWN:
|
|
input_joydown(event->jbutton.button);
|
|
break;
|
|
case SDL_JOYBUTTONUP:
|
|
input_joyup(event->jbutton.button);
|
|
break;
|
|
case SDL_KEYDOWN:
|
|
input_keydown(event->key.keysym.sym);
|
|
break;
|
|
case SDL_KEYUP:
|
|
input_keyup(event->key.keysym.sym);
|
|
break;
|
|
}
|
|
}
|
|
|