bool installtex(int tnum, char *texname, int &xs, int &ys, bool clamp)
{
SDL_Surface *s = IMG_Load(texname);
if(!s) { conoutf("couldn't load texture %s", texname); return false; };
if(s->format->BitsPerPixel!=24) { conoutf("texture must be 24bpp: %s", texname); return false; };
// loopi(s->w*s->h*3) { uchar *p = (uchar *)s->pixels+i; *p = 255-*p; };
glBindTexture(GL_TEXTURE_2D, tnum);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //NEAREST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
xs = s->w;
ys = s->h;
while(xs>glmaxtexsize || ys>glmaxtexsize) { xs /= 2; ys /= 2; };
void *scaledimg = s->pixels;
if(xs!=s->w)
{
conoutf("warning: quality loss: scaling %s", texname); // for voodoo cards under linux
scaledimg = alloc(xs*ys*3);
gluScaleImage(GL_RGB, s->w, s->h, GL_UNSIGNED_BYTE, s->pixels, xs, ys, GL_UNSIGNED_BYTE, scaledimg);
};
if(gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, xs, ys, GL_RGB, GL_UNSIGNED_BYTE, scaledimg)) fatal("could not build mipmaps");
if(xs!=s->w) free(scaledimg);
SDL_FreeSurface(s);
return true;
};
void sendmap(char *mapname)
{
if(*mapname) save_world(mapname);
changemap(mapname);
mapname = getclientmap();
int mapsize;
uchar *mapdata = readmap(mapname, &mapsize);
if(!mapdata) return;
ENetPacket *packet = enet_packet_create(NULL, MAXTRANS + mapsize, ENET_PACKET_FLAG_RELIABLE);
uchar *start = packet->data;
uchar *p = start+2;
putint(p, SV_SENDMAP);
sendstring(mapname, p);
putint(p, mapsize);
if(65535 - (p - start) < mapsize)
{
conoutf("map %s is too large to send", mapname);
free(mapdata);
enet_packet_destroy(packet);
return;
};
memcpy(p, mapdata, mapsize);
p += mapsize;
free(mapdata);
*(ushort *)start = ENET_HOST_TO_NET_16(p-start);
enet_packet_resize(packet, p-start);
sendpackettoserv(packet);
conoutf("sending map %s to server...", mapname);
sprintf_sd(msg)("[map %s uploaded to server, \"getmap\" to receive it]", mapname);
toserver(msg);
}
void audiomanager::musicpreload(int id)
{
if(nosound) return;
stopsound();
if(musicvol && (id>=M_FLAGGRAB && id<=M_LASTMINUTE2))
{
char *name = musics[id];
conoutf("preloading music #%d : %s", id, name);
if(gamemusic->open(name))
{
defformatstring(whendone)("musicvol %d", musicvol);
musicdonecmd = newstring(whendone);
//conoutf("when done: %s", musicdonecmd);
const int preloadfadetime = 3;
gamemusic->fadein(lastmillis, preloadfadetime);
gamemusic->fadeout(lastmillis+2*preloadfadetime, preloadfadetime);
if(!gamemusic->playback(false))
{
conoutf("could not play music: %s", name);
return;
}
setmusicvol(1); // not 0 !
}
else conoutf("could not open music: %s", name);
}
else setmusicvol(musicvol); // call "musicpreload -1" to ensure musicdonecmd runs - but it should w/o that
}
void arenarespawn()
{
if(arenarespawnwait)
{
if(arenarespawnwait<lastmillis)
{
arenarespawnwait = 0;
conoutf("new round starting... fight!");
respawnself();
};
}
else if(arenadetectwait==0 || arenadetectwait<lastmillis)
{
arenadetectwait = 0;
int alive = 0, dead = 0;
char *lastteam = NULL;
bool oneteam = true;
loopv(players) if(players[i]) arenacount(players[i], alive, dead, lastteam, oneteam);
arenacount(player1, alive, dead, lastteam, oneteam);
if(dead>0 && (alive<=1 || (m_teammode && oneteam)))
{
conoutf("arena round is over! next round in 5 seconds...");
if(alive) conoutf("team %s is last man standing", lastteam);
else conoutf("everyone died!");
arenarespawnwait = lastmillis+5000;
arenadetectwait = lastmillis+10000;
player1->roll = 0;
};
};
void audiomanager::music(char *name, int millis, char *cmd)
{
if(nosound) return;
stopsound();
if(musicvol && *name)
{
if(cmd[0]) musicdonecmd = newstring(cmd);
if(gamemusic->open(name))
{
// fade
if(millis > 0)
{
const int fadetime = 1000;
gamemusic->fadein(lastmillis, fadetime);
gamemusic->fadeout(lastmillis+millis, fadetime);
}
// play
bool loop = cmd && cmd[0];
if(!gamemusic->playback(loop))
{
conoutf("could not play music: %s", name);
return;
}
setmusicvol(musicvol);
}
else conoutf("could not open music: %s", name);
}
}
void init(fpsent *d, int at, int ocn, int sk, int bn, int pm, const char *name, const char *team)
{
loadwaypoints();
fpsent *o = newclient(ocn);
d->aitype = at;
bool resetthisguy = false;
if(!d->name[0])
{
if(aidebug) conoutf("%s assigned to %s at skill %d", colorname(d, name), o ? colorname(o) : "?", sk);
else conoutf("connected: %s", colorname(d, name));
resetthisguy = true;
}
else
{
if(d->ownernum != ocn)
{
if(aidebug) conoutf("%s reassigned to %s", colorname(d, name), o ? colorname(o) : "?");
resetthisguy = true;
}
if(d->skill != sk && aidebug) conoutf("%s changed skill to %d", colorname(d, name), sk);
}
copystring(d->name, name, MAXNAMELEN+1);
copystring(d->team, team, MAXTEAMLEN+1);
d->ownernum = ocn;
d->skill = sk;
d->playermodel = chooserandomplayermodel(pm);
if(resetthisguy) removeweapons(d);
if(player1->clientnum == d->ownernum) create(d);
else if(d->ai) destroy(d);
}
void run(const char *map) {
if (started) {
conoutf("Stopping old server instance ..");
stop();
}
conoutf("Starting server, please wait ..");
#ifndef WIN32
if (!fork()) {
const char *a0 = "bin_unix/server_" BINARY_OS_STR "_"
BINARY_ARCH_STR;
defformatstring(a1, "-g%s", logger::names[logger::current_level]);
defformatstring(a2, "-l%s", server_log_file);
defformatstring(a3, "-mmap/%s.tar.gz", map);
execl(a0, a0, a1, a2, a3, "-shutdown-if-idle",
"-shutdown-if-empty", (char*)NULL);
exit(0);
}
#else
#ifdef WIN64
const char *exe = "bin_win64\\server_" BINARY_OS_STR "_"
BINARY_ARCH_STR ".exe";
#else
const char *exe = "bin_win32\\server_" BINARY_OS_STR "_"
BINARY_ARCH_STR ".exe";
#endif
char buf[4096];
char *cptr = buf;
defformatstring(a1, "-g%s", logger::names[logger::current_level]);
defformatstring(a2, "-l%s", server_log_file);
defformatstring(a3, "-mmap/%s.tar.gz", map);
const char a4[] = "-shutdown-if-idle";
const char a5[] = "-shutdown-if-empty";
size_t len = strlen(a1);
memcpy(cptr, a1, len); cptr += len; *(cptr++) = ' ';
len = strlen(a2);
memcpy(cptr, a2, len); cptr += len; *(cptr++) = ' ';
len = strlen(a3);
memcpy(cptr, a3, len); cptr += len; *(cptr++) = ' ';
len = sizeof(a4) - 1;
memcpy(cptr, a4, len); cptr += len; *(cptr++) = ' ';
len = sizeof(a5) - 1;
memcpy(cptr, a5, len); cptr += len; *cptr = '\0';
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&si, sizeof(pi));
CreateProcess(exe, buf, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
#endif
started = true;
}
void savegame(char *name)
{
if(!m_classicsp) { conoutf("can only save classic sp games"); return; };
sprintf_sd(fn)("savegames/%s.csgz", name);
savestate(fn);
stop();
conoutf("wrote %s", fn);
};
static use *checkuse(int type)
{
if(!loadinguse)
conoutf(CON_ERROR, "\fs\f3ERROR:\fr use not defined or being loaded");
else if(loadinguse->type < type)
conoutf(CON_ERROR, "\fs\f3ERROR:\fr trying to set an unavailable use property");
else
return loadinguse;
return NULL;
}
void paste()
{
EDITMP;
if(!copybuf) { conoutf("nothing to paste"); return; };
sel.xs = copybuf->xs;
sel.ys = copybuf->ys;
correctsel();
if(!selset || sel.xs!=copybuf->xs || sel.ys!=copybuf->ys) { conoutf("incorrect selection"); return; };
makeundo();
copybuf->x = sel.x;
copybuf->y = sel.y;
blockpaste(*copybuf);
};
void record(char *name)
{
if(m_sp) { conoutf("cannot record singleplayer games"); return; };
int cn = getclientnum();
if(cn<0) return;
sprintf_sd(fn)("demos/%s.cdgz", name);
savestate(fn);
gzputi(cn);
conoutf("started recording demo to %s", fn);
demorecording = true;
starttime = lastmillis;
ddamage = bdamage = 0;
};
static void ignorelist()
{
if (ips.isempty())
{
conoutf("ip ignore list is empty");
return;
}
conoutf("ignoring %u ip%s", (uint)ips.getsize(), plural(ips.getsize()));
int counter = 0;
ips.loopips(showignoredip, &counter);
}
void Client::initConnect(int cn, int protocol)
{
conoutf("Client::initConnect");
if(protocol!=CubeJ::PROTOCOL_VERSION)
{
conoutf(CON_ERROR, "you are using a different game protocol (you: %d, server: %d)", CubeJ::PROTOCOL_VERSION, protocol);
disconnect();
return;
}
self.clientnum = cn;
CubeJ::MsgDataType<CubeJ::MSG_REQ_CONNECT> data(self.name);
SendMessage(data);
}
void trydisconnect()
{
if(connpeer)
{
conoutf("aborting connection attempt");
abortconnect();
}
else if(curpeer)
{
conoutf("attempting to disconnect...");
disconnect(!discmillis);
}
else conoutf("not connected");
}
void trydisconnect(bool local)
{
if(connpeer)
{
conoutf("aborting connection attempt");
abortconnect();
}
else if(curpeer)
{
conoutf("attempting to disconnect...");
disconnect(!discmillis);
}
else if(local && haslocalclients()) localdisconnect();
else conoutf("not connected");
}
void takefromplayer(char *name, char *ok, char *notok)
{
rpgobj *o = playerobj->take(name);
if(o)
{
stack[0]->add(o, false);
conoutf("\f2you hand over a %s", o->name);
if(currentquest)
{
conoutf("\f2you finish a quest for %s", currentquest->npc);
currentquest->completed = true;
}
}
execute(o ? ok : notok);
}
void connectserv(const char *servername, int serverport, const char *serverpassword)
{
if(connpeer)
{
conoutf("aborting connection attempt");
abortconnect();
}
if(serverport <= 0) serverport = server::serverport();
ENetAddress address;
address.port = serverport;
if(servername)
{
if(strcmp(servername, connectname)) setsvar("connectname", servername);
if(serverport != connectport) setvar("connectport", serverport);
conoutf("attempting to connect to %s:%d", servername, serverport);
if(!resolverwait(servername, &address))
{
conoutf("\f3could not resolve server %s", servername);
return;
}
}
else
{
setsvar("connectname", "");
setvar("connectport", 0);
conoutf("attempting to connect over LAN");
address.host = ENET_HOST_BROADCAST;
}
if(!clienthost)
{
clienthost = enet_host_create(NULL, 2, server::numchannels(), rate*1024, rate*1024);
if(!clienthost)
{
conoutf("\f3could not connect to server");
return;
}
clienthost->duplicatePeers = 0;
}
connpeer = enet_host_connect(clienthost, &address, server::numchannels(), 0);
enet_host_flush(clienthost);
connmillis = totalmillis;
connattempts = 0;
}
void stopreset()
{
conoutf("demo stopped (%d msec elapsed)", lastmillis-starttime);
stop();
loopv(players) zapdynent(players[i]);
disconnect(0, 0);
};
void savestate(char *fn) {
stop();
f = gzopen(fn, "wb9");
if (!f) {
conoutf("could not write %s", fn);
return;
};
gzwrite(f, (void *) "CUBESAVE", 8);
gzputc(f, islittleendian);
gzputi(SAVEGAMEVERSION);
gzputi(sizeof(Sprite));
char buf[_MAXDEFSTR];
sprintf(buf, "%s", getclientmap().c_str());
gzwrite(f, buf, _MAXDEFSTR);
gzputi(gamemode);
gzputi(entityList.size());
for(Entity &en : entityList) {
gzputc(f, en.spawned);
}
gzwrite(f, player1, sizeof(Sprite));
std::vector<Sprite *> &monsters = getmonsters();
gzputi(monsters.size());
for(Sprite *m : monsters) {
gzwrite(f, m, sizeof(Sprite));
}
gzputi(players.size());
for(Sprite *p : players) {
gzput(p == NULL);
gzwrite(f, p, sizeof(Sprite));
};
}
void stopfollowing()
{
if(following<0) return;
following = -1;
followdir = 0;
conoutf("follow off");
}
bool execcfg(const char *cfgfile, bool ignore_ret)
{
string s;
copystring(s, cfgfile);
char *buf = loadfile(path(s), NULL);
if(!buf) return false;
auto err = lapi::state.do_string(buf, lua::ERROR_TRACEBACK);
if (types::get<0>(err))
logger::log(logger::ERROR, "%s\n", types::get<1>(err));
bool ret = true;
if (!ignore_ret)
{
ret = lapi::state["OF_CFG_VERSION_PASSED"].to<bool>();
if (!ret)
{
conoutf(
"Your OctaForge config file was too old to run with "
"your current client. Initializing a default set."
);
}
lapi::state["OF_CFG_VERSION_PASSED"] = lua::nil;
}
delete[] buf;
return ret;
}
void disconnect(bool async, bool cleanup)
{
if(curpeer)
{
if(!discmillis)
{
enet_peer_disconnect(curpeer, DISC_NONE);
enet_host_flush(clienthost);
discmillis = totalmillis;
}
if(curpeer->state!=ENET_PEER_STATE_DISCONNECTED)
{
if(async) return;
enet_peer_reset(curpeer);
}
curpeer = NULL;
discmillis = 0;
conoutf("disconnected");
game::gamedisconnect(cleanup);
setvar("mainmenu", 1);
}
if(!connpeer && clienthost)
{
enet_host_destroy(clienthost);
clienthost = NULL;
}
}
void Client::connectRemoteInterface(int n) {
conoutf("[DEBUG] Client::connectRemoteInterface, clientnum: %d", n);
remoteclientnum = n;
clients.add(new ClientInfo (n, CLIENT_TYPE_REMOTE, NULL));
CubeJ::MsgDataType<CubeJ::MSG_ACK_REMOTE> data(n);
SendMessage(data);
}
//! Upload the last map once more. This does NOT save the world - it can be called without
//! even having a world loaded (e.g., from the main menu, right after startup). It simply
//! packages the files in the map directory and uploads them. This is useful for making
//! fixes to map scripts that crash the server, but can also be used after manually
//! replacing the .ogz file, etc.
void repeat_upload()
{
std::string lastUploadedMapAsset = last_uploaded_map_asset;
// Acquire the asset info, so we know its file locations, asset server, etc.
renderprogress(0.2, "getting map asset info...");
REFLECT_PYTHON( AssetManager );
boost::python::object assetInfo = AssetManager.attr("get_info")( lastUploadedMapAsset );
// Set the map asset ID to the last one uploaded
REFLECT_PYTHON( set_curr_map_asset_id );
set_curr_map_asset_id( lastUploadedMapAsset );
REFLECT_PYTHON( World );
World.attr("asset_info") = assetInfo;
// // Make sure the script compiles ok TODO: All scripts, not just the main one
// renderprogress(0.5, "compiling scripts...");
// REFLECT_PYTHON( get_map_script_filename );
// std::string filename = boost::python::extract<std::string>( get_map_script_filename() );
// if (!checkCompile(filename)) XXX - need engine for this!
// return;
// Do the upload
renderprogress(0.7, "compiling scripts...");
REFLECT_PYTHON( upload_map );
upload_map();
conoutf("Upload complete.");
}
void stopn() {
if (demoplayback)
stopreset();
else
stop();
conoutf("demo stopped");
}
static void showglslinfo(GLenum type, GLuint obj, const char *name, const char **parts = NULL, int numparts = 0)
{
GLint length = 0;
if(type) glGetShaderiv_(obj, GL_INFO_LOG_LENGTH, &length);
else glGetProgramiv_(obj, GL_INFO_LOG_LENGTH, &length);
if(length > 1)
{
conoutf(CON_ERROR, "GLSL ERROR (%s:%s)", type == GL_VERTEX_SHADER ? "VS" : (type == GL_FRAGMENT_SHADER ? "FS" : "PROG"), name);
FILE *l = getlogfile();
if(l)
{
GLchar *log = new GLchar[length];
if(type) glGetShaderInfoLog_(obj, length, &length, log);
else glGetProgramInfoLog_(obj, length, &length, log);
fprintf(l, "%s\n", log);
bool partlines = log[0] != '0';
int line = 0;
loopi(numparts)
{
const char *part = parts[i];
int startline = line;
while(*part)
{
const char *next = strchr(part, '\n');
if(++line > 1000) goto done;
if(partlines) fprintf(l, "%d(%d): ", i, line - startline); else fprintf(l, "%d: ", line);
fwrite(part, 1, next ? next - part + 1 : strlen(part), l);
if(!next) { fputc('\n', l); break; }
part = next + 1;
}
}
done:
delete[] log;
}
}
void connectserv(const char *servername, int serverport, const char *serverpassword)
{
if(connpeer)
{
conoutf("aborting connection attempt");
abortconnect();
}
if(serverport <= 0) serverport = server::serverport();
ENetAddress address;
address.port = serverport;
if(servername)
{
if(strcmp(servername, GETSV(connectname))) SETVF(connectname, servername);
if(serverport != GETIV(connectport)) SETVF(connectport, serverport);
addserver(servername, serverport, serverpassword && serverpassword[0] ? serverpassword : NULL); // INTENSITY: Remove?
conoutf("attempting to connect to %s:%d", servername, serverport);
if(!resolverwait(servername, &address))
{
conoutf("\f3could not resolve server %s", servername);
return;
}
}
else
{
SETVF(connectname, "");
SETVF(connectport, 0);
conoutf("attempting to connect over LAN");
address.host = ENET_HOST_BROADCAST;
}
if(!clienthost)
clienthost = enet_host_create(NULL, 2, server::numchannels(), GETIV(rate), GETIV(rate));
if(clienthost)
{
connpeer = enet_host_connect(clienthost, &address, server::numchannels(), 0);
enet_host_flush(clienthost);
connmillis = totalmillis;
connattempts = 0;
game::connectattempt(servername ? servername : "", serverpassword ? serverpassword : "", address);
}
else conoutf("\f3could not connect to server");
}
void finalize()
{
center = vec(bbmin).add(bbmax).mul(0.5f);
radius = bbmin.dist(bbmax)/2;
cullmin = ivec::floor(bbmin);
cullmax = ivec::ceil(bbmax);
if(dbgpseed) conoutf(CON_DEBUG, "radius: %f, maxfade: %d", radius, maxfade);
}
void finalize()
{
center = vec(bbmin).add(bbmax).mul(0.5f);
radius = bbmin.dist(bbmax)/2;
bborigin = ivec(int(floor(bbmin.x)), int(floor(bbmin.y)), int(floor(bbmin.z)));
bbsize = ivec(int(ceil(bbmax.x)), int(ceil(bbmax.y)), int(ceil(bbmax.z))).sub(bborigin);
if(dbgpseed) conoutf(CON_DEBUG, "radius: %f, maxfade: %d", radius, maxfade);
}
void editundo()
{
EDITMP;
if(undos.empty()) { conoutf("nothing more to undo"); return; };
block *p = undos.pop();
blockpaste(*p);
free(p);
};
