Migrate more strings
FossilOrigin-Name: e7b5d33cada1ff8db653655ab2c77ead76ab7625a5d2f793b9aee3ec21e3778b
This commit is contained in:
parent
b00de734e8
commit
2860953c0b
24 changed files with 692 additions and 556 deletions
20
src/Cube.mm
20
src/Cube.mm
|
|
@ -202,16 +202,16 @@ int framesinmap = 0;
|
|||
initsound();
|
||||
|
||||
log("cfg");
|
||||
newmenu("frags\tpj\tping\tteam\tname");
|
||||
newmenu("ping\tplr\tserver");
|
||||
exec("data/keymap.cfg");
|
||||
exec("data/menus.cfg");
|
||||
exec("data/prefabs.cfg");
|
||||
exec("data/sounds.cfg");
|
||||
exec("servers.cfg");
|
||||
if (!execfile("config.cfg"))
|
||||
execfile("data/defaults.cfg");
|
||||
exec("autoexec.cfg");
|
||||
newmenu(@"frags\tpj\tping\tteam\tname");
|
||||
newmenu(@"ping\tplr\tserver");
|
||||
exec(@"data/keymap.cfg");
|
||||
exec(@"data/menus.cfg");
|
||||
exec(@"data/prefabs.cfg");
|
||||
exec(@"data/sounds.cfg");
|
||||
exec(@"servers.cfg");
|
||||
if (!execfile(@"config.cfg"))
|
||||
execfile(@"data/defaults.cfg");
|
||||
exec(@"autoexec.cfg");
|
||||
|
||||
log("localconnect");
|
||||
localconnect();
|
||||
|
|
|
|||
|
|
@ -57,21 +57,24 @@ throttle()
|
|||
}
|
||||
|
||||
void
|
||||
newname(char *name)
|
||||
newname(OFString *name)
|
||||
{
|
||||
c2sinit = false;
|
||||
strn0cpy(player1->name, name, 16);
|
||||
@autoreleasepool {
|
||||
strn0cpy(player1->name, name.UTF8String, 16);
|
||||
}
|
||||
}
|
||||
COMMANDN(name, newname, ARG_1STR)
|
||||
|
||||
void
|
||||
newteam(char *name)
|
||||
newteam(OFString *name)
|
||||
{
|
||||
c2sinit = false;
|
||||
strn0cpy(player1->team, name, 5);
|
||||
@autoreleasepool {
|
||||
strn0cpy(player1->team, name.UTF8String, 5);
|
||||
}
|
||||
|
||||
COMMANDN(team, newteam, ARG_1CSTR)
|
||||
COMMANDN(name, newname, ARG_1CSTR)
|
||||
}
|
||||
COMMANDN(team, newteam, ARG_1STR)
|
||||
|
||||
void
|
||||
writeclientinfo(FILE *f)
|
||||
|
|
@ -80,17 +83,19 @@ writeclientinfo(FILE *f)
|
|||
}
|
||||
|
||||
void
|
||||
connects(char *servername)
|
||||
connects(OFString *servername)
|
||||
{
|
||||
@autoreleasepool {
|
||||
disconnect(1); // reset state
|
||||
addserver(servername);
|
||||
|
||||
conoutf(@"attempting to connect to %s", servername);
|
||||
conoutf(@"attempting to connect to %s", servername.UTF8String);
|
||||
ENetAddress address = {ENET_HOST_ANY, CUBE_SERVER_PORT};
|
||||
if (enet_address_set_host(&address, servername) < 0) {
|
||||
if (enet_address_set_host(&address, servername.UTF8String) <
|
||||
0) {
|
||||
conoutf(@"could not resolve server %s", servername);
|
||||
return;
|
||||
};
|
||||
}
|
||||
|
||||
clienthost = enet_host_create(NULL, 1, rate, rate);
|
||||
|
||||
|
|
@ -104,6 +109,7 @@ connects(char *servername)
|
|||
disconnect();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
disconnect(int onlyclean, int async)
|
||||
|
|
@ -173,7 +179,7 @@ echo(char *text)
|
|||
|
||||
COMMAND(echo, ARG_VARI)
|
||||
COMMANDN(say, toserver, ARG_VARI)
|
||||
COMMANDN(connect, connects, ARG_1CSTR)
|
||||
COMMANDN(connect, connects, ARG_1STR)
|
||||
COMMANDN(disconnect, trydisconnect, ARG_NONE)
|
||||
|
||||
// collect c2s messages conveniently
|
||||
|
|
@ -218,11 +224,13 @@ bool senditemstoserver =
|
|||
|
||||
string clientpassword;
|
||||
void
|
||||
password(char *p)
|
||||
password(OFString *p)
|
||||
{
|
||||
strcpy_s(clientpassword, p);
|
||||
@autoreleasepool {
|
||||
strcpy_s(clientpassword, p.UTF8String);
|
||||
}
|
||||
COMMAND(password, ARG_1CSTR)
|
||||
}
|
||||
COMMAND(password, ARG_1STR)
|
||||
|
||||
bool
|
||||
netmapstart()
|
||||
|
|
@ -237,8 +245,8 @@ initclientnet()
|
|||
ctext[0] = 0;
|
||||
toservermap = @"";
|
||||
clientpassword[0] = 0;
|
||||
newname("unnamed");
|
||||
newteam("red");
|
||||
newname(@"unnamed");
|
||||
newteam(@"red");
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ int frame[] = {178, 184, 190, 137, 183, 189, 197, 164, 46, 51, 54, 32, 0, 0, 40,
|
|||
int range[] = {6, 6, 8, 28, 1, 1, 1, 1, 8, 19, 4, 18, 40, 1, 6, 15, 1, 1, 1, 1};
|
||||
|
||||
void
|
||||
renderclient(dynent *d, bool team, char *mdlname, bool hellpig, float scale)
|
||||
renderclient(dynent *d, bool team, OFString *mdlname, bool hellpig, float scale)
|
||||
{
|
||||
int n = 3;
|
||||
float speed = 100.0f;
|
||||
|
|
@ -27,7 +27,7 @@ renderclient(dynent *d, bool team, char *mdlname, bool hellpig, float scale)
|
|||
} else {
|
||||
n = (intptr_t)d % 3;
|
||||
r = range[n];
|
||||
};
|
||||
}
|
||||
basetime = d->lastaction;
|
||||
int t = lastmillis - d->lastaction;
|
||||
if (t < 0 || t > 20000)
|
||||
|
|
@ -61,15 +61,15 @@ renderclient(dynent *d, bool team, char *mdlname, bool hellpig, float scale)
|
|||
speed = 1200 / d->maxspeed * scale;
|
||||
if (hellpig)
|
||||
speed = 300 / d->maxspeed;
|
||||
};
|
||||
}
|
||||
if (hellpig) {
|
||||
n++;
|
||||
scale *= 32;
|
||||
mz -= 1.9f;
|
||||
};
|
||||
}
|
||||
rendermodel(mdlname, frame[n], range[n], 0, 1.5f, d->o.x, mz, d->o.y,
|
||||
d->yaw + 90, d->pitch / 2, team, scale, speed, 0, basetime);
|
||||
};
|
||||
}
|
||||
|
||||
extern int democlientnum;
|
||||
|
||||
|
|
@ -79,9 +79,9 @@ renderclients()
|
|||
dynent *d;
|
||||
loopv(players) if ((d = players[i]) &&
|
||||
(!demoplayback || i != democlientnum))
|
||||
renderclient(
|
||||
d, isteam(player1->team, d->team), "monster/ogro", false, 1.0f);
|
||||
};
|
||||
renderclient(d, isteam(player1->team, d->team), @"monster/ogro",
|
||||
false, 1.0f);
|
||||
}
|
||||
|
||||
// creation of scoreboard pseudo-menu
|
||||
|
||||
|
|
@ -161,15 +161,15 @@ renderscores()
|
|||
// sendmap/getmap commands, should be replaced by more intuitive map downloading
|
||||
|
||||
void
|
||||
sendmap(const char *mapname)
|
||||
sendmap(OFString *mapname)
|
||||
{
|
||||
@autoreleasepool {
|
||||
if (*mapname)
|
||||
if (mapname.length > 0)
|
||||
save_world(mapname);
|
||||
changemap(@(mapname));
|
||||
mapname = getclientmap().UTF8String;
|
||||
changemap(mapname);
|
||||
mapname = getclientmap();
|
||||
int mapsize;
|
||||
uchar *mapdata = readmap(mapname, &mapsize);
|
||||
uchar *mapdata = readmap(mapname.UTF8String, &mapsize);
|
||||
if (!mapdata)
|
||||
return;
|
||||
ENetPacket *packet = enet_packet_create(
|
||||
|
|
@ -177,10 +177,11 @@ sendmap(const char *mapname)
|
|||
uchar *start = packet->data;
|
||||
uchar *p = start + 2;
|
||||
putint(p, SV_SENDMAP);
|
||||
sendstring(mapname, p);
|
||||
sendstring(mapname.UTF8String, p);
|
||||
putint(p, mapsize);
|
||||
if (65535 - (p - start) < mapsize) {
|
||||
conoutf(@"map %s is too large to send", mapname);
|
||||
conoutf(
|
||||
@"map %s is too large to send", mapname.UTF8String);
|
||||
free(mapdata);
|
||||
enet_packet_destroy(packet);
|
||||
return;
|
||||
|
|
@ -191,10 +192,10 @@ sendmap(const char *mapname)
|
|||
*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
|
||||
enet_packet_resize(packet, p - start);
|
||||
sendpackettoserv(packet);
|
||||
conoutf(@"sending map %s to server...", mapname);
|
||||
conoutf(@"sending map %s to server...", mapname.UTF8String);
|
||||
sprintf_sd(msg)(
|
||||
"[map %s uploaded to server, \"getmap\" to receive it]",
|
||||
mapname);
|
||||
mapname.UTF8String);
|
||||
toserver(msg);
|
||||
}
|
||||
}
|
||||
|
|
@ -213,5 +214,5 @@ getmap()
|
|||
conoutf(@"requesting map from server...");
|
||||
}
|
||||
|
||||
COMMAND(sendmap, ARG_1CSTR)
|
||||
COMMAND(sendmap, ARG_1STR)
|
||||
COMMAND(getmap, ARG_NONE)
|
||||
|
|
|
|||
|
|
@ -2,6 +2,8 @@
|
|||
|
||||
#include "cube.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
int nextmode = 0; // nextmode becomes gamemode after next map load
|
||||
VAR(gamemode, 1, 0, 0);
|
||||
|
||||
|
|
@ -231,13 +233,13 @@ respawn()
|
|||
}
|
||||
|
||||
int sleepwait = 0;
|
||||
string sleepcmd;
|
||||
static OFString *sleepcmd = nil;
|
||||
void
|
||||
sleepf(char *msec, char *cmd)
|
||||
sleepf(OFString *msec, OFString *cmd)
|
||||
{
|
||||
sleepwait = atoi(msec) + lastmillis;
|
||||
strcpy_s(sleepcmd, cmd);
|
||||
};
|
||||
sleepwait = (int)msec.longLongValue + lastmillis;
|
||||
sleepcmd = cmd;
|
||||
}
|
||||
COMMANDN(sleep, sleepf, ARG_2STR)
|
||||
|
||||
void
|
||||
|
|
@ -247,8 +249,12 @@ updateworld(int millis) // main game update loop
|
|||
curtime = millis - lastmillis;
|
||||
if (sleepwait && lastmillis > sleepwait) {
|
||||
sleepwait = 0;
|
||||
execute(sleepcmd);
|
||||
};
|
||||
@autoreleasepool {
|
||||
std::unique_ptr<char> cmd(
|
||||
strdup(sleepcmd.UTF8String));
|
||||
execute(cmd.get());
|
||||
}
|
||||
}
|
||||
physicsframe();
|
||||
checkquad(curtime);
|
||||
if (m_arena)
|
||||
|
|
@ -508,9 +514,9 @@ startmap(char *name) // called just after a map load
|
|||
}
|
||||
if (editmode)
|
||||
toggleedit();
|
||||
setvar("gamespeed", 100);
|
||||
setvar("fog", 180);
|
||||
setvar("fogcolour", 0x8099B3);
|
||||
setvar(@"gamespeed", 100);
|
||||
setvar(@"fog", 180);
|
||||
setvar(@"fogcolour", 0x8099B3);
|
||||
showscores(false);
|
||||
intermission = false;
|
||||
framesinmap = 0;
|
||||
|
|
|
|||
215
src/command.mm
215
src/command.mm
|
|
@ -3,6 +3,8 @@
|
|||
|
||||
#include "cube.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
enum { ID_VAR, ID_COMMAND, ID_ALIAS };
|
||||
|
||||
@interface Ident : OFObject
|
||||
|
|
@ -36,77 +38,65 @@ exchangestr(char *o, const char *n)
|
|||
OFMutableDictionary<OFString *, Ident *> *idents;
|
||||
|
||||
void
|
||||
alias(char *name, char *action)
|
||||
alias(OFString *name, OFString *action)
|
||||
{
|
||||
@autoreleasepool {
|
||||
Ident *b = idents[@(name)];
|
||||
Ident *b = idents[name];
|
||||
|
||||
if (!b) {
|
||||
if (b == nil) {
|
||||
Ident *b = [[Ident alloc] init];
|
||||
b.type = ID_ALIAS;
|
||||
b.name = @(name);
|
||||
b.action = @(action);
|
||||
b.name = name;
|
||||
b.action = action;
|
||||
b.persist = true;
|
||||
|
||||
idents[b.name] = b;
|
||||
} else {
|
||||
if (b.type == ID_ALIAS)
|
||||
b.action = @(action);
|
||||
b.action = action;
|
||||
else
|
||||
conoutf(
|
||||
@"cannot redefine builtin %s with an alias",
|
||||
name);
|
||||
@"cannot redefine builtin %s with an alias", name.UTF8String);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
COMMAND(alias, ARG_2STR)
|
||||
|
||||
int
|
||||
variable(char *name, int min, int cur, int max, int *storage, void (*fun)(),
|
||||
variable(OFString *name, int min, int cur, int max, int *storage, void (*fun)(),
|
||||
bool persist)
|
||||
{
|
||||
if (idents == nil)
|
||||
idents = [[OFMutableDictionary alloc] init];
|
||||
|
||||
@autoreleasepool {
|
||||
Ident *v = [[Ident alloc] init];
|
||||
v.type = ID_VAR;
|
||||
v.name = @(name);
|
||||
v.name = name;
|
||||
v.min = min;
|
||||
v.max = max;
|
||||
v.storage = storage;
|
||||
v.fun = fun;
|
||||
v.persist = persist;
|
||||
|
||||
idents[v.name] = v;
|
||||
}
|
||||
idents[name] = v;
|
||||
|
||||
return cur;
|
||||
}
|
||||
|
||||
void
|
||||
setvar(char *name, int i)
|
||||
setvar(OFString *name, int i)
|
||||
{
|
||||
@autoreleasepool {
|
||||
*idents[@(name)].storage = i;
|
||||
}
|
||||
*idents[name].storage = i;
|
||||
}
|
||||
|
||||
int
|
||||
getvar(char *name)
|
||||
getvar(OFString *name)
|
||||
{
|
||||
@autoreleasepool {
|
||||
return *idents[@(name)].storage;
|
||||
}
|
||||
return *idents[name].storage;
|
||||
}
|
||||
|
||||
bool
|
||||
identexists(char *name)
|
||||
identexists(OFString *name)
|
||||
{
|
||||
@autoreleasepool {
|
||||
return (idents[@(name)] != nil);
|
||||
}
|
||||
return (idents[name] != nil);
|
||||
}
|
||||
|
||||
OFString *
|
||||
|
|
@ -296,34 +286,63 @@ execute(char *p, bool isdown) // all evaluation happens here, recursively
|
|||
((void(__cdecl *)())
|
||||
ID.fun)();
|
||||
break;
|
||||
case ARG_1CSTR:
|
||||
if (isdown)
|
||||
((void(__cdecl *)(
|
||||
char *))ID.fun)(
|
||||
w[1]);
|
||||
case ARG_1STR:
|
||||
if (isdown) {
|
||||
@autoreleasepool {
|
||||
((void(
|
||||
__cdecl *)(
|
||||
OFString *))
|
||||
ID.fun)(
|
||||
@(w[1]));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ARG_2STR:
|
||||
if (isdown)
|
||||
((void(__cdecl *)(
|
||||
char *,
|
||||
char *))ID.fun)(
|
||||
w[1], w[2]);
|
||||
if (isdown) {
|
||||
@autoreleasepool {
|
||||
((void(
|
||||
__cdecl *)(
|
||||
OFString *,
|
||||
OFString *))
|
||||
ID.fun)(
|
||||
@(w[1]),
|
||||
@(w[2]));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ARG_3STR:
|
||||
if (isdown)
|
||||
((void(__cdecl *)(
|
||||
char *, char *,
|
||||
char *))ID.fun)(
|
||||
w[1], w[2], w[3]);
|
||||
if (isdown) {
|
||||
@autoreleasepool {
|
||||
((void(
|
||||
__cdecl *)(
|
||||
OFString *,
|
||||
OFString *,
|
||||
OFString *))
|
||||
ID.fun)(
|
||||
@(w[1]),
|
||||
@(w[2]),
|
||||
@(w[3]));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ARG_5STR:
|
||||
if (isdown)
|
||||
((void(__cdecl *)(
|
||||
char *, char *,
|
||||
char *, char *,
|
||||
char *))ID.fun)(
|
||||
w[1], w[2], w[3],
|
||||
w[4], w[5]);
|
||||
if (isdown) {
|
||||
@autoreleasepool {
|
||||
((void(
|
||||
__cdecl *)(
|
||||
OFString *,
|
||||
OFString *,
|
||||
OFString *,
|
||||
OFString *,
|
||||
OFString *))
|
||||
ID.fun)(
|
||||
@(w[1]),
|
||||
@(w[2]),
|
||||
@(w[3]),
|
||||
@(w[4]),
|
||||
@(w[5]));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ARG_DOWN:
|
||||
((void(__cdecl *)(bool))ID.fun)(
|
||||
|
|
@ -383,17 +402,6 @@ execute(char *p, bool isdown) // all evaluation happens here, recursively
|
|||
char *))ID.fun)(r);
|
||||
break;
|
||||
}
|
||||
case ARG_1STR:
|
||||
if (isdown) {
|
||||
@autoreleasepool {
|
||||
((void(
|
||||
__cdecl *)(
|
||||
OFString *))
|
||||
ID.fun)(
|
||||
@(w[1]));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -479,11 +487,16 @@ execute(char *p, bool isdown) // all evaluation happens here, recursively
|
|||
// variables
|
||||
case ID_ALIAS:
|
||||
for (int i = 1; i < numargs; i++) {
|
||||
@autoreleasepool {
|
||||
// set any arguments as
|
||||
// (global) arg values so
|
||||
// functions can access them
|
||||
sprintf_sd(t)("arg%d", i);
|
||||
alias(t, w[i]);
|
||||
// (global) arg values
|
||||
// so functions can
|
||||
// access them
|
||||
OFString *t = [OFString
|
||||
stringWithFormat:
|
||||
@"arg%d", i];
|
||||
alias(t, @(w[i]));
|
||||
}
|
||||
}
|
||||
// create new string here because alias
|
||||
// could rebind itself
|
||||
|
|
@ -541,10 +554,11 @@ complete(char *s)
|
|||
}
|
||||
|
||||
bool
|
||||
execfile(char *cfgfile)
|
||||
execfile(OFString *cfgfile)
|
||||
{
|
||||
@autoreleasepool {
|
||||
string s;
|
||||
strcpy_s(s, cfgfile);
|
||||
strcpy_s(s, cfgfile.UTF8String);
|
||||
char *buf = loadfile(path(s), NULL);
|
||||
if (!buf)
|
||||
return false;
|
||||
|
|
@ -552,12 +566,16 @@ execfile(char *cfgfile)
|
|||
free(buf);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
exec(char *cfgfile)
|
||||
exec(OFString *cfgfile)
|
||||
{
|
||||
if (!execfile(cfgfile))
|
||||
conoutf(@"could not read \"%s\"", cfgfile);
|
||||
if (!execfile(cfgfile)) {
|
||||
@autoreleasepool {
|
||||
conoutf(@"could not read \"%s\"", cfgfile.UTF8String);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -600,36 +618,50 @@ COMMAND(writecfg, ARG_NONE)
|
|||
// () and [] expressions, any control construct can be defined trivially.
|
||||
|
||||
void
|
||||
intset(char *name, int v)
|
||||
intset(OFString *name, int v)
|
||||
{
|
||||
string b;
|
||||
itoa(b, v);
|
||||
alias(name, b);
|
||||
@autoreleasepool {
|
||||
alias(name, [OFString stringWithFormat:@"%d", v]);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ifthen(char *cond, char *thenp, char *elsep)
|
||||
ifthen(OFString *cond, OFString *thenp, OFString *elsep)
|
||||
{
|
||||
execute(cond[0] != '0' ? thenp : elsep);
|
||||
@autoreleasepool {
|
||||
std::unique_ptr<char> cmd(strdup(
|
||||
(cond.UTF8String[0] != '0' ? thenp : elsep).UTF8String));
|
||||
|
||||
execute(cmd.get());
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
loopa(char *times, char *body)
|
||||
loopa(OFString *times, OFString *body_)
|
||||
{
|
||||
int t = atoi(times);
|
||||
@autoreleasepool {
|
||||
int t = (int)times.longLongValue;
|
||||
std::unique_ptr<char> body(strdup(body_.UTF8String));
|
||||
|
||||
loopi(t)
|
||||
{
|
||||
intset("i", i);
|
||||
execute(body);
|
||||
intset(@"i", i);
|
||||
execute(body.get());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
whilea(char *cond, char *body)
|
||||
whilea(OFString *cond_, OFString *body_)
|
||||
{
|
||||
while (execute(cond))
|
||||
execute(body);
|
||||
} // can't get any simpler than this :)
|
||||
@autoreleasepool {
|
||||
std::unique_ptr<char> cond(strdup(cond_.UTF8String));
|
||||
std::unique_ptr<char> body(strdup(body_.UTF8String));
|
||||
|
||||
while (execute(cond.get()))
|
||||
execute(body.get());
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
onrelease(bool on, char *body)
|
||||
|
|
@ -641,7 +673,9 @@ onrelease(bool on, char *body)
|
|||
void
|
||||
concat(char *s)
|
||||
{
|
||||
alias("s", s);
|
||||
@autoreleasepool {
|
||||
alias(@"s", @(s));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -666,19 +700,24 @@ listlen(char *a)
|
|||
}
|
||||
|
||||
void
|
||||
at(char *s, char *pos)
|
||||
at(OFString *s_, OFString *pos)
|
||||
{
|
||||
int n = atoi(pos);
|
||||
@autoreleasepool {
|
||||
int n = (int)pos.longLongValue;
|
||||
std::unique_ptr<char> copy(strdup(s_.UTF8String));
|
||||
char *s = copy.get();
|
||||
|
||||
loopi(n) s += strspn(s += strcspn(s, " \0"), " ");
|
||||
s[strcspn(s, " \0")] = 0;
|
||||
concat(s);
|
||||
}
|
||||
}
|
||||
|
||||
COMMANDN(loop, loopa, ARG_2STR)
|
||||
COMMANDN(while, whilea, ARG_2STR)
|
||||
COMMANDN(if, ifthen, ARG_3STR)
|
||||
COMMAND(onrelease, ARG_DWN1)
|
||||
COMMAND(exec, ARG_1CSTR)
|
||||
COMMAND(exec, ARG_1STR)
|
||||
COMMAND(concat, ARG_VARI)
|
||||
COMMAND(concatword, ARG_VARI)
|
||||
COMMAND(at, ARG_2STR)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
// console.cpp: the console buffer, its display, and command line control
|
||||
|
||||
#include "cube.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <memory>
|
||||
|
||||
struct cline {
|
||||
char *cref;
|
||||
|
|
@ -94,25 +96,30 @@ struct keym {
|
|||
int numkm = 0;
|
||||
|
||||
void
|
||||
keymap(char *code, char *key, char *action)
|
||||
keymap(OFString *code, OFString *key, OFString *action)
|
||||
{
|
||||
keyms[numkm].code = atoi(code);
|
||||
keyms[numkm].name = newstring(key);
|
||||
keyms[numkm++].action = newstringbuf(action);
|
||||
@autoreleasepool {
|
||||
keyms[numkm].code = (int)code.longLongValue;
|
||||
keyms[numkm].name = newstring(key.UTF8String);
|
||||
keyms[numkm++].action = newstringbuf(action.UTF8String);
|
||||
}
|
||||
}
|
||||
COMMAND(keymap, ARG_3STR)
|
||||
|
||||
void
|
||||
bindkey(char *key, char *action)
|
||||
bindkey(OFString *key_, OFString *action)
|
||||
{
|
||||
for (char *x = key; *x; x++)
|
||||
@autoreleasepool {
|
||||
std::unique_ptr<char> key(strdup(key_.UTF8String));
|
||||
for (char *x = key.get(); *x; x++)
|
||||
*x = toupper(*x);
|
||||
loopi(numkm) if (strcmp(keyms[i].name, key) == 0)
|
||||
loopi(numkm) if (strcmp(keyms[i].name, key.get()) == 0)
|
||||
{
|
||||
strcpy_s(keyms[i].action, action);
|
||||
strcpy_s(keyms[i].action, action.UTF8String);
|
||||
return;
|
||||
};
|
||||
conoutf(@"unknown key \"%s\"", key);
|
||||
}
|
||||
conoutf(@"unknown key \"%s\"", key.get());
|
||||
}
|
||||
}
|
||||
COMMANDN(bind, bindkey, ARG_2STR)
|
||||
|
||||
|
|
@ -125,16 +132,17 @@ saycommand(char *init) // turns input to the command line on or off
|
|||
if (!init)
|
||||
init = "";
|
||||
strcpy_s(commandbuf, init);
|
||||
};
|
||||
}
|
||||
COMMAND(saycommand, ARG_VARI)
|
||||
|
||||
void
|
||||
mapmsg(char *s)
|
||||
mapmsg(OFString *s)
|
||||
{
|
||||
strn0cpy(hdr.maptitle, s, 128);
|
||||
@autoreleasepool {
|
||||
strn0cpy(hdr.maptitle, s.UTF8String, 128);
|
||||
}
|
||||
|
||||
COMMAND(saycommand, ARG_VARI)
|
||||
COMMAND(mapmsg, ARG_1CSTR)
|
||||
}
|
||||
COMMAND(mapmsg, ARG_1STR)
|
||||
|
||||
#ifndef _WIN32
|
||||
# include <SDL_syswm.h>
|
||||
|
|
|
|||
17
src/cube.h
17
src/cube.h
|
|
@ -110,7 +110,7 @@ struct block {
|
|||
};
|
||||
struct mapmodelinfo {
|
||||
int rad, h, zoff, snap;
|
||||
char *name;
|
||||
const char *name;
|
||||
};
|
||||
|
||||
enum {
|
||||
|
|
@ -379,7 +379,7 @@ enum // function signatures for script functions, see command.cpp
|
|||
ARG_3INT,
|
||||
ARG_4INT,
|
||||
ARG_NONE,
|
||||
ARG_1CSTR,
|
||||
ARG_1STR,
|
||||
ARG_2STR,
|
||||
ARG_3STR,
|
||||
ARG_5STR,
|
||||
|
|
@ -389,8 +389,7 @@ enum // function signatures for script functions, see command.cpp
|
|||
ARG_2EXP,
|
||||
ARG_1EST,
|
||||
ARG_2EST,
|
||||
ARG_VARI,
|
||||
ARG_1STR
|
||||
ARG_VARI
|
||||
};
|
||||
|
||||
// nasty macros for registering script functions, abuses globals to avoid
|
||||
|
|
@ -408,8 +407,8 @@ enum // function signatures for script functions, see command.cpp
|
|||
OF_CONSTRUCTOR() \
|
||||
{ \
|
||||
enqueueInit(^{ \
|
||||
name = \
|
||||
variable(#name, min, cur, max, &name, NULL, true); \
|
||||
name = variable( \
|
||||
@ #name, min, cur, max, &name, NULL, true); \
|
||||
}); \
|
||||
}
|
||||
#define VAR(name, min, cur, max) \
|
||||
|
|
@ -418,7 +417,7 @@ enum // function signatures for script functions, see command.cpp
|
|||
{ \
|
||||
enqueueInit(^{ \
|
||||
name = variable( \
|
||||
#name, min, cur, max, &name, NULL, false); \
|
||||
@ #name, min, cur, max, &name, NULL, false); \
|
||||
}); \
|
||||
}
|
||||
#define VARF(name, min, cur, max, body) \
|
||||
|
|
@ -428,7 +427,7 @@ enum // function signatures for script functions, see command.cpp
|
|||
{ \
|
||||
enqueueInit(^{ \
|
||||
name = variable( \
|
||||
#name, min, cur, max, &name, var_##name, false); \
|
||||
@ #name, min, cur, max, &name, var_##name, false); \
|
||||
}); \
|
||||
} \
|
||||
void var_##name() { body; }
|
||||
|
|
@ -439,7 +438,7 @@ enum // function signatures for script functions, see command.cpp
|
|||
{ \
|
||||
enqueueInit(^{ \
|
||||
name = variable( \
|
||||
#name, min, cur, max, &name, var_##name, true); \
|
||||
@ #name, min, cur, max, &name, var_##name, true); \
|
||||
}); \
|
||||
} \
|
||||
void var_##name() { body; }
|
||||
|
|
|
|||
|
|
@ -9,12 +9,19 @@ bool editmode = false;
|
|||
// invariant: all code assumes that these are kept inside MINBORD distance of
|
||||
// the edge of the map
|
||||
|
||||
block sel = {
|
||||
variable("selx", 0, 0, 4096, &sel.x, NULL, false),
|
||||
variable("sely", 0, 0, 4096, &sel.y, NULL, false),
|
||||
variable("selxs", 0, 0, 4096, &sel.xs, NULL, false),
|
||||
variable("selys", 0, 0, 4096, &sel.ys, NULL, false),
|
||||
block sel;
|
||||
|
||||
OF_CONSTRUCTOR()
|
||||
{
|
||||
enqueueInit(^{
|
||||
sel = {
|
||||
variable(@"selx", 0, 0, 4096, &sel.x, NULL, false),
|
||||
variable(@"sely", 0, 0, 4096, &sel.y, NULL, false),
|
||||
variable(@"selxs", 0, 0, 4096, &sel.xs, NULL, false),
|
||||
variable(@"selys", 0, 0, 4096, &sel.ys, NULL, false),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
int selh = 0;
|
||||
bool selset = false;
|
||||
|
|
@ -593,12 +600,15 @@ edittag(int tag)
|
|||
};
|
||||
|
||||
void
|
||||
newent(char *what, char *a1, char *a2, char *a3, char *a4)
|
||||
newent(OFString *what, OFString *a1, OFString *a2, OFString *a3, OFString *a4)
|
||||
{
|
||||
EDITSEL;
|
||||
newentity(sel.x, sel.y, (int)player1->o.z, what, ATOI(a1), ATOI(a2),
|
||||
ATOI(a3), ATOI(a4));
|
||||
};
|
||||
@autoreleasepool {
|
||||
newentity(sel.x, sel.y, (int)player1->o.z, what,
|
||||
(int)a1.longLongValue, (int)a2.longLongValue,
|
||||
(int)a3.longLongValue, (int)a4.longLongValue);
|
||||
}
|
||||
}
|
||||
|
||||
COMMANDN(select, selectpos, ARG_4INT)
|
||||
COMMAND(edittag, ARG_1INT)
|
||||
|
|
|
|||
|
|
@ -4,23 +4,23 @@
|
|||
|
||||
vector<entity> ents;
|
||||
|
||||
char *entmdlnames[] = {
|
||||
"shells",
|
||||
"bullets",
|
||||
"rockets",
|
||||
"rrounds",
|
||||
"health",
|
||||
"boost",
|
||||
"g_armour",
|
||||
"y_armour",
|
||||
"quad",
|
||||
"teleporter",
|
||||
static OFString *entmdlnames[] = {
|
||||
@"shells",
|
||||
@"bullets",
|
||||
@"rockets",
|
||||
@"rrounds",
|
||||
@"health",
|
||||
@"boost",
|
||||
@"g_armour",
|
||||
@"y_armour",
|
||||
@"quad",
|
||||
@"teleporter",
|
||||
};
|
||||
|
||||
int triggertime = 0;
|
||||
|
||||
void
|
||||
renderent(entity &e, char *mdlname, float z, float yaw, int frame = 0,
|
||||
renderent(entity &e, OFString *mdlname, float z, float yaw, int frame = 0,
|
||||
int numf = 1, int basetime = 0, float speed = 10.0f)
|
||||
{
|
||||
rendermodel(mdlname, frame, numf, 0, 1.1f, e.x, z + S(e.x, e.y)->floor,
|
||||
|
|
@ -39,11 +39,15 @@ renderentities()
|
|||
mapmodelinfo *mmi = getmminfo(e.attr2);
|
||||
if (!mmi)
|
||||
continue;
|
||||
rendermodel(mmi->name, 0, 1, e.attr4, (float)mmi->rad,
|
||||
e.x,
|
||||
(float)S(e.x, e.y)->floor + mmi->zoff + e.attr3,
|
||||
e.y, (float)((e.attr1 + 7) - (e.attr1 + 7) % 15), 0,
|
||||
false, 1.0f, 10.0f, mmi->snap);
|
||||
@autoreleasepool {
|
||||
rendermodel(@(mmi->name), 0, 1, e.attr4,
|
||||
(float)mmi->rad, e.x,
|
||||
(float)S(e.x, e.y)->floor + mmi->zoff +
|
||||
e.attr3,
|
||||
e.y,
|
||||
(float)((e.attr1 + 7) - (e.attr1 + 7) % 15),
|
||||
0, false, 1.0f, 10.0f, mmi->snap);
|
||||
}
|
||||
} else {
|
||||
if (OUTBORD(e.x, e.y))
|
||||
continue;
|
||||
|
|
@ -67,7 +71,7 @@ renderentities()
|
|||
case 0:
|
||||
if (!e.spawned)
|
||||
continue;
|
||||
renderent(e, "carrot",
|
||||
renderent(e, @"carrot",
|
||||
(float)(1 + sin(lastmillis / 100.0 +
|
||||
e.x + e.y) /
|
||||
20),
|
||||
|
|
@ -76,7 +80,7 @@ renderentities()
|
|||
break;
|
||||
|
||||
case 4:
|
||||
renderent(e, "switch2", 3,
|
||||
renderent(e, @"switch2", 3,
|
||||
(float)e.attr3 * 90,
|
||||
(!e.spawned && !triggertime) ? 1
|
||||
: 0,
|
||||
|
|
@ -84,7 +88,7 @@ renderentities()
|
|||
triggertime, 1050.0f);
|
||||
break;
|
||||
case 5:
|
||||
renderent(e, "switch1", -0.15f,
|
||||
renderent(e, @"switch1", -0.15f,
|
||||
(float)e.attr3 * 90,
|
||||
(!e.spawned && !triggertime) ? 30
|
||||
: 0,
|
||||
|
|
|
|||
44
src/menus.mm
44
src/menus.mm
|
|
@ -26,17 +26,21 @@ menuset(int menu)
|
|||
resetmovement(player1);
|
||||
if (vmenu == 1)
|
||||
menus[1].menusel = 0;
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
showmenu(char *name)
|
||||
showmenu(OFString *name_)
|
||||
{
|
||||
@autoreleasepool {
|
||||
const char *name = name_.UTF8String;
|
||||
loopv(menus) if (i > 1 && strcmp(menus[i].name, name) == 0)
|
||||
{
|
||||
menuset(i);
|
||||
return;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
COMMAND(showmenu, ARG_1STR)
|
||||
|
||||
int
|
||||
menucompare(mitem *a, mitem *b)
|
||||
|
|
@ -103,12 +107,15 @@ rendermenu()
|
|||
};
|
||||
|
||||
void
|
||||
newmenu(char *name)
|
||||
newmenu(OFString *name)
|
||||
{
|
||||
@autoreleasepool {
|
||||
gmenu &menu = menus.add();
|
||||
menu.name = newstring(name);
|
||||
menu.name = newstring(name.UTF8String);
|
||||
menu.menusel = 0;
|
||||
};
|
||||
}
|
||||
}
|
||||
COMMAND(newmenu, ARG_1STR)
|
||||
|
||||
void
|
||||
menumanual(int m, int n, char *text)
|
||||
|
|
@ -121,18 +128,18 @@ menumanual(int m, int n, char *text)
|
|||
}
|
||||
|
||||
void
|
||||
menuitem(char *text, char *action)
|
||||
menuitem(OFString *text, OFString *action)
|
||||
{
|
||||
@autoreleasepool {
|
||||
gmenu &menu = menus.last();
|
||||
mitem &mi = menu.items.add();
|
||||
mi.text = newstring(text);
|
||||
mi.action = action[0] ? newstring(action) : mi.text;
|
||||
mi.text = newstring(text.UTF8String);
|
||||
mi.action =
|
||||
action.length > 0 ? newstring(action.UTF8String) : mi.text;
|
||||
}
|
||||
}
|
||||
COMMAND(menuitem, ARG_2STR)
|
||||
|
||||
COMMAND(showmenu, ARG_1CSTR)
|
||||
COMMAND(newmenu, ARG_1CSTR)
|
||||
|
||||
bool
|
||||
menukey(int code, bool isdown)
|
||||
{
|
||||
|
|
@ -158,12 +165,15 @@ menukey(int code, bool isdown)
|
|||
} else {
|
||||
if (code == SDLK_RETURN || code == -2) {
|
||||
char *action = menus[vmenu].items[menusel].action;
|
||||
if (vmenu == 1)
|
||||
connects(getservername(menusel));
|
||||
if (vmenu == 1) {
|
||||
@autoreleasepool {
|
||||
connects(@(getservername(menusel)));
|
||||
}
|
||||
}
|
||||
menustack.add(vmenu);
|
||||
menuset(-1);
|
||||
execute(action, true);
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -26,26 +26,26 @@ struct monstertype // see docs for how these values modify behaviour
|
|||
short gun, speed, health, freq, lag, rate, pain, loyalty, mscale,
|
||||
bscale;
|
||||
short painsound, diesound;
|
||||
char *name, *mdlname;
|
||||
OFConstantString *name, *mdlname;
|
||||
}
|
||||
|
||||
monstertypes[NUMMONSTERTYPES] = {
|
||||
{GUN_FIREBALL, 15, 100, 3, 0, 100, 800, 1, 10, 10, S_PAINO, S_DIE1,
|
||||
"an ogre", "monster/ogro"},
|
||||
{GUN_CG, 18, 70, 2, 70, 10, 400, 2, 8, 9, S_PAINR, S_DEATHR, "a rhino",
|
||||
"monster/rhino"},
|
||||
@"an ogre", @"monster/ogro"},
|
||||
{GUN_CG, 18, 70, 2, 70, 10, 400, 2, 8, 9, S_PAINR, S_DEATHR, @"a rhino",
|
||||
@"monster/rhino"},
|
||||
{GUN_SG, 14, 120, 1, 100, 300, 400, 4, 14, 14, S_PAINE, S_DEATHE,
|
||||
"ratamahatta", "monster/rat"},
|
||||
@"ratamahatta", @"monster/rat"},
|
||||
{GUN_RIFLE, 15, 200, 1, 80, 300, 300, 4, 18, 18, S_PAINS, S_DEATHS,
|
||||
"a slith", "monster/slith"},
|
||||
{GUN_RL, 13, 500, 1, 0, 100, 200, 6, 24, 24, S_PAINB, S_DEATHB, "bauul",
|
||||
"monster/bauul"},
|
||||
@"a slith", @"monster/slith"},
|
||||
{GUN_RL, 13, 500, 1, 0, 100, 200, 6, 24, 24, S_PAINB, S_DEATHB, @"bauul",
|
||||
@"monster/bauul"},
|
||||
{GUN_BITE, 22, 50, 3, 0, 100, 400, 1, 12, 15, S_PAINP, S_PIGGR2,
|
||||
"a hellpig", "monster/hellpig"},
|
||||
@"a hellpig", @"monster/hellpig"},
|
||||
{GUN_ICEBALL, 12, 250, 1, 0, 10, 400, 6, 18, 18, S_PAINH, S_DEATHH,
|
||||
"a knight", "monster/knight"},
|
||||
@"a knight", @"monster/knight"},
|
||||
{GUN_SLIMEBALL, 15, 100, 1, 0, 200, 400, 2, 13, 10, S_PAIND, S_DEATHD,
|
||||
"a goblin", "monster/goblin"},
|
||||
@"a goblin", @"monster/goblin"},
|
||||
};
|
||||
|
||||
dynent *
|
||||
|
|
@ -54,7 +54,7 @@ basicmonster(int type, int yaw, int state, int trigger, int move)
|
|||
if (type >= NUMMONSTERTYPES) {
|
||||
conoutf(@"warning: unknown monster in spawn: %d", type);
|
||||
type = 0;
|
||||
};
|
||||
}
|
||||
dynent *m = newdynent();
|
||||
monstertype *t = &monstertypes[m->mtype = type];
|
||||
m->eyeheight = 2.0f;
|
||||
|
|
@ -78,7 +78,9 @@ basicmonster(int type, int yaw, int state, int trigger, int move)
|
|||
m->roll = 0;
|
||||
m->state = CS_ALIVE;
|
||||
m->anger = 0;
|
||||
strcpy_s(m->name, t->name);
|
||||
@autoreleasepool {
|
||||
strcpy_s(m->name, t->name.UTF8String);
|
||||
}
|
||||
monsters.add(m);
|
||||
return m;
|
||||
};
|
||||
|
|
@ -406,4 +408,4 @@ monsterrender()
|
|||
loopv(monsters) renderclient(monsters[i], false,
|
||||
monstertypes[monsters[i]->mtype].mdlname, monsters[i]->mtype == 5,
|
||||
monstertypes[monsters[i]->mtype].mscale / 10.0f);
|
||||
};
|
||||
}
|
||||
|
|
|
|||
28
src/protos.h
28
src/protos.h
|
|
@ -1,18 +1,18 @@
|
|||
// protos for ALL external functions in cube...
|
||||
|
||||
// command
|
||||
extern int variable(char *name, int min, int cur, int max, int *storage,
|
||||
extern int variable(OFString *name, int min, int cur, int max, int *storage,
|
||||
void (*fun)(), bool persist);
|
||||
extern void setvar(char *name, int i);
|
||||
extern int getvar(char *name);
|
||||
extern bool identexists(char *name);
|
||||
extern void setvar(OFString *name, int i);
|
||||
extern int getvar(OFString *name);
|
||||
extern bool identexists(OFString *name);
|
||||
extern bool addcommand(OFString *name, void (*fun)(), int narg);
|
||||
extern int execute(char *p, bool down = true);
|
||||
extern void exec(char *cfgfile);
|
||||
extern bool execfile(char *cfgfile);
|
||||
extern void exec(OFString *cfgfile);
|
||||
extern bool execfile(OFString *cfgfile);
|
||||
extern void resetcomplete();
|
||||
extern void complete(char *s);
|
||||
extern void alias(char *name, char *action);
|
||||
extern void alias(OFString *name, OFString *action);
|
||||
extern OFString *getalias(OFString *name);
|
||||
extern void writecfg();
|
||||
|
||||
|
|
@ -33,10 +33,10 @@ extern void menuset(int menu);
|
|||
extern void menumanual(int m, int n, char *text);
|
||||
extern void sortmenu(int start, int num);
|
||||
extern bool menukey(int code, bool isdown);
|
||||
extern void newmenu(char *name);
|
||||
extern void newmenu(OFString *name);
|
||||
|
||||
// serverbrowser
|
||||
extern void addserver(char *servername);
|
||||
extern void addserver(OFString *servername);
|
||||
extern char *getservername(int n);
|
||||
extern void writeservercfg();
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ extern void setarraypointers();
|
|||
|
||||
// client
|
||||
extern void localservertoclient(uchar *buf, int len);
|
||||
extern void connects(char *servername);
|
||||
extern void connects(OFString *servername);
|
||||
extern void disconnect(int onlyclean = 0, int async = 0);
|
||||
extern void toserver(char *text);
|
||||
extern void addmsg(int rel, int num, int type, ...);
|
||||
|
|
@ -106,7 +106,7 @@ extern void fixplayer1range();
|
|||
// clientextras
|
||||
extern void renderclients();
|
||||
extern void renderclient(
|
||||
dynent *d, bool team, char *mdlname, bool hellpig, float scale);
|
||||
dynent *d, bool team, OFString *mdlname, bool hellpig, float scale);
|
||||
void showscores(bool on);
|
||||
extern void renderscores();
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ extern void trigger(int tag, int type, bool savegame);
|
|||
extern void resettagareas();
|
||||
extern void settagareas();
|
||||
extern entity *newentity(
|
||||
int x, int y, int z, char *what, int v1, int v2, int v3, int v4);
|
||||
int x, int y, int z, OFString *what, int v1, int v2, int v3, int v4);
|
||||
|
||||
// worldlight
|
||||
extern void calclight();
|
||||
|
|
@ -182,7 +182,7 @@ extern void particle_trail(int type, int fade, vec &from, vec &to);
|
|||
extern void render_particles(int time);
|
||||
|
||||
// worldio
|
||||
extern void save_world(const char *fname);
|
||||
extern void save_world(OFString *fname);
|
||||
extern void load_world(char *mname);
|
||||
extern void writemap(char *mname, int msize, uchar *mdata);
|
||||
extern uchar *readmap(const char *mname, int *msize);
|
||||
|
|
@ -208,7 +208,7 @@ extern void initsound();
|
|||
extern void cleansound();
|
||||
|
||||
// rendermd2
|
||||
extern void rendermodel(char *mdl, int frame, int range, int tex, float rad,
|
||||
extern void rendermodel(OFString *mdl, int frame, int range, int tex, float rad,
|
||||
float x, float y, float z, float yaw, float pitch, bool teammate,
|
||||
float scale, float speed, int snap = 0, int basetime = 0);
|
||||
extern mapmodelinfo *getmminfo(int i);
|
||||
|
|
|
|||
|
|
@ -147,30 +147,30 @@ renderspheres(int time)
|
|||
};
|
||||
|
||||
string closeent;
|
||||
char *entnames[] = {
|
||||
"none?",
|
||||
"light",
|
||||
"playerstart",
|
||||
"shells",
|
||||
"bullets",
|
||||
"rockets",
|
||||
"riflerounds",
|
||||
"health",
|
||||
"healthboost",
|
||||
"greenarmour",
|
||||
"yellowarmour",
|
||||
"quaddamage",
|
||||
"teleport",
|
||||
"teledest",
|
||||
"mapmodel",
|
||||
"monster",
|
||||
"trigger",
|
||||
"jumppad",
|
||||
"?",
|
||||
"?",
|
||||
"?",
|
||||
"?",
|
||||
"?",
|
||||
OFString *entnames[] = {
|
||||
@"none?",
|
||||
@"light",
|
||||
@"playerstart",
|
||||
@"shells",
|
||||
@"bullets",
|
||||
@"rockets",
|
||||
@"riflerounds",
|
||||
@"health",
|
||||
@"healthboost",
|
||||
@"greenarmour",
|
||||
@"yellowarmour",
|
||||
@"quaddamage",
|
||||
@"teleport",
|
||||
@"teledest",
|
||||
@"mapmodel",
|
||||
@"monster",
|
||||
@"trigger",
|
||||
@"jumppad",
|
||||
@"?",
|
||||
@"?",
|
||||
@"?",
|
||||
@"?",
|
||||
@"?",
|
||||
};
|
||||
|
||||
void
|
||||
|
|
@ -190,31 +190,38 @@ renderents() // show sparkly thingies for map entities in edit mode
|
|||
int e = closestent();
|
||||
if (e >= 0) {
|
||||
entity &c = ents[e];
|
||||
sprintf_s(closeent)("closest entity = %s (%d, %d, %d, %d), "
|
||||
@autoreleasepool {
|
||||
sprintf_s(closeent)(
|
||||
"closest entity = %s (%d, %d, %d, %d), "
|
||||
"selection = (%d, %d)",
|
||||
entnames[c.type], c.attr1, c.attr2, c.attr3, c.attr4,
|
||||
getvar("selxs"), getvar("selys"));
|
||||
};
|
||||
};
|
||||
entnames[c.type].UTF8String, c.attr1, c.attr2,
|
||||
c.attr3, c.attr4, getvar(@"selxs"),
|
||||
getvar(@"selys"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
loadsky(char *basename)
|
||||
loadsky(OFString *basename)
|
||||
{
|
||||
static string lastsky = "";
|
||||
if (strcmp(lastsky, basename) == 0)
|
||||
@autoreleasepool {
|
||||
static OFString *lastsky = @"";
|
||||
if ([lastsky isEqual:basename])
|
||||
return;
|
||||
char *side[] = {"ft", "bk", "lf", "rt", "dn", "up"};
|
||||
int texnum = 14;
|
||||
loopi(6)
|
||||
{
|
||||
sprintf_sd(name)("packages/%s_%s.jpg", basename, side[i]);
|
||||
sprintf_sd(name)(
|
||||
"packages/%s_%s.jpg", basename.UTF8String, side[i]);
|
||||
int xs, ys;
|
||||
if (!installtex(texnum + i, path(name), xs, ys, true))
|
||||
conoutf(@"could not load sky textures");
|
||||
};
|
||||
strcpy_s(lastsky, basename);
|
||||
}
|
||||
COMMAND(loadsky, ARG_1CSTR)
|
||||
lastsky = basename;
|
||||
}
|
||||
}
|
||||
COMMAND(loadsky, ARG_1STR)
|
||||
|
||||
float cursordepth = 0.9f;
|
||||
GLint viewport[4];
|
||||
|
|
|
|||
|
|
@ -150,16 +150,18 @@ texturereset()
|
|||
COMMAND(texturereset, ARG_NONE)
|
||||
|
||||
void
|
||||
texture(char *aframe, char *name)
|
||||
texture(OFString *aframe, OFString *name)
|
||||
{
|
||||
int num = curtexnum++, frame = atoi(aframe);
|
||||
@autoreleasepool {
|
||||
int num = curtexnum++, frame = (int)aframe.longLongValue;
|
||||
if (num < 0 || num >= 256 || frame < 0 || frame >= MAXFRAMES)
|
||||
return;
|
||||
mapping[num][frame] = 1;
|
||||
char *n = mapname[num][frame];
|
||||
strcpy_s(n, name);
|
||||
strcpy_s(n, name.UTF8String);
|
||||
path(n);
|
||||
}
|
||||
}
|
||||
COMMAND(texture, ARG_2STR)
|
||||
|
||||
int
|
||||
|
|
@ -302,8 +304,8 @@ VAR(fogcolour, 0, 0x8099B3, 0xFFFFFF);
|
|||
|
||||
VARP(hudgun, 0, 1, 1);
|
||||
|
||||
char *hudgunnames[] = {"hudguns/fist", "hudguns/shotg", "hudguns/chaing",
|
||||
"hudguns/rocket", "hudguns/rifle"};
|
||||
OFString *hudgunnames[] = {@"hudguns/fist", @"hudguns/shotg", @"hudguns/chaing",
|
||||
@"hudguns/rocket", @"hudguns/rifle"};
|
||||
|
||||
void
|
||||
drawhudmodel(int start, int end, float speed, int base)
|
||||
|
|
@ -311,7 +313,7 @@ drawhudmodel(int start, int end, float speed, int base)
|
|||
rendermodel(hudgunnames[player1->gunselect], start, end, 0, 1.0f,
|
||||
player1->o.x, player1->o.z, player1->o.y, player1->yaw + 90,
|
||||
player1->pitch, false, 1.0f, speed, 0, base);
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
drawhudgun(float fovy, float aspect, int farplane)
|
||||
|
|
|
|||
|
|
@ -216,34 +216,37 @@ delayedload(md2 *m)
|
|||
int xs, ys;
|
||||
installtex(FIRSTMDL + m->mdlnum, path(name2), xs, ys);
|
||||
m->loaded = true;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
int modelnum = 0;
|
||||
|
||||
md2 *
|
||||
loadmodel(char *name)
|
||||
loadmodel(OFString *name)
|
||||
{
|
||||
@autoreleasepool {
|
||||
if (!mdllookup)
|
||||
mdllookup = new hashtable<md2 *>;
|
||||
md2 **mm = mdllookup->access(name);
|
||||
md2 **mm = mdllookup->access(name.UTF8String);
|
||||
if (mm)
|
||||
return *mm;
|
||||
md2 *m = new md2();
|
||||
m->mdlnum = modelnum++;
|
||||
mapmodelinfo mmi = {2, 2, 0, 0, ""};
|
||||
m->mmi = mmi;
|
||||
m->loadname = newstring(name);
|
||||
m->loadname = newstring(name.UTF8String);
|
||||
mdllookup->access(m->loadname, &m);
|
||||
return m;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
mapmodel(char *rad, char *h, char *zoff, char *snap, char *name)
|
||||
mapmodel(
|
||||
OFString *rad, OFString *h, OFString *zoff, OFString *snap, OFString *name)
|
||||
{
|
||||
md2 *m = loadmodel(name);
|
||||
mapmodelinfo mmi = {
|
||||
atoi(rad), atoi(h), atoi(zoff), atoi(snap), m->loadname};
|
||||
mapmodelinfo mmi = {(int)rad.longLongValue, (int)h.longLongValue,
|
||||
(int)zoff.longLongValue, (int)snap.longLongValue, m->loadname};
|
||||
m->mmi = mmi;
|
||||
mapmodels.add(m);
|
||||
}
|
||||
|
|
@ -263,7 +266,7 @@ getmminfo(int i)
|
|||
}
|
||||
|
||||
void
|
||||
rendermodel(char *mdl, int frame, int range, int tex, float rad, float x,
|
||||
rendermodel(OFString *mdl, int frame, int range, int tex, float rad, float x,
|
||||
float y, float z, float yaw, float pitch, bool teammate, float scale,
|
||||
float speed, int snap, int basetime)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -119,18 +119,20 @@ savestate(char *fn)
|
|||
}
|
||||
|
||||
void
|
||||
savegame(char *name)
|
||||
savegame(OFString *name)
|
||||
{
|
||||
@autoreleasepool {
|
||||
if (!m_classicsp) {
|
||||
conoutf(@"can only save classic sp games");
|
||||
return;
|
||||
}
|
||||
sprintf_sd(fn)("savegames/%s.csgz", name);
|
||||
sprintf_sd(fn)("savegames/%s.csgz", name.UTF8String);
|
||||
savestate(fn);
|
||||
stop();
|
||||
conoutf(@"wrote %s", fn);
|
||||
}
|
||||
COMMAND(savegame, ARG_1CSTR)
|
||||
}
|
||||
COMMAND(savegame, ARG_1STR)
|
||||
|
||||
void
|
||||
loadstate(char *fn)
|
||||
|
|
@ -157,9 +159,9 @@ loadstate(char *fn)
|
|||
gzread(f, mapname, _MAXDEFSTR);
|
||||
nextmode = gzgeti();
|
||||
@autoreleasepool {
|
||||
changemap(
|
||||
@(mapname)); // continue below once map has been loaded and
|
||||
// client & server have updated
|
||||
// continue below once map has been loaded and client & server
|
||||
// have updated
|
||||
changemap(@(mapname));
|
||||
}
|
||||
return;
|
||||
out:
|
||||
|
|
@ -169,12 +171,14 @@ out:
|
|||
}
|
||||
|
||||
void
|
||||
loadgame(char *name)
|
||||
loadgame(OFString *name)
|
||||
{
|
||||
sprintf_sd(fn)("savegames/%s.csgz", name);
|
||||
@autoreleasepool {
|
||||
sprintf_sd(fn)("savegames/%s.csgz", name.UTF8String);
|
||||
loadstate(fn);
|
||||
}
|
||||
COMMAND(loadgame, ARG_1CSTR)
|
||||
}
|
||||
COMMAND(loadgame, ARG_1STR)
|
||||
|
||||
void
|
||||
loadgameout()
|
||||
|
|
@ -243,16 +247,17 @@ int ddamage, bdamage;
|
|||
vec dorig;
|
||||
|
||||
void
|
||||
record(char *name)
|
||||
record(OFString *name)
|
||||
{
|
||||
@autoreleasepool {
|
||||
if (m_sp) {
|
||||
conoutf(@"cannot record singleplayer games");
|
||||
return;
|
||||
};
|
||||
}
|
||||
int cn = getclientnum();
|
||||
if (cn < 0)
|
||||
return;
|
||||
sprintf_sd(fn)("demos/%s.cdgz", name);
|
||||
sprintf_sd(fn)("demos/%s.cdgz", name.UTF8String);
|
||||
savestate(fn);
|
||||
gzputi(cn);
|
||||
conoutf(@"started recording demo to %s", fn);
|
||||
|
|
@ -260,7 +265,8 @@ record(char *name)
|
|||
starttime = lastmillis;
|
||||
ddamage = bdamage = 0;
|
||||
}
|
||||
COMMAND(record, ARG_1CSTR)
|
||||
}
|
||||
COMMAND(record, ARG_1STR)
|
||||
|
||||
void
|
||||
demodamage(int damage, vec &o)
|
||||
|
|
@ -306,13 +312,15 @@ incomingdemodata(uchar *buf, int len, bool extras)
|
|||
}
|
||||
|
||||
void
|
||||
demo(char *name)
|
||||
demo(OFString *name)
|
||||
{
|
||||
sprintf_sd(fn)("demos/%s.cdgz", name);
|
||||
@autoreleasepool {
|
||||
sprintf_sd(fn)("demos/%s.cdgz", name.UTF8String);
|
||||
loadstate(fn);
|
||||
demoloading = true;
|
||||
}
|
||||
COMMAND(demo, ARG_1CSTR)
|
||||
}
|
||||
COMMAND(demo, ARG_1STR)
|
||||
|
||||
void
|
||||
stopreset()
|
||||
|
|
|
|||
|
|
@ -147,12 +147,15 @@ char *
|
|||
getservername(int n)
|
||||
{
|
||||
return servers[n].name;
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
addserver(char *servername)
|
||||
addserver(OFString *servername_)
|
||||
{
|
||||
loopv(servers) if (strcmp(servers[i].name, servername) == 0) return;
|
||||
@autoreleasepool {
|
||||
const char *servername = servername_.UTF8String;
|
||||
loopv(servers) if (strcmp(servers[i].name, servername) ==
|
||||
0) return;
|
||||
serverinfo &si = servers.insert(0, serverinfo());
|
||||
strcpy_s(si.name, servername);
|
||||
si.full[0] = 0;
|
||||
|
|
@ -165,7 +168,8 @@ addserver(char *servername)
|
|||
si.sdesc[0] = 0;
|
||||
si.address.host = ENET_HOST_ANY;
|
||||
si.address.port = CUBE_SERVINFO_PORT;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
pingservers()
|
||||
|
|
@ -314,7 +318,7 @@ updatefrommaster()
|
|||
servermenu();
|
||||
}
|
||||
|
||||
COMMAND(addserver, ARG_1CSTR)
|
||||
COMMAND(addserver, ARG_1STR)
|
||||
COMMAND(servermenu, ARG_NONE)
|
||||
COMMAND(updatefrommaster, ARG_NONE)
|
||||
|
||||
|
|
@ -327,4 +331,4 @@ writeservercfg()
|
|||
fprintf(f, "// servers connected to are added here automatically\n\n");
|
||||
loopvrev(servers) fprintf(f, "addserver %s\n", servers[i].name);
|
||||
fclose(f);
|
||||
};
|
||||
}
|
||||
|
|
|
|||
40
src/sound.mm
40
src/sound.mm
|
|
@ -74,45 +74,47 @@ initsound()
|
|||
if (!FSOUND_Init(SOUNDFREQ, MAXCHAN, FSOUND_INIT_GLOBALFOCUS)) {
|
||||
conoutf(@"sound init failed (FMOD): %d", FSOUND_GetError());
|
||||
nosound = true;
|
||||
};
|
||||
}
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
music(char *name)
|
||||
music(OFString *name)
|
||||
{
|
||||
if (nosound)
|
||||
return;
|
||||
stopsound();
|
||||
if (soundvol && musicvol) {
|
||||
@autoreleasepool {
|
||||
string sn;
|
||||
strcpy_s(sn, "packages/");
|
||||
strcat_s(sn, name);
|
||||
strcat_s(sn, name.UTF8String);
|
||||
#ifdef USE_MIXER
|
||||
if (mod = Mix_LoadMUS(path(sn))) {
|
||||
Mix_PlayMusic(mod, -1);
|
||||
Mix_VolumeMusic((musicvol * MAXVOL) / 255);
|
||||
};
|
||||
}
|
||||
#else
|
||||
if (mod = FMUSIC_LoadSong(path(sn))) {
|
||||
FMUSIC_PlaySong(mod);
|
||||
FMUSIC_SetMasterVolume(mod, musicvol);
|
||||
} else if (stream = FSOUND_Stream_Open(
|
||||
path(sn), FSOUND_LOOP_NORMAL, 0, 0)) {
|
||||
int chan = FSOUND_Stream_Play(FSOUND_FREE, stream);
|
||||
int chan =
|
||||
FSOUND_Stream_Play(FSOUND_FREE, stream);
|
||||
if (chan >= 0) {
|
||||
FSOUND_SetVolume(
|
||||
chan, (musicvol * MAXVOL) / 255);
|
||||
FSOUND_SetPaused(chan, false);
|
||||
};
|
||||
}
|
||||
} else {
|
||||
conoutf(@"could not play music: %s", sn);
|
||||
};
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
COMMAND(music, ARG_1CSTR)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
COMMAND(music, ARG_1STR)
|
||||
|
||||
#ifdef USE_MIXER
|
||||
vector<Mix_Chunk *> samples;
|
||||
|
|
@ -129,8 +131,7 @@ registersound(char *name)
|
|||
snames.add(newstring(name));
|
||||
samples.add(NULL);
|
||||
return samples.length() - 1;
|
||||
};
|
||||
|
||||
}
|
||||
COMMAND(registersound, ARG_1EST)
|
||||
|
||||
void
|
||||
|
|
@ -161,10 +162,9 @@ updatechanvol(int chan, vec *loc)
|
|||
player1->yaw *
|
||||
(PI / 180.0f); // relative angle of
|
||||
// sound along X-Y axis
|
||||
pan = int(
|
||||
255.9f *
|
||||
(0.5 * sin(yaw) +
|
||||
0.5f)); // range is from 0 (left) to 255 (right)
|
||||
pan = int(255.9f * (0.5 * sin(yaw) +
|
||||
0.5f)); // range is from 0 (left)
|
||||
// to 255 (right)
|
||||
};
|
||||
};
|
||||
vol = (vol * MAXVOL) / 255;
|
||||
|
|
@ -225,8 +225,8 @@ playsound(int n, vec *loc)
|
|||
soundsatonce = 1;
|
||||
lastsoundmillis = lastmillis;
|
||||
if (soundsatonce > 5)
|
||||
return; // avoid bursts of sounds with heavy packetloss and in
|
||||
// sp
|
||||
return; // avoid bursts of sounds with heavy packetloss
|
||||
// and in sp
|
||||
if (n < 0 || n >= samples.length()) {
|
||||
conoutf(@"unregistered sound: %d", n);
|
||||
return;
|
||||
|
|
|
|||
15
src/tools.h
15
src/tools.h
|
|
@ -320,7 +320,7 @@ template <class T> struct vector {
|
|||
template <class T> struct hashtable {
|
||||
struct chain {
|
||||
chain *next;
|
||||
char *key;
|
||||
const char *key;
|
||||
T data;
|
||||
};
|
||||
|
||||
|
|
@ -344,14 +344,15 @@ template <class T> struct hashtable {
|
|||
void operator=(hashtable<T> &v);
|
||||
|
||||
T *
|
||||
access(char *key, T *data = NULL)
|
||||
access(const char *key, T *data = NULL)
|
||||
{
|
||||
unsigned int h = 5381;
|
||||
for (int i = 0, k; k = key[i]; i++)
|
||||
h = ((h << 5) + h) ^ k; // bernstein k=33 xor
|
||||
h = h & (size - 1); // primes not much of an advantage
|
||||
for (chain *c = table[h]; c; c = c->next) {
|
||||
for (char *p1 = key, *p2 = c->key, ch;
|
||||
char ch;
|
||||
for (const char *p1 = key, *p2 = c->key;
|
||||
(ch = *p1++) == *p2++;)
|
||||
if (!ch) // if(strcmp(key,c->key)==0)
|
||||
{
|
||||
|
|
@ -359,8 +360,8 @@ template <class T> struct hashtable {
|
|||
if (data)
|
||||
c->data = *data;
|
||||
return d;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
if (data) {
|
||||
chain *c = (chain *)parent->alloc(sizeof(chain));
|
||||
c->data = *data;
|
||||
|
|
@ -368,9 +369,9 @@ template <class T> struct hashtable {
|
|||
c->next = table[h];
|
||||
table[h] = c;
|
||||
numelems++;
|
||||
};
|
||||
}
|
||||
return NULL;
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
#define enumerate(ht, t, e, b) \
|
||||
|
|
|
|||
|
|
@ -60,10 +60,13 @@ reloadtime(int gun)
|
|||
};
|
||||
|
||||
void
|
||||
weapon(char *a1, char *a2, char *a3)
|
||||
weapon(OFString *a1, OFString *a2, OFString *a3)
|
||||
{
|
||||
selectgun(a1[0] ? atoi(a1) : -1, a2[0] ? atoi(a2) : -1,
|
||||
a3[0] ? atoi(a3) : -1);
|
||||
@autoreleasepool {
|
||||
selectgun(a1.UTF8String[0] ? atoi(a1.UTF8String) : -1,
|
||||
a2.UTF8String[0] ? atoi(a2.UTF8String) : -1,
|
||||
a3.UTF8String[0] ? atoi(a3.UTF8String) : -1);
|
||||
}
|
||||
}
|
||||
COMMAND(weapon, ARG_3STR)
|
||||
|
||||
|
|
|
|||
42
src/world.mm
42
src/world.mm
|
|
@ -2,7 +2,9 @@
|
|||
|
||||
#include "cube.h"
|
||||
|
||||
extern char *entnames[]; // lookup from map entities above to strings
|
||||
#include <memory>
|
||||
|
||||
extern OFString *entnames[]; // lookup from map entities above to strings
|
||||
|
||||
sqr *world = NULL;
|
||||
int sfactor, ssize, cubicsize, mipsize;
|
||||
|
|
@ -58,12 +60,22 @@ trigger(int tag, int type, bool savegame)
|
|||
{
|
||||
if (!tag)
|
||||
return;
|
||||
|
||||
settag(tag, type);
|
||||
|
||||
if (!savegame && type != 3)
|
||||
playsound(S_RUMBLE);
|
||||
sprintf_sd(aliasname)("level_trigger_%d", tag);
|
||||
if (identexists(aliasname))
|
||||
execute(aliasname);
|
||||
|
||||
@autoreleasepool {
|
||||
OFString *aliasname =
|
||||
[OFString stringWithFormat:@"level_trigger_%d", tag];
|
||||
|
||||
if (identexists(aliasname)) {
|
||||
std::unique_ptr<char> cmd(strdup(aliasname.UTF8String));
|
||||
execute(cmd.get());
|
||||
}
|
||||
}
|
||||
|
||||
if (type == 2)
|
||||
endsp(false);
|
||||
}
|
||||
|
|
@ -80,7 +92,7 @@ remip(block &b, int level)
|
|||
{
|
||||
if (level >= SMALLEST_FACTOR)
|
||||
return;
|
||||
int lighterr = getvar("lighterror") * 3;
|
||||
int lighterr = getvar(@"lighterror") * 3;
|
||||
sqr *w = wmip[level];
|
||||
sqr *v = wmip[level + 1];
|
||||
int ws = ssize >> level;
|
||||
|
|
@ -296,23 +308,27 @@ delent()
|
|||
return;
|
||||
};
|
||||
int t = ents[e].type;
|
||||
conoutf(@"%s entity deleted", entnames[t]);
|
||||
@autoreleasepool {
|
||||
conoutf(@"%s entity deleted", entnames[t].UTF8String);
|
||||
}
|
||||
ents[e].type = NOTUSED;
|
||||
addmsg(1, 10, SV_EDITENT, e, NOTUSED, 0, 0, 0, 0, 0, 0, 0);
|
||||
if (t == LIGHT)
|
||||
calclight();
|
||||
};
|
||||
}
|
||||
|
||||
int
|
||||
findtype(char *what)
|
||||
findtype(OFString *what)
|
||||
{
|
||||
loopi(MAXENTTYPES) if (strcmp(what, entnames[i]) == 0) return i;
|
||||
conoutf(@"unknown entity type \"%s\"", what);
|
||||
@autoreleasepool {
|
||||
loopi(MAXENTTYPES) if ([what isEqual:entnames[i]]) return i;
|
||||
conoutf(@"unknown entity type \"%s\"", what.UTF8String);
|
||||
return NOTUSED;
|
||||
}
|
||||
}
|
||||
|
||||
entity *
|
||||
newentity(int x, int y, int z, char *what, int v1, int v2, int v3, int v4)
|
||||
newentity(int x, int y, int z, OFString *what, int v1, int v2, int v3, int v4)
|
||||
{
|
||||
int type = findtype(what);
|
||||
persistent_entity e = {(short)x, (short)y, (short)z, (short)v1,
|
||||
|
|
@ -346,7 +362,7 @@ newentity(int x, int y, int z, char *what, int v1, int v2, int v3, int v4)
|
|||
};
|
||||
|
||||
void
|
||||
clearents(char *name)
|
||||
clearents(OFString *name)
|
||||
{
|
||||
int type = findtype(name);
|
||||
if (noteditmode() || multiplayer())
|
||||
|
|
@ -360,7 +376,7 @@ clearents(char *name)
|
|||
if (type == LIGHT)
|
||||
calclight();
|
||||
}
|
||||
COMMAND(clearents, ARG_1CSTR)
|
||||
COMMAND(clearents, ARG_1STR)
|
||||
|
||||
void
|
||||
scalecomp(uchar &c, int intens)
|
||||
|
|
|
|||
105
src/worldio.mm
105
src/worldio.mm
|
|
@ -7,7 +7,7 @@ backup(char *name, char *backupname)
|
|||
{
|
||||
remove(backupname);
|
||||
rename(name, backupname);
|
||||
};
|
||||
}
|
||||
|
||||
string cgzname, bakname, pcfname, mcfname;
|
||||
|
||||
|
|
@ -43,7 +43,7 @@ inline bool
|
|||
nhf(sqr *s)
|
||||
{
|
||||
return s->type != FHF && s->type != CHF;
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
voptimize() // reset vdeltas on non-hf cubes
|
||||
|
|
@ -57,8 +57,8 @@ voptimize() // reset vdeltas on non-hf cubes
|
|||
s->vdelta = 0;
|
||||
} else
|
||||
s->vdelta = 0;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
topt(sqr *s, bool &wf, bool &uf, int &wt, int &ut)
|
||||
|
|
@ -77,28 +77,28 @@ topt(sqr *s, bool &wf, bool &uf, int &wt, int &ut)
|
|||
wt = s->wtex;
|
||||
ut = s->utex;
|
||||
return;
|
||||
};
|
||||
}
|
||||
} else {
|
||||
loopi(4) if (!SOLID(o[i]))
|
||||
{
|
||||
if (o[i]->floor < s->floor) {
|
||||
wt = s->wtex;
|
||||
wf = false;
|
||||
};
|
||||
}
|
||||
if (o[i]->ceil > s->ceil) {
|
||||
ut = s->utex;
|
||||
uf = false;
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
toptimize() // FIXME: only does 2x2, make atleast for 4x4 also
|
||||
{
|
||||
bool wf[4], uf[4];
|
||||
sqr *s[4];
|
||||
for (int x = 2; x < ssize - 4; x += 2)
|
||||
for (int x = 2; x < ssize - 4; x += 2) {
|
||||
for (int y = 2; y < ssize - 4; y += 2) {
|
||||
s[0] = S(x, y);
|
||||
int wt = s[0]->wtex, ut = s[0]->utex;
|
||||
|
|
@ -115,9 +115,10 @@ toptimize() // FIXME: only does 2x2, make atleast for 4x4 also
|
|||
s[i]->wtex = wt;
|
||||
if (uf[i])
|
||||
s[i]->utex = ut;
|
||||
};
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// these two are used by getmap/sendmap.. transfers compressed maps directly
|
||||
|
||||
|
|
@ -130,7 +131,7 @@ writemap(char *mname, int msize, uchar *mdata)
|
|||
if (!f) {
|
||||
conoutf(@"could not write map to %s", cgzname);
|
||||
return;
|
||||
};
|
||||
}
|
||||
fwrite(mdata, 1, msize, f);
|
||||
fclose(f);
|
||||
conoutf(@"wrote map %s as file %s", mname, cgzname);
|
||||
|
|
@ -144,7 +145,7 @@ readmap(const char *mname, int *msize)
|
|||
if (!mdata) {
|
||||
conoutf(@"could not read map %s", cgzname);
|
||||
return NULL;
|
||||
};
|
||||
}
|
||||
return mdata;
|
||||
}
|
||||
|
||||
|
|
@ -154,22 +155,22 @@ readmap(const char *mname, int *msize)
|
|||
// miniscule map sizes.
|
||||
|
||||
void
|
||||
save_world(const char *mname)
|
||||
save_world(OFString *mname)
|
||||
{
|
||||
@autoreleasepool {
|
||||
resettagareas(); // wouldn't be able to reproduce tagged areas
|
||||
// otherwise
|
||||
voptimize();
|
||||
toptimize();
|
||||
if (!*mname)
|
||||
mname = getclientmap().UTF8String;
|
||||
setnames(mname);
|
||||
if (mname.length == 0)
|
||||
mname = getclientmap();
|
||||
setnames(mname.UTF8String);
|
||||
backup(cgzname, bakname);
|
||||
gzFile f = gzopen(cgzname, "wb9");
|
||||
if (!f) {
|
||||
conoutf(@"could not write map to %s", cgzname);
|
||||
return;
|
||||
};
|
||||
}
|
||||
hdr.version = MAPVERSION;
|
||||
hdr.numents = 0;
|
||||
loopv(ents) if (ents[i].type != NOTUSED) hdr.numents++;
|
||||
|
|
@ -183,8 +184,8 @@ save_world(const char *mname)
|
|||
entity tmp = ents[i];
|
||||
endianswap(&tmp, sizeof(short), 4);
|
||||
gzwrite(f, &tmp, sizeof(persistent_entity));
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
sqr *t = NULL;
|
||||
int sc = 0;
|
||||
#define spurge \
|
||||
|
|
@ -197,7 +198,7 @@ save_world(const char *mname)
|
|||
gzputc(f, sc); \
|
||||
sc = 0; \
|
||||
} \
|
||||
};
|
||||
}
|
||||
loopk(cubicsize)
|
||||
{
|
||||
sqr *s = &world[k];
|
||||
|
|
@ -216,7 +217,7 @@ save_world(const char *mname)
|
|||
gzputc(f, s->type);
|
||||
gzputc(f, s->wtex);
|
||||
gzputc(f, s->vdelta);
|
||||
};
|
||||
}
|
||||
} else {
|
||||
if (t && c(type) && c(floor) && c(ceil) &&
|
||||
c(ctex) && c(ftex) && c(utex) && c(wtex) &&
|
||||
|
|
@ -233,16 +234,17 @@ save_world(const char *mname)
|
|||
gzputc(f, s->vdelta);
|
||||
gzputc(f, s->utex);
|
||||
gzputc(f, s->tag);
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
t = s;
|
||||
};
|
||||
}
|
||||
spurge;
|
||||
gzclose(f);
|
||||
conoutf(@"wrote map file %s", cgzname);
|
||||
settagareas();
|
||||
}
|
||||
}
|
||||
COMMANDN(savemap, save_world, ARG_1STR)
|
||||
|
||||
void
|
||||
load_world(char *mname) // still supports all map formats that have existed
|
||||
|
|
@ -256,7 +258,7 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
if (!f) {
|
||||
conoutf(@"could not read map %s", cgzname);
|
||||
return;
|
||||
};
|
||||
}
|
||||
gzread(f, &hdr, sizeof(header) - sizeof(int) * 16);
|
||||
endianswap(&hdr.version, sizeof(int), 4);
|
||||
if (strncmp(hdr.head, "CUBE", 4) != 0)
|
||||
|
|
@ -270,7 +272,7 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
endianswap(&hdr.waterlevel, sizeof(int), 16);
|
||||
} else {
|
||||
hdr.waterlevel = -100000;
|
||||
};
|
||||
}
|
||||
ents.setsize(0);
|
||||
loopi(hdr.numents)
|
||||
{
|
||||
|
|
@ -283,8 +285,8 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
e.attr2 = 255; // needed for MAPVERSION<=2
|
||||
if (e.attr1 > 32)
|
||||
e.attr1 = 32; // 12_03 and below
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
free(world);
|
||||
setupworld(hdr.sfactor);
|
||||
char texuse[256];
|
||||
|
|
@ -301,14 +303,14 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
memcpy(&world[k], t, sizeof(sqr));
|
||||
k--;
|
||||
break;
|
||||
};
|
||||
}
|
||||
case 254: // only in MAPVERSION<=2
|
||||
{
|
||||
memcpy(s, t, sizeof(sqr));
|
||||
s->r = s->g = s->b = gzgetc(f);
|
||||
gzgetc(f);
|
||||
break;
|
||||
};
|
||||
}
|
||||
case SOLID: {
|
||||
s->type = SOLID;
|
||||
s->wtex = gzgetc(f);
|
||||
|
|
@ -316,7 +318,7 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
if (hdr.version <= 2) {
|
||||
gzgetc(f);
|
||||
gzgetc(f);
|
||||
};
|
||||
}
|
||||
s->ftex = DEFAULT_FLOOR;
|
||||
s->ctex = DEFAULT_CEIL;
|
||||
s->utex = s->wtex;
|
||||
|
|
@ -324,13 +326,13 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
s->floor = 0;
|
||||
s->ceil = 16;
|
||||
break;
|
||||
};
|
||||
}
|
||||
default: {
|
||||
if (type < 0 || type >= MAXTYPE) {
|
||||
sprintf_sd(t)("%d @ %d", type, k);
|
||||
fatal("while reading map: type out of range: ",
|
||||
t);
|
||||
};
|
||||
}
|
||||
s->type = type;
|
||||
s->floor = gzgetc(f);
|
||||
s->ceil = gzgetc(f);
|
||||
|
|
@ -342,19 +344,19 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
if (hdr.version <= 2) {
|
||||
gzgetc(f);
|
||||
gzgetc(f);
|
||||
};
|
||||
}
|
||||
s->vdelta = gzgetc(f);
|
||||
s->utex = (hdr.version >= 2) ? gzgetc(f) : s->wtex;
|
||||
s->tag = (hdr.version >= 5) ? gzgetc(f) : 0;
|
||||
s->type = type;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
s->defer = 0;
|
||||
t = s;
|
||||
texuse[s->wtex] = 1;
|
||||
if (!SOLID(s))
|
||||
texuse[s->utex] = texuse[s->ftex] = texuse[s->ctex] = 1;
|
||||
};
|
||||
}
|
||||
gzclose(f);
|
||||
calclight();
|
||||
settagareas();
|
||||
|
|
@ -366,14 +368,17 @@ load_world(char *mname) // still supports all map formats that have existed
|
|||
startmap(mname);
|
||||
loopl(256)
|
||||
{
|
||||
sprintf_sd(aliasname)(
|
||||
"level_trigger_%d", l); // can this be done smarter?
|
||||
@autoreleasepool {
|
||||
// can this be done smarter?
|
||||
OFString *aliasname =
|
||||
[OFString stringWithFormat:@"level_trigger_%d", l];
|
||||
if (identexists(aliasname))
|
||||
alias(aliasname, "");
|
||||
};
|
||||
execfile("data/default_map_settings.cfg");
|
||||
execfile(pcfname);
|
||||
execfile(mcfname);
|
||||
alias(aliasname, @"");
|
||||
}
|
||||
}
|
||||
execfile(@"data/default_map_settings.cfg");
|
||||
@autoreleasepool {
|
||||
execfile(@(pcfname));
|
||||
execfile(@(mcfname));
|
||||
}
|
||||
}
|
||||
|
||||
COMMANDN(savemap, save_world, ARG_1CSTR)
|
||||
|
|
|
|||
|
|
@ -171,19 +171,19 @@ calclight()
|
|||
{
|
||||
sqr *s = S(x, y);
|
||||
s->r = s->g = s->b = 10;
|
||||
};
|
||||
}
|
||||
|
||||
loopv(ents)
|
||||
{
|
||||
entity &e = ents[i];
|
||||
if (e.type == LIGHT)
|
||||
calclightsource(e);
|
||||
};
|
||||
}
|
||||
|
||||
block b = {1, 1, ssize - 2, ssize - 2};
|
||||
postlightarea(b);
|
||||
setvar("fullbright", 0);
|
||||
};
|
||||
setvar(@"fullbright", 0);
|
||||
}
|
||||
|
||||
VARP(dynlight, 0, 16, 32);
|
||||
|
||||
|
|
@ -196,8 +196,8 @@ cleardlights()
|
|||
block *backup = dlights.pop();
|
||||
blockpaste(*backup);
|
||||
free(backup);
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
dodynlight(vec &vold, vec &v, int reach, int strength, dynent *owner)
|
||||
|
|
@ -230,7 +230,7 @@ dodynlight(vec &vold, vec &v, int reach, int strength, dynent *owner)
|
|||
LIGHT, (uchar)strength, 0, 0};
|
||||
calclightsource(l);
|
||||
postlightarea(b);
|
||||
};
|
||||
}
|
||||
|
||||
// utility functions also used by editing code
|
||||
|
||||
|
|
@ -244,7 +244,7 @@ blockcopy(block &s)
|
|||
for (int y = s.y; y < s.ys + s.y; y++)
|
||||
*q++ = *S(x, y);
|
||||
return b;
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
blockpaste(block &b)
|
||||
|
|
@ -254,4 +254,4 @@ blockpaste(block &b)
|
|||
for (int y = b.y; y < b.ys + b.y; y++)
|
||||
*S(x, y) = *q++;
|
||||
remipmore(b);
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,10 +24,10 @@ computeraytable(float vx, float vy)
|
|||
if (!ocull)
|
||||
return;
|
||||
|
||||
odist = getvar("fog") * 1.5f;
|
||||
odist = getvar(@"fog") * 1.5f;
|
||||
|
||||
float apitch = (float)fabs(player1->pitch);
|
||||
float af = getvar("fov") / 2 + apitch / 1.5f + 3;
|
||||
float af = getvar(@"fov") / 2 + apitch / 1.5f + 3;
|
||||
float byaw = (player1->yaw - 90 + af) / 360 * PI2;
|
||||
float syaw = (player1->yaw - 90 - af) / 360 * PI2;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue