static void game_draw_items(struct s_rend *rend,
const struct s_vary *vary,
const float *bill_M, float t)
{
int hi;
int type = ITEM_NONE;
int value = 0;
sol_color_mtrl(rend, 1);
{
for (hi = 0; hi < vary->hc; hi++)
{
struct v_item *hp = &vary->hv[hi];
/* Skip picked up items. */
if (hp->t == ITEM_NONE)
continue;
/* Lazily update color. */
if (hp->t != type || hp->n != value)
{
float c[4];
item_color(hp, c);
glColor4f(c[0], c[1], c[2], c[3]);
type = hp->t;
value = hp->n;
}
/* Draw model. */
glPushMatrix();
{
glTranslatef(hp->p[0],
hp->p[1],
hp->p[2]);
item_draw(rend, hp, bill_M, t);
}
glPopMatrix();
}
}
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
sol_color_mtrl(rend, 0);
}
void item_draw(const struct s_item *hp, float r)
{
float c[3];
struct s_file *fp = NULL;
switch (hp->t)
{
case ITEM_COIN: fp = &item_coin_file; break;
case ITEM_GROW: fp = &item_grow_file; break;
case ITEM_SHRINK: fp = &item_shrink_file; break;
}
item_color(hp, c);
glColor3fv(c);
sol_draw(fp, 0, 1);
}
static void game_run_cmd(const union cmd *cmd)
{
if (gd.state)
{
struct game_view *view = &gl.view[CURR];
struct game_tilt *tilt = &gl.tilt[CURR];
struct s_vary *vary = &gd.vary;
struct v_item *hp;
float v[4];
float dt;
int idx;
if (cs.next_update)
{
game_lerp_copy(&gl);
cs.next_update = 0;
}
switch (cmd->type)
{
case CMD_END_OF_UPDATE:
cs.got_tilt_axes = 0;
cs.next_update = 1;
if (cs.first_update)
{
game_lerp_copy(&gl);
/* Hack to sync state before the next update. */
game_lerp_apply(&gl, &gd);
cs.first_update = 0;
break;
}
/* Compute gravity for particle effects. */
if (status == GAME_GOAL)
game_tilt_grav(v, GRAVITY_UP, tilt);
else
game_tilt_grav(v, GRAVITY_DN, tilt);
/* Step particle, goal and jump effects. */
if (cs.ups > 0)
{
dt = 1.0f / cs.ups;
if (gd.goal_e && gl.goal_k[CURR] < 1.0f)
gl.goal_k[CURR] += dt;
if (gd.jump_b)
{
gl.jump_dt[CURR] += dt;
if (gl.jump_dt[PREV] >= 1.0f)
gd.jump_b = 0;
}
part_step(v, dt);
}
break;
case CMD_MAKE_BALL:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_MAKE_ITEM:
/* Allocate and initialize a new item. */
if ((hp = realloc(vary->hv, sizeof (*hp) * (vary->hc + 1))))
{
vary->hv = hp;
hp = &vary->hv[vary->hc];
vary->hc++;
memset(hp, 0, sizeof (*hp));
v_cpy(hp->p, cmd->mkitem.p);
hp->t = cmd->mkitem.t;
hp->n = cmd->mkitem.n;
}
break;
case CMD_PICK_ITEM:
/* Set up particle effects and discard the item. */
if ((idx = cmd->pkitem.hi) >= 0 && idx < vary->hc)
{
hp = &vary->hv[idx];
item_color(hp, v);
part_burst(hp->p, v);
hp->t = ITEM_NONE;
}
break;
case CMD_TILT_ANGLES:
if (!cs.got_tilt_axes)
{
/*
* Neverball <= 1.5.1 does not send explicit tilt
* axes, rotation happens directly around view
* vectors. So for compatibility if at the time of
* receiving tilt angles we have not yet received the
* tilt axes, we use the view vectors.
*/
game_tilt_axes(tilt, view->e);
}
tilt->rx = cmd->tiltangles.x;
tilt->rz = cmd->tiltangles.z;
break;
case CMD_SOUND:
/* Play the sound. */
if (cmd->sound.n)
audio_play(cmd->sound.n, cmd->sound.a);
break;
case CMD_TIMER:
timer = cmd->timer.t;
break;
case CMD_STATUS:
status = cmd->status.t;
break;
case CMD_COINS:
coins = cmd->coins.n;
break;
case CMD_JUMP_ENTER:
gd.jump_b = 1;
gd.jump_e = 0;
gl.jump_dt[PREV] = 0.0f;
gl.jump_dt[CURR] = 0.0f;
break;
case CMD_JUMP_EXIT:
gd.jump_e = 1;
break;
case CMD_MOVE_PATH:
case CMD_MOVE_TIME:
case CMD_BODY_PATH:
case CMD_BODY_TIME:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_GOAL_OPEN:
/*
* Enable the goal and make sure it's fully visible if
* this is the first update.
*/
if (!gd.goal_e)
{
gd.goal_e = 1;
gl.goal_k[CURR] = cs.first_update ? 1.0f : 0.0f;
}
break;
case CMD_SWCH_ENTER:
if ((idx = cmd->swchenter.xi) >= 0 && idx < vary->xc)
vary->xv[idx].e = 1;
break;
case CMD_SWCH_TOGGLE:
if ((idx = cmd->swchtoggle.xi) >= 0 && idx < vary->xc)
vary->xv[idx].f = !vary->xv[idx].f;
break;
case CMD_SWCH_EXIT:
if ((idx = cmd->swchexit.xi) >= 0 && idx < vary->xc)
vary->xv[idx].e = 0;
break;
case CMD_UPDATES_PER_SECOND:
cs.ups = cmd->ups.n;
break;
case CMD_BALL_RADIUS:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_CLEAR_ITEMS:
free(vary->hv);
vary->hv = NULL;
vary->hc = 0;
break;
case CMD_CLEAR_BALLS:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_BALL_POSITION:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_BALL_BASIS:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_BALL_PEND_BASIS:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_VIEW_POSITION:
v_cpy(view->p, cmd->viewpos.p);
break;
case CMD_VIEW_CENTER:
v_cpy(view->c, cmd->viewcenter.c);
break;
case CMD_VIEW_BASIS:
v_cpy(view->e[0], cmd->viewbasis.e[0]);
v_cpy(view->e[1], cmd->viewbasis.e[1]);
v_crs(view->e[2], view->e[0], view->e[1]);
break;
case CMD_CURRENT_BALL:
if ((idx = cmd->currball.ui) >= 0 && idx < vary->uc)
cs.curr_ball = idx;
break;
case CMD_PATH_FLAG:
if ((idx = cmd->pathflag.pi) >= 0 && idx < vary->pc)
vary->pv[idx].f = cmd->pathflag.f;
break;
case CMD_STEP_SIMULATION:
sol_lerp_cmd(&gl.lerp, &cs, cmd);
break;
case CMD_MAP:
/*
* Note a version (mis-)match between the loaded map and what
* the server has. (This doesn't actually load a map.)
*/
game_compat_map = (version.x == cmd->map.version.x);
break;
case CMD_TILT_AXES:
cs.got_tilt_axes = 1;
v_cpy(tilt->x, cmd->tiltaxes.x);
v_cpy(tilt->z, cmd->tiltaxes.z);
break;
case CMD_NONE:
case CMD_MAX:
break;
}
}
}
