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-07-15 10:47:50 +00:00
|
|
|
#include <engine/config.h>
|
2007-08-22 21:13:33 +00:00
|
|
|
#include "../version.h"
|
2007-07-15 10:47:50 +00:00
|
|
|
#include "game_server.h"
|
2007-09-25 23:03:15 +00:00
|
|
|
#include "srv_common.h"
|
|
|
|
#include "srv_ctf.h"
|
|
|
|
#include "srv_tdm.h"
|
|
|
|
#include "srv_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);
|
2007-08-05 09:12:38 +00:00
|
|
|
void create_damageind(vec2 p, float angle_mod, int amount);
|
2007-07-14 22:35:00 +00:00
|
|
|
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-05-22 15:03:32 +00:00
|
|
|
void create_sound(vec2 pos, int sound, int loopflags = 0);
|
2007-08-04 17:28:31 +00:00
|
|
|
void create_targetted_sound(vec2 pos, int sound, int target, int loopflags = 0);
|
2007-07-15 10:47:50 +00:00
|
|
|
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;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
//////////////////////////////////////////////////
|
|
|
|
// Event handler
|
|
|
|
//////////////////////////////////////////////////
|
|
|
|
event_handler::event_handler()
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
clear();
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-08-04 17:28:31 +00:00
|
|
|
void *event_handler::create(int type, int size, int target)
|
2007-07-15 10:47:50 +00:00
|
|
|
{
|
2007-08-14 18:37:16 +00:00
|
|
|
if(num_events == MAX_EVENTS)
|
|
|
|
return 0;
|
|
|
|
if(current_offset+size >= MAX_DATASIZE)
|
|
|
|
return 0;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void *p = &data[current_offset];
|
|
|
|
offsets[num_events] = current_offset;
|
|
|
|
types[num_events] = type;
|
|
|
|
sizes[num_events] = size;
|
2007-08-04 17:28:31 +00:00
|
|
|
targets[num_events] = target;
|
2007-07-15 10:47:50 +00:00
|
|
|
current_offset += size;
|
|
|
|
num_events++;
|
|
|
|
return p;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void event_handler::clear()
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
num_events = 0;
|
|
|
|
current_offset = 0;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +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-08-04 17:28:31 +00:00
|
|
|
if (targets[i] == -1 || targets[i] == snapping_client)
|
|
|
|
{
|
|
|
|
void *d = snap_new_item(types[i], i, sizes[i]);
|
|
|
|
mem_copy(d, &data[offsets[i]], sizes[i]);
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
event_handler events;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
|
|
// Entity
|
|
|
|
//////////////////////////////////////////////////
|
|
|
|
entity::entity(int objtype)
|
|
|
|
{
|
|
|
|
this->objtype = objtype;
|
|
|
|
pos = vec2(0,0);
|
|
|
|
flags = FLAG_ALIVE;
|
|
|
|
proximity_radius = 0;
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-08-14 18:37:16 +00:00
|
|
|
id = snap_new_id();
|
2007-07-14 13:09:42 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
next_entity = 0;
|
|
|
|
prev_entity = 0;
|
|
|
|
prev_type_entity = 0;
|
|
|
|
next_type_entity = 0;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
entity::~entity()
|
|
|
|
{
|
2007-08-14 18:37:16 +00:00
|
|
|
snap_free_id(id);
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
//////////////////////////////////////////////////
|
|
|
|
// game world
|
|
|
|
//////////////////////////////////////////////////
|
|
|
|
game_world::game_world()
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +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
|
|
|
|
2007-07-15 10:47:50 +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-07-15 10:47:50 +00:00
|
|
|
if(!(ent->flags&entity::FLAG_ALIVE))
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +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
|
|
|
{
|
2007-07-15 10:47:50 +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-07-14 13:09:42 +00:00
|
|
|
if(!(ent->flags&entity::FLAG_ALIVE))
|
|
|
|
continue;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// 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;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// 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;
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
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();
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
for(entity *ent = first_entity; ent; ent = ent->next_entity)
|
|
|
|
ent->post_reset();
|
|
|
|
remove_entities();
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
reset_requested = false;
|
|
|
|
}
|
2007-07-14 13:09:42 +00:00
|
|
|
|
2007-07-15 10:47:50 +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
|
|
|
{
|
2007-07-15 10:47:50 +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
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void game_world::tick()
|
|
|
|
{
|
|
|
|
if(reset_requested)
|
|
|
|
reset();
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
if(!paused)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
|
|
|
// update all objects
|
|
|
|
for(entity *ent = first_entity; ent; ent = ent->next_entity)
|
|
|
|
ent->tick();
|
2007-07-13 13:40:04 +00:00
|
|
|
|
|
|
|
for(entity *ent = first_entity; ent; ent = ent->next_entity)
|
|
|
|
ent->tick_defered();
|
2007-05-22 15:03:32 +00:00
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
|
|
|
|
remove_entities();
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +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;
|
|
|
|
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;
|
2007-09-23 22:54:31 +00:00
|
|
|
world->insert_entity(this);
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void projectile::reset()
|
|
|
|
{
|
2007-09-23 22:54:31 +00:00
|
|
|
world->destroy_entity(this);
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void projectile::tick()
|
|
|
|
{
|
|
|
|
vec2 oldpos = pos;
|
2007-08-04 19:00:06 +00:00
|
|
|
|
|
|
|
int collide = 0;
|
|
|
|
if(bounce)
|
|
|
|
{
|
|
|
|
int numbounces;
|
|
|
|
vel.y += 0.25f;
|
2007-08-04 19:28:40 +00:00
|
|
|
move_point(&pos, &vel, 0.25f, &numbounces);
|
2007-08-04 19:00:06 +00:00
|
|
|
bounce -= numbounces;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
vel.y += 0.25f;
|
|
|
|
pos += vel;
|
|
|
|
collide = col_check_point((int)pos.x, (int)pos.y);
|
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
lifespan--;
|
2007-07-13 13:40:04 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// check player intersection as well
|
2007-07-21 18:07:27 +00:00
|
|
|
vec2 new_pos;
|
|
|
|
entity *targetplayer = (entity*)intersect_player(oldpos, pos, new_pos, powner);
|
2007-08-04 19:00:06 +00:00
|
|
|
|
|
|
|
if(targetplayer || lifespan < 0 || collide || bounce < 0)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-26 14:08:56 +00:00
|
|
|
if (lifespan >= 0 || weapon == WEAPON_ROCKET)
|
2007-07-15 10:47:50 +00:00
|
|
|
create_sound(pos, sound_impact);
|
|
|
|
|
|
|
|
if (flags & PROJECTILE_FLAGS_EXPLODE)
|
|
|
|
create_explosion(oldpos, owner, weapon, false);
|
|
|
|
else if (targetplayer)
|
2007-08-04 17:28:31 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
targetplayer->take_damage(normalize(vel) * max(0.001f, force), damage, owner, weapon);
|
2007-08-04 17:28:31 +00:00
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-09-23 22:54:31 +00:00
|
|
|
world->destroy_entity(this);
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void projectile::snap(int snapping_client)
|
|
|
|
{
|
|
|
|
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; // TODO: should be an angle
|
|
|
|
proj->vy = (int)vel.y;
|
|
|
|
proj->type = type;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
//////////////////////////////////////////////////
|
|
|
|
// player
|
|
|
|
//////////////////////////////////////////////////
|
|
|
|
// TODO: move to separate file
|
|
|
|
player::player()
|
|
|
|
: entity(OBJTYPE_PLAYER)
|
|
|
|
{
|
|
|
|
init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void player::init()
|
|
|
|
{
|
|
|
|
proximity_radius = phys_size;
|
|
|
|
name[0] = 'n';
|
|
|
|
name[1] = 'o';
|
|
|
|
name[2] = 'o';
|
|
|
|
name[3] = 'b';
|
|
|
|
name[4] = 0;
|
|
|
|
client_id = -1;
|
2007-07-22 13:46:45 +00:00
|
|
|
team = 0;
|
2007-07-21 19:03:50 +00:00
|
|
|
extrapowerflags = 0;
|
|
|
|
ninjaactivationtick = 0;
|
2007-08-14 18:37:16 +00:00
|
|
|
|
|
|
|
latency_accum = 0;
|
|
|
|
latency_accum_min = 0;
|
|
|
|
latency_accum_max = 0;
|
|
|
|
latency_avg = 0;
|
|
|
|
latency_min = 0;
|
|
|
|
latency_max = 0;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
void player::reset()
|
|
|
|
{
|
|
|
|
pos = vec2(0.0f, 0.0f);
|
2007-09-09 18:21:14 +00:00
|
|
|
core.vel = vec2(0.0f, 0.0f);
|
|
|
|
//direction = vec2(0.0f, 1.0f);
|
2007-07-15 10:47:50 +00:00
|
|
|
score = 0;
|
|
|
|
dead = true;
|
2007-08-02 20:17:18 +00:00
|
|
|
spawning = false;
|
2007-07-15 10:47:50 +00:00
|
|
|
die_tick = 0;
|
2007-08-05 09:12:38 +00:00
|
|
|
damage_taken = 0;
|
2007-07-26 11:33:49 +00:00
|
|
|
state = STATE_UNKNOWN;
|
2007-08-14 18:37:16 +00:00
|
|
|
|
|
|
|
mem_zero(&input, sizeof(input));
|
|
|
|
mem_zero(&previnput, sizeof(previnput));
|
|
|
|
|
2007-08-10 11:55:59 +00:00
|
|
|
last_action = -1;
|
2007-08-14 18:37:16 +00:00
|
|
|
|
|
|
|
emote_stop = 0;
|
|
|
|
damage_taken_tick = 0;
|
|
|
|
attack_tick = 0;
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void player::destroy() { }
|
2007-08-14 18:37:16 +00:00
|
|
|
|
|
|
|
void player::set_weapon(int w)
|
|
|
|
{
|
|
|
|
last_weapon = active_weapon;
|
|
|
|
active_weapon = w;
|
|
|
|
}
|
|
|
|
|
2007-07-13 13:40:04 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void player::respawn()
|
|
|
|
{
|
2007-08-02 20:17:18 +00:00
|
|
|
spawning = true;
|
|
|
|
}
|
|
|
|
|
2007-08-30 07:15:26 +00:00
|
|
|
bool try_spawntype(int t, vec2 *pos)
|
2007-08-02 20:17:18 +00:00
|
|
|
{
|
|
|
|
// get spawn point
|
|
|
|
int start, num;
|
2007-08-30 07:15:26 +00:00
|
|
|
map_get_type(t, &start, &num);
|
|
|
|
if(!num)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
mapres_spawnpoint *sp = (mapres_spawnpoint*)map_get_item(start + (rand()%num), NULL, NULL);
|
|
|
|
*pos = vec2((float)sp->x, (float)sp->y);
|
|
|
|
return true;
|
|
|
|
}
|
2007-08-02 20:17:18 +00:00
|
|
|
|
2007-08-30 07:15:26 +00:00
|
|
|
|
|
|
|
void player::try_respawn()
|
|
|
|
{
|
2007-08-02 20:17:18 +00:00
|
|
|
vec2 spawnpos = vec2(100.0f, -60.0f);
|
2007-08-30 07:15:26 +00:00
|
|
|
|
|
|
|
// get spawn point
|
|
|
|
if(gameobj->gametype == GAMETYPE_CTF)
|
2007-08-02 20:17:18 +00:00
|
|
|
{
|
2007-08-30 07:15:26 +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
|
|
|
}
|
2007-08-30 07:15:26 +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};
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
spawning = false;
|
|
|
|
pos = spawnpos;
|
2007-09-09 18:21:14 +00:00
|
|
|
|
|
|
|
core.pos = pos;
|
|
|
|
core.hooked_player = -1;
|
2007-08-02 20:17:18 +00:00
|
|
|
|
|
|
|
|
2007-08-30 07:15:26 +00:00
|
|
|
health = 10;
|
2007-07-15 10:47:50 +00:00
|
|
|
armor = 0;
|
|
|
|
jumped = 0;
|
|
|
|
dead = false;
|
|
|
|
set_flag(entity::FLAG_ALIVE);
|
2007-07-26 11:33:49 +00:00
|
|
|
state = STATE_PLAYING;
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-09-09 18:21:14 +00:00
|
|
|
core.hook_state = HOOK_IDLE;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
mem_zero(&input, sizeof(input));
|
2007-09-09 18:21:14 +00:00
|
|
|
core.vel = vec2(0.0f, 0.0f);
|
2007-07-15 10:47:50 +00:00
|
|
|
|
|
|
|
// init weapons
|
|
|
|
mem_zero(&weapons, sizeof(weapons));
|
|
|
|
weapons[WEAPON_HAMMER].got = true;
|
|
|
|
weapons[WEAPON_HAMMER].ammo = -1;
|
|
|
|
weapons[WEAPON_GUN].got = true;
|
2007-08-14 18:37:16 +00:00
|
|
|
weapons[WEAPON_GUN].ammo = data->weapons[WEAPON_GUN].maxammo;
|
2007-08-04 01:53:26 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
active_weapon = WEAPON_GUN;
|
2007-08-14 18:37:16 +00:00
|
|
|
last_weapon = WEAPON_HAMMER;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
reload_timer = 0;
|
2007-08-09 00:18:11 +00:00
|
|
|
|
2007-07-21 19:03:50 +00:00
|
|
|
// Create sound and spawn effects
|
2007-07-15 10:47:50 +00:00
|
|
|
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-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +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
|
|
|
|
2007-07-21 19:03:50 +00:00
|
|
|
int player::handle_ninja()
|
|
|
|
{
|
2007-09-09 18:21:14 +00:00
|
|
|
vec2 direction = normalize(vec2(input.target_x, input.target_y));
|
|
|
|
|
2007-07-21 19:03:50 +00:00
|
|
|
if ((server_tick() - ninjaactivationtick) > (data->weapons[WEAPON_NINJA].duration * server_tickspeed() / 1000))
|
|
|
|
{
|
|
|
|
// time's up, return
|
2007-08-14 18:37:16 +00:00
|
|
|
active_weapon = last_weapon;
|
2007-07-21 19:03:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if it should activate
|
|
|
|
if ((input.fire && !(previnput.fire)) && (server_tick() > currentcooldown))
|
|
|
|
{
|
|
|
|
// 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();
|
|
|
|
// reset hit objects
|
|
|
|
numobjectshit = 0;
|
|
|
|
|
|
|
|
create_sound(pos, SOUND_NINJA_FIRE);
|
2007-08-04 08:31:44 +00:00
|
|
|
|
|
|
|
// 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--;
|
|
|
|
|
|
|
|
if (currentmovetime == 0)
|
|
|
|
{
|
|
|
|
// reset player velocity
|
2007-09-09 18:21:14 +00:00
|
|
|
core.vel *= 0.2f;
|
2007-07-21 19:03:50 +00:00
|
|
|
//return MODIFIER_RETURNFLAGS_OVERRIDEWEAPON;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (currentmovetime > 0)
|
|
|
|
{
|
|
|
|
// Set player velocity
|
2007-09-09 18:21:14 +00:00
|
|
|
core.vel = activationdir * data->weapons[WEAPON_NINJA].velocity;
|
2007-07-21 19:03:50 +00:00
|
|
|
vec2 oldpos = pos;
|
2007-09-09 18:21:14 +00:00
|
|
|
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
|
2007-09-09 18:21:14 +00:00
|
|
|
core.vel = vec2(0.0f,0.0f);
|
2007-07-21 19:03:50 +00:00
|
|
|
if ((currentmovetime % 2) == 0)
|
|
|
|
{
|
|
|
|
create_smoke(pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
// check if we hit anything along the way
|
|
|
|
{
|
|
|
|
int type = OBJTYPE_PLAYER;
|
|
|
|
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;
|
|
|
|
|
|
|
|
// hit a player, give him damage and stuffs...
|
|
|
|
create_sound(ents[i]->pos, SOUND_NINJA_HIT);
|
|
|
|
// set his velocity to fast upward (for now)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int player::handle_weapons()
|
2007-07-15 10:47:50 +00:00
|
|
|
{
|
2007-09-09 18:21:14 +00:00
|
|
|
vec2 direction = normalize(vec2(input.target_x, input.target_y));
|
|
|
|
|
2007-08-14 18:37:16 +00:00
|
|
|
if(config.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--;
|
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// check reload timer
|
|
|
|
if(reload_timer)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
reload_timer--;
|
2007-07-21 19:03:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (active_weapon == WEAPON_NINJA)
|
|
|
|
{
|
|
|
|
// don't update other weapons while ninja is active
|
|
|
|
return handle_ninja();
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// switch weapon if wanted
|
2007-10-04 22:37:35 +00:00
|
|
|
if(input.activeweapon && data->weapons[active_weapon].duration <= 0)
|
2007-08-04 16:49:57 +00:00
|
|
|
{
|
2007-10-04 22:37:35 +00:00
|
|
|
int new_weapon = active_weapon;
|
|
|
|
if(input.activeweapon > 0) // straight selection
|
|
|
|
new_weapon = input.activeweapon-1;
|
|
|
|
else if(input.activeweapon == -1 && !previnput.activeweapon) // next weapon
|
|
|
|
{
|
|
|
|
do
|
|
|
|
new_weapon = (new_weapon+1)%NUM_WEAPONS;
|
|
|
|
while(!weapons[new_weapon].got);
|
|
|
|
}
|
|
|
|
else if(input.activeweapon == -2 && !previnput.activeweapon)
|
|
|
|
{
|
|
|
|
do
|
|
|
|
new_weapon = (new_weapon-1)<0?NUM_WEAPONS-1:new_weapon-1;
|
|
|
|
while(!weapons[new_weapon].got);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(new_weapon >= 0 && new_weapon < NUM_WEAPONS && weapons[new_weapon].got)
|
|
|
|
{
|
|
|
|
if(active_weapon != new_weapon)
|
|
|
|
create_sound(pos, SOUND_WEAPON_SWITCH);
|
2007-08-04 16:49:57 +00:00
|
|
|
|
2007-10-04 22:37:35 +00:00
|
|
|
last_weapon = active_weapon;
|
|
|
|
active_weapon = new_weapon;
|
|
|
|
}
|
2007-08-04 16:49:57 +00:00
|
|
|
}
|
2007-10-04 22:37:35 +00:00
|
|
|
|
2007-07-21 19:03:50 +00:00
|
|
|
if(!previnput.fire && input.fire)
|
2007-07-15 10:47:50 +00:00
|
|
|
{
|
|
|
|
if(reload_timer == 0)
|
2007-07-13 13:40:04 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
// fire!
|
|
|
|
if(weapons[active_weapon].ammo)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
switch(active_weapon)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
case WEAPON_HAMMER:
|
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);
|
2007-07-15 10:47:50 +00:00
|
|
|
break;
|
2007-07-13 13:40:04 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
case WEAPON_GUN:
|
2007-10-04 23:58:22 +00:00
|
|
|
new projectile(WEAPON_GUN,
|
2007-07-15 10:47:50 +00:00
|
|
|
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);
|
2007-07-15 10:47:50 +00:00
|
|
|
break;
|
|
|
|
case WEAPON_ROCKET:
|
2007-08-04 19:00:06 +00:00
|
|
|
{
|
2007-10-04 23:58:22 +00:00
|
|
|
new projectile(WEAPON_ROCKET,
|
2007-07-15 10:47:50 +00:00
|
|
|
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);
|
2007-07-15 10:47:50 +00:00
|
|
|
break;
|
2007-08-04 19:00:06 +00:00
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
case WEAPON_SHOTGUN:
|
2007-08-04 01:57:01 +00:00
|
|
|
{
|
2007-08-04 19:28:40 +00:00
|
|
|
int shotspread = 2;
|
2007-08-04 01:53:26 +00:00
|
|
|
for(int i = -shotspread; i <= shotspread; i++)
|
2007-07-15 10:47:50 +00:00
|
|
|
{
|
2007-07-15 23:52:36 +00:00
|
|
|
float a = get_angle(direction);
|
2007-08-04 19:00:06 +00:00
|
|
|
a += i*0.08f;
|
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-07-15 23:52:36 +00:00
|
|
|
vec2(cosf(a), sinf(a))*25.0f,
|
|
|
|
//vec2(cosf(a), sinf(a))*20.0f,
|
2007-08-04 19:00:06 +00:00
|
|
|
(int)(server_tickspeed()*0.4f),
|
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-15 10:47:50 +00:00
|
|
|
}
|
2007-07-21 17:35:28 +00:00
|
|
|
create_sound(pos, SOUND_SHOTGUN_FIRE);
|
2007-07-15 10:47:50 +00:00
|
|
|
break;
|
2007-09-25 21:53:14 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
}
|
|
|
|
|
2007-08-04 16:49:57 +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;
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2007-08-04 16:49:57 +00:00
|
|
|
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;
|
|
|
|
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;
|
|
|
|
|
|
|
|
// 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-07-21 19:03:50 +00:00
|
|
|
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);
|
2007-09-09 18:21:14 +00:00
|
|
|
target->core.vel += dir * 25.0f + vec2(0,-5.0f);
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void player::tick()
|
|
|
|
{
|
2007-07-26 07:15:52 +00:00
|
|
|
// do latency stuff
|
|
|
|
{
|
2007-08-22 07:52:33 +00:00
|
|
|
CLIENT_INFO info;
|
2007-07-26 07:15:52 +00:00
|
|
|
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-08-02 20:17:18 +00:00
|
|
|
|
|
|
|
if(spawning)
|
|
|
|
try_respawn();
|
2007-07-26 07:15:52 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// 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
|
2007-07-15 10:47:50 +00:00
|
|
|
respawn();
|
|
|
|
if(input.fire && server_tick()-die_tick >= server_tickspeed()/2) // auto respawn after 0.5 sec
|
|
|
|
respawn();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-09-09 18:21:14 +00:00
|
|
|
//player_core core;
|
|
|
|
//core.pos = pos;
|
|
|
|
//core.jumped = jumped;
|
|
|
|
core.input = input;
|
|
|
|
core.tick();
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
|
|
|
|
// handle weapons
|
2007-09-23 22:54:31 +00:00
|
|
|
handle_weapons();
|
2007-09-09 18:21:14 +00:00
|
|
|
/*
|
2007-07-21 19:03:50 +00:00
|
|
|
if (!(retflags & (MODIFIER_RETURNFLAGS_OVERRIDEVELOCITY | MODIFIER_RETURNFLAGS_OVERRIDEPOSITION)))
|
|
|
|
{
|
|
|
|
// add gravity
|
2007-09-09 18:21:14 +00:00
|
|
|
//if (!(retflags & MODIFIER_RETURNFLAGS_OVERRIDEGRAVITY))
|
|
|
|
//vel.y += gravity;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-07-21 19:03:50 +00:00
|
|
|
// do the move
|
|
|
|
defered_pos = pos;
|
2007-09-09 18:21:14 +00:00
|
|
|
move_box(&core.pos, &vel, vec2(phys_size, phys_size), 0);
|
|
|
|
}*/
|
2007-07-26 11:33:49 +00:00
|
|
|
|
2007-09-09 18:21:14 +00:00
|
|
|
//defered_pos = core.pos;
|
|
|
|
//jumped = core.jumped;
|
|
|
|
|
2007-07-26 11:33:49 +00:00
|
|
|
state = input.state;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-07-21 19:03:50 +00:00
|
|
|
// Previnput
|
|
|
|
previnput = input;
|
2007-07-15 10:47:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void player::tick_defered()
|
|
|
|
{
|
2007-09-09 18:21:14 +00:00
|
|
|
core.move();
|
|
|
|
core.quantize();
|
|
|
|
pos = core.pos;
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// apply the new position
|
2007-09-09 18:21:14 +00:00
|
|
|
//pos = defered_pos;
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
void player::die(int killer, int weapon)
|
|
|
|
{
|
2007-09-25 21:53:14 +00:00
|
|
|
gameobj->on_player_death(this, get_player(killer), weapon);
|
|
|
|
|
2007-08-14 18:37:16 +00:00
|
|
|
dbg_msg("game", "kill killer='%d:%s' victim='%d:%s' weapon=%d", killer, players[killer].name, client_id, name, weapon);
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// 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_end();
|
|
|
|
server_send_msg(-1);
|
|
|
|
|
|
|
|
// a nice sound
|
|
|
|
create_sound(pos, SOUND_PLAYER_DIE);
|
|
|
|
|
|
|
|
// set dead state
|
|
|
|
dead = true;
|
|
|
|
die_tick = server_tick();
|
|
|
|
clear_flag(entity::FLAG_ALIVE);
|
2007-07-21 21:17:38 +00:00
|
|
|
create_death(pos);
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
bool player::take_damage(vec2 force, int dmg, int from, int weapon)
|
|
|
|
{
|
2007-09-09 18:21:14 +00:00
|
|
|
core.vel += force;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-08-04 19:00:06 +00:00
|
|
|
// player only inflicts half damage on self
|
|
|
|
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
|
|
|
|
2007-08-05 09:12:38 +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);
|
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
if(armor)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
armor -= 1;
|
|
|
|
dmg--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(dmg > armor)
|
|
|
|
{
|
|
|
|
dmg -= armor;
|
|
|
|
armor = 0;
|
|
|
|
health -= dmg;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
armor -= dmg;
|
|
|
|
|
2007-08-05 09:12:38 +00:00
|
|
|
damage_taken_tick = server_tick();
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-08-05 08:59:38 +00:00
|
|
|
// do damage hit sound
|
|
|
|
if(from >= 0)
|
2007-08-09 00:35:27 +00:00
|
|
|
create_targetted_sound(get_player(from)->pos, SOUND_HIT, from);
|
2007-08-05 08:59:38 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// check for death
|
|
|
|
if(health <= 0)
|
|
|
|
{
|
|
|
|
die(from, weapon);
|
2007-08-09 00:35:27 +00:00
|
|
|
|
|
|
|
// 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();
|
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
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
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
// spawn blood?
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void player::snap(int snaping_client)
|
|
|
|
{
|
|
|
|
obj_player *player = (obj_player *)snap_new_item(OBJTYPE_PLAYER, client_id, sizeof(obj_player));
|
|
|
|
|
2007-09-09 18:21:14 +00:00
|
|
|
core.write(player);
|
|
|
|
|
|
|
|
if(snaping_client != client_id)
|
|
|
|
{
|
|
|
|
player->vx = 0; // make sure that we don't send these to clients who don't need them
|
|
|
|
player->vy = 0;
|
|
|
|
player->hook_dx = 0;
|
|
|
|
player->hook_dy = 0;
|
|
|
|
}
|
2007-08-09 00:18:11 +00:00
|
|
|
|
|
|
|
if (emote_stop < server_tick())
|
|
|
|
{
|
|
|
|
emote_type = EMOTE_NORMAL;
|
|
|
|
emote_stop = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
player->emote = emote_type;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-07-26 07:15:52 +00:00
|
|
|
player->latency = latency_avg;
|
|
|
|
player->latency_flux = latency_max-latency_min;
|
2007-07-22 09:15:34 +00:00
|
|
|
|
2007-07-15 10:47:50 +00:00
|
|
|
player->ammocount = weapons[active_weapon].ammo;
|
|
|
|
player->health = 0;
|
|
|
|
player->armor = 0;
|
|
|
|
player->local = 0;
|
|
|
|
player->clientid = client_id;
|
|
|
|
player->weapon = active_weapon;
|
|
|
|
player->attacktick = attack_tick;
|
|
|
|
|
|
|
|
if(client_id == snaping_client)
|
|
|
|
{
|
|
|
|
player->local = 1;
|
|
|
|
player->health = health;
|
|
|
|
player->armor = armor;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(dead)
|
|
|
|
player->health = -1;
|
|
|
|
|
2007-08-09 00:47:34 +00:00
|
|
|
//if(length(vel) > 15.0f)
|
|
|
|
// player->emote = EMOTE_HAPPY;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-08-09 00:18:11 +00:00
|
|
|
//if(damage_taken_tick+50 > server_tick())
|
|
|
|
// player->emote = EMOTE_PAIN;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-08-10 11:55:59 +00:00
|
|
|
if (player->emote == EMOTE_NORMAL)
|
2007-07-15 10:47:50 +00:00
|
|
|
{
|
2007-08-10 11:55:59 +00:00
|
|
|
if(250 - ((server_tick() - last_action)%(250)) < 5)
|
2007-07-15 10:47:50 +00:00
|
|
|
player->emote = EMOTE_BLINK;
|
2007-05-22 15:03:32 +00:00
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
|
|
|
|
player->score = score;
|
2007-07-21 21:47:21 +00:00
|
|
|
player->team = team;
|
2007-07-26 11:33:49 +00:00
|
|
|
|
|
|
|
player->state = state;
|
2007-07-15 10:47:50 +00:00
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-08-14 18:37:16 +00:00
|
|
|
player *players;
|
2007-05-22 15:03:32 +00:00
|
|
|
|
2007-07-15 10:47:50 +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;
|
2007-07-15 10:47:50 +00:00
|
|
|
|
|
|
|
reset();
|
2007-05-22 15:03:32 +00:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2007-07-15 10:47:50 +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-07-15 10:47:50 +00:00
|
|
|
}
|
|
|
|
|
2007-05-22 15:03:32 +00:00
|
|
|
void powerup::tick()
|
|
|
|
{
|
|
|
|
// wait for respawn
|
|
|
|
if(spawntick > 0)
|
|
|
|
{
|
|
|
|
if(server_tick() > spawntick)
|
2007-07-29 16:44:30 +00:00
|
|
|
{
|
|
|
|
// respawn
|
2007-05-22 15:03:32 +00:00
|
|
|
spawntick = -1;
|
2007-07-29 16:44:30 +00:00
|
|
|
|
|
|
|
if(type == POWERUP_WEAPON)
|
|
|
|
create_sound(pos, SOUND_WEAPON_SPAWN, 0);
|
|
|
|
}
|
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:
|
2007-08-30 07:15:26 +00:00
|
|
|
if(pplayer->health < 10)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-29 16:44:30 +00:00
|
|
|
create_sound(pos, SOUND_PICKUP_HEALTH, 0);
|
2007-08-30 07:15:26 +00:00
|
|
|
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:
|
2007-08-30 07:15:26 +00:00
|
|
|
if(pplayer->armor < 10)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-07-29 16:44:30 +00:00
|
|
|
create_sound(pos, SOUND_PICKUP_ARMOR, 0);
|
2007-08-30 07:15:26 +00:00
|
|
|
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-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
|
|
|
|
pplayer->ninjaactivationtick = server_tick();
|
|
|
|
pplayer->weapons[WEAPON_NINJA].got = true;
|
2007-08-14 18:37:16 +00:00
|
|
|
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};
|
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-07-21 19:03:50 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
};
|
|
|
|
|
|
|
|
if(respawntime >= 0)
|
2007-08-14 18:37:16 +00:00
|
|
|
{
|
|
|
|
dbg_msg("game", "pickup player='%d:%s' item=%d/%d", pplayer->client_id, pplayer->name, type, subtype);
|
2007-05-22 15:03:32 +00:00
|
|
|
spawntick = server_tick() + server_tickspeed() * respawntime;
|
2007-08-14 18:37:16 +00:00
|
|
|
}
|
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];
|
|
|
|
}
|
|
|
|
|
2007-08-05 09:12:38 +00:00
|
|
|
void create_damageind(vec2 p, float angle, int amount)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
2007-08-05 09:12:38 +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));
|
2007-08-14 18:37:16 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2007-07-14 22:35:00 +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));
|
2007-08-14 18:37:16 +00:00
|
|
|
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;
|
2007-07-21 18:07:27 +00:00
|
|
|
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);
|
2007-07-21 18:07:27 +00:00
|
|
|
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));
|
2007-08-14 18:37:16 +00:00
|
|
|
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));
|
2007-08-14 18:37:16 +00:00
|
|
|
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));
|
2007-08-14 18:37:16 +00:00
|
|
|
if(ev)
|
|
|
|
{
|
|
|
|
ev->x = (int)p.x;
|
|
|
|
ev->y = (int)p.y;
|
|
|
|
}
|
2007-07-21 21:17:38 +00:00
|
|
|
}
|
|
|
|
|
2007-08-04 17:28:31 +00:00
|
|
|
void create_targetted_sound(vec2 pos, int sound, int target, int loopingflags)
|
2007-05-22 15:03:32 +00:00
|
|
|
{
|
|
|
|
if (sound < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// create a sound
|
2007-08-04 17:28:31 +00:00
|
|
|
ev_sound *ev = (ev_sound *)events.create(EVENT_SOUND, sizeof(ev_sound), target);
|
2007-08-14 18:37:16 +00:00
|
|
|
if(ev)
|
|
|
|
{
|
|
|
|
ev->x = (int)pos.x;
|
|
|
|
ev->y = (int)pos.y;
|
|
|
|
ev->sound = sound | loopingflags;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
}
|
|
|
|
|
2007-08-04 17:28:31 +00:00
|
|
|
void create_sound(vec2 pos, int sound, int loopingflags)
|
|
|
|
{
|
|
|
|
create_targetted_sound(pos, sound, -1, loopingflags);
|
|
|
|
}
|
|
|
|
|
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;
|
2007-07-14 13:09:42 +00:00
|
|
|
const int types[] = {OBJTYPE_PLAYER};
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Server hooks
|
|
|
|
void mods_tick()
|
|
|
|
{
|
|
|
|
// clear all events
|
|
|
|
events.clear();
|
2007-09-23 22:54:31 +00:00
|
|
|
world->tick();
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-09-23 22:54:31 +00:00
|
|
|
if(world->paused) // make sure that the game object always updates
|
2007-08-14 18:37:16 +00:00
|
|
|
gameobj->tick();
|
2007-10-04 23:58:22 +00:00
|
|
|
|
|
|
|
if(config.restart)
|
|
|
|
{
|
|
|
|
gameobj->startround();
|
|
|
|
config.restart = 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)
|
2007-07-15 10:47:50 +00:00
|
|
|
{
|
2007-08-10 11:55:59 +00:00
|
|
|
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;
|
2007-07-15 10:47:50 +00:00
|
|
|
players[client_id].input = *(player_input*)input;
|
|
|
|
}
|
2007-05-22 15:03:32 +00:00
|
|
|
}
|
|
|
|
|
2007-09-25 21:53:14 +00:00
|
|
|
void send_chat(int cid, int team, const char *msg)
|
2007-07-30 07:05:34 +00:00
|
|
|
{
|
2007-08-14 18:37:16 +00:00
|
|
|
if(cid >= 0 && cid < MAX_CLIENTS)
|
2007-09-25 21:53:14 +00:00
|
|
|
dbg_msg("chat", "%d:%d:%s: %s", cid, team, players[cid].name, msg);
|
2007-08-14 18:37:16 +00:00
|
|
|
else
|
|
|
|
dbg_msg("chat", "*** %s", msg);
|
|
|
|
|
2007-10-04 22:00:10 +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();
|
|
|
|
|
|
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
|
|
{
|
|
|
|
if(players[i].client_id != -1 && players[i].team == team)
|
|
|
|
server_send_msg(i);
|
|
|
|
}
|
|
|
|
}
|
2007-07-30 07:05:34 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 22:48:49 +00:00
|
|
|
void send_set_name(int cid, const char *old_name, const char *new_name)
|
|
|
|
{
|
|
|
|
msg_pack_start(MSG_SETNAME, MSGFLAG_VITAL);
|
|
|
|
msg_pack_int(cid);
|
|
|
|
msg_pack_string(new_name, 64);
|
|
|
|
msg_pack_end();
|
|
|
|
server_send_msg(-1);
|
|
|
|
|
|
|
|
char msg[256];
|
|
|
|
sprintf(msg, "*** %s changed name to %s", old_name, new_name);
|
2007-09-25 21:53:14 +00:00
|
|
|
send_chat(-1, -1, msg);
|
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-05-22 15:03:32 +00:00
|
|
|
void mods_client_enter(int client_id)
|
|
|
|
{
|
2007-07-15 10:47:50 +00:00
|
|
|
players[client_id].init();
|
2007-05-22 15:03:32 +00:00
|
|
|
players[client_id].client_id = client_id;
|
2007-09-23 22:54:31 +00:00
|
|
|
world->insert_entity(&players[client_id]);
|
2007-07-15 10:47:50 +00:00
|
|
|
players[client_id].respawn();
|
|
|
|
|
2007-08-22 07:52:33 +00:00
|
|
|
CLIENT_INFO info; // fetch login name
|
2007-07-14 13:09:42 +00:00
|
|
|
if(server_getclientinfo(client_id, &info))
|
2007-07-22 09:16:44 +00:00
|
|
|
{
|
2007-07-14 13:09:42 +00:00
|
|
|
strcpy(players[client_id].name, info.name);
|
2007-07-22 09:16:44 +00:00
|
|
|
}
|
2007-07-14 13:09:42 +00:00
|
|
|
else
|
|
|
|
strcpy(players[client_id].name, "(bot)");
|
2007-07-22 09:16:44 +00:00
|
|
|
|
2007-08-14 18:37:16 +00:00
|
|
|
|
|
|
|
dbg_msg("game", "join player='%d:%s'", client_id, players[client_id].name);
|
|
|
|
|
|
|
|
if (gameobj->gametype == GAMETYPE_TDM)
|
2007-07-22 09:16:44 +00:00
|
|
|
{
|
|
|
|
// Check which team the player should be on
|
2007-08-14 18:37:16 +00:00
|
|
|
players[client_id].team = gameobj->getteam(client_id);
|
2007-07-22 09:16:44 +00:00
|
|
|
}
|
2007-07-14 13:09:42 +00:00
|
|
|
|
|
|
|
msg_pack_start(MSG_SETNAME, MSGFLAG_VITAL);
|
|
|
|
msg_pack_int(client_id);
|
|
|
|
msg_pack_string(players[client_id].name, 64);
|
|
|
|
msg_pack_end();
|
|
|
|
server_send_msg(-1);
|
|
|
|
|
|
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
|
|
{
|
|
|
|
if(players[client_id].client_id != -1)
|
|
|
|
{
|
|
|
|
msg_pack_start(MSG_SETNAME, MSGFLAG_VITAL);
|
|
|
|
msg_pack_int(i);
|
|
|
|
msg_pack_string(players[i].name, 64);
|
|
|
|
msg_pack_end();
|
|
|
|
server_send_msg(client_id);
|
|
|
|
}
|
|
|
|
}
|
2007-07-29 22:56:25 +00:00
|
|
|
|
2007-07-30 07:05:34 +00:00
|
|
|
char buf[512];
|
|
|
|
sprintf(buf, "%s has joined the game", players[client_id].name);
|
2007-09-25 21:53:14 +00:00
|
|
|
send_chat(-1, -1, buf);
|
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", players[client_id].name);
|
2007-09-25 21:53:14 +00:00
|
|
|
send_chat(-1, -1, buf);
|
2007-08-14 18:37:16 +00:00
|
|
|
|
|
|
|
dbg_msg("game", "leave player='%d:%s'", client_id, players[client_id].name);
|
2007-07-30 07:05:34 +00:00
|
|
|
|
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]);
|
2007-07-26 07:15:52 +00:00
|
|
|
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-07-22 11:53:15 +00:00
|
|
|
else if (msg == MSG_SWITCHTEAM)
|
|
|
|
{
|
|
|
|
// Switch team on given client and kill/respawn him
|
|
|
|
players[client_id].team = !players[client_id].team;
|
|
|
|
players[client_id].die(client_id, -1);
|
|
|
|
players[client_id].score--;
|
|
|
|
}
|
2007-08-14 22:48:49 +00:00
|
|
|
else if (msg == MSG_CHANGENAME)
|
|
|
|
{
|
|
|
|
const char *name = msg_unpack_string();
|
|
|
|
|
|
|
|
// check for invalid chars
|
|
|
|
const char *p = name;
|
|
|
|
while (*p)
|
|
|
|
if (*p++ < 32)
|
|
|
|
return;
|
|
|
|
|
|
|
|
send_set_name(client_id, players[client_id].name, name);
|
|
|
|
strcpy(players[client_id].name, name);
|
|
|
|
}
|
|
|
|
else if (msg == MSG_EMOTICON)
|
|
|
|
{
|
|
|
|
int emoteicon = msg_unpack_int();
|
|
|
|
send_emoticon(client_id, emoteicon % 16);
|
|
|
|
}
|
2007-07-14 13:09:42 +00:00
|
|
|
}
|
|
|
|
|
2007-07-24 23:46:29 +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;
|
2007-08-14 18:37:16 +00:00
|
|
|
players = new player[MAX_CLIENTS];
|
2007-09-25 23:03:15 +00:00
|
|
|
|
|
|
|
// select gametype
|
|
|
|
if(strcmp(config.gametype, "ctf") == 0)
|
|
|
|
gameobj = new gameobject_ctf;
|
|
|
|
else if(strcmp(config.gametype, "tdm") == 0)
|
|
|
|
gameobj = new gameobject_tdm;
|
|
|
|
else
|
|
|
|
gameobj = new gameobject_dm;
|
2007-09-09 18:21:14 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
world->core.players[i] = &players[i].core;
|
2007-09-09 18:21:14 +00:00
|
|
|
}
|
2007-08-14 18:37:16 +00:00
|
|
|
|
2007-09-09 18:21:14 +00:00
|
|
|
//
|
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);
|
|
|
|
|
|
|
|
int type = -1;
|
2007-08-14 18:37:16 +00:00
|
|
|
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-07-23 17:52:04 +00:00
|
|
|
type = POWERUP_NINJA;
|
2007-07-22 11:53:15 +00:00
|
|
|
subtype = WEAPON_NINJA;
|
|
|
|
break;
|
2007-05-22 15:03:32 +00:00
|
|
|
};
|
|
|
|
|
2007-07-22 12:01:20 +00:00
|
|
|
if(type != -1)
|
|
|
|
{
|
2007-07-29 13:21:33 +00:00
|
|
|
// 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
|
|
|
}
|
2007-07-15 10:47:50 +00:00
|
|
|
|
2007-08-30 07:15:26 +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)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
static int count = 0;
|
|
|
|
if(count >= 0)
|
|
|
|
{
|
|
|
|
count++;
|
|
|
|
if(count == 10)
|
|
|
|
{*/
|
|
|
|
for(int i = 0; i < config.dbg_bots ; i++)
|
|
|
|
{
|
|
|
|
mods_client_enter(MAX_CLIENTS-i-1);
|
|
|
|
strcpy(players[MAX_CLIENTS-i-1].name, "(bot)");
|
|
|
|
if(gameobj->gametype != GAMETYPE_DM)
|
|
|
|
players[MAX_CLIENTS-i-1].team = i&1;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
count = -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; }
|