-/*
+/*
* Copyright (C) 2003 Robert Kooima
*
* NEVERBALL is free software; you can redistribute it and/or modify
#include "geom.h"
#include "back.h"
#include "part.h"
-#include "hud.h"
#include "image.h"
#include "audio.h"
-#include "solid.h"
-#include "level.h"
+#include "solid_gl.h"
#include "config.h"
#include "binary.h"
+#include "level.h"
/*---------------------------------------------------------------------------*/
static struct s_file file;
static struct s_file back;
-static float clock = 0.f; /* Clock time */
+static float clock = 0.f; /* Clock time */
+static int clock_down = 1; /* Clock go up or down? */
static float game_ix; /* Input rotation about X axis */
static float game_iz; /* Input rotation about Z axis */
static float view_e[3][3]; /* Current view orientation */
static float view_k;
-static int goal_e = 0; /* Goal enabled flag */
+static int coins = 0; /* Collected coins */
+static int goal_c = 0; /* Goal coins remaining (0 = open) */
static float goal_k = 0; /* Goal animation */
-static int goal_s = 0; /* Goal reached flag */
-static int swch_e = 1; /* Switching enabled flag */
static int jump_e = 1; /* Jumping enabled flag */
static int jump_b = 0; /* Jump-in-progress flag */
static float jump_dt; /* Jump duration */
static float jump_p[3]; /* Jump destination */
static float fade_k = 0.0; /* Fade in/out level */
static float fade_d = 0.0; /* Fade in/out direction */
+static int drawball = 1; /* Should the ball be drawn? */
+static int ball_b = 0; /* Is the ball a bonus ball? */
+
+static int grow = 0; /* Should the ball be changing size? */
+static float grow_orig = 0; /* the original ball size */
+static float grow_goal = 0; /* how big or small to get! */
+static float grow_t = 0.0; /* timer for the ball to grow... */
+static float grow_strt = 0; /* starting value for growth */
+static int got_orig = 0; /* Do we know original ball size? */
+
+#define GROW_TIME 0.5f /* sec for the ball to get to size. */
+#define GROW_BIG 1.5f /* large factor */
+#define GROW_SMALL 0.5f /* small factor */
/*---------------------------------------------------------------------------*/
+static void grow_set(const struct s_file *fp, int size)
+{
+ if (!got_orig)
+ {
+ grow_orig = fp->uv->r;
+ grow_goal = grow_orig;
+ grow_strt = grow_orig;
+ got_orig = 1;
+ }
+
+ if (size == 50)
+ {
+ if (grow_goal == grow_orig * GROW_SMALL)
+ return;
+ else if (grow_goal == grow_orig * GROW_BIG)
+ {
+ grow = 1;
+ grow_goal = grow_orig;
+ }
+ else
+ {
+ grow_goal = grow_orig * GROW_SMALL;
+ grow = 1;
+ }
+ }
+ if (size == 150)
+ {
+ if (grow_goal == grow_orig * GROW_BIG)
+ return;
+ else if (grow_goal == grow_orig * GROW_SMALL)
+ {
+ grow = 1;
+ grow_goal = grow_orig;
+ }
+ else
+ {
+ grow_goal = grow_orig * GROW_BIG;
+ grow = 1;
+ }
+ }
+
+ if (grow)
+ {
+ grow_t = 0.0;
+ grow_strt = fp->uv->r;
+ }
+}
+
+static void grow_ball(const struct s_file *fp, float dt)
+{
+ float dr;
+
+ /* Calculate new size based on how long since you touched the coin... */
+
+ grow_t += dt;
+
+ if (grow_t >= GROW_TIME)
+ {
+ grow = 0;
+ grow_t = GROW_TIME;
+ }
+
+ dr = grow_strt + ((grow_goal-grow_strt) * (1.0f / (GROW_TIME / grow_t)));
+
+ /* No sinking through the floor! Keeps ball's bottom constant. */
+ fp->uv->p[1] += (dr - fp->uv->r);
+ fp->uv->r = dr;
+}
+
static void view_init(void)
{
view_a = 0.f;
view_e[2][2] = 1.f;
}
-int game_init(const char *file_name,
- const char *back_name,
- const char *grad_name, int t, int e)
+int game_init(const struct level *level, int t, int g)
{
- if (level_mode() == MODE_FREE)
- clock = 0.f;
- else
- clock = (float) t / 100.f;
+ clock = (float) t / 100.f;
+ clock_down = (t > 0);
+ coins = 0;
if (game_state)
game_free();
+ if (!sol_load_gl(&file, level->file, config_get_d(CONFIG_TEXTURES),
+ config_get_d(CONFIG_SHADOW)))
+ return (game_state = 0);
+
+ game_state = 1;
+
game_ix = 0.f;
game_iz = 0.f;
game_rx = 0.f;
game_rz = 0.f;
+ drawball = 1;
+
/* Initialize jump and goal states. */
jump_e = 1;
jump_b = 0;
- goal_e = e ? 1 : 0;
- goal_k = e ? 1.0f : 0.0f;
- goal_s = 0;
-
- /* Reset the hud. */
+ goal_c = g;
+ goal_k = (g == 0) ? 1.0f : 0.0f;
- hud_ball_pulse(0.f);
- hud_time_pulse(0.f);
- hud_coin_pulse(0.f);
+ ball_b = level->is_bonus;
/* Initialise the level, background, particles, fade, and view. */
part_reset(GOAL_HEIGHT);
view_init();
- back_init(grad_name, config_get_d(CONFIG_GEOMETRY));
-
- if (sol_load(&back, config_data(back_name),
- config_get_d(CONFIG_TEXTURES), 0) &&
- sol_load(&file, config_data(file_name),
- config_get_d(CONFIG_TEXTURES), config_get_d(CONFIG_SHADOW)))
- return (game_state = 1);
- else
- return (game_state = 0);
+ back_init(level->grad, config_get_d(CONFIG_GEOMETRY));
+
+ sol_load_gl(&back, config_data(level->back),
+ config_get_d(CONFIG_TEXTURES), 0);
+
+ /* Initialize ball size tracking... */
+
+ got_orig = 0;
+
+ return game_state;
}
void game_free(void)
{
if (game_state)
{
- sol_free(&file);
- sol_free(&back);
+ sol_free_gl(&file);
+ sol_free_gl(&back);
back_free();
}
game_state = 0;
return (int) (clock * 100.f);
}
-char *curr_intro(void)
+int curr_coins(void)
{
- return (file.ac > 0) ? file.av : NULL;
+ return coins;
+}
+
+int curr_goal(void)
+{
+ return goal_c;
}
/*---------------------------------------------------------------------------*/
glColor4fv(c);
- ball_draw();
+ ball_draw(ball_b);
}
glPopMatrix();
}
int ci;
coin_push();
+ coin_push_text(0); /* Regular coins. */
{
for (ci = 0; ci < fp->cc; ci++)
- if (fp->cv[ci].n > 0)
+
+ if (fp->cv[ci].n > 0 && fp->cv[ci].n < 50)
+ {
+ glPushMatrix();
+ {
+ glTranslatef(fp->cv[ci].p[0],
+ fp->cv[ci].p[1],
+ fp->cv[ci].p[2]);
+ glRotatef(r, 0.0f, 1.0f, 0.0f);
+ coin_draw(fp->cv[ci].n, r);
+ }
+ glPopMatrix();
+ }
+ }
+ coin_pull();
+
+ /* FIXME: there has got to be a better way than three seperate loops, once
+ * for each texture, but someone else is going to have to do it! */
+
+ coin_push();
+ coin_push_text(50); /* Any shrink coins? */
+ {
+ for (ci = 0; ci < fp->cc; ci++)
+
+ if (fp->cv[ci].n == 50)
+ {
+ glPushMatrix();
+ {
+ glTranslatef(fp->cv[ci].p[0],
+ fp->cv[ci].p[1],
+ fp->cv[ci].p[2]);
+ glRotatef(r, 0.0f, 1.0f, 0.0f);
+ coin_draw(fp->cv[ci].n, r);
+ }
+ glPopMatrix();
+ }
+ }
+ coin_pull();
+
+ coin_push();
+ coin_push_text(150); /* Any grow coins? */
+ {
+ for (ci = 0; ci < fp->cc; ci++)
+
+ if (fp->cv[ci].n == 150)
{
glPushMatrix();
{
{
int zi;
- if (goal_e)
+ if (goal_c == 0)
for (zi = 0; zi < fp->zc; zi++)
{
glPushMatrix();
fp->zv[zi].p[1],
fp->zv[zi].p[2]);
- part_draw_goal(rx, ry, fp->zv[zi].r, goal_k);
+ part_draw_goal(rx, ry, fp->zv[zi].r, goal_k, fp->zv[zi].c);
glScalef(fp->zv[zi].r, goal_k, fp->zv[zi].r);
goal_draw();
fp->jv[ji].p[2]);
glScalef(fp->jv[ji].r, 1.f, fp->jv[ji].r);
- jump_draw();
+ jump_draw(!jump_e);
}
glPopMatrix();
}
for (xi = 0; xi < fp->xc; xi++)
{
+ if (fp->xv[xi].i)
+ continue;
glPushMatrix();
{
glTranslatef(fp->xv[xi].p[0],
fp->xv[xi].p[2]);
glScalef(fp->xv[xi].r, 1.f, fp->xv[xi].r);
- swch_draw(fp->xv[xi].f);
+ swch_draw(fp->xv[xi].f, fp->xv[xi].e);
}
glPopMatrix();
}
{
const float *ball_p = file.uv->p;
const float ball_r = file.uv->r;
-
+
glPushAttrib(GL_LIGHTING_BIT | GL_COLOR_BUFFER_BIT);
{
glPushMatrix();
sol_draw(&file);
- if (config_get_d(CONFIG_SHADOW))
+ if (config_get_d(CONFIG_SHADOW) && drawball)
{
shad_draw_set(ball_p, ball_r);
sol_shad(&file);
{
part_draw_coin(-rx * d, -ry);
game_draw_coins(&file);
- game_draw_balls(&file);
+ if (drawball)
+ game_draw_balls(&file);
}
game_draw_goals(&file, -rx * d, -ry);
game_draw_jumps(&file);
static void game_update_time(float dt, int b)
{
- int tick = (int) floor(clock);
- int tock = (int) floor(clock * 2);
-
- if (goal_e && goal_k < 1.0f)
+ if (goal_c == 0 && goal_k < 1.0f)
goal_k += dt;
/* The ticking clock. */
- if (b==2)
- clock += dt;
- else if (b)
+ if (b && clock_down)
{
if (clock < 600.f)
clock -= dt;
if (clock < 0.f)
clock = 0.f;
-
- if (0 < tick && tick <= 10 && tick == (int) ceil(clock))
- {
- audio_play(AUD_TICK, 1.f);
- hud_time_pulse(1.50);
- }
- else if (0 < tock && tock <= 10 && tock == (int) ceil(clock * 2))
- {
- audio_play(AUD_TOCK, 1.f);
- hud_time_pulse(1.25);
- }
+ }
+ else if (b)
+ {
+ clock += dt;
}
}
-static int game_update_state(void)
+static int game_update_state(int *state_value)
{
struct s_file *fp = &file;
float p[3];
float c[3];
- int n, e = swch_e;
+ int bt = state_value != NULL;
+ int n;
+ struct s_goal *g;
- /* Test for a coin grab and a possible 1UP. */
+ /* Test for a coin grab. */
- if ((n = sol_coin_test(fp, p, COIN_RADIUS)) > 0)
+ if (bt && (n = sol_coin_test(fp, p, COIN_RADIUS)) > 0)
{
coin_color(c, n);
part_burst(p, c);
- if (level_score(n))
- goal_e = 1;
+ /* Add coins if regular, change radius if not. */
+
+ if (n <= 10)
+ coins += n;
+ else
+ {
+ grow_set(fp, n);
+ n = 0;
+ }
+
+ /* Check for goal open. */
+ if (goal_c > 0)
+ {
+ goal_c = goal_c - n;
+ if (goal_c <= 0)
+ {
+ audio_play(AUD_SWITCH, 1.f);
+ goal_c = 0;
+ }
+ else
+ audio_play(AUD_COIN, 1.f);
+ }
+ else
+ audio_play(AUD_COIN, 1.f);
}
/* Test for a switch. */
-
- if ((swch_e = sol_swch_test(fp, swch_e, 0)) != e && e)
+ if (sol_swch_test(fp, 0))
audio_play(AUD_SWITCH, 1.f);
/* Test for a jump. */
jump_b = 1;
jump_e = 0;
jump_dt = 0.f;
-
+
audio_play(AUD_JUMP, 1.f);
}
if (jump_e == 0 && jump_b == 0 && sol_jump_test(fp, jump_p, 0) == 0)
/* Test for a goal. */
- if (goal_e && sol_goal_test(fp, p, 0))
+ if (bt && goal_c == 0 && (g = sol_goal_test(fp, p, 0)))
{
- if (!goal_s)
- {
- goal_s = 1;
- audio_play(AUD_GOAL, 1.0f);
- }
- return GAME_GOAL;
+ *state_value = g->s;
+ audio_play(AUD_GOAL, 1.0f);
+ return g->c ? GAME_SPEC : GAME_GOAL;
}
/* Test for time-out. */
- if (clock <= 0.f)
+ if (bt && clock_down && clock <= 0.f)
+ {
+ const GLfloat *p = fp->uv->p;
+ const GLfloat c[5] = {1.0f, 1.0f, 0.0f, 0.0f, 1.0f};
+ part_burst(p, c);
+ part_burst(p, c+1);
+ part_burst(p, c+2);
+ part_burst(p, c);
+ part_burst(p, c+1);
+ part_burst(p, c+2);
+ drawball = 0;
+ audio_play(AUD_TIME, 1.0f);
return GAME_TIME;
+ }
/* Test for fall-out. */
- if (fp->uv[0].p[1] < fp->vv[0].p[1])
+ if (bt && fp->uv[0].p[1] < fp->vv[0].p[1])
+ {
+ audio_play(AUD_FALL, 1.0f);
return GAME_FALL;
+ }
return GAME_NONE;
}
* graphics frame rate.
*/
-int game_step(const float g[3], float dt, int bt)
+int game_step(const float g[3], float dt, int *state_value)
{
struct s_file *fp = &file;
game_rz = game_iz;
}
+ if (grow)
+ grow_ball(fp, dt);
+
game_update_grav(h, g);
part_step(h, t);
- if (jump_b)
+ if (!drawball)
+ /* nothing */;
+ else if (jump_b)
{
jump_dt += t;
game_step_fade(dt);
game_update_view(dt);
- game_update_time(dt, bt);
+ game_update_time(dt, state_value != NULL);
- return game_update_state();
+ return game_update_state(state_value);
}
return GAME_NONE;
}
/*---------------------------------------------------------------------------*/
+void game_no_aa(void)
+{
+ float max = game_ix * game_ix + game_iz * game_iz;
+ if (max > ANGLE_BOUND * ANGLE_BOUND)
+ {
+ max = ANGLE_BOUND / sqrt(max);
+ game_ix *= max;
+ game_iz *= max;
+ }
+}
+
void game_set_x(int k)
{
- game_ix = -20.f * k / JOY_MAX;
+ game_ix = -(ANGLE_BOUND) * k / JOY_MAX;
+#if NO_AA
+ game_no_aa();
+#endif
}
void game_set_z(int k)
{
- game_iz = +20.f * k / JOY_MAX;
+ game_iz = +ANGLE_BOUND * k / JOY_MAX;
+#if NO_AA
+ game_no_aa();
+#endif
}
void game_set_pos(int x, int y)
{
- float bound = 20.f;
-
game_ix += 40.f * y / config_get_d(CONFIG_MOUSE_SENSE);
game_iz += 40.f * x / config_get_d(CONFIG_MOUSE_SENSE);
- if (game_ix > +bound) game_ix = +bound;
- if (game_ix < -bound) game_ix = -bound;
- if (game_iz > +bound) game_iz = +bound;
- if (game_iz < -bound) game_iz = -bound;
+#if NO_AA
+ game_no_aa();
+#else
+ if (game_ix > +ANGLE_BOUND) game_ix = +ANGLE_BOUND;
+ if (game_ix < -ANGLE_BOUND) game_ix = -ANGLE_BOUND;
+ if (game_iz > +ANGLE_BOUND) game_iz = +ANGLE_BOUND;
+ if (game_iz < -ANGLE_BOUND) game_iz = -ANGLE_BOUND;
+#endif
}
void game_set_rot(float r)
float p1[3] = { 0.f, 0.f, 0.f };
float v[3];
+ z[0] = fsinf(V_RAD(view_a));
+ z[2] = fcosf(V_RAD(view_a));
+
v_cpy(view_e[0], x);
v_cpy(view_e[1], y);
v_cpy(view_e[2], z);