static int groupplayers()
{
int numgroups = 0;
spectators.shrink(0);
loopv(players)
{
fpsent *o = players[i];
if(!showconnecting && !o->name[0]) continue;
if(o->state==CS_SPECTATOR) { spectators.add(o); continue; }
const char *team = m_teammode && o->team[0] ? o->team : NULL;
bool found = false;
loopj(numgroups)
{
scoregroup &g = *groups[j];
if(team!=g.team && (!team || !g.team || strcmp(team, g.team))) continue;
if(team && (!cmode || !cmode->hidefrags())) g.score += o->frags;
g.players.add(o);
found = true;
}
if(found) continue;
if(numgroups>=groups.length()) groups.add(new scoregroup);
scoregroup &g = *groups[numgroups++];
g.team = team;
if(!team) g.score = 0;
else if(cmode && cmode->hidefrags()) g.score = cmode->getteamscore(o->team);
else g.score = o->frags;
g.players.shrink(0);
g.players.add(o);
}
loopi(numgroups) groups[i]->players.sort(playersort);
spectators.sort(playersort);
groups.sort(scoregroupcmp, 0, numgroups);
return numgroups;
}
static void addarg(vector<char> &argstr, const char *name, const char *val)
{
addarg(argstr, name);
bool space = strchr(val, ' ')!=NULL;
if(space) argstr.add('"');
argstr.put(val, strlen(val));
if(space) argstr.add('"');
}
bool listdir(const char *dir, const char *ext, vector<char *> &files)
{
int extsize = ext ? (int)strlen(ext)+1 : 0;
#if defined(WIN32)
defformatstring(pathname)("%s\\*.%s", dir, ext ? ext : "*");
WIN32_FIND_DATA FindFileData;
HANDLE Find = FindFirstFile(path(pathname), &FindFileData);
if(Find != INVALID_HANDLE_VALUE)
{
do {
if(!(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
files.add(newstring(FindFileData.cFileName, (int)strlen(FindFileData.cFileName) - extsize));
} while(FindNextFile(Find, &FindFileData));
FindClose(Find);
return true;
}
#else
string pathname;
copystring(pathname, dir);
DIR *d = opendir(path(pathname));
if(d)
{
struct dirent *de, b;
while(!readdir_r(d, &b, &de) && de != NULL)
{
bool isreg = false;
#ifdef _DIRENT_HAVE_D_TYPE
if(de->d_type == DT_REG) isreg = true;
else if(de->d_type == DT_UNKNOWN)
#endif
{
struct stat s;
int dl = (int)strlen(pathname);
concatformatstring(pathname, "/%s", de->d_name);
isreg = !lstat(pathname, &s) && S_ISREG(s.st_mode);
pathname[dl] = '\0';
}
if(isreg)
{
if(!ext) files.add(newstring(de->d_name));
else
{
int namelength = (int)strlen(de->d_name) - extsize;
if(namelength > 0 && de->d_name[namelength] == '.' && strncmp(de->d_name+namelength+1, ext, extsize-1)==0)
files.add(newstring(de->d_name, namelength));
}
}
}
closedir(d);
return true;
}
#endif
else return false;
}
static void updateval(char *var, int val, char *onchange)
{
ident *id = getident(var);
string assign;
if(!id) return;
else if(id->_type==ID_VAR) s_sprintf(assign)("%s %d", var, val);
else if(id->_type==ID_ALIAS) s_sprintf(assign)("%s = %d", var, val);
else return;
executelater.add(newstring(assign));
if(onchange[0]) executelater.add(newstring(onchange));
};
void CslGameRedEclipse::GetPlayerstatsDescriptions(vector<wxString>& desc) const
{
desc.add(_("Player"));
desc.add(_("Team"));
desc.add(_("Frags"));
desc.add(_("Deaths"));
desc.add(_("Teamkills"));
desc.add(_("Ping"));
desc.add(_("Accuracy"));
desc.add(_("Health"));
desc.add(_("Spree"));
desc.add(_("Weapon"));
}
int addvert(const vertex &v)
{
uint h = hthash(v.pos)&(SIZE-1);
for(int i = table[h]; i>=0; i = chain[i])
{
const vertex &c = verts[i];
if(c.pos==v.pos && c.tc==v.tc && c.norm==v.norm && c.tangent==v.tangent && c.bitangent==v.bitangent)
return i;
}
if(verts.length() >= USHRT_MAX) return -1;
verts.add(v);
chain.add(table[h]);
return table[h] = verts.length()-1;
}
void mmodel(char *name, int *tex)
{
mapmodelinfo &mmi = mapmodels.add();
s_strcpy(mmi.name, name);
mmi.tex = *tex;
mmi.m = NULL;
};
void resolverquery(char *name)
{
SDL_LockMutex(resolvermutex);
resolverqueries.add(name);
SDL_SemPost(resolversem);
SDL_UnlockMutex(resolvermutex);
};
uint32_t get_next_shared_ptr_id() {
shared_ptr_list_lock.lock();
shared_ptr_is_alive.add(true);
uint32_t ret = shared_ptr_is_alive.length() - 1;
shared_ptr_list_lock.unlock();
return ret;
}
void mapmodel(char *name)
{
mapmodelinfo &mmi = mapmodels.add();
if(name[0]) formatstring(mmi.name, "%s%s", mmprefix, name);
else mmi.name[0] = '\0';
mmi.m = mmi.collide = NULL;
}
void renderscore(dynent *d)
{
sprintf_sd(lag)("%d", d->plag);
sprintf_sd(name) ("(%s)", d->name);
sprintf_s(scorelines.add().s)("%d\t%s\t%d\t%s\t%s", d->frags, d->state==CS_LAGGED ? "LAG" : lag, d->ping, d->team, d->state==CS_DEAD ? name : d->name);
menumanual(0, scorelines.length()-1, scorelines.last().s);
};
void mapmodel(char *rad, char *h, char *zoff, char *snap, char *name)
{
md2 *m = loadmodel(name);
mapmodelinfo mmi = { atoi(rad), atoi(h), atoi(zoff), atoi(snap), m->loadname };
m->mmi = mmi;
mapmodels.add(m);
}
void clearmonsters() // called after map start or when toggling edit mode to reset/spawn all monsters to initial state
{
removetrackedparticles();
removetrackeddynlights();
loopv(monsters) delete monsters[i];
cleardynentcache();
monsters.shrink(0);
numkilled = 0;
monstertotal = 0;
spawnremain = 0;
remain = 0;
monsterhurt = false;
if(m_dmsp)
{
nextmonster = mtimestart = lastmillis+10000;
monstertotal = spawnremain = skill*10;
}
else if(m_classicsp || !spguard)
{
mtimestart = lastmillis;
loopv(entities::ents)
{
extentity &e = *entities::ents[i];
if(e.type!=MONSTER) continue;
monster *m = new monster(e.attr2, e.attr1, e.attr3, M_SLEEP, 100, 0);
monsters.add(m);
m->o = e.o;
entinmap(m);
updatedynentcache(m);
monstertotal++;
}
}
int resolverloop(void * data)
{
resolverthread *rt = (resolverthread *)data;
for(;;)
{
SDL_SemWait(resolversem);
SDL_LockMutex(resolvermutex);
if(resolverqueries.empty())
{
SDL_UnlockMutex(resolvermutex);
continue;
}
rt->query = resolverqueries.pop();
rt->starttime = lastmillis;
SDL_UnlockMutex(resolvermutex);
ENetAddress address = { ENET_HOST_ANY, CUBE_SERVINFO_PORT };
enet_address_set_host(&address, rt->query);
SDL_LockMutex(resolvermutex);
resolverresult &rr = resolverresults.add();
rr.query = rt->query;
rr.address = address;
rt->query = NULL;
rt->starttime = 0;
SDL_UnlockMutex(resolvermutex);
};
return 0;
};
void getbestteams(vector<const char *> &best)
{
vector<teamscore> teamscores;
sortteams(teamscores);
while(teamscores.length()>1 && teamscores.last().score < teamscores[0].score) teamscores.drop();
loopv(teamscores) best.add(teamscores[i].team);
}
client &addclient(int type)
{
client *c = NULL;
loopv(clients) if(clients[i]->type==ST_EMPTY)
{
c = clients[i];
break;
}
if(!c)
{
c = new client;
c->num = clients.length();
clients.add(c);
}
c->info = server::newclientinfo();
c->type = type;
switch(type)
{
case ST_TCPIP:
nonlocalclients++;
break;
case ST_LOCAL:
localclients++;
break;
}
return *c;
}
static void addnormal(const vec &key, const vec &surface)
{
nval &val = normalgroups[key];
normal &n = normals.add();
n.next = val.normals;
n.surface = surface;
val.normals = normals.length()-1;
}
void guiimage(char *path, char *action, float *scale, int *overlaid)
{
if(cgui && cgui->image(path, *scale, *overlaid!=0)&G3D_UP && *action)
{
executelater.add(newstring(action));
clearlater = true;
};
};
void addasleep(int *msec, char *cmd)
{
sleepcmd &s = asleepcmds.add();
s.delay = max(*msec, 1);
s.millis = totalmillis;
s.command = newstring(cmd);
s.flags = identflags;
}
static int addnormal(const vec &key, const vec &surface)
{
normalgroup &g = normalgroups.access(key, key);
normal &n = normals.add();
n.next = g.normals;
n.surface = surface;
return g.normals = normals.length()-1;
}
static int addnormal(const vec &pos, int smooth, const vec &surface)
{
normalkey key = { pos, smooth };
normalgroup &g = normalgroups.access(key, key);
normal &n = normals.add();
n.next = g.normals;
n.surface = surface;
return g.normals = normals.length()-1;
}
static bool readzipdirectory(const char *archname, FILE *f, int entries, int offset, uint size, vector<zipfile> &files)
{
uchar *buf = new uchar[size], *src = buf;
if(fseek(f, offset, SEEK_SET) < 0 || fread(buf, 1, size, f) != size) { delete[] buf; return false; }
loopi(entries)
{
if(src + ZIP_FILE_SIZE > &buf[size]) break;
zipfileheader hdr;
hdr.signature = lilswap(*(uint *)src); src += 4;
hdr.version = lilswap(*(ushort *)src); src += 2;
hdr.needversion = lilswap(*(ushort *)src); src += 2;
hdr.flags = lilswap(*(ushort *)src); src += 2;
hdr.compression = lilswap(*(ushort *)src); src += 2;
hdr.modtime = lilswap(*(ushort *)src); src += 2;
hdr.moddate = lilswap(*(ushort *)src); src += 2;
hdr.crc32 = lilswap(*(uint *)src); src += 4;
hdr.compressedsize = lilswap(*(uint *)src); src += 4;
hdr.uncompressedsize = lilswap(*(uint *)src); src += 4;
hdr.namelength = lilswap(*(ushort *)src); src += 2;
hdr.extralength = lilswap(*(ushort *)src); src += 2;
hdr.commentlength = lilswap(*(ushort *)src); src += 2;
hdr.disknumber = lilswap(*(ushort *)src); src += 2;
hdr.internalattribs = lilswap(*(ushort *)src); src += 2;
hdr.externalattribs = lilswap(*(uint *)src); src += 4;
hdr.offset = lilswap(*(uint *)src); src += 4;
if(hdr.signature != ZIP_FILE_SIGNATURE) break;
if(!hdr.namelength || !hdr.uncompressedsize || (hdr.compression && (hdr.compression != Z_DEFLATED || !hdr.compressedsize)))
{
src += hdr.namelength + hdr.extralength + hdr.commentlength;
continue;
}
if(src + hdr.namelength > &buf[size]) break;
string pname;
int namelen = min((int)hdr.namelength, (int)sizeof(pname)-1);
memcpy(pname, src, namelen);
pname[namelen] = '\0';
path(pname);
char *name = newstring(pname);
zipfile &f = files.add();
f.name = name;
f.header = hdr.offset;
f.size = hdr.uncompressedsize;
f.compressedsize = hdr.compression ? hdr.compressedsize : 0;
#ifndef STANDALONE
if(dbgzip) conoutf(CON_DEBUG, "%s: file %s, size %d, compress %d, flags %x", archname, name, hdr.uncompressedsize, hdr.compression, hdr.flags);
#endif
src += hdr.namelength + hdr.extralength + hdr.commentlength;
}
delete[] buf;
return files.length() > 0;
}
void menuset(void *m, bool save)
{
if(curmenu==m) return;
if(curmenu)
{
if(save && curmenu->allowinput) menustack.add(curmenu);
else curmenu->close();
}
if((curmenu = (gmenu *)m)) curmenu->open();
}
void ClientSystem::addHUDText(const char *text, float x, float y, float scale, int color)
{
queuedHUDText q;
q.text = text;
q.x = x;
q.y = y;
q.scale = scale;
q.color = color;
queuedHUDTexts.add(q);
}
void addpackagedir(const char *dir)
{
#ifndef STANDALONE
clientlogf("Adding package directory: %s", dir);
#endif
string pdir;
copystring(pdir, dir);
if(fixpackagedir(pdir) > 0) packagedirs.add(newstring(pdir));
}
void ignore(int cn, int attempt) {
fpsent *d = game::getclient(cn);
if(attempt == 0) {error("please connect to a server to ignore");}
else if(!d) {error("please enter a valid client number");}
else if(d == game::player1) {error("you cannot ignore yourself");}
else if(isignored(cn)) {error("user %s is already being ignored", d->name);}
else {
info("ignoring %s", d->name);
if(ignores.find(cn) < 0) ignores.add(cn);
}
}
void ClientSystem::addHUDRect(float x1, float y1, float x2, float y2, int color, float alpha)
{
queuedHUDRect q;
q.x1 = x1;
q.y1 = y1;
q.x2 = x2;
q.y2 = y2;
q.color = color;
q.alpha = alpha;
queuedHUDRects.add(q);
}
void ClientSystem::addHUDImage(const char *tex, float centerX, float centerY, float width, float height, int color, float alpha)
{
queuedHUDImage q;
q.tex = tex;
q.centerX = centerX;
q.centerY = centerY;
q.width = width;
q.height = height;
q.color = color;
q.alpha = alpha;
queuedHUDImages.add(q);
}
void addparticleemitters()
{
emitters.shrink(0);
const vector<extentity *> &ents = entities::getents();
loopv(ents)
{
extentity &e = *ents[i];
if(e.type != ET_PARTICLES) continue;
emitters.add(particleemitter(&e));
}
regenemitters = false;
}
static void addtnormal(const vec &key, float offset, int normal1, int normal2, normalgroup *group1, normalgroup *group2)
{
normalgroup &g = normalgroups.access(key, key);
tnormal &n = tnormals.add();
n.next = g.tnormals;
n.offset = offset;
n.normals[0] = normal1;
n.normals[1] = normal2;
n.groups[0] = group1;
n.groups[1] = group2;
g.tnormals = tnormals.length()-1;
}
