ddnet/src/game/server/gs_server.cpp

1979 lines
45 KiB
C++
Raw Normal View History

2007-11-25 19:42:40 +00:00
/* copyright (c) 2007 magnus auvinen, see licence.txt for more info */
2007-05-22 15:03:32 +00:00
#include <stdlib.h>
2007-07-30 07:05:34 +00:00
#include <stdio.h>
2007-05-22 15:03:32 +00:00
#include <string.h>
2007-12-15 10:24:49 +00:00
#include <engine/e_config.h>
#include "../g_version.h"
#include "gs_common.h"
#include "gs_game_ctf.h"
#include "gs_game_tdm.h"
#include "gs_game_dm.h"
2007-05-22 15:03:32 +00:00
2007-07-21 19:03:50 +00:00
data_container *data = 0x0;
2007-05-22 15:03:32 +00:00
class player* get_player(int index);
void create_damageind(vec2 p, float angle_mod, int amount);
void create_explosion(vec2 p, int owner, int weapon, bool bnodamage);
2007-05-22 15:03:32 +00:00
void create_smoke(vec2 p);
2007-07-21 19:03:50 +00:00
void create_spawn(vec2 p);
2007-07-21 21:17:38 +00:00
void create_death(vec2 p);
2007-12-09 12:40:34 +00:00
void create_sound(vec2 pos, int sound, int mask=-1);
class player *intersect_player(vec2 pos0, vec2 pos1, vec2 &new_pos, class entity *notthis = 0);
2007-05-22 15:03:32 +00:00
2007-09-23 22:54:31 +00:00
game_world *world;
//////////////////////////////////////////////////
// Event handler
//////////////////////////////////////////////////
event_handler::event_handler()
2007-05-22 15:03:32 +00:00
{
clear();
}
2007-05-22 15:03:32 +00:00
2007-12-09 12:40:34 +00:00
void *event_handler::create(int type, int size, int mask)
{
if(num_events == MAX_EVENTS)
return 0;
if(current_offset+size >= MAX_DATASIZE)
return 0;
void *p = &data[current_offset];
offsets[num_events] = current_offset;
types[num_events] = type;
sizes[num_events] = size;
2007-12-09 12:40:34 +00:00
client_masks[num_events] = mask;
current_offset += size;
num_events++;
return p;
}
2007-05-22 15:03:32 +00:00
void event_handler::clear()
2007-05-22 15:03:32 +00:00
{
num_events = 0;
current_offset = 0;
}
2007-05-22 15:03:32 +00:00
void event_handler::snap(int snapping_client)
{
for(int i = 0; i < num_events; i++)
2007-05-22 15:03:32 +00:00
{
2007-12-09 12:40:34 +00:00
if(cmask_is_set(client_masks[i], snapping_client))
2007-08-04 17:28:31 +00:00
{
ev_common *ev = (ev_common *)&data[offsets[i]];
if(distance(players[snapping_client].pos, vec2(ev->x, ev->y)) < 1500.0f)
{
void *d = snap_new_item(types[i], i, sizes[i]);
mem_copy(d, &data[offsets[i]], sizes[i]);
}
2007-08-04 17:28:31 +00:00
}
2007-05-22 15:03:32 +00:00
}
}
event_handler events;
//////////////////////////////////////////////////
// Entity
//////////////////////////////////////////////////
entity::entity(int objtype)
{
this->objtype = objtype;
pos = vec2(0,0);
2007-10-07 20:23:33 +00:00
flags = FLAG_PHYSICS;
proximity_radius = 0;
id = snap_new_id();
next_entity = 0;
prev_entity = 0;
prev_type_entity = 0;
next_type_entity = 0;
}
2007-05-22 15:03:32 +00:00
entity::~entity()
{
snap_free_id(id);
}
2007-05-22 15:03:32 +00:00
//////////////////////////////////////////////////
// game world
//////////////////////////////////////////////////
game_world::game_world()
2007-05-22 15:03:32 +00:00
{
paused = false;
reset_requested = false;
first_entity = 0x0;
for(int i = 0; i < NUM_ENT_TYPES; i++)
first_entity_types[i] = 0;
}
2007-07-14 13:09:42 +00:00
int game_world::find_entities(vec2 pos, float radius, entity **ents, int max)
{
int num = 0;
for(entity *ent = first_entity; ent; ent = ent->next_entity)
2007-05-22 15:03:32 +00:00
{
2007-10-07 20:23:33 +00:00
if(!(ent->flags&entity::FLAG_PHYSICS))
continue;
if(distance(ent->pos, pos) < radius+ent->proximity_radius)
{
ents[num] = ent;
num++;
if(num == max)
break;
}
2007-05-22 15:03:32 +00:00
}
return num;
}
int game_world::find_entities(vec2 pos, float radius, entity **ents, int max, const int* types, int maxtypes)
{
int num = 0;
for(int t = 0; t < maxtypes; t++)
2007-05-22 15:03:32 +00:00
{
for(entity *ent = first_entity_types[types[t]]; ent; ent = ent->next_type_entity)
2007-05-22 15:03:32 +00:00
{
2007-10-07 20:23:33 +00:00
if(!(ent->flags&entity::FLAG_PHYSICS))
2007-07-14 13:09:42 +00:00
continue;
2007-05-22 15:03:32 +00:00
if(distance(ent->pos, pos) < radius+ent->proximity_radius)
{
ents[num] = ent;
num++;
if(num == max)
break;
}
}
}
return num;
}
void game_world::insert_entity(entity *ent)
{
2007-07-25 07:24:57 +00:00
entity *cur = first_entity;
while(cur)
{
dbg_assert(cur != ent, "err");
cur = cur->next_entity;
}
// insert it
if(first_entity)
first_entity->prev_entity = ent;
ent->next_entity = first_entity;
ent->prev_entity = 0x0;
first_entity = ent;
// into typelist aswell
if(first_entity_types[ent->objtype])
first_entity_types[ent->objtype]->prev_type_entity = ent;
ent->next_type_entity = first_entity_types[ent->objtype];
ent->prev_type_entity = 0x0;
first_entity_types[ent->objtype] = ent;
}
void game_world::destroy_entity(entity *ent)
{
ent->set_flag(entity::FLAG_DESTROY);
}
void game_world::remove_entity(entity *ent)
{
2007-08-05 15:42:48 +00:00
// not in the list
if(!ent->next_entity && !ent->prev_entity && first_entity != ent)
return;
// remove
if(ent->prev_entity)
ent->prev_entity->next_entity = ent->next_entity;
else
first_entity = ent->next_entity;
if(ent->next_entity)
ent->next_entity->prev_entity = ent->prev_entity;
if(ent->prev_type_entity)
ent->prev_type_entity->next_type_entity = ent->next_type_entity;
else
first_entity_types[ent->objtype] = ent->next_type_entity;
if(ent->next_type_entity)
ent->next_type_entity->prev_type_entity = ent->prev_type_entity;
2007-08-05 15:42:48 +00:00
ent->next_entity = 0;
ent->prev_entity = 0;
ent->next_type_entity = 0;
ent->prev_type_entity = 0;
}
//
void game_world::snap(int snapping_client)
{
for(entity *ent = first_entity; ent; ent = ent->next_entity)
ent->snap(snapping_client);
}
void game_world::reset()
{
// reset all entities
for(entity *ent = first_entity; ent; ent = ent->next_entity)
ent->reset();
remove_entities();
for(entity *ent = first_entity; ent; ent = ent->next_entity)
ent->post_reset();
remove_entities();
reset_requested = false;
}
2007-07-14 13:09:42 +00:00
void game_world::remove_entities()
{
// destroy objects marked for destruction
entity *ent = first_entity;
while(ent)
2007-05-22 15:03:32 +00:00
{
entity *next = ent->next_entity;
if(ent->flags&entity::FLAG_DESTROY)
{
remove_entity(ent);
ent->destroy();
}
ent = next;
2007-05-22 15:03:32 +00:00
}
}
void game_world::tick()
{
if(reset_requested)
reset();
if(!paused)
2007-05-22 15:03:32 +00:00
{
2007-12-16 15:33:44 +00:00
static PERFORMACE_INFO scopes[OBJTYPE_FLAG+1] =
{
{"null", 0},
{"game", 0},
{"player_info", 0},
{"player_character", 0},
{"projectile", 0},
{"powerup", 0},
{"flag", 0}
};
static PERFORMACE_INFO scopes_def[OBJTYPE_FLAG+1] =
{
{"null", 0},
{"game", 0},
{"player_info", 0},
{"player_character", 0},
{"projectile", 0},
{"powerup", 0},
{"flag", 0}
};
static PERFORMACE_INFO tick_scope = {"tick", 0};
perf_start(&tick_scope);
2007-05-22 15:03:32 +00:00
// update all objects
for(entity *ent = first_entity; ent; ent = ent->next_entity)
2007-12-16 14:00:22 +00:00
{
2007-12-16 15:33:44 +00:00
if(ent->objtype >= 0 && ent->objtype < OBJTYPE_FLAG)
perf_start(&scopes[ent->objtype]);
2007-05-22 15:03:32 +00:00
ent->tick();
2007-12-16 15:33:44 +00:00
if(ent->objtype >= 0 && ent->objtype < OBJTYPE_FLAG)
perf_end();
2007-12-16 14:00:22 +00:00
}
2007-12-16 15:33:44 +00:00
perf_end();
2007-12-16 15:33:44 +00:00
static PERFORMACE_INFO deftick_scope = {"tick_defered", 0};
perf_start(&deftick_scope);
2007-07-13 13:40:04 +00:00
for(entity *ent = first_entity; ent; ent = ent->next_entity)
2007-12-16 14:00:22 +00:00
{
2007-12-16 15:33:44 +00:00
if(ent->objtype >= 0 && ent->objtype < OBJTYPE_FLAG)
perf_start(&scopes_def[ent->objtype]);
2007-07-13 13:40:04 +00:00
ent->tick_defered();
2007-12-16 15:33:44 +00:00
if(ent->objtype >= 0 && ent->objtype < OBJTYPE_FLAG)
perf_end();
2007-12-16 14:00:22 +00:00
}
2007-12-16 15:33:44 +00:00
perf_end();
2007-05-22 15:03:32 +00:00
}
remove_entities();
}
2007-05-22 15:03:32 +00:00
//////////////////////////////////////////////////
// projectile
//////////////////////////////////////////////////
projectile::projectile(int type, int owner, vec2 pos, vec2 vel, int span, entity* powner,
int damage, int flags, float force, int sound_impact, int weapon)
: entity(OBJTYPE_PROJECTILE)
{
this->type = type;
this->pos = pos;
this->vel = vel * SERVER_TICK_SPEED; // TODO: remove this
this->lifespan = span;
this->owner = owner;
this->powner = powner;
this->flags = flags;
this->force = force;
this->damage = damage;
this->sound_impact = sound_impact;
this->weapon = weapon;
2007-08-04 19:00:06 +00:00
this->bounce = 0;
this->start_tick = server_tick();
2007-09-23 22:54:31 +00:00
world->insert_entity(this);
}
void projectile::reset()
{
2007-09-23 22:54:31 +00:00
world->destroy_entity(this);
}
void projectile::tick()
{
float gravity = -400;
2007-12-09 13:51:55 +00:00
if(type != WEAPON_ROCKET)
gravity = -100;
float pt = (server_tick()-start_tick-1)/(float)SERVER_TICK_SPEED;
float ct = (server_tick()-start_tick)/(float)SERVER_TICK_SPEED;
vec2 prevpos = calc_pos(pos, vel, gravity, pt);
vec2 curpos = calc_pos(pos, vel, gravity, ct);
lifespan--;
int collide = col_check_point((int)curpos.x, (int)curpos.y);
vec2 new_pos;
entity *targetplayer = (entity*)intersect_player(prevpos, curpos, new_pos, powner);
if(targetplayer || collide || lifespan < 0 )
2007-05-22 15:03:32 +00:00
{
2007-07-26 14:08:56 +00:00
if (lifespan >= 0 || weapon == WEAPON_ROCKET)
create_sound(pos, sound_impact);
if (flags & PROJECTILE_FLAGS_EXPLODE)
create_explosion(prevpos, owner, weapon, false);
else if (targetplayer)
2007-08-04 17:28:31 +00:00
{
targetplayer->take_damage(normalize(vel) * max(0.001f, force), damage, owner, weapon);
2007-08-04 17:28:31 +00:00
}
2007-09-23 22:54:31 +00:00
world->destroy_entity(this);
}
}
2007-05-22 15:03:32 +00:00
void projectile::snap(int snapping_client)
{
float ct = (server_tick()-start_tick)/(float)SERVER_TICK_SPEED;
vec2 curpos = calc_pos(pos, vel, -7.5f*SERVER_TICK_SPEED, ct);
if(distance(players[snapping_client].pos, curpos) > 1000.0f)
return;
obj_projectile *proj = (obj_projectile *)snap_new_item(OBJTYPE_PROJECTILE, id, sizeof(obj_projectile));
proj->x = (int)pos.x;
proj->y = (int)pos.y;
proj->vx = (int)vel.x;
proj->vy = (int)vel.y;
proj->start_tick = start_tick;
proj->type = type;
}
2007-05-22 15:03:32 +00:00
//////////////////////////////////////////////////
// player
//////////////////////////////////////////////////
// TODO: move to separate file
player::player()
: entity(OBJTYPE_PLAYER_CHARACTER)
{
init();
}
void player::init()
{
proximity_radius = phys_size;
client_id = -1;
2007-10-07 20:23:33 +00:00
team = -1; // -1 == spectator
2007-07-21 19:03:50 +00:00
extrapowerflags = 0;
latency_accum = 0;
latency_accum_min = 0;
latency_accum_max = 0;
latency_avg = 0;
latency_min = 0;
latency_max = 0;
reset();
}
void player::reset()
{
pos = vec2(0.0f, 0.0f);
core.vel = vec2(0.0f, 0.0f);
//direction = vec2(0.0f, 1.0f);
score = 0;
dead = true;
clear_flag(entity::FLAG_PHYSICS);
2007-08-02 20:17:18 +00:00
spawning = false;
die_tick = 0;
damage_taken = 0;
2007-07-26 11:33:49 +00:00
state = STATE_UNKNOWN;
mem_zero(&input, sizeof(input));
mem_zero(&previnput, sizeof(previnput));
num_inputs = 0;
last_action = -1;
emote_stop = 0;
damage_taken_tick = 0;
attack_tick = 0;
2007-12-13 20:28:22 +00:00
numobjectshit = 0;
2007-12-15 12:04:48 +00:00
ninja_activationtick = 0;
sniper_chargetick = -1;
2007-12-13 20:28:22 +00:00
currentmovetime = 0;
2007-12-10 19:13:00 +00:00
active_weapon = WEAPON_GUN;
last_weapon = WEAPON_HAMMER;
wanted_weapon = WEAPON_GUN;
}
2007-05-22 15:03:32 +00:00
void player::destroy() { }
void player::set_weapon(int w)
{
last_weapon = active_weapon;
active_weapon = w;
2007-12-10 19:13:00 +00:00
if(active_weapon < 0 || active_weapon >= NUM_WEAPONS)
active_weapon = 0;
}
void player::respawn()
{
2007-08-02 20:17:18 +00:00
spawning = true;
}
2007-10-07 20:23:33 +00:00
void player::set_team(int new_team)
{
team = new_team;
die(client_id, -1);
2007-10-07 20:23:33 +00:00
dbg_msg("game", "cid=%d team=%d", client_id, team);
2007-10-07 20:23:33 +00:00
if(team == -1)
clear_flag(FLAG_PHYSICS);
else
set_flag(FLAG_PHYSICS);
}
bool try_spawntype(int t, vec2 *outpos)
2007-08-02 20:17:18 +00:00
{
// get spawn point
int start, num;
map_get_type(t, &start, &num);
if(!num)
return false;
int id = rand()%num;
mapres_spawnpoint *sp = (mapres_spawnpoint*)map_get_item(start + id, NULL, NULL);
*outpos = vec2((float)sp->x, (float)sp->y);
return true;
}
2007-08-02 20:17:18 +00:00
void player::try_respawn()
{
2007-08-02 20:17:18 +00:00
vec2 spawnpos = vec2(100.0f, -60.0f);
2007-12-10 19:13:00 +00:00
// get spawn point
if(gameobj->gametype == GAMETYPE_CTF)
2007-08-02 20:17:18 +00:00
{
// try first try own team spawn, then normal spawn and then enemy
if(!try_spawntype(MAPRES_SPAWNPOINT_RED+(team&1), &spawnpos))
{
if(!try_spawntype(MAPRES_SPAWNPOINT, &spawnpos))
try_spawntype(MAPRES_SPAWNPOINT_RED+((team+1)&1), &spawnpos);
}
2007-08-02 20:17:18 +00:00
}
else
{
if(!try_spawntype(MAPRES_SPAWNPOINT, &spawnpos))
try_spawntype(MAPRES_SPAWNPOINT_RED+(rand()&1), &spawnpos);
}
2007-08-02 20:17:18 +00:00
// check if the position is occupado
entity *ents[2] = {0};
int types[] = {OBJTYPE_PLAYER_CHARACTER};
2007-09-23 22:54:31 +00:00
int num_ents = world->find_entities(spawnpos, 64, ents, 2, types, 1);
2007-08-02 20:17:18 +00:00
for(int i = 0; i < num_ents; i++)
{
if(ents[i] != this)
return;
}
2007-12-13 22:22:25 +00:00
2007-08-02 20:17:18 +00:00
spawning = false;
pos = spawnpos;
core.pos = pos;
core.vel = vec2(0,0);
core.hooked_player = -1;
health = 10;
armor = 0;
jumped = 0;
2007-12-15 12:04:48 +00:00
ninja_activationtick = 0;
sniper_chargetick = -1;
2007-12-15 15:32:01 +00:00
currentcooldown = 0;
2007-12-15 12:04:48 +00:00
dead = false;
2007-10-07 20:23:33 +00:00
set_flag(entity::FLAG_PHYSICS);
2007-07-26 11:33:49 +00:00
state = STATE_PLAYING;
core.hook_state = HOOK_IDLE;
mem_zero(&input, sizeof(input));
// init weapons
mem_zero(&weapons, sizeof(weapons));
weapons[WEAPON_HAMMER].got = true;
weapons[WEAPON_HAMMER].ammo = -1;
weapons[WEAPON_GUN].got = true;
weapons[WEAPON_GUN].ammo = data->weapons[WEAPON_GUN].maxammo;
2007-10-14 13:54:02 +00:00
//weapons[WEAPON_SNIPER].got = true;
//weapons[WEAPON_SNIPER].ammo = data->weapons[WEAPON_SNIPER].maxammo;
active_weapon = WEAPON_GUN;
last_weapon = WEAPON_HAMMER;
2007-12-09 17:15:18 +00:00
wanted_weapon = WEAPON_GUN;
reload_timer = 0;
2007-08-09 00:18:11 +00:00
2007-07-21 19:03:50 +00:00
// Create sound and spawn effects
create_sound(pos, SOUND_PLAYER_SPAWN);
2007-07-21 19:03:50 +00:00
create_spawn(pos);
2007-09-25 21:53:14 +00:00
gameobj->on_player_spawn(this);
}
2007-05-22 15:03:32 +00:00
bool player::is_grounded()
{
if(col_check_point((int)(pos.x+phys_size/2), (int)(pos.y+phys_size/2+5)))
return true;
if(col_check_point((int)(pos.x-phys_size/2), (int)(pos.y+phys_size/2+5)))
return true;
return false;
}
2007-05-22 15:03:32 +00:00
struct input_count
{
int presses;
int releases;
};
static input_count count_input(int prev, int cur)
{
input_count c = {0,0};
prev &= INPUT_STATE_MASK;
cur &= INPUT_STATE_MASK;
int i = prev;
while(i != cur)
{
i = (i+1)&INPUT_STATE_MASK;
if(i&1)
c.presses++;
else
c.releases++;
}
return c;
}
2007-07-21 19:03:50 +00:00
int player::handle_ninja()
{
vec2 direction = normalize(vec2(input.target_x, input.target_y));
2007-12-15 12:04:48 +00:00
if ((server_tick() - ninja_activationtick) > (data->weapons[WEAPON_NINJA].duration * server_tickspeed() / 1000))
2007-07-21 19:03:50 +00:00
{
// time's up, return
2007-12-10 21:14:45 +00:00
weapons[WEAPON_NINJA].got = false;
active_weapon = last_weapon;
2007-12-10 19:13:00 +00:00
set_weapon(active_weapon);
2007-07-21 19:03:50 +00:00
return 0;
}
2007-07-21 19:03:50 +00:00
// Check if it should activate
if (count_input(previnput.fire, input.fire).presses && (server_tick() > currentcooldown))
2007-07-21 19:03:50 +00:00
{
// ok then, activate ninja
attack_tick = server_tick();
activationdir = direction;
currentmovetime = data->weapons[WEAPON_NINJA].movetime * server_tickspeed() / 1000;
currentcooldown = data->weapons[WEAPON_NINJA].firedelay * server_tickspeed() / 1000 + server_tick();
2007-12-13 20:28:22 +00:00
2007-07-21 19:03:50 +00:00
// reset hit objects
numobjectshit = 0;
create_sound(pos, SOUND_NINJA_FIRE);
// release all hooks when ninja is activated
2007-09-25 21:53:14 +00:00
//release_hooked();
//release_hooks();
2007-07-21 19:03:50 +00:00
}
currentmovetime--;
2007-07-21 19:03:50 +00:00
if (currentmovetime == 0)
{
2007-07-21 19:03:50 +00:00
// reset player velocity
core.vel *= 0.2f;
2007-07-21 19:03:50 +00:00
//return MODIFIER_RETURNFLAGS_OVERRIDEWEAPON;
}
2007-07-21 19:03:50 +00:00
if (currentmovetime > 0)
{
// Set player velocity
core.vel = activationdir * data->weapons[WEAPON_NINJA].velocity;
2007-07-21 19:03:50 +00:00
vec2 oldpos = pos;
move_box(&core.pos, &core.vel, vec2(phys_size, phys_size), 0.0f);
2007-07-21 19:03:50 +00:00
// reset velocity so the client doesn't predict stuff
core.vel = vec2(0.0f,0.0f);
2007-07-21 19:03:50 +00:00
if ((currentmovetime % 2) == 0)
{
create_smoke(pos);
}
2007-07-21 19:03:50 +00:00
// check if we hit anything along the way
{
int type = OBJTYPE_PLAYER_CHARACTER;
2007-07-21 19:03:50 +00:00
entity *ents[64];
vec2 dir = pos - oldpos;
2007-07-22 13:46:45 +00:00
float radius = phys_size * 2.0f; //length(dir * 0.5f);
2007-07-21 19:03:50 +00:00
vec2 center = oldpos + dir * 0.5f;
2007-09-23 22:54:31 +00:00
int num = world->find_entities(center, radius, ents, 64, &type, 1);
2007-07-21 19:03:50 +00:00
for (int i = 0; i < num; i++)
{
// Check if entity is a player
if (ents[i] == this)
continue;
// make sure we haven't hit this object before
bool balreadyhit = false;
for (int j = 0; j < numobjectshit; j++)
{
if (hitobjects[j] == ents[i])
balreadyhit = true;
}
if (balreadyhit)
continue;
// check so we are sufficiently close
if (distance(ents[i]->pos, pos) > (phys_size * 2.0f))
continue;
2007-07-21 19:03:50 +00:00
// hit a player, give him damage and stuffs...
create_sound(ents[i]->pos, SOUND_NINJA_HIT);
// set his velocity to fast upward (for now)
2007-12-12 19:52:57 +00:00
if(numobjectshit < 10)
hitobjects[numobjectshit++] = ents[i];
2007-08-05 08:59:38 +00:00
ents[i]->take_damage(vec2(0,10.0f), data->weapons[WEAPON_NINJA].meleedamage, client_id,WEAPON_NINJA);
2007-07-21 19:03:50 +00:00
}
}
return MODIFIER_RETURNFLAGS_OVERRIDEVELOCITY | MODIFIER_RETURNFLAGS_OVERRIDEPOSITION | MODIFIER_RETURNFLAGS_OVERRIDEGRAVITY;
}
2007-12-10 19:13:00 +00:00
2007-07-21 19:03:50 +00:00
return 0;
}
2007-10-14 13:54:02 +00:00
int player::handle_sniper()
{
2007-12-15 12:04:48 +00:00
/*
2007-10-14 13:54:02 +00:00
struct input_count button = count_input(previnput.fire, input.fire);
2007-12-15 12:04:48 +00:00
bool must_release = false;
int current_load = (server_tick()-sniper_chargetick) / server_tickspeed() + 1;
if(input.fire&1)
{
if(sniper_chargetick == -1)
{
// start charge
sniper_chargetick = server_tick();
}
else
{
if(current_load > weapons[WEAPON_SNIPER].ammo+3)
must_release = true;
}
}
if(button.releases || must_release)
{
vec2 direction = normalize(vec2(input.target_x, input.target_y));
// released
sniper_chargetick = -1;
if(current_load > weapons[WEAPON_SNIPER].ammo)
current_load = weapons[WEAPON_SNIPER].ammo;
weapons[WEAPON_SNIPER].ammo -= current_load;
new projectile(projectile::WEAPON_PROJECTILETYPE_SNIPER,
client_id, pos+vec2(0,0), direction*50.0f,
100, this, current_load, 0, 0, -1, WEAPON_SNIPER);
create_sound(pos, SOUND_SNIPER_FIRE);
}
*/
/*
if(button.releases)
2007-10-14 13:54:02 +00:00
{
vec2 direction = normalize(vec2(input.target_x, input.target_y));
// Check if we were charging, if so fire
if (weapons[WEAPON_SNIPER].weaponstage >= WEAPONSTAGE_SNIPER_CHARGING)
{
new projectile(projectile::WEAPON_PROJECTILETYPE_SNIPER,
client_id, pos+vec2(0,0), direction*50.0f,
100 + weapons[WEAPON_SNIPER].weaponstage * 20,this, weapons[WEAPON_SNIPER].weaponstage, 0, 0, -1, WEAPON_SNIPER);
create_sound(pos, SOUND_SNIPER_FIRE);
}
// Add blowback
core.vel = -direction * 10.0f * weapons[WEAPON_SNIPER].weaponstage;
// update ammo and stuff
weapons[WEAPON_SNIPER].ammo = max(0,weapons[WEAPON_SNIPER].ammo - weapons[WEAPON_SNIPER].weaponstage);
weapons[WEAPON_SNIPER].weaponstage = WEAPONSTAGE_SNIPER_NEUTRAL;
weapons[WEAPON_SNIPER].chargetick = 0;
}
else if (input.fire & 1)
{
// Charge!! (if we are on the ground)
if (is_grounded() && weapons[WEAPON_SNIPER].ammo > 0)
{
if (!weapons[WEAPON_SNIPER].chargetick)
{
weapons[WEAPON_SNIPER].chargetick = server_tick();
dbg_msg("game", "Chargetick='%d:'", server_tick());
}
if ((server_tick() - weapons[WEAPON_SNIPER].chargetick) > server_tickspeed() * data->weapons[active_weapon].chargetime)
{
if (weapons[WEAPON_SNIPER].ammo > weapons[WEAPON_SNIPER].weaponstage)
{
weapons[WEAPON_SNIPER].weaponstage++;
weapons[WEAPON_SNIPER].chargetick = server_tick();
}
else if ((server_tick() - weapons[WEAPON_SNIPER].chargetick) > server_tickspeed() * data->weapons[active_weapon].overchargetime)
{
// Ooopsie, weapon exploded
create_explosion(pos, client_id, WEAPON_SNIPER, false);
create_sound(pos, SOUND_ROCKET_EXPLODE);
// remove this weapon and change weapon to gun
weapons[WEAPON_SNIPER].got = false;
weapons[WEAPON_SNIPER].ammo = 0;
last_weapon = active_weapon;
active_weapon = WEAPON_GUN;
return 0;
}
}
// While charging, don't move
2007-12-15 12:04:48 +00:00
return 0;
2007-10-14 13:54:02 +00:00
}
else if (weapons[WEAPON_SNIPER].weaponstage)
weapons[WEAPON_SNIPER].weaponstage = WEAPONSTAGE_SNIPER_NEUTRAL;
2007-12-15 12:04:48 +00:00
}*/
2007-10-14 13:54:02 +00:00
return 0;
}
2007-07-21 19:03:50 +00:00
int player::handle_weapons()
{
vec2 direction = normalize(vec2(input.target_x, input.target_y));
2007-12-11 23:10:07 +00:00
if(config.dbg_stress)
{
for(int i = 0; i < NUM_WEAPONS; i++)
{
weapons[i].got = true;
weapons[i].ammo = 10;
}
if(reload_timer) // twice as fast reload
reload_timer--;
}
// check reload timer
if(reload_timer)
2007-05-22 15:03:32 +00:00
{
reload_timer--;
2007-07-21 19:03:50 +00:00
return 0;
}
2007-12-09 17:15:18 +00:00
2007-07-21 19:03:50 +00:00
if (active_weapon == WEAPON_NINJA)
{
// don't update other weapons while ninja is active
return handle_ninja();
}
2007-05-22 15:03:32 +00:00
2007-12-09 17:15:18 +00:00
// select weapon
int next = count_input(previnput.next_weapon, input.next_weapon).presses;
int prev = count_input(previnput.prev_weapon, input.prev_weapon).presses;
2007-12-10 19:13:00 +00:00
if(next < 128) // make sure we only try sane stuff
{
2007-12-10 19:13:00 +00:00
while(next) // next weapon selection
{
wanted_weapon = (wanted_weapon+1)%NUM_WEAPONS;
if(weapons[wanted_weapon].got)
next--;
}
2007-12-09 17:15:18 +00:00
}
2007-10-07 23:43:14 +00:00
2007-12-10 19:13:00 +00:00
if(prev < 128) // make sure we only try sane stuff
2007-12-09 17:15:18 +00:00
{
2007-12-10 19:13:00 +00:00
while(prev) // prev weapon selection
{
wanted_weapon = (wanted_weapon-1)<0?NUM_WEAPONS-1:wanted_weapon-1;
if(weapons[wanted_weapon].got)
prev--;
}
2007-12-09 17:15:18 +00:00
}
if(input.wanted_weapon) // direct weapon selection
wanted_weapon = input.wanted_weapon-1;
2007-12-10 19:13:00 +00:00
if(wanted_weapon < 0 || wanted_weapon >= NUM_WEAPONS)
wanted_weapon = 0;
2007-12-09 17:15:18 +00:00
// switch weapon if wanted
if(data->weapons[active_weapon].duration <= 0)
{
2007-12-10 19:13:00 +00:00
if(wanted_weapon != -1 && wanted_weapon != active_weapon && wanted_weapon >= 0 && wanted_weapon < NUM_WEAPONS && weapons[wanted_weapon].got)
{
2007-12-09 17:15:18 +00:00
if(active_weapon != wanted_weapon)
create_sound(pos, SOUND_WEAPON_SWITCH);
2007-12-10 19:13:00 +00:00
set_weapon(wanted_weapon);
}
}
2007-10-14 13:54:02 +00:00
2007-12-15 12:04:48 +00:00
// don't update other weapons while sniper is active
/*
2007-10-14 13:54:02 +00:00
if (active_weapon == WEAPON_SNIPER)
return handle_sniper();
2007-12-15 12:04:48 +00:00
*/
2007-10-07 23:43:14 +00:00
if(count_input(previnput.fire, input.fire).presses) //previnput.fire != input.fire && (input.fire&1))
{
if(reload_timer == 0)
2007-07-13 13:40:04 +00:00
{
// fire!
if(weapons[active_weapon].ammo)
2007-05-22 15:03:32 +00:00
{
switch(active_weapon)
2007-05-22 15:03:32 +00:00
{
case WEAPON_HAMMER:
2007-12-15 12:04:48 +00:00
{
2007-07-21 19:03:50 +00:00
// reset objects hit
numobjectshit = 0;
2007-07-21 17:35:28 +00:00
create_sound(pos, SOUND_HAMMER_FIRE);
break;
2007-12-15 12:04:48 +00:00
}
2007-07-13 13:40:04 +00:00
case WEAPON_GUN:
2007-12-15 12:04:48 +00:00
{
2007-10-04 23:58:22 +00:00
new projectile(WEAPON_GUN,
client_id,
pos+vec2(0,0),
direction*30.0f,
100,
this,
1, 0, 0, -1, WEAPON_GUN);
2007-07-21 17:35:28 +00:00
create_sound(pos, SOUND_GUN_FIRE);
break;
2007-12-15 12:04:48 +00:00
}
case WEAPON_ROCKET:
2007-08-04 19:00:06 +00:00
{
2007-10-04 23:58:22 +00:00
new projectile(WEAPON_ROCKET,
client_id,
pos+vec2(0,0),
direction*15.0f,
100,
this,
2007-07-21 17:35:28 +00:00
1, projectile::PROJECTILE_FLAGS_EXPLODE, 0, SOUND_ROCKET_EXPLODE, WEAPON_ROCKET);
create_sound(pos, SOUND_ROCKET_FIRE);
break;
2007-08-04 19:00:06 +00:00
}
case WEAPON_SHOTGUN:
2007-08-04 01:57:01 +00:00
{
int shotspread = 2;
2007-08-04 01:53:26 +00:00
for(int i = -shotspread; i <= shotspread; i++)
{
2007-12-09 13:51:55 +00:00
float spreading[] = {-0.12f, -0.05f, 0, 0.05f, 0.12f};
float a = get_angle(direction);
2007-12-09 13:51:55 +00:00
float v = 1.0f-fabs(i/(float)shotspread);
a += spreading[i+2];
2007-10-04 23:58:22 +00:00
new projectile(WEAPON_SHOTGUN,
2007-07-13 13:40:04 +00:00
client_id,
pos+vec2(0,0),
2007-12-09 13:51:55 +00:00
vec2(cosf(a), sinf(a))*(30.0f + 15.0f*v),
//vec2(cosf(a), sinf(a))*20.0f,
2007-12-09 13:51:55 +00:00
(int)(server_tickspeed()*0.3f),
2007-07-13 13:40:04 +00:00
this,
2007-08-04 19:00:06 +00:00
1, 0, 0, -1, WEAPON_SHOTGUN);
}
2007-07-21 17:35:28 +00:00
create_sound(pos, SOUND_SHOTGUN_FIRE);
break;
}
2007-12-15 12:04:48 +00:00
case WEAPON_SNIPER:
{
new projectile(WEAPON_SNIPER,
client_id,
pos+vec2(0,0),
direction*300.0f,
100,
this,
1, 0, 0, -1, WEAPON_SNIPER);
create_sound(pos, SOUND_SNIPER_FIRE);
break;
}
2007-05-22 15:03:32 +00:00
}
weapons[active_weapon].ammo--;
2007-07-21 19:03:50 +00:00
attack_tick = server_tick();
reload_timer = data->weapons[active_weapon].firedelay * server_tickspeed() / 1000;
}
else
{
create_sound(pos, SOUND_WEAPON_NOAMMO);
2007-05-22 15:03:32 +00:00
}
}
}
2007-07-21 19:03:50 +00:00
// Update weapons
if (active_weapon == WEAPON_HAMMER && reload_timer > 0)
{
// Handle collisions
// only one that needs update (for now)
// do selection for the weapon and bash anything in it
// check if we hit anything along the way
int type = OBJTYPE_PLAYER_CHARACTER;
2007-07-21 19:03:50 +00:00
entity *ents[64];
vec2 lookdir(direction.x > 0.0f ? 1.0f : -1.0f, 0.0f);
vec2 dir = lookdir * data->weapons[active_weapon].meleereach;
float radius = length(dir * 0.5f);
vec2 center = pos + dir * 0.5f;
2007-09-23 22:54:31 +00:00
int num = world->find_entities(center, radius, ents, 64, &type, 1);
2007-07-21 19:03:50 +00:00
for (int i = 0; i < num; i++)
{
// Check if entity is a player
if (ents[i] == this)
continue;
// make sure we haven't hit this object before
bool balreadyhit = false;
for (int j = 0; j < numobjectshit; j++)
{
if (hitobjects[j] == ents[i])
balreadyhit = true;
}
if (balreadyhit)
continue;
// check so we are sufficiently close
if (distance(ents[i]->pos, pos) > (phys_size * 2.0f))
continue;
2007-07-21 19:03:50 +00:00
// hit a player, give him damage and stuffs...
// create sound for bash
//create_sound(ents[i]->pos, sound_impact);
2007-08-04 19:00:06 +00:00
vec2 fdir = normalize(ents[i]->pos- pos);
2007-07-21 19:03:50 +00:00
// set his velocity to fast upward (for now)
create_smoke(ents[i]->pos);
2007-07-22 14:16:57 +00:00
create_sound(pos, SOUND_HAMMER_HIT);
2007-12-12 19:52:57 +00:00
if(numobjectshit < 10)
hitobjects[numobjectshit++] = ents[i];
2007-08-04 19:00:06 +00:00
ents[i]->take_damage(vec2(0,-1.0f), data->weapons[active_weapon].meleedamage, client_id, active_weapon);
2007-07-21 19:03:50 +00:00
player* target = (player*)ents[i];
vec2 dir;
if (length(target->pos - pos) > 0.0f)
dir = normalize(target->pos - pos);
else
dir = vec2(0,-1);
target->core.vel += normalize(dir + vec2(0,-1.1f)) * 10.0f;
2007-07-21 19:03:50 +00:00
}
}
2007-12-10 19:13:00 +00:00
2007-07-21 19:03:50 +00:00
if (data->weapons[active_weapon].ammoregentime)
{
// If equipped and not active, regen ammo?
if (reload_timer <= 0)
{
if (weapons[active_weapon].ammoregenstart < 0)
weapons[active_weapon].ammoregenstart = server_tick();
if ((server_tick() - weapons[active_weapon].ammoregenstart) >= data->weapons[active_weapon].ammoregentime * server_tickspeed() / 1000)
{
// Add some ammo
weapons[active_weapon].ammo = min(weapons[active_weapon].ammo + 1, data->weapons[active_weapon].maxammo);
weapons[active_weapon].ammoregenstart = -1;
}
}
else
{
weapons[active_weapon].ammoregenstart = -1;
}
}
2007-12-10 19:13:00 +00:00
2007-07-21 19:03:50 +00:00
return 0;
}
void player::tick()
{
server_setclientscore(client_id, score);
// check if we have enough input
// this is to prevent initial weird clicks
if(num_inputs < 2)
previnput = input;
2007-12-10 19:13:00 +00:00
// do latency stuff
{
CLIENT_INFO info;
if(server_getclientinfo(client_id, &info))
{
latency_accum += info.latency;
latency_accum_max = max(latency_accum_max, info.latency);
latency_accum_min = min(latency_accum_min, info.latency);
}
if(server_tick()%server_tickspeed() == 0)
{
latency_avg = latency_accum/server_tickspeed();
latency_max = latency_accum_max;
latency_min = latency_accum_min;
latency_accum = 0;
latency_accum_min = 1000;
latency_accum_max = 0;
}
}
2007-11-26 20:19:59 +00:00
// enable / disable physics
if(team == -1 || dead)
world->core.players[client_id] = 0;
else
world->core.players[client_id] = &core;
// spectator
2007-10-07 20:23:33 +00:00
if(team == -1)
return;
2007-08-02 20:17:18 +00:00
if(spawning)
try_respawn();
// TODO: rework the input to be more robust
if(dead)
{
2007-07-22 12:27:49 +00:00
if(server_tick()-die_tick >= server_tickspeed()*5) // auto respawn after 3 sec
respawn();
2007-10-07 23:43:14 +00:00
if((input.fire&1) && server_tick()-die_tick >= server_tickspeed()/2) // auto respawn after 0.5 sec
respawn();
return;
}
//player_core core;
//core.pos = pos;
//core.jumped = jumped;
core.input = input;
core.tick();
// handle weapons
2007-09-23 22:54:31 +00:00
handle_weapons();
2007-07-26 11:33:49 +00:00
state = input.state;
2007-07-21 19:03:50 +00:00
// Previnput
previnput = input;
return;
}
2007-05-22 15:03:32 +00:00
void player::tick_defered()
{
2007-11-26 20:58:44 +00:00
if(!dead)
{
2007-12-12 19:52:57 +00:00
vec2 start_pos = core.pos;
vec2 start_vel = core.vel;
bool stuck_before = test_box(core.pos, vec2(28.0f, 28.0f));
2007-12-16 13:32:59 +00:00
// TODO: this should be moved into the g_game
// but not done to preserve the nethash
if(length(core.vel) > 150.0f)
{
dbg_msg("server", "insane move! clamping (%f,%f) %f", core.vel.x, core.vel.y, length(core.vel));
core.vel = normalize(core.vel) * 150.0f;
}
2007-11-26 20:58:44 +00:00
core.move();
2007-12-12 19:52:57 +00:00
bool stuck_after_move = test_box(core.pos, vec2(28.0f, 28.0f));
2007-11-26 20:58:44 +00:00
core.quantize();
2007-12-12 19:52:57 +00:00
bool stuck_after_quant = test_box(core.pos, vec2(28.0f, 28.0f));
2007-11-26 20:58:44 +00:00
pos = core.pos;
2007-12-12 19:52:57 +00:00
if(!stuck_before && (stuck_after_move || stuck_after_quant))
{
2007-12-12 20:05:18 +00:00
dbg_msg("player", "STUCK!!! %d %d %d %f %f %f %f %x %x %x %x",
stuck_before,
stuck_after_move,
stuck_after_quant,
2007-12-12 19:52:57 +00:00
start_pos.x, start_pos.y,
start_vel.x, start_vel.y,
2007-12-12 20:05:18 +00:00
*((unsigned *)&start_pos.x), *((unsigned *)&start_pos.y),
*((unsigned *)&start_vel.x), *((unsigned *)&start_vel.y));
2007-12-12 19:52:57 +00:00
}
2007-12-09 12:40:34 +00:00
int events = core.triggered_events;
int mask = cmask_all_except_one(client_id);
if(events&COREEVENT_GROUND_JUMP) create_sound(pos, SOUND_PLAYER_JUMP, mask);
if(events&COREEVENT_AIR_JUMP)
{
create_sound(pos, SOUND_PLAYER_AIRJUMP, mask);
ev_common *c = (ev_common *)::events.create(EVENT_AIR_JUMP, sizeof(ev_common), mask);
2007-12-13 20:28:22 +00:00
if(c)
{
c->x = (int)pos.x;
c->y = (int)pos.y;
}
}
2007-12-09 12:40:34 +00:00
//if(events&COREEVENT_HOOK_LAUNCH) snd_play_random(CHN_WORLD, SOUND_HOOK_LOOP, 1.0f, pos);
if(events&COREEVENT_HOOK_ATTACH_PLAYER) create_sound(pos, SOUND_HOOK_ATTACH_PLAYER, mask);
if(events&COREEVENT_HOOK_ATTACH_GROUND) create_sound(pos, SOUND_HOOK_ATTACH_GROUND, mask);
2007-12-09 12:40:34 +00:00
//if(events&COREEVENT_HOOK_RETRACT) snd_play_random(CHN_WORLD, SOUND_PLAYER_JUMP, 1.0f, pos);
2007-11-26 20:58:44 +00:00
}
2007-11-26 20:19:59 +00:00
if(team == -1)
{
pos.x = input.target_x;
pos.y = input.target_y;
}
}
2007-05-22 15:03:32 +00:00
void player::die(int killer, int weapon)
{
int mode_special = gameobj->on_player_death(this, get_player(killer), weapon);
dbg_msg("game", "kill killer='%d:%s' victim='%d:%s' weapon=%d special=%d",
killer, server_clientname(killer),
client_id, server_clientname(client_id), weapon, mode_special);
// send the kill message
msg_pack_start(MSG_KILLMSG, MSGFLAG_VITAL);
msg_pack_int(killer);
msg_pack_int(client_id);
msg_pack_int(weapon);
msg_pack_int(mode_special);
msg_pack_end();
server_send_msg(-1);
// a nice sound
create_sound(pos, SOUND_PLAYER_DIE);
// set dead state
dead = true;
die_tick = server_tick();
2007-10-07 20:23:33 +00:00
clear_flag(FLAG_PHYSICS);
2007-07-21 21:17:38 +00:00
create_death(pos);
}
2007-05-22 15:03:32 +00:00
bool player::take_damage(vec2 force, int dmg, int from, int weapon)
{
core.vel += force;
2007-12-10 20:53:37 +00:00
if(gameobj->is_friendly_fire(client_id, from) && !config.sv_teamdamage)
return false;
// player only inflicts half damage on self
2007-08-04 19:00:06 +00:00
if(from == client_id)
dmg = max(1, dmg/2);
2007-09-25 21:53:14 +00:00
// CTF and TDM (TODO: check for FF)
//if (gameobj->gametype != GAMETYPE_DM && from >= 0 && players[from].team == team)
//return false;
2007-07-22 12:32:57 +00:00
damage_taken++;
// create healthmod indicator
if(server_tick() < damage_taken_tick+25)
{
// make sure that the damage indicators doesn't group together
create_damageind(pos, damage_taken*0.25f, dmg);
}
else
{
damage_taken = 0;
create_damageind(pos, 0, dmg);
}
if(armor)
2007-05-22 15:03:32 +00:00
{
armor -= 1;
dmg--;
}
if(dmg > armor)
{
dmg -= armor;
armor = 0;
health -= dmg;
}
else
armor -= dmg;
damage_taken_tick = server_tick();
2007-08-05 08:59:38 +00:00
// do damage hit sound
if(from >= 0)
2007-12-09 12:40:34 +00:00
create_sound(get_player(from)->pos, SOUND_HIT, cmask_one(from));
// check for death
if(health <= 0)
{
die(from, weapon);
// set attacker's face to happy (taunt!)
if (from >= 0 && from != client_id)
{
player *p = get_player(from);
p->emote_type = EMOTE_HAPPY;
p->emote_stop = server_tick() + server_tickspeed();
}
return false;
}
if (dmg > 2)
create_sound(pos, SOUND_PLAYER_PAIN_LONG);
else
create_sound(pos, SOUND_PLAYER_PAIN_SHORT);
2007-08-09 00:18:11 +00:00
emote_type = EMOTE_PAIN;
emote_stop = server_tick() + 500 * server_tickspeed() / 1000;
2007-08-05 08:59:38 +00:00
// spawn blood?
return true;
}
void player::snap(int snaping_client)
{
if(1)
{
obj_player_info *info = (obj_player_info *)snap_new_item(OBJTYPE_PLAYER_INFO, client_id, sizeof(obj_player_info));
2007-08-09 00:18:11 +00:00
info->latency = latency_avg;
info->latency_flux = latency_max-latency_min;
info->local = 0;
info->clientid = client_id;
info->score = score;
info->team = team;
2007-08-09 00:18:11 +00:00
if(client_id == snaping_client)
info->local = 1;
}
if(health > 0 && distance(players[snaping_client].pos, pos) < 1000.0f)
{
obj_player_character *character = (obj_player_character *)snap_new_item(OBJTYPE_PLAYER_CHARACTER, client_id, sizeof(obj_player_character));
core.write(character);
2007-10-28 17:54:28 +00:00
// this is to make sure that players that are just standing still
// isn't sent. this is because the physics keep bouncing between
// 0-128 when just standing.
// TODO: fix the physics so this isn't needed
if(snaping_client != client_id && abs(character->vy) < 256.0f)
character->vy = 0;
if (emote_stop < server_tick())
{
emote_type = EMOTE_NORMAL;
emote_stop = -1;
}
character->emote = emote_type;
character->ammocount = weapons[active_weapon].ammo;
character->health = 0;
character->armor = 0;
character->weapon = active_weapon;
character->weaponstage = weapons[active_weapon].weaponstage;
character->attacktick = attack_tick;
if(client_id == snaping_client)
{
character->health = health;
character->armor = armor;
}
if(dead)
character->health = -1;
//if(length(vel) > 15.0f)
// player->emote = EMOTE_HAPPY;
2007-07-26 11:33:49 +00:00
//if(damage_taken_tick+50 > server_tick())
// player->emote = EMOTE_PAIN;
if (character->emote == EMOTE_NORMAL)
{
if(250 - ((server_tick() - last_action)%(250)) < 5)
character->emote = EMOTE_BLINK;
}
character->state = state;
}
}
2007-05-22 15:03:32 +00:00
player *players;
2007-05-22 15:03:32 +00:00
//////////////////////////////////////////////////
// powerup
//////////////////////////////////////////////////
2007-07-13 13:40:04 +00:00
powerup::powerup(int _type, int _subtype)
: entity(OBJTYPE_POWERUP)
2007-05-22 15:03:32 +00:00
{
type = _type;
subtype = _subtype;
proximity_radius = phys_size;
reset();
2007-07-13 13:40:04 +00:00
// TODO: should this be done here?
2007-09-23 22:54:31 +00:00
world->insert_entity(this);
2007-05-22 15:03:32 +00:00
}
void powerup::reset()
{
2007-07-23 17:52:04 +00:00
if (data->powerupinfo[type].startspawntime > 0)
spawntick = server_tick() + server_tickspeed() * data->powerupinfo[type].startspawntime;
else
spawntick = -1;
}
2007-11-24 14:07:06 +00:00
void send_weapon_pickup(int cid, int weapon);
2007-05-22 15:03:32 +00:00
void powerup::tick()
{
// wait for respawn
if(spawntick > 0)
{
if(server_tick() > spawntick)
{
// respawn
2007-05-22 15:03:32 +00:00
spawntick = -1;
if(type == POWERUP_WEAPON)
2007-12-09 12:40:34 +00:00
create_sound(pos, SOUND_WEAPON_SPAWN);
}
2007-05-22 15:03:32 +00:00
else
return;
}
// Check if a player intersected us
vec2 meh;
player* pplayer = intersect_player(pos, pos + vec2(0,16), meh, 0);
if (pplayer)
{
// player picked us up, is someone was hooking us, let them go
int respawntime = -1;
switch (type)
{
2007-07-23 17:52:04 +00:00
case POWERUP_HEALTH:
if(pplayer->health < 10)
2007-05-22 15:03:32 +00:00
{
2007-12-09 12:40:34 +00:00
create_sound(pos, SOUND_PICKUP_HEALTH);
pplayer->health = min(10, pplayer->health + data->powerupinfo[type].amount);
2007-07-23 17:52:04 +00:00
respawntime = data->powerupinfo[type].respawntime;
2007-05-22 15:03:32 +00:00
}
2007-07-13 13:40:04 +00:00
break;
2007-07-23 17:52:04 +00:00
case POWERUP_ARMOR:
if(pplayer->armor < 10)
2007-05-22 15:03:32 +00:00
{
2007-12-09 12:40:34 +00:00
create_sound(pos, SOUND_PICKUP_ARMOR);
pplayer->armor = min(10, pplayer->armor + data->powerupinfo[type].amount);
2007-07-23 17:52:04 +00:00
respawntime = data->powerupinfo[type].respawntime;
2007-05-22 15:03:32 +00:00
}
2007-07-13 13:40:04 +00:00
break;
2007-07-23 17:52:04 +00:00
case POWERUP_WEAPON:
2007-07-13 13:40:04 +00:00
if(subtype >= 0 && subtype < NUM_WEAPONS)
2007-05-22 15:03:32 +00:00
{
2007-07-13 13:40:04 +00:00
if(pplayer->weapons[subtype].ammo < 10 || !pplayer->weapons[subtype].got)
2007-05-22 15:03:32 +00:00
{
2007-07-13 13:40:04 +00:00
pplayer->weapons[subtype].got = true;
2007-07-23 17:52:04 +00:00
pplayer->weapons[subtype].ammo = min(10, pplayer->weapons[subtype].ammo + data->powerupinfo[type].amount);
respawntime = data->powerupinfo[type].respawntime;
2007-08-03 06:35:35 +00:00
// TODO: data compiler should take care of stuff like this
if(subtype == WEAPON_ROCKET)
create_sound(pos, SOUND_PICKUP_ROCKET);
else if(subtype == WEAPON_SHOTGUN)
create_sound(pos, SOUND_PICKUP_SHOTGUN);
2007-11-24 14:07:06 +00:00
send_weapon_pickup(pplayer->client_id, subtype);
2007-05-22 15:03:32 +00:00
}
}
2007-07-13 13:40:04 +00:00
break;
2007-07-23 17:52:04 +00:00
case POWERUP_NINJA:
2007-07-21 19:03:50 +00:00
{
// activate ninja on target player
2007-12-15 12:04:48 +00:00
pplayer->ninja_activationtick = server_tick();
2007-07-21 19:03:50 +00:00
pplayer->weapons[WEAPON_NINJA].got = true;
pplayer->last_weapon = pplayer->active_weapon;
2007-07-21 19:03:50 +00:00
pplayer->active_weapon = WEAPON_NINJA;
2007-07-23 17:52:04 +00:00
respawntime = data->powerupinfo[type].respawntime;
2007-08-03 06:35:35 +00:00
create_sound(pos, SOUND_PICKUP_NINJA);
2007-08-09 00:18:11 +00:00
// loop through all players, setting their emotes
entity *ents[64];
const int types[] = {OBJTYPE_PLAYER_CHARACTER};
2007-09-23 22:54:31 +00:00
int num = world->find_entities(vec2(0, 0), 1000000, ents, 64, types, 1);
2007-08-09 00:18:11 +00:00
for (int i = 0; i < num; i++)
{
player *p = (player *)ents[i];
if (p != pplayer)
{
p->emote_type = EMOTE_SURPRISE;
p->emote_stop = server_tick() + server_tickspeed();
}
}
pplayer->emote_type = EMOTE_ANGRY;
pplayer->emote_stop = server_tick() + 1200 * server_tickspeed() / 1000;
2007-12-15 15:32:01 +00:00
2007-07-21 19:03:50 +00:00
break;
}
2007-05-22 15:03:32 +00:00
default:
break;
};
2007-05-22 15:03:32 +00:00
if(respawntime >= 0)
{
dbg_msg("game", "pickup player='%d:%s' item=%d/%d",
pplayer->client_id, server_clientname(pplayer->client_id), type, subtype);
2007-05-22 15:03:32 +00:00
spawntick = server_tick() + server_tickspeed() * respawntime;
}
2007-05-22 15:03:32 +00:00
}
}
void powerup::snap(int snapping_client)
{
if(spawntick != -1)
return;
2007-07-13 13:40:04 +00:00
obj_powerup *up = (obj_powerup *)snap_new_item(OBJTYPE_POWERUP, id, sizeof(obj_powerup));
up->x = (int)pos.x;
up->y = (int)pos.y;
up->type = type; // TODO: two diffrent types? what gives?
up->subtype = subtype;
2007-05-22 15:03:32 +00:00
}
// POWERUP END ///////////////////////
player *get_player(int index)
{
return &players[index];
}
void create_damageind(vec2 p, float angle, int amount)
2007-05-22 15:03:32 +00:00
{
float a = 3 * 3.14159f / 2 + angle;
2007-07-21 12:57:36 +00:00
//float a = get_angle(dir);
2007-07-14 13:09:42 +00:00
float s = a-pi/3;
float e = a+pi/3;
for(int i = 0; i < amount; i++)
{
float f = mix(s, e, float(i+1)/float(amount+2));
ev_damageind *ev = (ev_damageind *)events.create(EVENT_DAMAGEINDICATION, sizeof(ev_damageind));
if(ev)
{
ev->x = (int)p.x;
ev->y = (int)p.y;
ev->angle = (int)(f*256.0f);
}
2007-07-14 13:09:42 +00:00
}
2007-05-22 15:03:32 +00:00
}
void create_explosion(vec2 p, int owner, int weapon, bool bnodamage)
2007-05-22 15:03:32 +00:00
{
// create the event
ev_explosion *ev = (ev_explosion *)events.create(EVENT_EXPLOSION, sizeof(ev_explosion));
if(ev)
{
ev->x = (int)p.x;
ev->y = (int)p.y;
}
2007-05-22 15:03:32 +00:00
if (!bnodamage)
{
// deal damage
entity *ents[64];
const float radius = 128.0f;
const float innerradius = 42.0f;
2007-09-23 22:54:31 +00:00
int num = world->find_entities(p, radius, ents, 64);
2007-05-22 15:03:32 +00:00
for(int i = 0; i < num; i++)
{
vec2 diff = ents[i]->pos - p;
vec2 forcedir(0,1);
float l = length(diff);
if(l)
forcedir = normalize(diff);
l = 1-clamp((l-innerradius)/(radius-innerradius), 0.0f, 1.0f);
float dmg = 6 * l;
2007-05-22 15:03:32 +00:00
if((int)dmg)
2007-08-04 19:00:06 +00:00
ents[i]->take_damage(forcedir*dmg*2, (int)dmg, owner, weapon);
2007-05-22 15:03:32 +00:00
}
}
}
void create_smoke(vec2 p)
{
// create the event
ev_explosion *ev = (ev_explosion *)events.create(EVENT_SMOKE, sizeof(ev_explosion));
if(ev)
{
ev->x = (int)p.x;
ev->y = (int)p.y;
}
2007-05-22 15:03:32 +00:00
}
2007-07-21 19:03:50 +00:00
void create_spawn(vec2 p)
{
// create the event
ev_spawn *ev = (ev_spawn *)events.create(EVENT_SPAWN, sizeof(ev_spawn));
if(ev)
{
ev->x = (int)p.x;
ev->y = (int)p.y;
}
2007-07-21 19:03:50 +00:00
}
2007-07-21 21:17:38 +00:00
void create_death(vec2 p)
{
// create the event
ev_death *ev = (ev_death *)events.create(EVENT_DEATH, sizeof(ev_death));
if(ev)
{
ev->x = (int)p.x;
ev->y = (int)p.y;
}
2007-07-21 21:17:38 +00:00
}
2007-12-09 12:40:34 +00:00
void create_sound(vec2 pos, int sound, int mask)
2007-05-22 15:03:32 +00:00
{
if (sound < 0)
return;
// create a sound
2007-12-09 12:40:34 +00:00
ev_sound *ev = (ev_sound *)events.create(EVENT_SOUND_WORLD, sizeof(ev_sound), mask);
if(ev)
{
ev->x = (int)pos.x;
ev->y = (int)pos.y;
2007-12-09 12:40:34 +00:00
ev->sound = sound;
}
2007-05-22 15:03:32 +00:00
}
void create_sound_global(int sound, int target)
{
if (sound < 0)
return;
msg_pack_start(MSG_SOUND_GLOBAL, MSGFLAG_VITAL);
msg_pack_int(sound);
2007-12-15 15:35:50 +00:00
server_send_msg(target);
}
2007-07-13 13:40:04 +00:00
// TODO: should be more general
2007-05-22 15:03:32 +00:00
player* intersect_player(vec2 pos0, vec2 pos1, vec2& new_pos, entity* notthis)
{
// Find other players
entity *ents[64];
vec2 dir = pos1 - pos0;
float radius = length(dir * 0.5f);
vec2 center = pos0 + dir * 0.5f;
const int types[] = {OBJTYPE_PLAYER_CHARACTER};
2007-09-23 22:54:31 +00:00
int num = world->find_entities(center, radius, ents, 64, types, 1);
2007-05-22 15:03:32 +00:00
for (int i = 0; i < num; i++)
{
// Check if entity is a player
2007-07-14 13:09:42 +00:00
if (ents[i] != notthis)
2007-05-22 15:03:32 +00:00
{
new_pos = ents[i]->pos;
return (player*)ents[i];
}
}
return 0;
}
2007-10-07 20:48:15 +00:00
void send_chat(int cid, int team, const char *msg)
{
if(cid >= 0 && cid < MAX_CLIENTS)
dbg_msg("chat", "%d:%d:%s: %s", cid, team, server_clientname(cid), msg);
2007-10-07 20:48:15 +00:00
else
dbg_msg("chat", "*** %s", msg);
2007-10-07 20:48:15 +00:00
if(team == -1)
{
msg_pack_start(MSG_CHAT, MSGFLAG_VITAL);
msg_pack_int(cid);
msg_pack_int(0);
msg_pack_string(msg, 512);
msg_pack_end();
server_send_msg(-1);
}
else
{
msg_pack_start(MSG_CHAT, MSGFLAG_VITAL);
msg_pack_int(cid);
msg_pack_int(1);
msg_pack_string(msg, 512);
msg_pack_end();
2007-10-07 20:48:15 +00:00
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(players[i].client_id != -1 && players[i].team == team)
server_send_msg(i);
}
}
}
2007-05-22 15:03:32 +00:00
// Server hooks
void mods_tick()
{
// clear all events
events.clear();
2007-12-16 15:33:44 +00:00
2007-09-23 22:54:31 +00:00
world->tick();
2007-09-23 22:54:31 +00:00
if(world->paused) // make sure that the game object always updates
gameobj->tick();
2007-12-11 23:10:07 +00:00
if(config.sv_restart)
2007-10-04 23:58:22 +00:00
{
2007-12-11 23:10:07 +00:00
if(config.sv_restart > 1)
gameobj->do_warmup(config.sv_restart);
2007-10-06 17:36:24 +00:00
else
gameobj->startround();
2007-12-11 23:10:07 +00:00
config.sv_restart = 0;
2007-10-04 23:58:22 +00:00
}
2007-10-07 20:48:15 +00:00
if(config.sv_msg[0] != 0)
{
send_chat(-1, 0, config.sv_msg);
config.sv_msg[0] = 0;
}
2007-05-22 15:03:32 +00:00
}
void mods_snap(int client_id)
{
2007-09-23 22:54:31 +00:00
world->snap(client_id);
2007-05-22 15:03:32 +00:00
events.snap(client_id);
}
void mods_client_input(int client_id, void *input)
{
2007-09-23 22:54:31 +00:00
if(!world->paused)
{
if (memcmp(&players[client_id].input, input, sizeof(player_input)) != 0)
players[client_id].last_action = server_tick();
2007-07-21 19:03:50 +00:00
//players[client_id].previnput = players[client_id].input;
players[client_id].input = *(player_input*)input;
players[client_id].num_inputs++;
2007-12-16 20:07:31 +00:00
if(players[client_id].input.target_x == 0 && players[client_id].input.target_y == 0)
players[client_id].input.target_y = -1;
}
2007-05-22 15:03:32 +00:00
}
void send_info(int who, int to_who)
2007-08-14 22:48:49 +00:00
{
msg_pack_start(MSG_SETINFO, MSGFLAG_VITAL);
msg_pack_int(who);
msg_pack_string(server_clientname(who), 64);
msg_pack_string(players[who].skin_name, 64);
msg_pack_int(players[who].use_custom_color);
msg_pack_int(players[who].color_body);
msg_pack_int(players[who].color_feet);
2007-08-14 22:48:49 +00:00
msg_pack_end();
server_send_msg(to_who);
2007-08-14 22:48:49 +00:00
}
void send_emoticon(int cid, int emoticon)
{
msg_pack_start(MSG_EMOTICON, MSGFLAG_VITAL);
msg_pack_int(cid);
msg_pack_int(emoticon % 16);
msg_pack_end();
server_send_msg(-1);
}
2007-11-24 14:07:06 +00:00
void send_weapon_pickup(int cid, int weapon)
{
msg_pack_start(MSG_WEAPON_PICKUP, MSGFLAG_VITAL);
msg_pack_int(weapon);
msg_pack_end();
server_send_msg(cid);
}
2007-05-22 15:03:32 +00:00
void mods_client_enter(int client_id)
{
2007-09-23 22:54:31 +00:00
world->insert_entity(&players[client_id]);
players[client_id].respawn();
dbg_msg("game", "join player='%d:%s'", client_id, server_clientname(client_id));
char buf[512];
sprintf(buf, "%s has joined the game", server_clientname(client_id));
send_chat(-1, -1, buf);
}
void mods_connected(int client_id)
{
players[client_id].init();
players[client_id].client_id = client_id;
//dbg_msg("game", "connected player='%d:%s'", client_id, server_clientname(client_id));
2007-10-07 20:23:33 +00:00
// Check which team the player should be on
if(gameobj->gametype == GAMETYPE_DM)
players[client_id].team = 0;
else
players[client_id].team = gameobj->getteam(client_id);
2007-05-22 15:03:32 +00:00
}
void mods_client_drop(int client_id)
{
2007-07-30 07:05:34 +00:00
char buf[512];
sprintf(buf, "%s has left the game", server_clientname(client_id));
2007-09-25 21:53:14 +00:00
send_chat(-1, -1, buf);
dbg_msg("game", "leave player='%d:%s'", client_id, server_clientname(client_id));
2007-09-25 21:53:14 +00:00
gameobj->on_player_death(&players[client_id], 0, -1);
2007-09-23 22:54:31 +00:00
world->remove_entity(&players[client_id]);
world->core.players[client_id] = 0x0;
players[client_id].client_id = -1;
2007-05-22 15:03:32 +00:00
}
2007-07-14 13:09:42 +00:00
void mods_message(int msg, int client_id)
{
if(msg == MSG_SAY)
{
2007-09-25 21:53:14 +00:00
int team = msg_unpack_int();
const char *text = msg_unpack_string();
2007-10-04 22:00:10 +00:00
if(team)
team = players[client_id].team;
else
team = -1;
2007-09-25 21:53:14 +00:00
send_chat(client_id, team, text);
2007-07-14 13:09:42 +00:00
}
2007-10-07 20:23:33 +00:00
else if (msg == MSG_SETTEAM)
2007-07-22 11:53:15 +00:00
{
// Switch team on given client and kill/respawn him
2007-10-07 20:23:33 +00:00
players[client_id].set_team(msg_unpack_int());
2007-11-18 14:49:56 +00:00
gameobj->on_player_info_change(&players[client_id]);
// send all info to this client
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(players[i].client_id != -1)
send_info(i, -1);
}
2007-07-22 11:53:15 +00:00
}
else if (msg == MSG_CHANGEINFO || msg == MSG_STARTINFO)
2007-08-14 22:48:49 +00:00
{
const char *name = msg_unpack_string();
const char *skin_name = msg_unpack_string();
players[client_id].use_custom_color = msg_unpack_int();
players[client_id].color_body = msg_unpack_int();
players[client_id].color_feet = msg_unpack_int();
2007-08-14 22:48:49 +00:00
// check for invalid chars
const char *p = name;
while (*p)
{
if(*p < 32)
2007-08-14 22:48:49 +00:00
return;
p++;
}
//
if(msg == MSG_CHANGEINFO && strcmp(name, server_clientname(client_id)) != 0)
{
char msg[256];
sprintf(msg, "*** %s changed name to %s", server_clientname(client_id), name);
send_chat(-1, -1, msg);
}
//send_set_name(client_id, players[client_id].name, name);
strncpy(players[client_id].skin_name, skin_name, 64);
server_setclientname(client_id, name);
gameobj->on_player_info_change(&players[client_id]);
if(msg == MSG_STARTINFO)
{
// send all info to this client
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(players[i].client_id != -1)
send_info(i, client_id);
}
msg_pack_start(MSG_READY_TO_ENTER, MSGFLAG_VITAL);
msg_pack_end();
server_send_msg(client_id);
}
send_info(client_id, -1);
2007-08-14 22:48:49 +00:00
}
else if (msg == MSG_EMOTICON)
{
int emoteicon = msg_unpack_int();
send_emoticon(client_id, emoteicon % 16);
}
2007-07-14 13:09:42 +00:00
}
extern unsigned char internal_data[];
2007-05-22 15:03:32 +00:00
void mods_init()
{
2007-09-23 22:54:31 +00:00
if(!data) /* only load once */
data = load_data_from_memory(internal_data);
2007-05-22 15:03:32 +00:00
col_init(32);
2007-09-23 22:54:31 +00:00
world = new game_world;
players = new player[MAX_CLIENTS];
// select gametype
2007-12-11 23:10:07 +00:00
if(strcmp(config.sv_gametype, "ctf") == 0)
gameobj = new gameobject_ctf;
2007-12-11 23:10:07 +00:00
else if(strcmp(config.sv_gametype, "tdm") == 0)
gameobj = new gameobject_tdm;
else
gameobj = new gameobject_dm;
// setup core world
for(int i = 0; i < MAX_CLIENTS; i++)
2007-09-23 22:54:31 +00:00
players[i].core.world = &world->core;
//
2007-05-22 15:03:32 +00:00
int start, num;
map_get_type(MAPRES_ITEM, &start, &num);
2007-07-13 13:40:04 +00:00
// TODO: this is way more complicated then it should be
2007-05-22 15:03:32 +00:00
for(int i = 0; i < num; i++)
{
mapres_item *it = (mapres_item *)map_get_item(start+i, 0, 0);
2007-05-22 15:03:32 +00:00
int type = -1;
int subtype = 0;
2007-05-22 15:03:32 +00:00
switch(it->type)
{
case ITEM_WEAPON_GUN:
2007-07-23 17:52:04 +00:00
type = POWERUP_WEAPON;
2007-07-22 11:53:15 +00:00
subtype = WEAPON_GUN;
2007-05-22 15:03:32 +00:00
break;
case ITEM_WEAPON_SHOTGUN:
2007-07-23 17:52:04 +00:00
type = POWERUP_WEAPON;
2007-07-22 11:53:15 +00:00
subtype = WEAPON_SHOTGUN;
2007-05-22 15:03:32 +00:00
break;
case ITEM_WEAPON_ROCKET:
2007-07-23 17:52:04 +00:00
type = POWERUP_WEAPON;
2007-07-22 11:53:15 +00:00
subtype = WEAPON_ROCKET;
2007-05-22 15:03:32 +00:00
break;
case ITEM_WEAPON_HAMMER:
2007-07-23 17:52:04 +00:00
type = POWERUP_WEAPON;
2007-07-22 11:53:15 +00:00
subtype = WEAPON_HAMMER;
2007-05-22 15:03:32 +00:00
break;
2007-07-15 13:25:10 +00:00
case ITEM_HEALTH:
2007-07-23 17:52:04 +00:00
type = POWERUP_HEALTH;
2007-05-22 15:03:32 +00:00
break;
2007-07-15 13:25:10 +00:00
case ITEM_ARMOR:
2007-07-23 17:52:04 +00:00
type = POWERUP_ARMOR;
2007-05-22 15:03:32 +00:00
break;
2007-07-22 12:01:20 +00:00
2007-07-22 11:53:15 +00:00
case ITEM_NINJA:
2007-12-08 16:03:43 +00:00
if(config.sv_powerups)
{
type = POWERUP_NINJA;
subtype = WEAPON_NINJA;
}
2007-07-22 11:53:15 +00:00
break;
2007-05-22 15:03:32 +00:00
};
2007-07-22 12:01:20 +00:00
if(type != -1)
{
// LOL, the only new in the entire game code
2007-08-14 22:48:49 +00:00
// perhaps we can get rid of it. seems like a stupid thing to have
2007-07-22 12:01:20 +00:00
powerup *ppower = new powerup(type, subtype);
ppower->pos = vec2(it->x, it->y);
}
2007-05-22 15:03:32 +00:00
}
if(gameobj->gametype == GAMETYPE_CTF)
{
}
2007-09-23 22:54:31 +00:00
world->insert_entity(gameobj);
2007-10-04 23:00:20 +00:00
if(config.dbg_bots)
{
2007-11-18 14:49:56 +00:00
for(int i = 0; i < config.dbg_bots ; i++)
2007-10-04 23:00:20 +00:00
{
2007-11-18 14:49:56 +00:00
mods_connected(MAX_CLIENTS-i-1);
mods_client_enter(MAX_CLIENTS-i-1);
if(gameobj->gametype != GAMETYPE_DM)
players[MAX_CLIENTS-i-1].team = i&1;
}
}
2007-05-22 15:03:32 +00:00
}
2007-09-23 22:54:31 +00:00
void mods_shutdown()
{
delete [] players;
delete gameobj;
delete world;
gameobj = 0;
players = 0;
world = 0;
}
2007-05-22 15:03:32 +00:00
void mods_presnap() {}
void mods_postsnap() {}
2007-08-22 21:13:33 +00:00
extern "C" const char *mods_net_version() { return TEEWARS_NETVERSION; }