#include <stdlib.h>
#include <time.h>
#include <assert.h>
+#include <imago2.h>
+#ifdef BUILD_VR
+#include <goatvr.h>
+#endif
+#include <drawtext.h>
#include "opengl.h"
#include "game.h"
#include "screen.h"
#include "cmesh.h"
#include "blocks.h"
+#include "logger.h"
+#include "gameinp.h"
+#include "color.h"
+
+#define FONTSZ 75
+
+int init_starfield(void);
+void draw_starfield(void);
static int init(void);
static void cleanup(void);
static void stop(void);
static void update(float dt);
static void draw(void);
-static void draw_block(int block, const int *pos, int rot);
+static void draw_block(int block, const int *pos, int rot, float sat, float alpha);
static void drawpf(void);
static void reshape(int x, int y);
static void keyboard(int key, int pressed);
static void motion(int x, int y);
static void wheel(int dir);
+static void update_cur_block(void);
static void addscore(int nlines);
static int spawn(void);
static int collision(int block, const int *pos);
wheel
};
-static struct cmesh *blkmesh;
-static float cam_theta, cam_phi, cam_dist = 30;
-static int bnstate[16];
+static struct cmesh *blkmesh, *wellmesh;
+static unsigned int tex_well;
+
+static struct dtx_font *scorefont;
+
+static float cam_theta, cam_phi, cam_dist;
+static float cam_height;
+static unsigned int bnstate;
static int prev_mx, prev_my;
static long tick_interval;
static int score, level, lines;
static int just_spawned;
+#ifdef BUILD_VR
+static int vrbn_a = 0, vrbn_x = 4;
+static float vrscale = 40.0f;
+#endif
+
#define NUM_LEVELS 21
static const long level_speed[NUM_LEVELS] = {
887, 820, 753, 686, 619, 552, 469, 368, 285, 184,
167, 151, 134, 117, 107, 98, 88, 79, 69, 60, 50
};
+static const float blkcolor[][4] = {
+ {1.0, 0.65, 0.0, 1},
+ {0.16, 1.0, 0.4, 1},
+ {0.65, 0.65, 1.0, 1},
+ {1.0, 0.9, 0.1, 1},
+ {0.0, 1.0, 1.0, 1},
+ {1.0, 0.5, 1.0, 1},
+ {1.0, 0.35, 0.2, 1},
+ {0.5, 0.5, 0.5, 1}
+};
+
+#define GAMEOVER_FILL_RATE 50
+
static int init(void)
{
- if(!(blkmesh = cmesh_alloc())) {
+ if(!(scorefont = dtx_open_font("data/score.font", 0))) {
+ error_log("failed to open score font\n");
+ return -1;
+ }
+ dtx_prepare_range(scorefont, FONTSZ, 32, 127);
+ dtx_save_glyphmap("foo.ppm", dtx_get_glyphmap(scorefont, 0));
+
+ if(init_starfield() == -1) {
return -1;
}
- if(cmesh_load(blkmesh, "data/noisecube.obj") == -1) {
- fprintf(stderr, "failed to load block model\n");
+
+ if(!(blkmesh = cmesh_alloc()) || cmesh_load(blkmesh, "data/noisecube.obj") == -1) {
+ error_log("failed to load block mesh\n");
return -1;
}
+
+ if(!(wellmesh = cmesh_alloc()) || cmesh_load(wellmesh, "data/well.obj") == -1) {
+ error_log("failed to load well mesh\n");
+ return -1;
+ }
+
+ if(!(tex_well = img_gltexture_load("data/grid.png"))) {
+ error_log("failed to load well texture\n");
+ return -1;
+ }
+
return 0;
}
static void cleanup(void)
{
cmesh_free(blkmesh);
+ cmesh_free(wellmesh);
+ glDeleteTextures(1, &tex_well);
+ dtx_close_font(scorefont);
}
static void start(void)
{
srand(time(0));
+ glClearColor(0.12, 0.12, 0.18, 1);
+
pause = 0;
gameover = 0;
num_complines = 0;
next_block = rand() % NUM_BLOCKS;
memset(pfield, 0, PF_COLS * PF_ROWS * sizeof *pfield);
+
+ ginp_repeat(500, 75, GINP_LEFT | GINP_RIGHT | GINP_DOWN);
+
+ dtx_use_font(scorefont, FONTSZ);
+
+ cam_theta = 0;
+ cam_phi = 0;
+ cam_dist = 30;
+ cam_height = 0;
+
+#ifdef BUILD_VR
+ if(goatvr_invr()) {
+ int bn = goatvr_lookup_button("A");
+ if(bn >= 0) vrbn_a = bn;
+
+ bn = goatvr_lookup_button("X");
+ if(bn >= 0) vrbn_x = bn;
+
+ /* switch to VR-optimized camera parameters */
+ cam_theta = 0;
+ cam_phi = -2.5;
+ cam_dist = 20;
+ cam_height = 3.5;
+ vrscale = 40.0f;
+
+ goatvr_set_units_scale(vrscale);
+ }
+#endif
}
static void stop(void)
{
+ goatvr_set_units_scale(1.0f);
+}
+
+#define JTHRES 0.6
+
+#define CHECK_BUTTON(idx, gbn) \
+ if(joy_bnstate & (1 << idx)) { \
+ ginp_bnstate |= gbn; \
+ }
+
+static void update_input(float dtsec)
+{
+#ifdef BUILD_VR
+ int num_vr_sticks;
+
+ if(goatvr_invr() && (num_vr_sticks = goatvr_num_sticks()) > 0) {
+ float p[2];
+
+ goatvr_stick_pos(0, p);
+ p[1] *= 0.65; /* drops harder to trigger accidentally */
+
+ if(fabs(p[0]) > fabs(joy_axis[GPAD_LSTICK_X])) {
+ joy_axis[GPAD_LSTICK_X] = p[0];
+ }
+ if(fabs(p[1]) > fabs(joy_axis[GPAD_LSTICK_Y])) {
+ joy_axis[GPAD_LSTICK_Y] = -p[1];
+ }
+
+ if(goatvr_button_state(vrbn_a)) {
+ joy_bnstate |= 1 << GPAD_A;
+ }
+ if(goatvr_button_state(vrbn_x)) {
+ joy_bnstate |= 1 << GPAD_START;
+ }
+ if(goatvr_action(0, GOATVR_ACTION_TRIGGER) || goatvr_action(1, GOATVR_ACTION_TRIGGER)) {
+ joy_bnstate |= 1 << GPAD_UP;
+ }
+ }
+#endif /* BUILD_VR */
+
+ ginp_bnstate = 0;
+
+ /* joystick axis */
+ if(joy_axis[GPAD_LSTICK_X] >= JTHRES) {
+ ginp_bnstate |= GINP_RIGHT;
+ } else if(joy_axis[GPAD_LSTICK_X] <= -JTHRES) {
+ ginp_bnstate |= GINP_LEFT;
+ }
+
+ if(joy_axis[GPAD_LSTICK_Y] >= JTHRES) {
+ ginp_bnstate |= GINP_DOWN;
+ } else if(joy_axis[GPAD_LSTICK_Y] <= -JTHRES) {
+ ginp_bnstate |= GINP_UP;
+ }
+
+ CHECK_BUTTON(GPAD_LEFT, GINP_LEFT);
+ CHECK_BUTTON(GPAD_RIGHT, GINP_RIGHT);
+ CHECK_BUTTON(GPAD_UP, GINP_UP);
+ CHECK_BUTTON(GPAD_DOWN, GINP_DOWN);
+ CHECK_BUTTON(GPAD_A, GINP_ROTATE);
+ CHECK_BUTTON(GPAD_START, GINP_PAUSE);
+
+ update_ginp();
+
+ if(GINP_PRESS(GINP_LEFT)) {
+ game_keyboard('a', 1);
+ }
+ if(GINP_PRESS(GINP_RIGHT)) {
+ game_keyboard('d', 1);
+ }
+ if(GINP_PRESS(GINP_DOWN)) {
+ game_keyboard('s', 1);
+ }
+ if(GINP_PRESS(GINP_UP)) {
+ game_keyboard('\t', 1);
+ }
+ if(GINP_PRESS(GINP_ROTATE)) {
+ game_keyboard('w', 1);
+ }
+ if(GINP_PRESS(GINP_PAUSE)) {
+ game_keyboard('p', 1);
+ }
+
+#ifdef BUILD_VR
+ memset(joy_axis, 0, sizeof joy_axis);
+ joy_bnstate = 0;
+#endif
}
static void update(float dtsec)
static long prev_tick;
long dt;
+ update_input(dtsec);
+
if(pause) {
prev_tick = time_msec;
return;
}
dt = time_msec - prev_tick;
- /*
if(gameover) {
int i, row = PF_ROWS - gameover;
- int *ptr;
+ unsigned int *ptr;
if(dt < GAMEOVER_FILL_RATE) {
return;
if(row >= 0) {
ptr = pfield + row * PF_COLS;
for(i=0; i<PF_COLS; i++) {
- *ptr++ = TILE_GAMEOVER;
+ *ptr++ = PF_VIS | PF_FULL | 7;
}
gameover++;
- prev_tick = msec;
+ prev_tick = time_msec;
}
return;
}
- */
if(num_complines) {
/* lines where completed, we're in blinking mode */
unsigned int *ptr = pfield + complines[i] * PF_COLS;
for(j=0; j<PF_COLS; j++) {
*ptr = (*ptr & ~PF_VIS) | ((blink & 1) << PF_VIS_SHIFT);
+ ptr++;
}
}
return;
dt -= tick_interval;
prev_tick = time_msec;
}
+
+ update_cur_block();
}
static void draw(void)
{
+ static const int nextblk_pos[] = {0, 0};
+ static const float lpos[] = {-1, 1, 6, 1};
+ float t;
+
glTranslatef(0, 0, -cam_dist);
glRotatef(cam_phi, 1, 0, 0);
glRotatef(cam_theta, 0, 1, 0);
+ glTranslatef(0, -cam_height, 0);
+
+ glLightfv(GL_LIGHT0, GL_POSITION, lpos);
+
+ draw_starfield();
+
+ glPushAttrib(GL_ENABLE_BIT);
+ glEnable(GL_COLOR_MATERIAL);
+ glBindTexture(GL_TEXTURE_2D, tex_well);
+ glEnable(GL_TEXTURE_2D);
+ //glDisable(GL_LIGHTING);
+ glColor3f(1, 1, 1);
+ cmesh_draw(wellmesh);
+ glPopAttrib();
/* center playfield */
glPushMatrix();
- glTranslatef(-PF_COLS / 2, PF_ROWS / 2, 0);
+ glTranslatef(-PF_COLS / 2 + 0.5, PF_ROWS / 2 - 0.5, 0);
drawpf();
if(cur_block >= 0) {
- draw_block(cur_block, pos, cur_rot);
+ draw_block(cur_block, pos, cur_rot, 1.0f, 1.0f);
}
+ glPopMatrix();
+
+ glPushAttrib(GL_ENABLE_BIT);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glPushMatrix();
+ t = (float)time_msec / 1000.0f;
+ glTranslatef(-PF_COLS / 2 + 0.5 + PF_COLS + 3, PF_ROWS / 2 - 0.5, 0);
+ glTranslatef(1.5, -1, 0);
+ glRotatef(cos(t) * 8.0f, 1, 0, 0);
+ glRotatef(sin(t * 1.2f) * 10.0f, 0, 1, 0);
+ glTranslatef(-1.5, 1, 0);
+ draw_block(next_block, nextblk_pos, 0, 0.25f, 0.75f);
glPopMatrix();
+ glPopAttrib();
+
+ glPushAttrib(GL_ENABLE_BIT);
+ glDisable(GL_LIGHTING);
+
+ glPushMatrix();
+ glTranslatef(-11, 6, 0);
+ glScalef(0.05, 0.05, 0.05);
+
+ glColor3f(1, 1, 1);
+ dtx_string("Score");
+ glTranslatef(0, -dtx_line_height() * 1.5, 0);
+ glPushMatrix();
+ glScalef(1.5, 1.5, 1.5);
+ dtx_printf("%d", score);
+ glPopMatrix();
+
+ glTranslatef(0, -dtx_line_height() * 2, 0);
+ dtx_string("Level");
+ glTranslatef(0, -dtx_line_height() * 1.5, 0);
+ glPushMatrix();
+ glScalef(1.5, 1.5, 1.5);
+ dtx_printf("%d", level);
+ glPopMatrix();
+
+ glTranslatef(0, -dtx_line_height() * 2, 0);
+ dtx_string("Lines");
+ glTranslatef(0, -dtx_line_height() * 1.5, 0);
+ glPushMatrix();
+ glScalef(1.5, 1.5, 1.5);
+ dtx_printf("%d", lines);
+ glPopMatrix();
+
+ glPopMatrix();
+ glPopAttrib();
}
-static void draw_block(int block, const int *pos, int rot)
+static const float blkspec[] = {0.85, 0.85, 0.85, 1};
+
+static void draw_block(int block, const int *pos, int rot, float sat, float alpha)
{
- int i, pal;
+ int i;
unsigned char *p = blocks[block][rot];
+ float col[4], hsv[3];
+
+ rgb_to_hsv(blkcolor[block][0], blkcolor[block][1], blkcolor[block][2],
+ hsv, hsv + 1, hsv + 2);
+ hsv_to_rgb(hsv[0], hsv[1] * sat, hsv[2], col, col + 1, col + 2);
+ col[3] = alpha;
- /*pal = FIRST_BLOCK_PAL + block;*/
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, col);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, blkspec);
+ glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0f);
for(i=0; i<4; i++) {
int x = pos[1] + BLKX(*p);
if(y < 0) continue;
glPushMatrix();
- glTranslatef(x, y, 0);
+ glTranslatef(x, -y, 0);
cmesh_draw(blkmesh);
glPopMatrix();
}
for(i=0; i<PF_ROWS; i++) {
for(j=0; j<PF_COLS; j++) {
unsigned int val = *sptr++;
- if(val & PF_FULL) {
+
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, blkcolor[val & 7]);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, blkspec);
+ glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0f);
+
+ if((val & (PF_FULL | PF_VIS)) == (PF_FULL | PF_VIS)) {
glPushMatrix();
- glTranslatef(j, i, 0);
+ glTranslatef(j, -i, 0);
cmesh_draw(blkmesh);
glPopMatrix();
}
switch(key) {
case 'a':
+ case KEY_LEFT:
if(!pause) {
next_pos[1] = pos[1] - 1;
if(collision(cur_block, next_pos)) {
break;
case 'd':
+ case KEY_RIGHT:
if(!pause) {
next_pos[1] = pos[1] + 1;
if(collision(cur_block, next_pos)) {
break;
case 'w':
+ case KEY_UP:
+ case ' ':
if(!pause) {
prev_rot = cur_rot;
cur_rot = (cur_rot + 1) & 3;
break;
case 's':
+ case KEY_DOWN:
/* ignore drops until the first update after a spawn */
if(cur_block >= 0 && !just_spawned && !pause) {
next_pos[0] = pos[0] + 1;
if(collision(cur_block, next_pos)) {
next_pos[0] = pos[0];
+ update_cur_block();
stick(cur_block, next_pos); /* stick immediately */
}
}
case '\n':
case '\t':
+ case '0':
if(!pause && cur_block >= 0) {
next_pos[0] = pos[0] + 1;
while(!collision(cur_block, next_pos)) {
next_pos[0]++;
}
next_pos[0]--;
+ update_cur_block();
stick(cur_block, next_pos); /* stick immediately */
}
break;
static void mouse(int bn, int pressed, int x, int y)
{
- bnstate[bn] = pressed;
+ if(pressed) {
+ bnstate |= 1 << bn;
+ } else {
+ bnstate &= ~(1 << bn);
+ }
prev_mx = x;
prev_my = y;
}
prev_mx = x;
prev_my = y;
- if(bnstate[0]) {
+ if(bnstate & 1) {
cam_theta += dx * 0.5;
cam_phi += dy * 0.5;
if(cam_phi < -90) cam_phi = -90;
if(cam_phi > 90) cam_phi = 90;
}
- if(bnstate[2]) {
+ if(bnstate & 2) {
+ cam_height += dy * 0.1;
+ }
+ if(bnstate & 4) {
cam_dist += dy * 0.1;
if(cam_dist < 0) cam_dist = 0;
}
+
+#ifdef DBG_PRINT_VIEW
+ if(bnstate) {
+ debug_log("Camera params\n");
+ debug_log(" theta: %g phi: %g dist: %g height: %g\n", cam_theta,
+ cam_phi, cam_dist, cam_height);
+ }
+#endif
}
static void wheel(int dir)
{
+ /* debug code, used to figure out the best scales */
+ /*
+ vrscale += dir * 0.01;
+ if(vrscale < 0.01) vrscale = 0.01;
+ goatvr_set_units_scale(vrscale);
+ debug_log("VR scale: %g\n", vrscale);
+ */
+}
+
+static void update_cur_block(void)
+{
+ if(cur_block < 0) return;
+
+ memcpy(pos, next_pos, sizeof pos);
+ prev_rot = cur_rot;
}
static void addscore(int nlines)
if(y < 0) continue;
+ if(x < 0 || x >= PF_COLS || y >= PF_ROWS) return 1;
if(pfield[y * PF_COLS + x] & PF_FULL) return 1;
}
projects / vrtris / blobdiff