Quake-Tools/QuakeEd/Map.m

#include "qedefs.h"

id	map_i;

@implementation Map

/*
===============================================================================

FILE METHODS

===============================================================================
*/

- init
{
	[super init];
	map_i = self;
	minz = 0;
	maxz = 80;
	
	oldselection = [[List alloc] init];
	
	return self;
}

- saveSelected
{
	int		i, c;
	id		o, w;
	
	[oldselection empty];
	w = [self objectAt: 0];
	c = [w count];
	sb_newowner = oldselection;
	for (i=0 ; i<c ; i++)
	{
		o = [w objectAt: 0];
		if ([o selected])
			[o moveToEntity];
		else
		{
			[w removeObjectAt: 0];
			[o free];
		}
	}
	
	c = [self count];
	for (i=0 ; i<c ; i++)
	{
		o = [self objectAt: 0];
		[self removeObjectAt: 0];
		[o freeObjects];
		[o free];
	}

	return self;
}

- addSelected
{
	int		i, c;
	id		n, w;
	
	c = [oldselection count];
	w = [self objectAt: 0];	// world object

	sb_newowner = w;
	for (i=0 ; i<c ; i++)
	{
		n = [oldselection objectAt:i];
		[n moveToEntity];
		i--;
		c--;
	}
	[oldselection empty];
	
	return self;
}


- newMap
{
	id	ent;
	
	[self saveSelected];
	ent = [[Entity alloc] initClass: "worldspawn"];
	[self addObject: ent];
	currentEntity = NULL;
	[self setCurrentEntity: ent];
	[self addSelected];

	return self;
}

- currentEntity
{
	return currentEntity;
}

- setCurrentEntity: ent
{
	id	old;
	
	old = currentEntity;
	currentEntity = ent;
	if (old != ent)
	{
		[things_i newCurrentEntity];	// update inspector
		[inspcontrol_i changeInspectorTo:i_things];
	}
	
	return self;
}

- (float)currentMinZ
{
	float	grid;
	
	grid = [xyview_i gridsize];
	minz = grid * rint(minz/grid);
	return minz;
}

- setCurrentMinZ: (float)m
{
	if (m > -2048)
		minz = m;
	return self;
}

- (float)currentMaxZ
{
	float	grid;
	
	[self currentMinZ];	// grid align
	
	grid = [xyview_i gridsize];
	maxz = grid * rint(maxz/grid);

	if (maxz <= minz)
		maxz = minz + grid;
	return maxz;
}

- setCurrentMaxZ: (float)m
{
	if (m < 2048)
		maxz = m;
	return self;
}

- removeObject: o
{
	o = [super removeObject: o];
	
	if (o == currentEntity)
	{	// select the world
		[self setCurrentEntity: [self objectAt: 0]];
	}

	return o;
}

- writeStats
{
	FILE	*f;
	extern	int	c_updateall;
	struct timeval tp;
	struct timezone tzp;

	gettimeofday(&tp, &tzp);
	
	f = fopen (FN_DEVLOG, "a");
	fprintf (f,"%i %i\n", (int)tp.tv_sec, c_updateall);
	c_updateall = 0;
	fclose (f);
	return self;
}

- (int)numSelected
{
	int		i, c;
	int		num;
	
	num = 0;
	c = [currentEntity count];
	for (i=0 ; i<c ; i++)
		if ( [[currentEntity objectAt: i] selected] )
			num++;
	return num;
}

- selectedBrush
{
	int		i, c;
	int		num;
	
	num = 0;
	c = [currentEntity count];
	for (i=0 ; i<c ; i++)
		if ( [[currentEntity objectAt: i] selected] )
			return [currentEntity objectAt: i];
	return nil;
}


/*
=================
readMapFile
=================
*/
- readMapFile: (char *)fname
{
	char	*dat, *cl;
	id		new;
	id		ent;
	int		i, c;
	vec3_t	org;
	float	angle;
	
	[self saveSelected];
	
	qprintf ("loading %s\n", fname);

	LoadFile (fname, (void **)&dat);
	StartTokenParsing (dat);

	do
	{
		new = [[Entity alloc] initFromTokens];
		if (!new)
			break;
		[self addObject: new];		
	} while (1);

	free (dat);

	[self setCurrentEntity: [self objectAt: 0]];

	[self addSelected];
		
// load the apropriate texture wad
	dat = [currentEntity valueForQKey: "wad"];
	if (dat && dat[0])
	{
		if (dat[0] == '/')	// remove old style fullpaths
			[currentEntity removeKeyPair: "wad"];
		else
		{
			if (strcmp ([texturepalette_i currentWad], dat) )
				[project_i 	setTextureWad: dat];
		}
	}

// center the camera and XY view on the playerstart
	c = [self count];
	for (i=1 ; i<c ; i++)
	{
		ent = [self objectAt: i];
		cl = [ent valueForQKey: "classname"];
		if (cl && !strcasecmp (cl,"info_player_start"))
		{
			angle = atof( [ent valueForQKey: "angle"] );
			angle = angle/180*M_PI;
			[ent getVector: org forKey: "origin"];
			[cameraview_i setOrigin: org angle:angle];
			[xyview_i centerOn: org];
			break;
		}
	}
	
	return self;
}

/*
=================
writeMapFile
=================
*/
- writeMapFile: (char *)fname useRegion: (BOOL)reg
{
	FILE	*f;
	int		i;
	
	qprintf ("writeMapFile: %s", fname);
	
	f = fopen (fname,"w");
	if (!f)
		Error ("couldn't write %s", fname);
	
	for (i=0 ; i<numElements ; i++)
		[[self objectAt: i] writeToFILE: f region: reg];
			
	fclose (f);
	
	return self;
}

/*
==============================================================================

DRAWING

==============================================================================
*/

- ZDrawSelf
{
	int		i, count;
	
	count = [self count];

	for (i=0 ; i<count ; i++)
		[[self objectAt: i] ZDrawSelf];

	return self;
}

- RenderSelf: (void (*) (face_t *))callback
{
	int		i, count;
	
	count = [self count];

	for (i=0 ; i<count ; i++)
		[[self objectAt: i] RenderSelf: callback];

	return self;
}


//============================================================================


/*
===================
entityConnect

A command-shift-click on an entity while an entity is selected will
make a target connection from the original entity.
===================
*/
- entityConnect: (vec3_t)p1 : (vec3_t)p2
{
	id	oldent, ent;
	
	oldent = [self currentEntity];
	if (oldent == [self objectAt: 0])
	{
		qprintf ("Must have a non-world entity selected to connect");
		return self;
	}

	[self selectRay: p1 : p2 : YES];
	ent = [self currentEntity];
	if (ent == oldent)
	{
		qprintf ("Must click on a different entity to connect");
		return self;
	}
	
	if (ent == [self objectAt: 0])
	{
		qprintf ("Must click on a non-world entity to connect");
		return self;
	}
	
	[oldent setKey:"target" toValue: [ent targetname]];
	[quakeed_i updateAll];

	return self;
}


/*
=================
selectRay

If ef is true, any entity brush along the ray will be selected in preference
to intervening world brushes
=================
*/
- selectRay: (vec3_t)p1 : (vec3_t)p2 : (BOOL)ef
{
	int		i, j, c, c2;
	id		ent, bestent;
	id		brush, bestbrush;
	int		face, bestface;
	float	time, besttime;
	texturedef_t	*td;
	
	bestent = nil;
	bestface = -1;
	bestbrush = nil;
	besttime = 99999;
	
	c = [self count];
	for (i=c-1 ; i>=0 ; i--)
	{
		ent = [self objectAt: i];
		c2 = [ent count];
		for (j=0 ; j<c2 ; j++)
		{
			brush = [ent objectAt: j];
			[brush hitByRay: p1 : p2 : &time : &face];
			if (time < 0 || time >besttime)
				continue;
			bestent = ent;
			besttime = time;
			bestbrush = brush;
			bestface = face;
		}
		if (i == 1 && ef && bestbrush)
			break;		// found an entity, so don't check the world
	}
	
	if (besttime == 99999)
	{
		qprintf ("trace missed");
		return self;
	}

	if ( [bestbrush regioned] )
	{
		qprintf ("WANRING: clicked on regioned brush");
		return self;
	}
	
	if (bestent != currentEntity)
	{
		[self makeSelectedPerform: @selector(deselect)];
		[self setCurrentEntity: bestent];
	}
	
	[quakeed_i disableFlushWindow];
	if ( ![bestbrush selected] )
	{
		if ( [map_i numSelected] == 0)
		{	// don't grab texture if others are selected
			td = [bestbrush texturedefForFace: bestface];
			[texturepalette_i setTextureDef: td];
		}

		[bestbrush setSelected: YES];
		qprintf ("selected entity %i brush %i face %i", [self indexOf:bestent], [bestent indexOf: bestbrush], bestface);
	}
	else 
	{
		[bestbrush setSelected: NO];
		qprintf ("deselected entity %i brush %i face %i", [self indexOf:bestent], [bestent indexOf: bestbrush], bestface);
	}

	[quakeed_i reenableFlushWindow];
	[quakeed_i updateAll];
	
	return self;
}

/*
=================
grabRay

only checks the selected brushes
Returns the brush hit, or nil if missed.
=================
*/
- grabRay: (vec3_t)p1 : (vec3_t)p2
{
	int		i, j, c, c2;
	id		ent;
	id		brush, bestbrush;
	int		face;
	float	time, besttime;
	
	bestbrush = nil;
	besttime = 99999;
	
	c = [self count];
	for (i=0 ; i<c ; i++)
	{
		ent = [self objectAt: i];		
		c2 = [ent count];
		for (j=0 ; j<c2 ; j++)
		{
			brush = [ent objectAt: j];
			if (![brush selected])
				continue;
			[brush hitByRay: p1 : p2 : &time : &face];
			if (time < 0 || time >besttime)
				continue;
			besttime = time;
			bestbrush = brush;
		}
	}
	
	if (besttime == 99999)
		return nil;
	
	return bestbrush;
}

/*
=================
getTextureRay
=================
*/
- getTextureRay: (vec3_t)p1 : (vec3_t)p2
{
	int		i, j, c, c2;
	id		ent, bestent;
	id		brush, bestbrush;
	int		face, bestface;
	float	time, besttime;
	texturedef_t	*td;
	vec3_t	mins, maxs;		


	bestbrush = nil;
	bestent = nil;
	besttime = 99999;
	bestface = -1;
	c = [self count];
	for (i=0 ; i<c ; i++)
	{
		ent = [self objectAt: i];		
		c2 = [ent count];
		for (j=0 ; j<c2 ; j++)
		{
			brush = [ent objectAt: j];
			[brush hitByRay: p1 : p2 : &time : &face];
			if (time < 0 || time >besttime)
				continue;
			bestent = ent;
			bestface = face;
			besttime = time;
			bestbrush = brush;
		}
	}
	
	if (besttime == 99999)
		return nil;

	if ( ![bestent modifiable])
	{
		qprintf ("can't modify spawned entities");
		return self;
	}
	
	td = [bestbrush texturedefForFace: bestface];
	[texturepalette_i setTextureDef: td];
	
	qprintf ("grabbed texturedef and sizes");
	
	[bestbrush getMins: mins maxs: maxs];
	
	minz = mins[2];
	maxz = maxs[2];
	
	return bestbrush;
}

/*
=================
setTextureRay
=================
*/
- setTextureRay: (vec3_t)p1 : (vec3_t)p2 : (BOOL)allsides;
{
	int		i, j, c, c2;
	id		ent, bestent;
	id		brush, bestbrush;
	int		face, bestface;
	float	time, besttime;
	texturedef_t	td;
		
	bestent = nil;
	bestface = -1;
	bestbrush = nil;
	besttime = 99999;
	
	c = [self count];
	for (i=0 ; i<c ; i++)
	{
		ent = [self objectAt: i];		
		c2 = [ent count];
		for (j=0 ; j<c2 ; j++)
		{
			brush = [ent objectAt: j];
			[brush hitByRay: p1 : p2 : &time : &face];
			if (time < 0 || time >besttime)
				continue;
			bestent = ent;
			besttime = time;
			bestbrush = brush;
			bestface = face;
		}
	}
	
	if (besttime == 99999)
	{
		qprintf ("trace missed");
		return self;
	}

	if ( ![bestent modifiable])
	{
		qprintf ("can't modify spawned entities");
		return self;
	}
	
	if ( [bestbrush regioned] )
	{
		qprintf ("WANRING: clicked on regioned brush");
		return self;
	}
	
	[texturepalette_i getTextureDef: &td];
	
	[quakeed_i disableFlushWindow];
	if (allsides)
	{
		[bestbrush setTexturedef: &td];
		qprintf ("textured entity %i brush %i", [self indexOf:bestent], [bestent indexOf: bestbrush]);
	}
	else 
	{
		[bestbrush setTexturedef: &td forFace: bestface];
		qprintf ("deselected entity %i brush %i face %i", [self indexOf:bestent], [bestent indexOf: bestbrush], bestface);
	}
	[quakeed_i reenableFlushWindow];
		
	[quakeed_i updateAll];
	
	return self;
}


/*
==============================================================================

OPERATIONS ON SELECTIONS

==============================================================================
*/

- makeSelectedPerform: (SEL)sel
{
	int	i,j, c, c2;
	id	ent, brush;
	int	total;
	
	total = 0;
	c = [self count];
	for (i=c-1 ; i>=0 ; i--)
	{
		ent = [self objectAt: i];
		c2 = [ent count];
		for (j = c2-1 ; j >=0 ; j--)
		{
			brush = [ent objectAt: j];
			if (! [brush selected] )
				continue;
			if ([brush regioned])
				continue;
			total++;
			[brush perform:sel];
		}
	}

//	if (!total)
//		qprintf ("nothing selected");
		
	return self;	
}

- makeUnselectedPerform: (SEL)sel
{
	int	i,j, c, c2;
	id	ent, brush;
	
	c = [self count];
	for (i=c-1 ; i>=0 ; i--)
	{
		ent = [self objectAt: i];
		c2 = [ent count];
		for (j = c2-1 ; j >=0 ; j--)
		{
			brush = [ent objectAt: j];
			if ( [brush selected] )
				continue;
			if ([brush regioned])
				continue;
			[brush perform:sel];
		}
	}

	return self;	
}

- makeAllPerform: (SEL)sel
{
	int	i,j, c, c2;
	id	ent, brush;
	
	c = [self count];
	for (i=c-1 ; i>=0 ; i--)
	{
		ent = [self objectAt: i];
		c2 = [ent count];
		for (j = c2-1 ; j >=0 ; j--)
		{
			brush = [ent objectAt: j];
			if ([brush regioned])
				continue;
			[brush perform:sel];
		}
	}

	return self;	
}

- makeGlobalPerform: (SEL)sel	// in and out of region
{
	int	i,j, c, c2;
	id	ent, brush;
	
	c = [self count];
	for (i=c-1 ; i>=0 ; i--)
	{
		ent = [self objectAt: i];
		c2 = [ent count];
		for (j = c2-1 ; j >=0 ; j--)
		{
			brush = [ent objectAt: j];
			[brush perform:sel];
		}
	}

	return self;	
}


void sel_identity (void)
{
	sel_x[0]=1; sel_x[1]=0; sel_x[2]=0;
	sel_y[0]=0; sel_y[1]=1; sel_y[2]=0;
	sel_z[0]=0; sel_z[1]=0; sel_z[2]=1;
}

- transformSelection
{
	if ( ![currentEntity modifiable])
	{
		qprintf ("can't modify spawned entities");
		return self;
	}

// find an origin to apply the transformation to
	sb_mins[0] = sb_mins[1] = sb_mins[2] = 99999;
	sb_maxs[0] = sb_maxs[1] = sb_maxs[2] = -99999;
	[self makeSelectedPerform: @selector(addToBBox)];
	sel_org[0] = [xyview_i snapToGrid: (sb_mins[0] + sb_maxs[0])/2];
	sel_org[1] = [xyview_i snapToGrid: (sb_mins[1] + sb_maxs[1])/2];
	sel_org[2] = [xyview_i snapToGrid: (sb_mins[2] + sb_maxs[2])/2];
	
// do it!
	[self makeSelectedPerform: @selector(transform)];

	[quakeed_i updateAll];
	return self;
}


void swapvectors (vec3_t a, vec3_t b)
{
	vec3_t	temp;
	
	VectorCopy (a, temp);
	VectorCopy (b, a);
	VectorSubtract (vec3_origin, temp, b);
}

/*
===============================================================================

UI operations

===============================================================================
*/

- rotate_x: sender
{
	sel_identity ();
	swapvectors(sel_y, sel_z);
	[self transformSelection];
	return self;
}

- rotate_y: sender
{
	sel_identity ();
	swapvectors(sel_x, sel_z);
	[self transformSelection];
	return self;
}

- rotate_z: sender
{
	sel_identity ();
	swapvectors(sel_x, sel_y);
	[self transformSelection];
	return self;
}


- flip_x: sender
{
	sel_identity ();
	sel_x[0] = -1;
	[self transformSelection];
	[map_i makeSelectedPerform: @selector(flipNormals)];
	return self;
}

- flip_y: sender
{
	sel_identity ();
	sel_y[1] = -1;
	[self transformSelection];
	[map_i makeSelectedPerform: @selector(flipNormals)];
	return self;
}


- flip_z: sender
{
	sel_identity ();
	sel_z[2] = -1;
	[self transformSelection];
	[map_i makeSelectedPerform: @selector(flipNormals)];
	return self;
}


- cloneSelection: sender
{
	int		i,j , c, originalElements;
	id		o, b;
	id		new;
	
	sb_translate[0] = sb_translate[1] = [xyview_i gridsize];
	sb_translate[2] = 0;

// copy individual brushes in the world entity
	o = [self objectAt: 0];
	c = [o count];
	for (i=0 ; i<c ; i++)
	{
		b = [o objectAt: i];
		if (![b selected])
			continue;
			
	// copy the brush, then translate the original
		new = [b copy];
		[new setSelected: YES];
		[new translate];
		[b setSelected: NO];
		[o addObject: new];
	}
	
// copy entire entities otherwise
	originalElements = numElements;	// don't copy the new ones
	for (i=1 ; i<originalElements ; i++)
	{
		o = [self objectAt: i];
		if (![[o objectAt: 0] selected])
			continue;

		new = [o copy];
		[self addObject: new];

		c = [o count];
		for (j=0 ; j<c ; j++)
			[[o objectAt: j] setSelected: NO];
		
		c = [new count];
		for (j=0 ; j<c ; j++)
		{
			b = [new objectAt: j];
			[b translate];
			[b setSelected: YES];
		}
	}

	[quakeed_i updateAll];

	return self;
}


- selectCompleteEntity: sender
{
	id	o;
	int	i, c;
	
	o = [self selectedBrush];
	if (!o)
	{
		qprintf ("nothing selected");
		return self;
	}
	o = [o parent];
	c = [o count];
	for (i=0 ; i<c ; i++)
		[[o objectAt: i] setSelected: YES];	
	qprintf ("%i brushes selected", c);

	[quakeed_i updateAll];

	return self;
}

- makeEntity: sender
{
	if (currentEntity != [self objectAt: 0])
	{
		qprintf ("ERROR: can't makeEntity inside an entity");
		NXBeep ();
		return self;
	}
	
	if ( [self numSelected] == 0)
	{
		qprintf ("ERROR: must have a seed brush to make an entity");
		NXBeep ();
		return self;
	}
	
	sb_newowner = [[Entity alloc] initClass: [things_i spawnName]];

	if ( [sb_newowner modifiable] )
		[self makeSelectedPerform: @selector(moveToEntity)];
	else
	{	// throw out seed brush and select entity fixed brush
		[self makeSelectedPerform: @selector(remove)];
		[[sb_newowner objectAt: 0] setSelected: YES];
	}
	
	[self addObject: sb_newowner];
	[self setCurrentEntity: sb_newowner];
	
	[quakeed_i updateAll];
	
	return self;
}


- selbox: (SEL)selector
{
	id	b;
	
	if ([self numSelected] != 1)
	{
		qprintf ("must have a single brush selected");
		return self;
	} 

	b = [self selectedBrush];
	[b getMins: select_min maxs: select_max];
	[b remove];
	
	[self makeUnselectedPerform: selector];
	
	qprintf ("identified contents");
	[quakeed_i updateAll];
	
	return self;
}

- selectCompletelyInside: sender
{
	return [self selbox:  @selector(selectComplete)];
}

- selectPartiallyInside: sender
{
	return [self selbox:  @selector(selectPartial)];
}


- tallBrush: sender
{
	id		b;
	vec3_t	mins, maxs;
	texturedef_t	td;
	
	if ([self numSelected] != 1)
	{
		qprintf ("must have a single brush selected");
		return self;
	} 

	b = [self selectedBrush];
	td = *[b texturedef];
	[b getMins: mins maxs: maxs];
	[b remove];

	mins[2] = -2048;
	maxs[2] = 2048;
	
	b = [[SetBrush alloc] initOwner: [map_i objectAt:0] mins: mins maxs: maxs texture: &td];
	[[map_i objectAt: 0] addObject: b];
	[b setSelected: YES];
	[quakeed_i updateAll];
		
	return self;
}

- shortBrush: sender
{
	id		b;
	vec3_t	mins, maxs;
	texturedef_t	td;
	
	if ([self numSelected] != 1)
	{
		qprintf ("must have a single brush selected");
		return self;
	} 

	b = [self selectedBrush];
	td = *[b texturedef];
	[b getMins: mins maxs: maxs];
	[b remove];

	mins[2] = 0;
	maxs[2] = 16;
	
	b = [[SetBrush alloc] initOwner: [map_i objectAt:0] mins: mins maxs: maxs texture: &td];
	[[map_i objectAt: 0] addObject: b];
	[b setSelected: YES];
	[quakeed_i updateAll];
	
	return self;
}

/*
==================
subtractSelection
==================
*/
- subtractSelection: semder
{
	int		i, j, c, c2;
	id		o, o2;
	id		sellist, sourcelist;
	
	qprintf ("performing brush subtraction...");

	sourcelist = [[List alloc] init];
	sellist = [[List alloc] init];
	carve_in = [[List alloc] init];
	carve_out = [[List alloc] init];
	
	c = [currentEntity count];
	for (i=0 ; i<c ; i++)
	{
		o = [currentEntity objectAt: i];
		if ([o selected])
			[sellist addObject: o];
		else
			[sourcelist addObject: o];
	}
	
		
	c = [sellist count];
	for (i=0 ; i<c ; i++)
	{
		o = [sellist objectAt: i];
		[o setCarveVars];
		
		c2 = [sourcelist count];
		for (j=0 ; j<c2 ; j++)
		{
			o2 = [sourcelist objectAt: j];
			[o2 carve];
			[carve_in freeObjects];
		}

		[sourcelist free];	// the individual have been moved/freed
		sourcelist = carve_out;
		carve_out = [[List alloc] init];
	}

// add the selection back to the remnants
	[currentEntity empty];
	[currentEntity appendList: sourcelist];
	[currentEntity appendList: sellist];

	[sourcelist free];
	[sellist free];
	[carve_in free];
	[carve_out free];
	
	if (![currentEntity count])
	{
		o = currentEntity;
		[self removeObject: o];
		[o free];
	}

	qprintf ("subtracted selection");
	[quakeed_i updateAll];
	
	return self;
}


@end