void GAMECLIENT::update_local_character_pos()
{
if(config.cl_predict && client_state() != CLIENTSTATE_DEMOPLAYBACK)
{
if(!snap.local_character || (snap.local_character->health < 0) || (snap.gameobj && snap.gameobj->game_over))
{
// don't use predicted
}
else
local_character_pos = mix(predicted_prev_char.pos, predicted_char.pos, client_predintratick());
}
else if(snap.local_character && snap.local_prev_character)
{
local_character_pos = mix(
vec2(snap.local_prev_character->x, snap.local_prev_character->y),
vec2(snap.local_character->x, snap.local_character->y), client_intratick());
}
if(spectate_cid == -1)
freeview = true;
if(snap.spectate && !freeview)
{
if(!snap.characters[spectate_cid].active || clients[spectate_cid].team == -1)
{
freeview = true;
return;
}
spectate_pos = mix(
vec2(snap.characters[spectate_cid].prev.x, snap.characters[spectate_cid].prev.y),
vec2(snap.characters[spectate_cid].cur.x, snap.characters[spectate_cid].cur.y), client_intratick());
}
}
void NAMEPLATES::render_nameplate(
const NETOBJ_CHARACTER *prev_char,
const NETOBJ_CHARACTER *player_char,
const NETOBJ_PLAYER_INFO *player_info
)
{
float intratick = client_intratick();
vec2 position = mix(vec2(prev_char->x, prev_char->y), vec2(player_char->x, player_char->y), intratick);
// render name plate
if(!player_info->local)
{
//gfx_text_color
float a = 1;
if(config.cl_nameplates_always == 0)
a = clamp(1-powf(distance(gameclient.controls->target_pos, position)/200.0f,16.0f), 0.0f, 1.0f);
const char *name = gameclient.clients[player_info->cid].name;
float tw = gfx_text_width(0, 28.0f, name, -1);
gfx_text_color(1,1,1,a);
gfx_text(0, position.x-tw/2.0f, position.y-60, 28.0f, name, -1);
if(config.debug) // render client id when in debug aswell
{
char buf[128];
str_format(buf, sizeof(buf),"%d", player_info->cid);
gfx_text(0, position.x, position.y-90, 28.0f, buf, -1);
}
gfx_text_color(1,1,1,1);
}
}
void GAMECLIENT::update_local_character_pos()
{
if ( config.cl_predict && client_state() != CLIENTSTATE_DEMOPLAYBACK ) {
if ( snap.local_character && ( snap.local_character->health > 0 ) ) {
local_character_pos = mix( predicted_prev_char.pos,
predicted_char.pos, client_predintratick( ) );
}
} else if( snap.local_character && snap.local_prev_character ) {
local_character_pos = mix(
vec2(snap.local_prev_character->x, snap.local_prev_character->y),
vec2(snap.local_character->x, snap.local_character->y), client_intratick());
}
}
void ITEMS::render_flag(const NETOBJ_FLAG *prev, const NETOBJ_FLAG *current)
{
float angle = 0.0f;
float size = 42.0f;
if(gameclient.snap.local_info && current->carried_by == gameclient.snap.local_info->cid && config.tc_hide_carrying)
return;
gfx_blend_normal();
if(config.tc_colored_flags)
gfx_texture_set(data->images[IMAGE_GAME_GRAY].id);
else
gfx_texture_set(data->images[IMAGE_GAME].id);
gfx_quads_begin();
if(config.tc_colored_flags && gameclient.snap.local_info)
{
vec3 col = TeecompUtils::getTeamColor(current->team, gameclient.snap.local_info->team,
config.tc_colored_tees_team1, config.tc_colored_tees_team2, config.tc_colored_tees_method);
gfx_setcolor(col.r, col.g, col.b, 1.0f);
}
if(current->team == 0) // red team
select_sprite(SPRITE_FLAG_RED);
else
select_sprite(SPRITE_FLAG_BLUE);
gfx_quads_setrotation(angle);
vec2 pos = mix(vec2(prev->x, prev->y), vec2(current->x, current->y), client_intratick());
// make sure that the flag isn't interpolated between capture and return
if(prev->carried_by != current->carried_by)
pos = vec2(current->x, current->y);
// make sure to use predicted position if we are the carrier
if(gameclient.snap.local_info && current->carried_by == gameclient.snap.local_info->cid)
pos = gameclient.local_character_pos;
gfx_quads_draw(pos.x, pos.y-size*0.75f, size, size*2);
gfx_quads_end();
}
void ITEMS::render_pickup(const NETOBJ_PICKUP *prev, const NETOBJ_PICKUP *current)
{
gfx_texture_set(data->images[IMAGE_GAME].id);
gfx_quads_begin();
vec2 pos = mix(vec2(prev->x, prev->y), vec2(current->x, current->y), client_intratick());
float angle = 0.0f;
float size = 64.0f;
if (current->type == POWERUP_WEAPON)
{
angle = 0; //-pi/6;//-0.25f * pi * 2.0f;
select_sprite(data->weapons.id[clamp(current->subtype, 0, NUM_WEAPONS-1)].sprite_body);
size = data->weapons.id[clamp(current->subtype, 0, NUM_WEAPONS-1)].visual_size;
}
else
{
const int c[] = {
SPRITE_PICKUP_HEALTH,
SPRITE_PICKUP_ARMOR,
SPRITE_PICKUP_WEAPON,
SPRITE_PICKUP_NINJA
};
select_sprite(c[current->type]);
if(c[current->type] == SPRITE_PICKUP_NINJA)
{
gameclient.effects->powerupshine(pos, vec2(96,18));
size *= 2.0f;
pos.x += 10.0f;
}
}
gfx_quads_setrotation(angle);
float offset = pos.y/32.0f + pos.x/32.0f;
pos.x += cosf(client_localtime()*2.0f+offset)*2.5f;
pos.y += sinf(client_localtime()*2.0f+offset)*2.5f;
draw_sprite(pos.x, pos.y, size);
gfx_quads_end();
}
void PLAYERS::render_player(
const NETOBJ_CHARACTER *prev_char,
const NETOBJ_CHARACTER *player_char,
const NETOBJ_PLAYER_INFO *prev_info,
const NETOBJ_PLAYER_INFO *player_info
)
{
NETOBJ_CHARACTER prev;
NETOBJ_CHARACTER player;
prev = *prev_char;
player = *player_char;
NETOBJ_PLAYER_INFO info = *player_info;
TEE_RENDER_INFO render_info = gameclient.clients[info.cid].render_info;
// check for teamplay modes
bool new_tick = gameclient.new_tick;
// check for ninja
if ( player.weapon == WEAPON_NINJA ) {
// change the skin for the player to the ninja
int skin = gameclient.skins->find("x_ninja");
if (skin != -1) {
render_info.texture = gameclient.skins->get( skin )->org_texture;
render_info.color_body = vec4( 1,1,1,1 );
render_info.color_feet = vec4( 1,1,1,1 );
}
}
// set size
render_info.size = 64.0f;
float intratick = client_intratick();
if(player.health < 0) // dont render dead players
return;
float angle = mix((float)prev.angle, (float)player.angle, intratick)/256.0f;
//float angle = 0;
// just use the direct input if it's local player we are rendering
if(info.local && client_state() != CLIENTSTATE_DEMOPLAYBACK)
angle = get_angle(gameclient.controls->mouse_pos);
// use preditect players if needed
if(info.local && config.cl_predict && client_state() != CLIENTSTATE_DEMOPLAYBACK)
{
if ( gameclient.snap.local_character && ( gameclient.snap.local_character->health >= 0 ) ) {
// apply predicted results
gameclient.predicted_char.write(&player);
gameclient.predicted_prev_char.write(&prev);
intratick = client_predintratick();
new_tick = gameclient.new_predicted_tick;
}
}
vec2 direction = get_direction((int)(angle*256.0f));
vec2 position = mix(vec2(prev.x, prev.y), vec2(player.x, player.y), intratick);
vec2 vel = mix(vec2(prev.vx/256.0f, prev.vy/256.0f), vec2(player.vx/256.0f, player.vy/256.0f), intratick);
gameclient.flow->add(position, vel*100.0f, 10.0f);
render_info.got_airjump = player.jumped&2?0:1;
// detect events
if(new_tick)
{
// detect air jump
if(!render_info.got_airjump && !(prev.jumped&2))
gameclient.effects->air_jump(position);
}
if(prev.health < 0) // Don't flicker from previous position
position = vec2(player.x, player.y);
bool stationary = player.vx < 1 && player.vx > -1;
bool inair = col_check_point(player.x, player.y+16) == 0;
bool want_other_dir = (player.direction == -1 && vel.x > 0) || (player.direction == 1 && vel.x < 0);
// evaluate animation
float walk_time = fmod(position.x, 100.0f)/100.0f;
ANIMSTATE state;
state.set(&data->animations[ANIM_BASE], 0);
if(inair)
state.add(&data->animations[ANIM_INAIR], 0, 1.0f); // TODO: some sort of time here
else if(stationary)
state.add(&data->animations[ANIM_IDLE], 0, 1.0f); // TODO: some sort of time here
else if(!want_other_dir)
state.add(&data->animations[ANIM_WALK], walk_time, 1.0f);
if (player.weapon == WEAPON_HAMMER)
{
float ct = (client_prevtick()-player.attacktick)/(float)SERVER_TICK_SPEED + client_ticktime();
state.add(&data->animations[ANIM_HAMMER_SWING], clamp(ct*5.0f,0.0f,1.0f), 1.0f);
}
if (player.weapon == WEAPON_NINJA)
{
float ct = (client_prevtick()-player.attacktick)/(float)SERVER_TICK_SPEED + client_ticktime();
state.add(&data->animations[ANIM_NINJA_SWING], clamp(ct*2.0f,0.0f,1.0f), 1.0f);
}
// do skidding
if(!inair && want_other_dir && length(vel*50) > 500.0f)
{
static int64 skid_sound_time = 0;
if(time_get()-skid_sound_time > time_freq()/10)
{
gameclient.sounds->play(SOUNDS::CHN_WORLD, SOUND_PLAYER_SKID, 0.25f, position);
skid_sound_time = time_get();
}
gameclient.effects->skidtrail(
position+vec2(-player.direction*6,12),
vec2(-player.direction*100*length(vel),-50)
);
}
// draw hook
if (prev.hook_state>0 && player.hook_state>0)
{
gfx_texture_set(data->images[IMAGE_GAME].id);
gfx_quads_begin();
//gfx_quads_begin();
vec2 pos = position;
vec2 hook_pos;
if(player_char->hooked_player != -1)
{
if(gameclient.snap.local_info && player_char->hooked_player == gameclient.snap.local_info->cid)
{
hook_pos = mix(vec2(gameclient.predicted_prev_char.pos.x, gameclient.predicted_prev_char.pos.y),
vec2(gameclient.predicted_char.pos.x, gameclient.predicted_char.pos.y), client_predintratick());
}
else
hook_pos = mix(vec2(prev_char->hook_x, prev_char->hook_y), vec2(player_char->hook_x, player_char->hook_y), client_intratick());
}
else
hook_pos = mix(vec2(prev.hook_x, prev.hook_y), vec2(player.hook_x, player.hook_y), intratick);
float d = distance(pos, hook_pos);
vec2 dir = normalize(pos-hook_pos);
gfx_quads_setrotation(get_angle(dir)+pi);
// render head
select_sprite(SPRITE_HOOK_HEAD);
gfx_quads_draw(hook_pos.x, hook_pos.y, 24,16);
// render chain
select_sprite(SPRITE_HOOK_CHAIN);
int i = 0;
for(float f = 24; f < d && i < 1024; f += 24, i++)
{
vec2 p = hook_pos + dir*f;
gfx_quads_draw(p.x, p.y,24,16);
}
gfx_quads_setrotation(0);
gfx_quads_end();
render_hand(&render_info, position, normalize(hook_pos-pos), -pi/2, vec2(20, 0));
}
// draw gun
{
gfx_texture_set(data->images[IMAGE_GAME].id);
gfx_quads_begin();
gfx_quads_setrotation(state.attach.angle*pi*2+angle);
// normal weapons
int iw = clamp(player.weapon, 0, NUM_WEAPONS-1);
select_sprite(data->weapons.id[iw].sprite_body, direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
vec2 dir = direction;
float recoil = 0.0f;
vec2 p;
if (player.weapon == WEAPON_HAMMER)
{
// Static position for hammer
p = position + vec2(state.attach.x, state.attach.y);
p.y += data->weapons.id[iw].offsety;
// if attack is under way, bash stuffs
if(direction.x < 0)
{
gfx_quads_setrotation(-pi/2-state.attach.angle*pi*2);
p.x -= data->weapons.id[iw].offsetx;
}
else
{
gfx_quads_setrotation(-pi/2+state.attach.angle*pi*2);
}
draw_sprite(p.x, p.y, data->weapons.id[iw].visual_size);
}
else if (player.weapon == WEAPON_NINJA)
{
p = position;
p.y += data->weapons.id[iw].offsety;
if(direction.x < 0)
{
gfx_quads_setrotation(-pi/2-state.attach.angle*pi*2);
p.x -= data->weapons.id[iw].offsetx;
gameclient.effects->powerupshine(p+vec2(32,0), vec2(32,12));
}
else
{
gfx_quads_setrotation(-pi/2+state.attach.angle*pi*2);
gameclient.effects->powerupshine(p-vec2(32,0), vec2(32,12));
}
draw_sprite(p.x, p.y, data->weapons.id[iw].visual_size);
// HADOKEN
if ((client_tick()-player.attacktick) <= (SERVER_TICK_SPEED / 6) && data->weapons.id[iw].num_sprite_muzzles)
{
int itex = rand() % data->weapons.id[iw].num_sprite_muzzles;
float alpha = 1.0f;
if (alpha > 0.0f && data->weapons.id[iw].sprite_muzzles[itex])
{
vec2 dir = vec2(player_char->x,player_char->y) - vec2(prev_char->x, prev_char->y);
dir = normalize(dir);
float hadokenangle = get_angle(dir);
gfx_quads_setrotation(hadokenangle);
//float offsety = -data->weapons[iw].muzzleoffsety;
select_sprite(data->weapons.id[iw].sprite_muzzles[itex], 0);
vec2 diry(-dir.y,dir.x);
p = position;
float offsetx = data->weapons.id[iw].muzzleoffsetx;
p -= dir * offsetx;
draw_sprite(p.x, p.y, 160.0f);
}
}
}
else
{
// TODO: should be an animation
recoil = 0;
float a = (client_tick()-player.attacktick+intratick)/5.0f;
if(a < 1)
recoil = sinf(a*pi);
p = position + dir * data->weapons.id[iw].offsetx - dir*recoil*10.0f;
p.y += data->weapons.id[iw].offsety;
draw_sprite(p.x, p.y, data->weapons.id[iw].visual_size);
}
if (player.weapon == WEAPON_GUN || player.weapon == WEAPON_SHOTGUN)
{
// check if we're firing stuff
if(data->weapons.id[iw].num_sprite_muzzles)//prev.attackticks)
{
float alpha = 0.0f;
int phase1tick = (client_tick() - player.attacktick);
if (phase1tick < (data->weapons.id[iw].muzzleduration + 3))
{
float t = ((((float)phase1tick) + intratick)/(float)data->weapons.id[iw].muzzleduration);
alpha = LERP(2.0, 0.0f, min(1.0f,max(0.0f,t)));
}
int itex = rand() % data->weapons.id[iw].num_sprite_muzzles;
if (alpha > 0.0f && data->weapons.id[iw].sprite_muzzles[itex])
{
float offsety = -data->weapons.id[iw].muzzleoffsety;
select_sprite(data->weapons.id[iw].sprite_muzzles[itex], direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
if(direction.x < 0)
offsety = -offsety;
vec2 diry(-dir.y,dir.x);
vec2 muzzlepos = p + dir * data->weapons.id[iw].muzzleoffsetx + diry * offsety;
draw_sprite(muzzlepos.x, muzzlepos.y, data->weapons.id[iw].visual_size);
}
}
}
gfx_quads_end();
switch (player.weapon)
{
case WEAPON_GUN: render_hand(&render_info, p, direction, -3*pi/4, vec2(-15, 4)); break;
case WEAPON_SHOTGUN: render_hand(&render_info, p, direction, -pi/2, vec2(-5, 4)); break;
case WEAPON_GRENADE: render_hand(&render_info, p, direction, -pi/2, vec2(-4, 7)); break;
}
}
// render the "shadow" tee
if(info.local && config.debug)
{
vec2 ghost_position = mix(vec2(prev_char->x, prev_char->y), vec2(player_char->x, player_char->y), client_intratick());
TEE_RENDER_INFO ghost = render_info;
ghost.color_body.a = 0.5f;
ghost.color_feet.a = 0.5f;
render_tee(&state, &ghost, player.emote, direction, ghost_position); // render ghost
}
render_info.size = 64.0f; // force some settings
render_info.color_body.a = 1.0f;
render_info.color_feet.a = 1.0f;
render_tee(&state, &render_info, player.emote, direction, position);
if(player.player_state == PLAYERSTATE_CHATTING)
{
gfx_texture_set(data->images[IMAGE_EMOTICONS].id);
gfx_quads_begin();
select_sprite(SPRITE_DOTDOT);
gfx_quads_draw(position.x + 24, position.y - 40, 64,64);
gfx_quads_end();
}
if (gameclient.clients[info.cid].emoticon_start != -1 && gameclient.clients[info.cid].emoticon_start + 2 * client_tickspeed() > client_tick())
{
gfx_texture_set(data->images[IMAGE_EMOTICONS].id);
gfx_quads_begin();
int since_start = client_tick() - gameclient.clients[info.cid].emoticon_start;
int from_end = gameclient.clients[info.cid].emoticon_start + 2 * client_tickspeed() - client_tick();
float a = 1;
if (from_end < client_tickspeed() / 5)
a = from_end / (client_tickspeed() / 5.0);
float h = 1;
if (since_start < client_tickspeed() / 10)
h = since_start / (client_tickspeed() / 10.0);
float wiggle = 0;
if (since_start < client_tickspeed() / 5)
wiggle = since_start / (client_tickspeed() / 5.0);
float wiggle_angle = sin(5*wiggle);
gfx_quads_setrotation(pi/6*wiggle_angle);
gfx_setcolor(1.0f,1.0f,1.0f,a);
// client_datas::emoticon is an offset from the first emoticon
select_sprite(SPRITE_OOP + gameclient.clients[info.cid].emoticon);
gfx_quads_draw(position.x, position.y - 23 - 32*h, 64, 64*h);
gfx_quads_end();
}
}
void ITEMS::render_laser(const struct NETOBJ_LASER *current)
{
vec2 pos = vec2(current->x, current->y);
vec2 from = vec2(current->from_x, current->from_y);
vec2 dir = normalize(pos-from);
float ticks = client_tick() + client_intratick() - current->start_tick;
float ms = (ticks/50.0f) * 1000.0f;
float a = ms / gameclient.tuning.laser_bounce_delay;
a = clamp(a, 0.0f, 1.0f);
float ia = 1-a;
vec2 out, border;
gfx_blend_normal();
gfx_texture_set(-1);
gfx_quads_begin();
//vec4 inner_color(0.15f,0.35f,0.75f,1.0f);
//vec4 outer_color(0.65f,0.85f,1.0f,1.0f);
// do outline
vec4 outer_color(
(config.tc_laser_color_outer>>16)/255.0f,
((config.tc_laser_color_outer>>8)&0xff)/255.0f,
(config.tc_laser_color_outer&0xff)/255.0f, 1.0f);
gfx_setcolor(outer_color.r,outer_color.g,outer_color.b,1.0f);
out = vec2(dir.y, -dir.x) * (7.0f*ia);
gfx_quads_draw_freeform(
from.x-out.x, from.y-out.y,
from.x+out.x, from.y+out.y,
pos.x-out.x, pos.y-out.y,
pos.x+out.x, pos.y+out.y
);
// do inner
vec4 inner_color(
(config.tc_laser_color_inner>>16)/255.0f,
((config.tc_laser_color_inner>>8)&0xff)/255.0f,
(config.tc_laser_color_inner&0xff)/255.0f, 1.0f);
out = vec2(dir.y, -dir.x) * (5.0f*ia);
gfx_setcolor(inner_color.r, inner_color.g, inner_color.b, 1.0f); // center
gfx_quads_draw_freeform(
from.x-out.x, from.y-out.y,
from.x+out.x, from.y+out.y,
pos.x-out.x, pos.y-out.y,
pos.x+out.x, pos.y+out.y
);
gfx_quads_end();
// render head
{
gfx_blend_normal();
gfx_texture_set(data->images[IMAGE_PARTICLES].id);
gfx_quads_begin();
int sprites[] = {SPRITE_PART_SPLAT01, SPRITE_PART_SPLAT02, SPRITE_PART_SPLAT03};
select_sprite(sprites[client_tick()%3]);
gfx_quads_setrotation(client_tick());
gfx_setcolor(outer_color.r,outer_color.g,outer_color.b,1.0f);
gfx_quads_draw(pos.x, pos.y, 24,24);
gfx_setcolor(inner_color.r, inner_color.g, inner_color.b, 1.0f);
gfx_quads_draw(pos.x, pos.y, 20,20);
gfx_quads_end();
}
gfx_blend_normal();
}
void ITEMS::render_projectile(const NETOBJ_PROJECTILE *current, int itemid)
{
// get positions
float curvature = 0;
float speed = 0;
if(current->type == WEAPON_GRENADE)
{
curvature = gameclient.tuning.grenade_curvature;
speed = gameclient.tuning.grenade_speed;
}
else if(current->type == WEAPON_SHOTGUN)
{
curvature = gameclient.tuning.shotgun_curvature;
speed = gameclient.tuning.shotgun_speed;
}
else if(current->type == WEAPON_GUN)
{
curvature = gameclient.tuning.gun_curvature;
speed = gameclient.tuning.gun_speed;
}
float ct = (client_prevtick()-current->start_tick)/(float)SERVER_TICK_SPEED + client_ticktime();
if(ct < 0)
return; // projectile havn't been shot yet
vec2 startpos(current->x, current->y);
vec2 startvel(current->vx/100.0f, current->vy/100.0f);
vec2 pos = calc_pos(startpos, startvel, curvature, speed, ct);
vec2 prevpos = calc_pos(startpos, startvel, curvature, speed, ct-0.001f);
gfx_texture_set(data->images[IMAGE_GAME].id);
gfx_quads_begin();
select_sprite(data->weapons.id[clamp(current->type, 0, NUM_WEAPONS-1)].sprite_proj);
vec2 vel = pos-prevpos;
//vec2 pos = mix(vec2(prev->x, prev->y), vec2(current->x, current->y), client_intratick());
// add particle for this projectile
if(current->type == WEAPON_GRENADE)
{
gameclient.effects->smoketrail(pos, vel*-1);
gameclient.flow->add(pos, vel*1000*client_frametime(), 10.0f);
gfx_quads_setrotation(client_localtime()*pi*2*2 + itemid);
}
else
{
gameclient.effects->bullettrail(pos);
gameclient.flow->add(pos, vel*1000*client_frametime(), 10.0f);
if(length(vel) > 0.00001f)
gfx_quads_setrotation(get_angle(vel));
else
gfx_quads_setrotation(0);
}
gfx_quads_draw(pos.x, pos.y, 32, 32);
///--- Added by Tigra
// Draw shadows of grenades
bool local_player_in_game =
gameclient.clients[gameclient.snap.local_cid].team != -1;
if(config.cl_antiping && current->type == WEAPON_GRENADE && local_player_in_game)
{
// Calculate average prediction offset, because client_predtick() gets varial values :(((
// Must be there is a normal way to realize it, but I'm too lazy to find it. ^)
if (gameclient.average_prediction_offset == -1)
{
int offset = client_predtick() - client_tick();
gameclient.prediction_offset_summ += offset;
gameclient.prediction_offset_count++;
if (gameclient.prediction_offset_count >= 100)
{
gameclient.average_prediction_offset =
round((float)gameclient.prediction_offset_summ / gameclient.prediction_offset_count);
}
}
// Draw shadow only if grenade directed to local player
int local_cid = gameclient.snap.local_cid;
NETOBJ_CHARACTER& cur_char = gameclient.snap.characters[local_cid].cur;
NETOBJ_CHARACTER& prev_char = gameclient.snap.characters[local_cid].prev;
vec2 server_pos = mix(vec2(prev_char.x, prev_char.y), vec2(cur_char.x, cur_char.y), client_intratick());
float d1 = distance(pos, server_pos);
float d2 = distance(prevpos, server_pos);
if (d1 < 0) d1 *= -1;
if (d2 < 0) d2 *= -1;
bool grenade_directed_to_local_player = d1 < d2;
if (gameclient.average_prediction_offset != -1 && grenade_directed_to_local_player)
{
int predicted_tick = client_prevtick() + gameclient.average_prediction_offset;
float predicted_ct = (predicted_tick - current->start_tick)/(float)SERVER_TICK_SPEED + client_ticktime();
if (predicted_ct >= 0)
{
int shadow_type = WEAPON_GUN; // Pistol bullet sprite is used for marker of shadow. TODO: use something custom.
select_sprite(data->weapons.id[clamp(shadow_type, 0, NUM_WEAPONS-1)].sprite_proj);
vec2 predicted_pos = calc_pos(startpos, startvel, curvature, speed, predicted_ct);
gfx_quads_draw(predicted_pos.x, predicted_pos.y, 32, 32);
}
}
}
///---
gfx_quads_setrotation(0);
gfx_quads_end();
}
