quakeforge/tools/Forge/Bundles/MapEdit/Entity.m

447 lines
8.2 KiB
Mathematica
Raw Normal View History

#include "QF/dstring.h"
#include "QF/script.h"
#include "QF/sys.h"
#include "Entity.h"
#include "EntityClass.h"
#include "TexturePalette.h"
#include "SetBrush.h"
#include "Map.h"
#include "CameraView.h"
#define THING Entity
#include "THING+NSArray.m"
@implementation Entity
vec3_t bad_mins = { -8, -8, -8 };
vec3_t bad_maxs = { 8, 8, 8 };
-createFixedBrush:(vec3_t) org
{
vec3_t emins, emaxs;
float *v, *v2, *color;
id new;
texturedef_t td;
// get class
new =[entity_classes_i classForName: [self valueForQKey:"classname"]];
if (new) {
v =[new mins];
v2 =[new maxs];
} else {
v = bad_mins;
v2 = bad_maxs;
}
color =[new drawColor];
modifiable = NO;
memset (&td, 0, sizeof (td));
strcpy (td.texture, "entity");
VectorAdd (org, v, emins);
VectorAdd (org, v2, emaxs);
new =[[SetBrush alloc] initOwner: self mins: emins maxs: emaxs texture:&td];
[new setEntityColor:color];
[self addObject:new];
return self;
}
2010-09-28 09:41:38 +00:00
-initClass:(const char *) classname
{
id new;
esize_t esize;
char value[80];
vec3_t min, max;
float *v;
self = [super init];
array = [[NSMutableArray alloc] init];
modifiable = YES;
[self setKey: "classname" toValue:classname];
// get class
new =[entity_classes_i classForName: [self valueForQKey:"classname"]];
if (!new)
esize = esize_model;
else
esize =[new esize];
// create a brush if needed
if (esize == esize_fixed) {
v =[new mins];
[[map_i selectedBrush] getMins: min maxs:max];
VectorSubtract (min, v, min);
sprintf (value, "%i %i %i", (int) min[0], (int) min[1], (int) min[2]);
[self setKey: "origin" toValue:value];
[self createFixedBrush:min];
} else
modifiable = YES;
return self;
}
-(void) dealloc
{
epair_t *e, *n;
for (e = epairs; e; e = n) {
n = e->next;
free (e->key);
free (e->value);
free (e);
}
[array release];
[super dealloc];
}
-(BOOL) modifiable
{
return modifiable;
}
-setModifiable:(BOOL) m
{
modifiable = m;
return self;
}
-(void) removeObject:o
{
[super removeObject:o];
if ([self count])
return;
// the entity is empty, so remove the entire thing
if (self ==[map_i objectAtIndex:0])
return; // never remove the world
[map_i removeObject:self];
[self release];
}
-(const char *) valueForQKey:(const char *) k
{
epair_t *e;
for (e = epairs; e; e = e->next)
if (!strcmp (k, e->key))
return e->value;
return "";
}
2010-09-28 09:41:38 +00:00
-getVector:(vec3_t) v forKey:(const char *) k
{
const char *c;
c =[self valueForQKey:k];
v[0] = v[1] = v[2] = 0;
sscanf (c, "%f %f %f", &v[0], &v[1], &v[2]);
return self;
}
-print
{
epair_t *e;
for (e = epairs; e; e = e->next)
printf ("%20s : %20s\n", e->key, e->value);
return self;
}
-setKey:(const char *)
k toValue:(const char *) v
{
epair_t *e;
while (*k && *k <= ' ')
k++;
if (!*k)
return self; // don't set NULL values
for (e = epairs; e; e = e->next) {
if (!strcmp (k, e->key)) {
free (e->value);
e->value = strdup (v);
return self;
}
}
e = malloc (sizeof (epair_t));
e->key = strdup (k);
e->value = strdup (v);
e->next = epairs;
epairs = e;
return self;
}
-(int) numPairs
{
int i;
epair_t *e;
i = 0;
for (e = epairs; e; e = e->next)
i++;
return i;
}
-(epair_t *) epairs
{
return epairs;
}
-removeKeyPair:(char *) key
{
epair_t *e, *e2;
if (!epairs)
return self;
e = epairs;
if (!strcmp (e->key, key)) {
epairs = e->next;
free (e);
return self;
}
for (; e; e = e->next) {
if (e->next && !strcmp (e->next->key, key)) {
e2 = e->next;
e->next = e2->next;
free (e2);
return self;
}
}
printf ("WARNING: removeKeyPair: %s not found\n", key);
return self;
}
/*
=============
targetname
If the entity does not have a "targetname" key, a unique one is generated
=============
*/
-(const char *) targetname
{
const char *t;
int i, count;
id ent;
int tval, maxt;
char name[20];
t =[self valueForQKey:"targetname"];
if (t && t[0])
return t;
// make a unique name of the form t<number>
count =[map_i count];
maxt = 0;
for (i = 1; i < count; i++) {
ent =[map_i objectAtIndex:i];
t =[ent valueForQKey:"targetname"];
if (!t || t[0] != 't')
continue;
tval = atoi (t + 1);
if (tval > maxt)
maxt = tval;
}
sprintf (name, "t%i", maxt + 1);
[self setKey: "targetname" toValue:name];
return[self valueForQKey:"targetname"];
// so it's not on the stack
}
/*
==============================================================================
FILE METHODS
==============================================================================
*/
int nument;
-initFromScript:(script_t *) script
{
char *key;
id eclass, brush;
const char *spawn;
vec3_t emins, emaxs;
vec3_t org;
texturedef_t td;
esize_t esize;
int i, c;
float *color;
self = [super init];
array = [[NSMutableArray alloc] init];
if (!Script_GetToken (script, true)) {
[self dealloc];
return nil;
}
if (strcmp (Script_Token (script), "{"))
Sys_Error ("initFromFileP: { not found");
do {
if (!Script_GetToken (script, true))
break;
if (!strcmp (Script_Token (script), "}"))
break;
if (!strcmp (Script_Token (script), "{")) {
// read a brush
brush =[[SetBrush alloc] initFromScript: script owner:self];
[self addObject:brush];
} else {
// read a key / value pair
key = strdup (Script_Token (script));
Script_GetToken (script, false);
[self setKey: key toValue:Script_Token (script)];
free (key);
}
} while (1);
nument++;
// get class
spawn =[self valueForQKey:"classname"];
eclass =[entity_classes_i classForName:spawn];
esize =[eclass esize];
[self getVector: org forKey:"origin"];
if ([self count] && esize != esize_model) {
printf ("WARNING:Entity with brushes and wrong model type\n");
[self removeAllObjects];
}
if (![self count] && esize == esize_model) {
printf ("WARNING:Entity with no brushes and esize_model: %s\n", [self valueForQKey:"classname"]);
[texturepalette_i getTextureDef:&td];
for (i = 0; i < 3; i++) {
emins[i] = org[i] - 8;
emaxs[i] = org[i] + 8;
}
brush =[[SetBrush alloc] initOwner: self mins: emins maxs: emaxs texture:&td];
[self addObject:brush];
}
// create a brush if needed
if (esize == esize_fixed)
[self createFixedBrush:org];
else
modifiable = YES;
// set all the brush colors
color =[eclass drawColor];
c =[self count];
for (i = 0; i < c; i++) {
brush =[self objectAtIndex:i];
[brush setEntityColor:color];
}
return self;
}
-writeToFILE:(FILE *)
f region:(BOOL) reg;
{
epair_t *e;
int i;
id new;
char value[80];
vec3_t mins, maxs, org;
const vec_t *v;
BOOL temporg;
char oldang[80];
temporg = NO;
if (reg) {
if (!strcmp ([self valueForQKey:"classname"], "info_player_start")) {
// move the playerstart
// temporarily to the camera
// position
temporg = YES;
strcpy (oldang,[self valueForQKey:"angle"]);
sprintf (value, "%i", (int) ([cameraview_i yawAngle] * 180 / M_PI));
[self setKey: "angle" toValue:value];
} else if (self !=[map_i objectAtIndex:0]
&&[[self objectAtIndex:0] regioned])
return self; // skip the entire entity definition
}
fprintf (f, "{\n");
// set an origin epair
if (!modifiable) {
[[self objectAtIndex: 0] getMins: mins maxs:maxs];
if (temporg) {
[cameraview_i getOrigin:mins];
mins[0] -= 16;
mins[1] -= 16;
mins[2] -= 48;
}
new =[entity_classes_i classForName:
[self valueForQKey:"classname"]];
if (new)
v =[new mins];
else
v = vec3_origin;
VectorSubtract (mins, v, org);
sprintf (value, "%i %i %i", (int) org[0], (int) org[1], (int) org[2]);
[self setKey: "origin" toValue:value];
}
for (e = epairs; e; e = e->next)
fprintf (f, "\"%s\"\t\"%s\"\n", e->key, e->value);
// fixed size entities don't save out brushes
if (modifiable) {
for (i = 0; i <[self count]; i++)
[[self objectAtIndex: i] writeToFILE: f region:reg];
}
fprintf (f, "}\n");
if (temporg)
[self setKey: "angle" toValue:oldang];
return self;
}
/*
==============================================================================
INTERACTION
==============================================================================
*/
@end