Index: src/Alias.h
==================================================================
--- src/Alias.h
+++ src/Alias.h
@@ -5,15 +5,15 @@
 @interface Alias: Identifier
 @property (direct, copy, nonatomic) OFString *action;
 @property (readonly, nonatomic) bool persisted;
 
 + (instancetype)aliasWithName: (OFString *)name
-                       action: (OFString *)action
-                    persisted: (bool)persisted OF_DIRECT;
+		       action: (OFString *)action
+		    persisted: (bool)persisted OF_DIRECT;
 - (instancetype)initWithName: (OFString *)name OF_UNAVAILABLE;
 - (instancetype)initWithName: (OFString *)name
-                      action: (OFString *)action
-                   persisted: (bool)persisted OF_DESIGNATED_INITIALIZER
+		      action: (OFString *)action
+		   persisted: (bool)persisted OF_DESIGNATED_INITIALIZER
     OF_DIRECT;
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/Alias.m
==================================================================
--- src/Alias.m
+++ src/Alias.m
@@ -1,20 +1,20 @@
 #import "Alias.h"
 
 @implementation Alias
 + (instancetype)aliasWithName: (OFString *)name
-                       action: (OFString *)action
-                    persisted: (bool)persisted;
+		       action: (OFString *)action
+		    persisted: (bool)persisted;
 {
 	return [[self alloc] initWithName: name
-	                           action: action
-	                        persisted: persisted];
+				   action: action
+				persisted: persisted];
 }
 
 - (instancetype)initWithName: (OFString *)name
-                      action: (OFString *)action
-                   persisted: (bool)persisted
+		      action: (OFString *)action
+		   persisted: (bool)persisted
 {
 	self = [super initWithName: name];
 
 	_action = [action copy];
 	_persisted = persisted;

Index: src/Command.h
==================================================================
--- src/Command.h
+++ src/Command.h
@@ -1,30 +1,30 @@
 #import "Identifier.h"
 
 OF_ASSUME_NONNULL_BEGIN
 
-#define COMMAND(name, nargs, block_)				\
-	OF_CONSTRUCTOR()					\
-	{							\
-		enqueueInit(^ {					\
-			Identifier.identifiers[@#name] =	\
-			    [Command commandWithName: @#name	\
-			              argumentsTypes: nargs	\
-			                       block: block_];	\
-		});						\
+#define COMMAND(name, nargs, block_)					\
+	OF_CONSTRUCTOR()						\
+	{								\
+		enqueueInit(^ {						\
+			Identifier.identifiers[@#name] = [Command	\
+			    commandWithName: @#name			\
+			     argumentsTypes: nargs			\
+				      block: block_];			\
+		});							\
 	}
 
 OF_DIRECT_MEMBERS
 @interface Command: Identifier
 @property (readonly, nonatomic) int argumentsTypes;
 
 + (instancetype)commandWithName: (OFString *)name
-                 argumentsTypes: (int)argumentsTypes
-                          block: (id)block;
+		 argumentsTypes: (int)argumentsTypes
+			  block: (id)block;
 - (instancetype)initWithName: (OFString *)name OF_UNAVAILABLE;
 - (instancetype)initWithName: (OFString *)name
-              argumentsTypes: (int)argumentsTypes
-                       block: (id)block OF_DESIGNATED_INITIALIZER;
+	      argumentsTypes: (int)argumentsTypes
+		       block: (id)block OF_DESIGNATED_INITIALIZER;
 - (int)callWithArguments: (OFArray<OFString *> *)arguments isDown: (bool)isDown;
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/Command.m
==================================================================
--- src/Command.m
+++ src/Command.m
@@ -23,21 +23,21 @@
 {
 	id _block;
 }
 
 + (instancetype)commandWithName: (OFString *)name
-                 argumentsTypes: (int)argumentsTypes
-                          block: (id)block
+		 argumentsTypes: (int)argumentsTypes
+			  block: (id)block
 {
 	return [[self alloc] initWithName: name
-	                   argumentsTypes: argumentsTypes
-	                            block: block];
+			   argumentsTypes: argumentsTypes
+				    block: block];
 }
 
 - (instancetype)initWithName: (OFString *)name
-              argumentsTypes: (int)argumentsTypes
-                       block: (id)block
+	      argumentsTypes: (int)argumentsTypes
+		       block: (id)block
 {
 	self = [super initWithName: name];
 
 	_argumentsTypes = argumentsTypes;
 	_block = block;

Index: src/Cube.m
==================================================================
--- src/Cube.m
+++ src/Cube.m
@@ -125,15 +125,13 @@
 		}
 
 		log(@"video: mode");
 		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 		if ((_window = SDL_CreateWindow("cube engine",
-		         SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-		         _width, _height,
-		         SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL |
-		             (!windowed ? SDL_WINDOW_FULLSCREEN : 0))) ==
-		        NULL ||
+		    SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+		    _width, _height, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL |
+		    (!windowed ? SDL_WINDOW_FULLSCREEN : 0))) == NULL ||
 		    SDL_GL_CreateContext(_window) == NULL)
 			fatal(@"Unable to create OpenGL screen");
 
 		log(@"video: misc");
 		SDL_SetWindowGrab(_window, SDL_TRUE);
@@ -242,12 +240,12 @@
 				case SDL_KEYDOWN:
 				case SDL_KEYUP:
 					if (_repeatsKeys ||
 					    event.key.repeat == 0)
 						keypress(event.key.keysym.sym,
-						    event.key.state ==
-						        SDL_PRESSED);
+						    (event.key.state ==
+						    SDL_PRESSED));
 					break;
 				case SDL_TEXTINPUT:
 					input(@(event.text.text));
 					break;
 				case SDL_MOUSEMOTION:
@@ -303,23 +301,21 @@
 {
 	SDL_Surface *image;
 	SDL_Surface *temp;
 
 	if ((image = SDL_CreateRGBSurface(SDL_SWSURFACE, _width, _height, 24,
-	         0x0000FF, 0x00FF00, 0xFF0000, 0)) != NULL) {
+	    0x0000FF, 0x00FF00, 0xFF0000, 0)) != NULL) {
 		if ((temp = SDL_CreateRGBSurface(SDL_SWSURFACE, _width, _height,
-		         24, 0x0000FF, 0x00FF00, 0xFF0000, 0)) != NULL) {
+		    24, 0x0000FF, 0x00FF00, 0xFF0000, 0)) != NULL) {
 			glReadPixels(0, 0, _width, _height, GL_RGB,
 			    GL_UNSIGNED_BYTE, image->pixels);
 
 			for (int idx = 0; idx < _height; idx++) {
 				char *dest =
 				    (char *)temp->pixels + 3 * _width * idx;
-				memcpy(dest,
-				    (char *)image->pixels +
-				        3 * _width * (_height - 1 - idx),
-				    3 * _width);
+				memcpy(dest, (char *)image->pixels + 3 *
+				    _width * (_height - 1 - idx), 3 * _width);
 				endianswap(dest, 3, _width);
 			}
 
 			OFString *path = [OFString stringWithFormat:
 			    @"screenshots/screenshot_%d.bmp", lastmillis];
@@ -345,11 +341,11 @@
 fatal(OFConstantString *s, ...)
 {
 	va_list args;
 	va_start(args, s);
 	OFMutableString *msg = [[OFMutableString alloc] initWithFormat: s
-	                                                     arguments: args];
+							     arguments: args];
 	va_end(args);
 
 	[msg appendFormat: @" (%s)\n", SDL_GetError()];
 
 	[Cube.sharedInstance showMessage: msg];

Index: src/MD2.h
==================================================================
--- src/MD2.h
+++ src/MD2.h
@@ -12,18 +12,18 @@
 @property (nonatomic) bool loaded;
 
 + (instancetype)md2;
 - (bool)loadWithIRI: (OFIRI *)IRI;
 - (void)renderWithLight: (OFColor *)light
-                  frame: (int)frame
-                  range: (int)range
-               position: (OFVector3D)position
-                    yaw: (float)yaw
-                  pitch: (float)pitch
-                  scale: (float)scale
-                  speed: (float)speed
-                   snap: (int)snap
-               basetime: (int)basetime;
+		  frame: (int)frame
+		  range: (int)range
+	       position: (OFVector3D)position
+		    yaw: (float)yaw
+		  pitch: (float)pitch
+		  scale: (float)scale
+		  speed: (float)speed
+		   snap: (int)snap
+	       basetime: (int)basetime;
 - (void)scaleWithFrame: (int)frame scale: (float)scale snap: (int)snap;
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/MD2.m
==================================================================
--- src/MD2.m
+++ src/MD2.m
@@ -67,11 +67,11 @@
 {
 	OFSeekableStream *stream;
 	@try {
 		stream = (OFSeekableStream *)[[OFIRIHandler handlerForIRI: IRI]
 		    openItemAtIRI: IRI
-		             mode: @"r"];
+			     mode: @"r"];
 	} @catch (id e) {
 		return false;
 	}
 
 	if (![stream isKindOfClass: OFSeekableStream.class])
@@ -90,11 +90,11 @@
 		return false;
 	}
 
 	[stream seekToOffset: header.offsetFrames whence: OFSeekSet];
 	[stream readIntoBuffer: _frames
-	           exactLength: header.frameSize * header.numFrames];
+		   exactLength: header.frameSize * header.numFrames];
 
 	for (int i = 0; i < header.numFrames; ++i)
 		endianswap(_frames + i * header.frameSize, sizeof(float), 6);
 
 	@try {
@@ -103,11 +103,11 @@
 		return false;
 	}
 
 	[stream seekToOffset: header.offsetGlCommands whence: OFSeekSet];
 	[stream readIntoBuffer: _glCommands
-	           exactLength: header.numGlCommands * sizeof(int)];
+		   exactLength: header.numGlCommands * sizeof(int)];
 	endianswap(_glCommands, sizeof(int), header.numGlCommands);
 
 	_numFrames = header.numFrames;
 	_numGlCommands = header.numGlCommands;
 	_frameSize = header.frameSize;
@@ -138,19 +138,19 @@
 		v->z = (snap(sn, cv[2] * cf->scale[2]) + cf->translate[2]) / sc;
 	}
 }
 
 - (void)renderWithLight: (OFColor *)light
-                  frame: (int)frame
-                  range: (int)range
-               position: (OFVector3D)position
-                    yaw: (float)yaw
-                  pitch: (float)pitch
-                  scale: (float)sc
-                  speed: (float)speed
-                   snap: (int)sn
-               basetime: (int)basetime
+		  frame: (int)frame
+		  range: (int)range
+	       position: (OFVector3D)position
+		    yaw: (float)yaw
+		  pitch: (float)pitch
+		  scale: (float)sc
+		  speed: (float)speed
+		   snap: (int)sn
+	       basetime: (int)basetime
 {
 	for (int i = 0; i < range; i++)
 		if (!_mverts[frame + i])
 			[self scaleWithFrame: frame + i scale: sc snap: sn];
 

Index: src/MapModelInfo.h
==================================================================
--- src/MapModelInfo.h
+++ src/MapModelInfo.h
@@ -6,18 +6,18 @@
 @interface MapModelInfo: OFObject
 @property (nonatomic) int rad, h, zoff, snap;
 @property (copy, nonatomic) OFString *name;
 
 + (instancetype)infoWithRad: (int)rad
-                          h: (int)h
-                       zoff: (int)zoff
-                       snap: (int)snap
-                       name: (OFString *)name;
+			  h: (int)h
+		       zoff: (int)zoff
+		       snap: (int)snap
+		       name: (OFString *)name;
 - (instancetype)init OF_UNAVAILABLE;
 - (instancetype)initWithRad: (int)rad
-                          h: (int)h
-                       zoff: (int)zoff
-                       snap: (int)snap
-                       name: (OFString *)name;
+			  h: (int)h
+		       zoff: (int)zoff
+		       snap: (int)snap
+		       name: (OFString *)name;
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/MapModelInfo.m
==================================================================
--- src/MapModelInfo.m
+++ src/MapModelInfo.m
@@ -1,26 +1,26 @@
 #import "MapModelInfo.h"
 
 @implementation MapModelInfo
 + (instancetype)infoWithRad: (int)rad
-                          h: (int)h
-                       zoff: (int)zoff
-                       snap: (int)snap
-                       name: (OFString *)name
+			  h: (int)h
+		       zoff: (int)zoff
+		       snap: (int)snap
+		       name: (OFString *)name
 {
 	return [[self alloc] initWithRad: rad
 				       h: h
 				    zoff: zoff
 				    snap: snap
 				    name: name];
 }
 
 - (instancetype)initWithRad: (int)rad
-                          h: (int)h
-                       zoff: (int)zoff
-                       snap: (int)snap
-                       name: (OFString *)name
+			  h: (int)h
+		       zoff: (int)zoff
+		       snap: (int)snap
+		       name: (OFString *)name
 {
 	self = [super init];
 
 	_rad = rad;
 	_h = h;

Index: src/Monster.h
==================================================================
--- src/Monster.h
+++ src/Monster.h
@@ -25,16 +25,16 @@
 + (void)thinkAll;
 + (void)renderAll;
 // TODO: Move this somewhere else
 + (void)endSinglePlayerWithAllKilled: (bool)allKilled;
 + (instancetype)monsterWithType: (int)type
-                            yaw: (int)yaw
-                          state: (int)state
-                        trigger: (int)trigger
-                           move: (int)move;
+			    yaw: (int)yaw
+			  state: (int)state
+			trigger: (int)trigger
+			   move: (int)move;
 - (instancetype)initWithType: (int)type
-                         yaw: (int)yaw
-                       state: (int)state
-                     trigger: (int)trigger
-                        move: (int)move;
+			 yaw: (int)yaw
+		       state: (int)state
+		     trigger: (int)trigger
+			move: (int)move;
 - (void)incurDamage: (int)damage fromEntity: (__kindof DynamicEntity *)d;
 @end

Index: src/Monster.m
==================================================================
--- src/Monster.m
+++ src/Monster.m
@@ -21,20 +21,20 @@
 {
 	return monsters;
 }
 
 + (instancetype)monsterWithType: (int)type
-                            yaw: (int)yaw
-                          state: (int)state
-                        trigger: (int)trigger
-                           move: (int)move
+			    yaw: (int)yaw
+			  state: (int)state
+			trigger: (int)trigger
+			   move: (int)move
 {
 	return [[self alloc] initWithType: type
-	                              yaw: yaw
-	                            state: state
-	                          trigger: trigger
-	                             move: move];
+				      yaw: yaw
+				    state: state
+				  trigger: trigger
+				     move: move];
 }
 
 VARF(skill, 1, 3, 10, conoutf(@"skill is now %d", skill));
 
 // for savegames
@@ -74,14 +74,14 @@
 	{ GUN_SLIMEBALL, 15, 100, 1, 0, 200, 400, 2, 13, 10, S_PAIND, S_DEATHD,
 	    @"a goblin", @"monster/goblin" },
 };
 
 - (instancetype)initWithType: (int)type
-                         yaw: (int)yaw
-                       state: (int)state
-                     trigger: (int)trigger
-                        move: (int)move
+			 yaw: (int)yaw
+		       state: (int)state
+		     trigger: (int)trigger
+			move: (int)move
 {
 	self = [super init];
 
 	if (type >= NUMMONSTERTYPES) {
 		conoutf(@"warning: unknown monster in spawn: %d", type);
@@ -170,14 +170,14 @@
 		for (Entity *e in ents) {
 			if (e.type != MONSTER)
 				continue;
 
 			Monster *m = [Monster monsterWithType: e.attr2
-			                                  yaw: e.attr1
-			                                state: M_SLEEP
-			                              trigger: 100
-			                                 move: 0];
+							  yaw: e.attr1
+							state: M_SLEEP
+						      trigger: 100
+							 move: 0];
 			m.origin = OFMakeVector3D(e.x, e.y, e.z);
 			[monsters addObject: m];
 			entinmap(m);
 			monstertotal++;
 		}
@@ -287,20 +287,18 @@
 		else if (self.trigger < lastmillis &&
 		    (self.monsterState != M_HOME || !rnd(5))) {
 			// patented "random walk" AI pathfinding (tm) ;)
 			self.targetYaw += 180 + rnd(180);
 			[self transitionWithState: M_SEARCH
-			                   moving: 1
-			                        n: 400
-			                        r: 1000];
+					   moving: 1
+						n: 400
+						r: 1000];
 		}
 	}
 
 	float enemyYaw = -(float)atan2(self.enemy.origin.x - self.origin.x,
-	                     self.enemy.origin.y - self.origin.y) /
-	        PI * 180 +
-	    180;
+	    self.enemy.origin.y - self.origin.y) / PI * 180 + 180;
 
 	switch (self.monsterState) {
 	case M_PAIN:
 	case M_ATTACKING:
 	case M_SEARCH:
@@ -309,21 +307,20 @@
 					   moving: 1
 						n: 100
 						r: 200];
 		break;
 
-	case M_SLEEP: // state classic sp monster start in, wait for visual
-	              // contact
-	{
+		// state classic sp monster start in, wait for visual contact
+	case M_SLEEP: {
 		OFVector3D target;
 		if (editmode || !enemylos(self, &target))
 			return; // skip running physics
 		[self normalizeWithAngle: enemyYaw];
 		float angle = (float)fabs(enemyYaw - self.yaw);
-		if (disttoenemy < 8 // the better the angle to the player, the
-		                    // further the monster can see/hear
-		    || (disttoenemy < 16 && angle < 135) ||
+		// the better the angle to the player, the further the monster
+		// can see/hear
+		if (disttoenemy < 8 || (disttoenemy < 16 && angle < 135) ||
 		    (disttoenemy < 32 && angle < 90) ||
 		    (disttoenemy < 64 && angle < 45) || angle < 10) {
 			[self transitionWithState: M_HOME
 					   moving: 1
 						n: 500
@@ -340,13 +337,13 @@
 		if (self.trigger < lastmillis) {
 			self.lastAction = 0;
 			self.attacking = true;
 			shoot(self, self.attackTarget);
 			[self transitionWithState: M_ATTACKING
-			                   moving: 0
-			                        n: 600
-			                        r: 0];
+					   moving: 0
+						n: 600
+						r: 0];
 		}
 		break;
 
 	case M_HOME:
 		// monster has visual contact, heads straight for player and
@@ -356,13 +353,13 @@
 			OFVector3D target;
 			if (!enemylos(self, &target)) {
 				// no visual contact anymore, let monster get
 				// as close as possible then search for player
 				[self transitionWithState: M_HOME
-				                   moving: 1
-				                        n: 800
-				                        r: 500];
+						   moving: 1
+							n: 800
+							r: 500];
 			} else {
 				// the closer the monster is the more likely he
 				// wants to shoot
 				if (!rnd((int)disttoenemy / 3 + 1) &&
 				    self.enemy.state == CS_ALIVE) {
@@ -369,21 +366,21 @@
 					// get ready to fire
 					self.attackTarget = target;
 					int n =
 					    monstertypes[self.monsterType].lag;
 					[self transitionWithState: M_AIMING
-					                   moving: 0
-					                        n: n
-					                        r: 10];
+							   moving: 0
+								n: n
+								r: 10];
 				} else {
 					// track player some more
 					int n =
 					    monstertypes[self.monsterType].rate;
 					[self transitionWithState: M_HOME
-					                   moving: 1
-					                        n: n
-					                        r: 0];
+							   moving: 1
+								n: n
+								r: 0];
 				}
 			}
 		}
 		break;
 	}
@@ -399,13 +396,12 @@
 
 		// guard for RL guys shooting themselves :)
 		if (self != m) {
 			// don't attack straight away, first get angry
 			self.anger++;
-			int anger =
-			    (self.monsterType == m.monsterType ? self.anger / 2
-			                                       : self.anger);
+			int anger = (self.monsterType == m.monsterType
+			    ? self.anger / 2 : self.anger);
 			if (anger >= monstertypes[self.monsterType].loyalty)
 				// monster infight if very angry
 				self.enemy = m;
 		}
 	} else {
@@ -414,13 +410,13 @@
 		self.enemy = d;
 	}
 
 	// in this state monster won't attack
 	[self transitionWithState: M_PAIN
-	                   moving: 0
-	                        n: monstertypes[self.monsterType].pain
-	                        r: 200];
+			   moving: 0
+				n: monstertypes[self.monsterType].pain
+				r: 200];
 
 	if ((self.health -= damage) <= 0) {
 		self.state = CS_DEAD;
 		self.lastAction = lastmillis;
 		numkilled++;
@@ -436,12 +432,12 @@
 	}
 }
 
 + (void)endSinglePlayerWithAllKilled: (bool)allKilled
 {
-	conoutf(allKilled ? @"you have cleared the map!"
-	                  : @"you reached the exit!");
+	conoutf(allKilled
+	    ? @"you have cleared the map!" : @"you reached the exit!");
 	conoutf(@"score: %d kills in %d seconds", numkilled,
 	    (lastmillis - mtimestart) / 1000);
 	monstertotal = 0;
 	startintermission();
 }

Index: src/Variable.h
==================================================================
--- src/Variable.h
+++ src/Variable.h
@@ -6,33 +6,33 @@
 	int name = cur;							\
 									\
 	OF_CONSTRUCTOR()						\
 	{								\
 		enqueueInit(^ {						\
-			Variable *variable =				\
-			    [Variable variableWithName: @#name		\
-			                           min: min_		\
-			                           max: max_		\
-			                       storage: &name		\
-			                      function: NULL		\
-			                     persisted: true];		\
+			Variable *variable = [Variable			\
+			    variableWithName: @#name			\
+					 min: min_			\
+					 max: max_			\
+				     storage: &name			\
+				    function: NULL			\
+				   persisted: true];			\
 			Identifier.identifiers[@#name] = variable;	\
 		});							\
 	}
 #define VAR(name, min_, cur, max_)					\
 	int name = cur;							\
 									\
 	OF_CONSTRUCTOR()						\
 	{								\
 		enqueueInit(^ {						\
-			Variable *variable =				\
-			    [Variable variableWithName: @#name		\
-			                           min: min_		\
-			                           max: max_		\
-			                       storage: &name		\
-			                      function: NULL		\
-			                     persisted: false];		\
+			Variable *variable = [Variable			\
+			    variableWithName: @#name			\
+					 min: min_			\
+					 max: max_			\
+				     storage: &name			\
+				    function: NULL			\
+				   persisted: false];			\
 			Identifier.identifiers[@#name] = variable;	\
 		});							\
 	}
 #define VARF(name, min_, cur, max_, body)				\
 	static void var_##name(void);					\
@@ -39,17 +39,17 @@
 	static int name = cur;						\
 									\
 	OF_CONSTRUCTOR()						\
 	{								\
 		enqueueInit(^ {						\
-			Variable *variable =				\
-			    [Variable variableWithName: @#name		\
-			                           min: min_		\
-			                           max: max_		\
-			                       storage: &name		\
-			                      function: var_##name	\
-			                     persisted: false];		\
+			Variable *variable = [Variable			\
+			    variableWithName: @#name			\
+					 min: min_			\
+					 max: max_			\
+				     storage: &name			\
+				    function: var_##name		\
+				   persisted: false];			\
 			Identifier.identifiers[@#name] = variable;	\
 		});							\
 	}								\
 									\
 	static void							\
@@ -62,17 +62,17 @@
 	static int name = cur;						\
 									\
 	OF_CONSTRUCTOR()						\
 	{								\
 		enqueueInit(^ {						\
-			Variable *variable =				\
-			    [Variable variableWithName: @#name		\
-			                           min: min_		\
-			                           max: max_		\
-			                       storage: &name		\
-			                      function: var_##name	\
-			                     persisted: true];		\
+			Variable *variable = [Variable			\
+			variableWithName: @#name			\
+				     min: min_				\
+				     max: max_				\
+				 storage: &name				\
+				function: var_##name			\
+			       persisted: true];			\
 			Identifier.identifiers[@#name] = variable;	\
 		});							\
 	}								\
 									\
 	static void							\
@@ -86,23 +86,23 @@
 @property (direct, readonly, nonatomic) int *storage;
 @property (direct, readonly, nullable, nonatomic) void (*function)();
 @property (readonly, nonatomic) bool persisted;
 
 + (instancetype)variableWithName: (OFString *)name
-                             min: (int)min
-                             max: (int)max
-                         storage: (int *)storage
-                        function: (void (*_Nullable)())function
-                       persisted: (bool)persisted OF_DIRECT;
+			     min: (int)min
+			     max: (int)max
+			 storage: (int *)storage
+			function: (void (*_Nullable)())function
+		       persisted: (bool)persisted OF_DIRECT;
 - (instancetype)initWithName: (OFString *)name OF_UNAVAILABLE;
 - (instancetype)initWithName: (OFString *)name
-                         min: (int)min
-                         max: (int)max
-                     storage: (int *)storage
-                    function: (void (*_Nullable)())function
-                   persisted: (bool)persisted OF_DESIGNATED_INITIALIZER
+			 min: (int)min
+			 max: (int)max
+		     storage: (int *)storage
+		    function: (void (*_Nullable)())function
+		   persisted: (bool)persisted OF_DESIGNATED_INITIALIZER
     OF_DIRECT;
 - (void)printValue OF_DIRECT;
 - (void)setValue: (int)value OF_DIRECT;
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/Variable.m
==================================================================
--- src/Variable.m
+++ src/Variable.m
@@ -2,30 +2,30 @@
 
 #include "cube.h"
 
 @implementation Variable
 + (instancetype)variableWithName: (OFString *)name
-                             min: (int)min
-                             max: (int)max
-                         storage: (int *)storage
-                        function: (void (*__cdecl)())function
-                       persisted: (bool)persisted
+			     min: (int)min
+			     max: (int)max
+			 storage: (int *)storage
+			function: (void (*__cdecl)())function
+		       persisted: (bool)persisted
 {
 	return [[self alloc] initWithName: name
-	                              min: min
-	                              max: max
-	                          storage: storage
-	                         function: function
-	                        persisted: persisted];
+				      min: min
+				      max: max
+				  storage: storage
+				 function: function
+				persisted: persisted];
 }
 
 - (instancetype)initWithName: (OFString *)name
-                         min: (int)min
-                         max: (int)max
-                     storage: (int *)storage
-                    function: (void (*__cdecl)())function
-                   persisted: (bool)persisted
+			 min: (int)min
+			 max: (int)max
+		     storage: (int *)storage
+		    function: (void (*__cdecl)())function
+		   persisted: (bool)persisted
 {
 	self = [super initWithName: name];
 
 	_min = min;
 	_max = max;

Index: src/clientextras.m
==================================================================
--- src/clientextras.m
+++ src/clientextras.m
@@ -8,16 +8,19 @@
 
 // render players & monsters
 // very messy ad-hoc handling of animation frames, should be made more
 // configurable
 
-//              D    D    D    D'   D    D    D    D'   A   A'  P   P'  I   I'
-//              R,  R'  E    L    J   J'
-int frame[] = { 178, 184, 190, 137, 183, 189, 197, 164, 46, 51, 54, 32, 0, 0,
-	40, 1, 162, 162, 67, 168 };
-int range[] = { 6, 6, 8, 28, 1, 1, 1, 1, 8, 19, 4, 18, 40, 1, 6, 15, 1, 1, 1,
-	1 };
+// D    D    D    D'   D    D    D    D'   A   A'  P   P'  I   I'
+// R,  R'  E    L    J   J'
+int frame[] = {
+	178, 184, 190, 137, 183, 189, 197, 164, 46, 51, 54, 32, 0, 0, 40, 1,
+	162, 162, 67, 168
+};
+int range[] = {
+	6, 6, 8, 28, 1, 1, 1, 1, 8, 19, 4, 18, 40, 1, 6, 15, 1, 1, 1, 1
+};
 
 void
 renderclient(
     DynamicEntity *d, bool team, OFString *mdlname, bool hellpig, float scale)
 {

Index: src/clientgame.m
==================================================================
--- src/clientgame.m
+++ src/clientgame.m
@@ -311,17 +311,13 @@
 	if (ad > Player.player1.armour)
 		ad = Player.player1.armour;
 	player1.armour -= ad;
 	damage -= ad;
 	float droll = damage / 0.5f;
-	player1.roll += player1.roll > 0
-	    ? droll
-	    : (player1.roll < 0
-	              ? -droll
-	              : (rnd(2) ? droll
-	                        : -droll)); // give player a kick depending
-	                                    // on amount of damage
+	// give player a kick depending on amount of damage
+	player1.roll += player1.roll > 0 ? droll : (player1.roll < 0 ? -droll :
+	    (rnd(2) ? droll : -droll));
 	if ((player1.health -= damage) <= 0) {
 		if (actor == -2) {
 			conoutf(@"you got killed by %@!", act.name);
 		} else if (actor == -1) {
 			actor = getclientnum();
@@ -330,12 +326,11 @@
 		} else {
 			Player *a = getclient(actor);
 			if (a != nil) {
 				if (isteam(a.team, player1.team))
 					conoutf(@"you got fragged by a "
-					        @"teammate (%@)",
-					    a.name);
+					    @"teammate (%@)", a.name);
 				else
 					conoutf(
 					    @"you got fragged by %@", a.name);
 			}
 		}

Index: src/clients.m
==================================================================
--- src/clients.m
+++ src/clients.m
@@ -41,12 +41,12 @@
 
 	return allow;
 }
 
 VARF(rate, 0, 0, 25000,
-    if (clienthost && (!rate || rate > 1000))
-        enet_host_bandwidth_limit(clienthost, rate, rate));
+	if (clienthost && (!rate || rate > 1000))
+		enet_host_bandwidth_limit(clienthost, rate, rate));
 
 void throttle();
 
 VARF(throttle_interval, 0, 5, 30, throttle());
 VARF(throttle_accel, 0, 2, 32, throttle());
@@ -214,11 +214,11 @@
 		conoutf(@"command flood protection (type %d)", type);
 		return;
 	}
 
 	OFMutableData *msg = [OFMutableData dataWithItemSize: sizeof(int)
-	                                            capacity: num + 2];
+						    capacity: num + 2];
 	[msg addItem: &num];
 	[msg addItem: &rel];
 	[msg addItem: &type];
 
 	va_list marker;

Index: src/clients2c.m
==================================================================
--- src/clients2c.m
+++ src/clients2c.m
@@ -43,21 +43,19 @@
 	const float dx = player1.origin.x - d.origin.x;
 	const float dy = player1.origin.y - d.origin.y;
 	const float dz = player1.origin.z - d.origin.z;
 	const float rz = player1.aboveEye + d.eyeHeight;
 	const float fx = (float)fabs(dx), fy = (float)fabs(dy),
-	            fz = (float)fabs(dz);
+	    fz = (float)fabs(dz);
 	if (fx < r && fy < r && fz < rz && d.state != CS_DEAD) {
 		if (fx < fy)
 			// push aside
-			d.origin = OFAddVectors3D(d.origin,
-			    OFMakeVector3D(
-			        0, (dy < 0 ? r - fy : -(r - fy)), 0));
+			d.origin = OFAddVectors3D(d.origin, OFMakeVector3D(
+			    0, (dy < 0 ? r - fy : -(r - fy)), 0));
 		else
-			d.origin = OFAddVectors3D(d.origin,
-			    OFMakeVector3D(
-			        (dx < 0 ? r - fx : -(r - fx)), 0, 0));
+			d.origin = OFAddVectors3D(d.origin, OFMakeVector3D(
+			    (dx < 0 ? r - fx : -(r - fx)), 0, 0));
 	}
 	int lagtime = lastmillis - d.lastUpdate;
 	if (lagtime) {
 		d.lag = (d.lag * 5 + lagtime) / 6;
 		d.lastUpdate = lastmillis;
@@ -85,11 +83,11 @@
 		{
 			cn = getint(&p);
 			int prot = getint(&p);
 			if (prot != PROTOCOL_VERSION) {
 				conoutf(@"you are using a different game "
-				        @"protocol (you: %d, server: %d)",
+				    @"protocol (you: %d, server: %d)",
 				    PROTOCOL_VERSION, prot);
 				disconnect(false, false);
 				return;
 			}
 			toservermap = @"";
@@ -100,11 +98,11 @@
 				toservermap = getclientmap();
 			sgetstr();
 			if (text[0] &&
 			    strcmp(text, clientpassword.UTF8String)) {
 				conoutf(@"you need to set the correct password "
-				        @"to join this server!");
+				    @"to join this server!");
 				disconnect(false, false);
 				return;
 			}
 			if (getint(&p) == 1)
 				conoutf(@"server is FULL, disconnecting..");
@@ -263,12 +261,12 @@
 			} else {
 				Player *a = getclient(actor);
 				if (a != nil) {
 					if (isteam(a.team, d.name))
 						conoutf(@"%@ fragged his "
-						        @"teammate (%@)",
-						    a.name, d.name);
+						    @"teammate (%@)", a.name,
+						    d.name);
 					else
 						conoutf(@"%@ fragged %@",
 						    a.name, d.name);
 				}
 			}
@@ -301,12 +299,13 @@
 		// server acknowledges that I picked up this item
 		case SV_ITEMACC:
 			realpickup(getint(&p), Player.player1);
 			break;
 
-		case SV_EDITH: // coop editing messages, should be extended to
-		               // include all possible editing ops
+		// coop editing messages, should be extended to include all
+		// possible editing ops
+		case SV_EDITH:
 		case SV_EDITT:
 		case SV_EDITS:
 		case SV_EDITD:
 		case SV_EDITE: {
 			int x = getint(&p);
@@ -365,12 +364,11 @@
 			break;
 
 		case SV_PONG:
 			addmsg(0, 2, SV_CLIENTPING,
 			    Player.player1.ping = (Player.player1.ping * 5 +
-			                              lastmillis - getint(&p)) /
-			        6);
+				lastmillis - getint(&p)) / 6);
 			break;
 
 		case SV_CLIENTPING:
 			OFAssert([players[cn] isKindOfClass: Player.class]);
 			((Player *)players[cn]).ping = getint(&p);
@@ -399,13 +397,13 @@
 		case SV_SERVMSG:
 			sgetstr();
 			conoutf(@"%s", text);
 			break;
 
-		case SV_EXT: // so we can messages without breaking previous
-		             // clients/servers, if necessary
-		{
+		// so we can messages without breaking previous
+		// clients/servers, if necessary
+		case SV_EXT: {
 			for (int n = getint(&p); n; n--)
 				getint(&p);
 			break;
 		}
 

Index: src/commands.m
==================================================================
--- src/commands.m
+++ src/commands.m
@@ -20,12 +20,12 @@
 {
 	Alias *alias = Identifier.identifiers[name];
 
 	if (alias == nil)
 		Identifier.identifiers[name] = [Alias aliasWithName: name
-		                                             action: action
-		                                          persisted: true];
+							     action: action
+							  persisted: true];
 	else {
 		if ([alias isKindOfClass: Alias.class])
 			alias.action = action;
 		else
 			conoutf(

Index: src/console.m
==================================================================
--- src/console.m
+++ src/console.m
@@ -60,11 +60,11 @@
 {
 	va_list arguments;
 	va_start(arguments, format);
 
 	OFString *string = [[OFString alloc] initWithFormat: format
-	                                          arguments: arguments];
+						  arguments: arguments];
 
 	va_end(arguments);
 
 	int n = 0;
 	while (string.length > WORDWRAP) {
@@ -81,12 +81,12 @@
 	int nd = 0;
 	OFString *refs[ndraw];
 
 	size_t i = 0;
 	for (ConsoleLine *conline in conlines) {
-		if (conskip ? i >= conskip - 1 || i >= conlines.count - ndraw
-		            : lastmillis - conline.outtime < 20000) {
+		if (conskip ? i >= conskip - 1 || i >= conlines.count - ndraw :
+		    lastmillis - conline.outtime < 20000) {
 			refs[nd++] = conline.text;
 			if (nd == ndraw)
 				break;
 		}
 
@@ -105,11 +105,11 @@
 COMMAND(keymap, ARG_3STR, ^ (OFString *code, OFString *key, OFString *action) {
 	if (keyMappings == nil)
 		keyMappings = [[OFMutableArray alloc] init];
 
 	KeyMapping *mapping = [KeyMapping mappingWithCode: code.cube_intValue
-	                                             name: key];
+						     name: key];
 	mapping.action = action;
 	[keyMappings addObject: mapping];
 })
 
 COMMAND(bind, ARG_2STR, ^ (OFString *key, OFString *action) {
@@ -183,12 +183,12 @@
 
 			case SDLK_BACKSPACE:
 			case SDLK_LEFT:
 				if (commandbuf.length > 0)
 					[commandbuf deleteCharactersInRange:
-					        OFMakeRange(
-					            commandbuf.length - 1, 1)];
+					    OFMakeRange(
+					    commandbuf.length - 1, 1)];
 
 				resetcomplete();
 				break;
 
 			case SDLK_UP:
@@ -219,13 +219,12 @@
 			}
 		} else {
 			if (code == SDLK_RETURN) {
 				if (commandbuf.length > 0) {
 					if (vhistory == nil)
-						vhistory =
-						    [[OFMutableArray alloc]
-						        init];
+						vhistory = [[OFMutableArray
+						    alloc] init];
 
 					if (vhistory.count == 0 ||
 					    ![vhistory.lastObject isEqual:
 					    commandbuf]) {
 						// cap this?

Index: src/cube.h
==================================================================
--- src/cube.h
+++ src/cube.h
@@ -106,12 +106,12 @@
 #define SMALLEST_FACTOR 6       // determines number of mips there can be
 #define DEFAULT_FACTOR 8
 #define LARGEST_FACTOR 11 // 10 is already insane
 #define SOLID(x) ((x)->type == SOLID)
 #define MINBORD 2 // 2 cubes from the edge of the world are always solid
-#define OUTBORD(x, y)                                                \
-	((x) < MINBORD || (y) < MINBORD || (x) >= ssize - MINBORD || \
+#define OUTBORD(x, y)							\
+	((x) < MINBORD || (y) < MINBORD || (x) >= ssize - MINBORD ||	\
 	    (y) >= ssize - MINBORD)
 
 struct block {
 	int x, y, xs, ys;
 };
@@ -253,20 +253,20 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
 // map data, the mips are sequential 2D arrays in memory
 extern struct sqr *world, *wmip[];
-extern struct header hdr;      // current map header
-extern int sfactor, ssize;     // ssize = 2^sfactor
-extern int cubicsize, mipsize; // cubicsize = ssize^2
+extern struct header hdr;	// current map header
+extern int sfactor, ssize;	// ssize = 2^sfactor
+extern int cubicsize, mipsize;	// cubicsize = ssize^2
 // all the other clients (in multiplayer)
 extern OFMutableArray *players;
 extern bool editmode;
 extern OFMutableArray<Entity *> *ents; // map entities
-extern OFVector3D worldpos; // current target of the crosshair in the world
-extern int lastmillis;      // last time
-extern int curtime;         // current frame time
+extern OFVector3D worldpos;	// current target of the crosshair in the world
+extern int lastmillis;		// last time
+extern int curtime;		// current frame time
 extern int gamemode, nextmode;
 extern int xtraverts;
 extern bool demoplayback;
 #ifdef __cplusplus
 }
@@ -282,26 +282,26 @@
 #define PIXELTAB (VIRTW / 12)
 
 #define PI (3.1415927f)
 #define PI2 (2 * PI)
 
-#define vreject(v, u, max)                                 \
-	((v).x > (u).x + (max) || (v).x < (u).x - (max) || \
-	    (v).y > (u).y + (max) || (v).y < (u).y - (max))
-#define vlinterp(v, f, u, g)                   \
-	{                                      \
-		(v).x = (v).x * f + (u).x * g; \
-		(v).y = (v).y * f + (u).y * g; \
-		(v).z = (v).z * f + (u).z * g; \
-	}
-
-#define sgetstr()                        \
-	{                                \
-		char *t = text;          \
-		do {                     \
-			*t = getint(&p); \
-		} while (*t++);          \
+#define vreject(v, u, max)					\
+	((v).x > (u).x + (max) || (v).x < (u).x - (max) ||	\
+	    (v).y > (u).y + (max) || (v).y < (u).y - (max))
+#define vlinterp(v, f, u, g)			\
+	{					\
+		(v).x = (v).x * f + (u).x * g;	\
+		(v).y = (v).y * f + (u).y * g;	\
+		(v).z = (v).z * f + (u).z * g;	\
+	}
+
+#define sgetstr()				\
+	{					\
+		char *t = text;			\
+		do {				\
+			*t = getint(&p);	\
+		} while (*t++);			\
 	} // used by networking
 
 #define m_noitems (gamemode >= 4)
 #define m_noitemsrail (gamemode <= 5)
 #define m_arena (gamemode >= 8)

Index: src/editing.m
==================================================================
--- src/editing.m
+++ src/editing.m
@@ -41,20 +41,20 @@
 }
 
 int selh = 0;
 bool selset = false;
 
-#define loopselxy(b)                                                       \
-	{                                                                  \
-		makeundo();                                                \
-		for (int x = 0; x < sel->xs; x++) {                        \
-			for (int y = 0; y < sel->ys; y++) {                \
+#define loopselxy(b)							   \
+	{								   \
+		makeundo();						   \
+		for (int x = 0; x < sel->xs; x++) {			   \
+			for (int y = 0; y < sel->ys; y++) {		   \
 				struct sqr *s = S(sel->x + x, sel->y + y); \
-				b;                                         \
-			}                                                  \
-		}                                                          \
-		remip(sel, 0);                                             \
+				b;					   \
+			}						   \
+		}							   \
+		remip(sel, 0);						   \
 	}
 
 int cx, cy, ch;
 
 int curedittex[] = { -1, -1, -1 };
@@ -70,20 +70,23 @@
 void
 toggleedit()
 {
 	Player *player1 = Player.player1;
 	if (player1.state == CS_DEAD)
-		return; // do not allow dead players to edit to avoid state
-		        // confusion
+		// do not allow dead players to edit to avoid state
+		return;
 	if (!editmode && !allowedittoggle())
-		return; // not in most multiplayer modes
+		// not in most multiplayer modes
+		return;
 	if (!(editmode = !editmode)) {
-		settagareas();     // reset triggers to allow quick playtesting
-		entinmap(player1); // find spawn closest to current floating pos
+		// reset triggers to allow quick playtesting
+		settagareas();
+		// find spawn closest to current floating pos
+		entinmap(player1);
 	} else {
-		resettagareas(); // clear trigger areas to allow them to be
-		                 // edited
+		// clear trigger areas to allow them to be edited
+		resettagareas();
 		player1.health = 100;
 		if (m_classicsp)
 			// all monsters back at their spawns for editing
 			[Monster resetAll];
 		projreset();
@@ -125,18 +128,18 @@
 	if (!selset)
 		conoutf(@"no selection");
 	return !selset;
 }
 
-#define EDITSEL                             \
-	if (noteditmode() || noselection()) \
-		return;
-#define EDITSELMP                                            \
-	if (noteditmode() || noselection() || multiplayer()) \
-		return;
-#define EDITMP                              \
-	if (noteditmode() || multiplayer()) \
+#define EDITSEL					\
+	if (noteditmode() || noselection())	\
+		return;
+#define EDITSELMP						\
+	if (noteditmode() || noselection() || multiplayer())	\
+		return;
+#define EDITMP					\
+	if (noteditmode() || multiplayer())	\
 		return;
 
 COMMAND(select, ARG_4INT, (^ (int x, int y, int xs, int ys) {
 	struct block s = { x, y, xs, ys };
 	sel = s;
@@ -340,13 +343,13 @@
 	copybuf->x = sel.x;
 	copybuf->y = sel.y;
 	blockpaste(copybuf);
 })
 
+// maintain most recently used of the texture lists when applying texture
 void
-tofronttex() // maintain most recently used of the texture lists when applying
-             // texture
+tofronttex()
 {
 	for (int i = 0; i < 3; i++) {
 		int c = curedittex[i];
 		if (c >= 0) {
 			unsigned char *p = hdr.texlists[i];
@@ -406,24 +409,26 @@
 })
 
 void
 edittexxy(int type, int t, const struct block *sel)
 {
-	loopselxy(switch (type) {
-	        case 0:
-		        s->ftex = t;
-		        break;
-	        case 1:
-		        s->wtex = t;
-		        break;
-	        case 2:
-		        s->ctex = t;
-		        break;
-	        case 3:
-		        s->utex = t;
-		        break;
-	});
+	loopselxy(
+		switch (type) {
+		case 0:
+			s->ftex = t;
+			break;
+		case 1:
+			s->wtex = t;
+			break;
+		case 2:
+			s->ctex = t;
+			break;
+		case 3:
+			s->utex = t;
+			break;
+		}
+	);
 }
 
 COMMAND(edittex, ARG_2INT, ^ (int type, int dir) {
 	EDITSEL;
 
@@ -484,13 +489,12 @@
 static void
 edittype(int type)
 {
 	EDITSEL;
 
-	if (type == CORNER &&
-	    (sel.xs != sel.ys || sel.xs == 3 || (sel.xs > 4 && sel.xs != 8) ||
-	        sel.x & ~-sel.xs || sel.y & ~-sel.ys)) {
+	if (type == CORNER && (sel.xs != sel.ys || sel.xs == 3 || (sel.xs > 4 &&
+	    sel.xs != 8) || sel.x & ~-sel.xs || sel.y & ~-sel.ys)) {
 		conoutf(@"corner selection must be power of 2 aligned");
 		return;
 	}
 
 	edittypexy(type, &sel);
@@ -580,15 +584,14 @@
 		sel.ys = MAXARCHVERT;
 
 	struct block *sel_ = &sel;
 	// Ugly hack to make the macro work.
 	struct block *sel = sel_;
-	loopselxy(s->vdelta = sel->xs > sel->ys
-	        ? (archverts[sel->xs - 1][x] +
-	              (y == 0 || y == sel->ys - 1 ? sidedelta : 0))
-	        : (archverts[sel->ys - 1][y] +
-	              (x == 0 || x == sel->xs - 1 ? sidedelta : 0)));
+	loopselxy(s->vdelta = sel->xs > sel->ys ? (archverts[sel->xs - 1][x] +
+	    (y == 0 || y == sel->ys - 1 ? sidedelta : 0)) :
+	    (archverts[sel->ys - 1][y] + (x == 0 || x == sel->xs - 1 ?
+	    sidedelta : 0)));
 	remipmore(sel, 0);
 })
 
 COMMAND(slope, ARG_2INT, ^ (int xd, int yd) {
 	EDITSELMP;

Index: src/entities.m
==================================================================
--- src/entities.m
+++ src/entities.m
@@ -49,28 +49,26 @@
 		if (e.type == MAPMODEL) {
 			MapModelInfo *mmi = getmminfo(e.attr2);
 			if (mmi == nil)
 				continue;
 			rendermodel(mmi.name, 0, 1, e.attr4, (float)mmi.rad,
-			    OFMakeVector3D(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, 0);
+			    OFMakeVector3D(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, 0);
 		} else {
 			if (OUTBORD(e.x, e.y))
 				continue;
 			if (e.type != CARROT) {
 				if (!e.spawned && e.type != TELEPORT)
 					continue;
 				if (e.type < I_SHELLS || e.type > TELEPORT)
 					continue;
 				renderent(e, entmdlnames[e.type - I_SHELLS],
-				    (float)(1 +
-				        sin(lastmillis / 100.0 + e.x + e.y) /
-				            20),
-				    lastmillis / 10.0f, 0, 1, 0, 10.0f);
+				    (float)(1 + sin(lastmillis / 100.0 + e.x +
+				    e.y) / 20), lastmillis / 10.0f, 0, 1, 0,
+				    10.0f);
 			} else {
 				switch (e.attr2) {
 				case 1:
 				case 3:
 					continue;
@@ -77,36 +75,30 @@
 
 				case 2:
 				case 0:
 					if (!e.spawned)
 						continue;
-					renderent(e, @"carrot",
-					    (float)(1 +
-					        sin(lastmillis / 100.0 + e.x +
-					            e.y) /
-					            20),
-					    lastmillis /
-					        (e.attr2 ? 1.0f : 10.0f),
-					    0, 1, 0, 10.0f);
+					renderent(e, @"carrot", (float)(1 +
+					    sin(lastmillis / 100.0 + e.x +
+					    e.y) / 20), lastmillis / (e.attr2 ?
+					    1.0f : 10.0f), 0, 1, 0, 10.0f);
 					break;
 
 				case 4:
 					renderent(e, @"switch2", 3,
 					    (float)e.attr3 * 90,
-					    (!e.spawned && !triggertime) ? 1
-					                                 : 0,
-					    (e.spawned || !triggertime) ? 1 : 2,
-					    triggertime, 1050.0f);
+					    (!e.spawned && !triggertime) ?
+					    1 : 0, (e.spawned || !triggertime) ?
+					    1 : 2, triggertime, 1050.0f);
 					break;
 				case 5:
 					renderent(e, @"switch1", -0.15f,
 					    (float)e.attr3 * 90,
-					    (!e.spawned && !triggertime) ? 30
-					                                 : 0,
-					    (e.spawned || !triggertime) ? 1
-					                                : 30,
-					    triggertime, 35.0f);
+					    (!e.spawned && !triggertime) ?
+					    30 : 0, (e.spawned ||
+					    !triggertime) ? 1 : 30, triggertime,
+					    35.0f);
 					break;
 				}
 			}
 		}
 	}

Index: src/physics.m
==================================================================
--- src/physics.m
+++ src/physics.m
@@ -13,12 +13,12 @@
 #import "Player.h"
 #import "Variable.h"
 
 // collide with player or monster
 static bool
-plcollide(
-    DynamicEntity *d, DynamicEntity *o, float *headspace, float *hi, float *lo)
+plcollide(DynamicEntity *d, DynamicEntity *o, float *headspace, float *hi,
+    float *lo)
 {
 	if (o.state != CS_ALIVE)
 		return true;
 
 	const float r = o.radius + d.radius;
@@ -123,42 +123,33 @@
 			switch (s->type) {
 			case SOLID:
 				return false;
 			case CORNER: {
 				int bx = x, by = y, bs = 1;
-				if ((x == x1 && y == y1 &&
-				        cornertest(
-				            0, x, y, -1, -1, &bx, &by, &bs) &&
-				        fx1 - bx + fy1 - by <= bs) ||
-				    (x == x2 && y == y1 &&
-				        cornertest(
-				            0, x, y, 1, -1, &bx, &by, &bs) &&
-				        fx2 - bx >= fy1 - by) ||
-				    (x == x1 && y == y2 &&
-				        cornertest(
-				            0, x, y, -1, 1, &bx, &by, &bs) &&
-				        fx1 - bx <= fy2 - by) ||
-				    (x == x2 && y == y2 &&
-				        cornertest(
-				            0, x, y, 1, 1, &bx, &by, &bs) &&
-				        fx2 - bx + fy2 - by >= bs))
+				if ((x == x1 && y == y1 && cornertest(0, x, y,
+				    -1, -1, &bx, &by, &bs) && fx1 - bx + fy1 -
+				    by <= bs) || (x == x2 && y == y1 &&
+				    cornertest(0, x, y, 1, -1, &bx, &by, &bs) &&
+				    fx2 - bx >= fy1 - by) || (x == x1 && y ==
+				    y2 && cornertest(0, x, y, -1, 1, &bx, &by,
+				    &bs) && fx1 - bx <= fy2 - by) || (x == x2 &&
+				    y == y2 && cornertest(0, x, y, 1, 1, &bx,
+				    &by, &bs) && fx2 - bx + fy2 - by >= bs))
 					return false;
 				break;
 			}
 			// FIXME: too simplistic collision with slopes, makes
 			// it feels like tiny stairs
 			case FHF:
 				floor -= (s->vdelta + S(x + 1, y)->vdelta +
-				             S(x, y + 1)->vdelta +
-				             S(x + 1, y + 1)->vdelta) /
-				    16.0f;
+				    S(x, y + 1)->vdelta +
+				    S(x + 1, y + 1)->vdelta) / 16.0f;
 				break;
 			case CHF:
 				ceil += (s->vdelta + S(x + 1, y)->vdelta +
-				            S(x, y + 1)->vdelta +
-				            S(x + 1, y + 1)->vdelta) /
-				    16.0f;
+				    S(x, y + 1)->vdelta +
+				    S(x + 1, y + 1)->vdelta) / 16.0f;
 			}
 
 			if (ceil < hi)
 				hi = ceil;
 			if (floor > lo)
@@ -212,13 +203,12 @@
 				    d.origin, OFMakeVector3D(0, 0, rise));
 			else
 				return false;
 		} else
 			// gravity
-			d.origin = OFSubtractVectors3D(d.origin,
-			    OFMakeVector3D(
-			        0, 0, min(min(drop, space), headspace)));
+			d.origin = OFSubtractVectors3D(d.origin, OFMakeVector3D(
+			    0, 0, min(min(drop, space), headspace)));
 
 		const float space2 = hi - (d.origin.z + d.aboveEye);
 		if (space2 < 0) {
 			if (space2 < -0.1)
 				return false; // hack alert!
@@ -405,15 +395,14 @@
 	if (pl.origin.x < 0 || pl.origin.x >= ssize || pl.origin.y < 0 ||
 	    pl.origin.y > ssize)
 		pl.outsideMap = true;
 	else {
 		struct sqr *s = S((int)pl.origin.x, (int)pl.origin.y);
-		pl.outsideMap = SOLID(s) ||
-		    pl.origin.z <
-		        s->floor - (s->type == FHF ? s->vdelta / 4 : 0) ||
-		    pl.origin.z >
-		        s->ceil + (s->type == CHF ? s->vdelta / 4 : 0);
+		pl.outsideMap = (SOLID(s) || pl.origin.z < s->floor -
+		    (s->type == FHF ? s->vdelta / 4 : 0) ||
+		    pl.origin.z > s->ceil + (s->type == CHF
+		    ? s->vdelta / 4 : 0));
 	}
 
 	// automatically apply smooth roll when strafing
 
 	if (pl.strafe == 0)
@@ -441,10 +430,8 @@
 
 void
 moveplayer(DynamicEntity *pl, int moveres, bool local)
 {
 	for (int i = 0; i < physicsrepeat; i++)
-		moveplayer4(pl, moveres, local,
-		    i ? curtime / physicsrepeat
-		      : curtime -
-		            curtime / physicsrepeat * (physicsrepeat - 1));
+		moveplayer4(pl, moveres, local, i ? curtime / physicsrepeat
+		    : curtime - curtime / physicsrepeat * (physicsrepeat - 1));
 }

Index: src/rendercubes.m
==================================================================
--- src/rendercubes.m
+++ src/rendercubes.m
@@ -29,32 +29,32 @@
 
 // generating the actual vertices is done dynamically every frame and sits at
 // the leaves of all these functions, and are part of the cpu bottleneck on
 // really slow machines, hence the macros.
 
-#define vertcheck()                         \
-	{                                   \
-		if (curvert >= curmaxverts) \
-			reallocv();         \
-	}
-
-#define vertf(v1, v2, v3, ls, t1, t2)                 \
-	{                                             \
-		struct vertex *v = &verts[curvert++]; \
-		v->u = t1;                            \
-		v->v = t2;                            \
-		v->x = v1;                            \
-		v->y = v2;                            \
-		v->z = v3;                            \
-		v->r = ls->r;                         \
-		v->g = ls->g;                         \
-		v->b = ls->b;                         \
-		v->a = 255;                           \
-	}
-
-#define vert(v1, v2, v3, ls, t1, t2)                                      \
-	{                                                                 \
+#define vertcheck()				\
+	{					\
+		if (curvert >= curmaxverts)	\
+			reallocv();		\
+	}
+
+#define vertf(v1, v2, v3, ls, t1, t2)			\
+	{						\
+		struct vertex *v = &verts[curvert++];	\
+		v->u = t1;				\
+		v->v = t2;				\
+		v->x = v1;				\
+		v->y = v2;				\
+		v->z = v3;				\
+		v->r = ls->r;				\
+		v->g = ls->g;				\
+		v->b = ls->b;				\
+		v->a = 255;				\
+	}
+
+#define vert(v1, v2, v3, ls, t1, t2)					  \
+	{								  \
 		vertf((float)(v1), (float)(v2), (float)(v3), ls, t1, t2); \
 	}
 
 int nquads;
 const float TEXTURESCALE = 32.0f;
@@ -73,16 +73,16 @@
 {
 	if (showm)
 		conoutf(@"1x1/2x2/4x4: %d / %d / %d", a, b, c);
 }
 
-#define stripend()                                                          \
-	{                                                                   \
-		if (floorstrip || deltastrip) {                             \
+#define stripend()							    \
+	{								    \
+		if (floorstrip || deltastrip) {				    \
 			addstrip(ogltex, firstindex, curvert - firstindex); \
-			floorstrip = deltastrip = false;                    \
-		}                                                           \
+			floorstrip = deltastrip = false;		    \
+		}							    \
 	}
 void
 finishstrips()
 {
 	stripend();
@@ -136,18 +136,17 @@
 		ol4g = l2->g;
 		ol4b = l2->b;
 	} else // continue strip
 	{
 		int lighterr = lighterror * 2;
+		// skip vertices if light values are close enough
 		if ((abs(ol3r - l3->r) < lighterr &&
-		        abs(ol4r - l4->r) < lighterr // skip vertices if light
-		                                     // values are close enough
-		        && abs(ol3g - l3->g) < lighterr &&
-		        abs(ol4g - l4->g) < lighterr &&
-		        abs(ol3b - l3->b) < lighterr &&
-		        abs(ol4b - l4->b) < lighterr) ||
-		    !wtex) {
+		    abs(ol4r - l4->r) < lighterr &&
+		    abs(ol3g - l3->g) < lighterr &&
+		    abs(ol4g - l4->g) < lighterr &&
+		    abs(ol3b - l3->b) < lighterr &&
+		    abs(ol4b - l4->b) < lighterr) || !wtex) {
 			curvert -= 2;
 			nquads--;
 		} else {
 			unsigned char *p3 =
 			    (unsigned char *)(&verts[curvert - 1].r);

Index: src/renderextras.m
==================================================================
--- src/renderextras.m
+++ src/renderextras.m
@@ -204,24 +204,23 @@
 	}
 
 	int e = closestent();
 	if (e >= 0) {
 		Entity *c = ents[e];
-		closeent =
-		    [OFString stringWithFormat:
-			@"closest entity = %@ (%d, %d, %d, %d), "
-			@"selection = (%d, %d)",
-		        entnames[c.type], c.attr1, c.attr2, c.attr3, c.attr4,
-		        getvar(@"selxs"), getvar(@"selys")];
+		closeent = [OFString stringWithFormat:
+		    @"closest entity = %@ (%d, %d, %d, %d), "
+		    @"selection = (%d, %d)",
+		    entnames[c.type], c.attr1, c.attr2, c.attr3, c.attr4,
+		    getvar(@"selxs"), getvar(@"selys")];
 	}
 }
 
 COMMAND(loadsky, ARG_1STR, (^ (OFString *basename) {
 	static OFString *lastsky = @"";
 
 	basename = [basename stringByReplacingOccurrencesOfString: @"\\"
-	                                               withString: @"/"];
+						       withString: @"/"];
 
 	if ([lastsky isEqual: basename])
 		return;
 
 	static const OFString *side[] = { @"ft", @"bk", @"lf", @"rt", @"dn",

Index: src/rendergl.m
==================================================================
--- src/rendergl.m
+++ src/rendergl.m
@@ -56,11 +56,11 @@
 
 	if (strstr(exts, "GL_EXT_texture_env_combine"))
 		hasoverbright = true;
 	else
 		conoutf(@"WARNING: cannot use overbright lighting, using old "
-		        @"lighting model!");
+		    @"lighting model!");
 
 	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glmaxtexsize);
 
 	purgetextures();
 
@@ -102,12 +102,11 @@
 		@try {
 			SDL_Surface *converted =
 			    SDL_ConvertSurface(s, format, 0);
 			if (converted == NULL) {
 				conoutf(@"texture cannot be converted "
-				        @"to 24bpp: %@",
-				    IRI.string);
+				    @"to 24bpp: %@", IRI.string);
 				return false;
 			}
 
 			SDL_FreeSurface(s);
 			s = converted;
@@ -149,11 +148,11 @@
 		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))
+	    GL_UNSIGNED_BYTE, scaledimg))
 		fatal(@"could not build mipmaps");
 
 	if (*xs != s->w)
 		free(scaledimg);
 
@@ -200,11 +199,11 @@
 	if (num < 0 || num >= 256 || frame < 0 || frame >= MAXFRAMES)
 		return;
 
 	mapping[num][frame] = 1;
 	mapname[num][frame] = [name stringByReplacingOccurrencesOfString: @"\\"
-	                                                      withString: @"/"];
+							      withString: @"/"];
 }))
 
 int
 lookuptexture(int tex, int *xs, int *ys)
 {
@@ -332,12 +331,12 @@
 	float f = gamma / 100.0f;
 	Uint16 ramp[256];
 
 	SDL_CalculateGammaRamp(f, ramp);
 
-	if (SDL_SetWindowGammaRamp(
-	        Cube.sharedInstance.window, ramp, ramp, ramp) == -1) {
+	if (SDL_SetWindowGammaRamp(Cube.sharedInstance.window,
+	    ramp, ramp, ramp) == -1) {
 		conoutf(
 		    @"Could not set gamma (card/driver doesn't support it?)");
 		conoutf(@"sdl: %s", SDL_GetError());
 	}
 })
@@ -353,12 +352,11 @@
 	glRotated(player1.pitch, -1.0, 0.0, 0.0);
 	glRotated(player1.yaw, 0.0, 1.0, 0.0);
 
 	glTranslated(-player1.origin.x,
 	    (player1.state == CS_DEAD ? player1.eyeHeight - 0.2f : 0) -
-	        player1.origin.z,
-	    -player1.origin.y);
+	    player1.origin.z, -player1.origin.y);
 }
 
 VARP(fov, 10, 105, 120);
 
 int xtraverts;
@@ -375,13 +373,13 @@
 drawhudmodel(int start, int end, float speed, int base)
 {
 	Player *player1 = Player.player1;
 
 	rendermodel(hudgunnames[player1.gunSelect], start, end, 0, 1.0f,
-	    OFMakeVector3D(
-	        player1.origin.x, player1.origin.z, player1.origin.y),
-	    player1.yaw + 90, player1.pitch, false, 1.0f, speed, 0, base);
+	    OFMakeVector3D(player1.origin.x, player1.origin.z,
+	    player1.origin.y), player1.yaw + 90, player1.pitch, false, 1.0f,
+	    speed, 0, base);
 }
 
 void
 drawhudgun(float fovy, float aspect, int farplane)
 {

Index: src/rendermd2.m
==================================================================
--- src/rendermd2.m
+++ src/rendermd2.m
@@ -89,11 +89,11 @@
     float speed, int snap, int basetime)
 {
 	MD2 *m = loadmodel(mdl);
 
 	if (isoccluded(Player.player1.origin.x, Player.player1.origin.y,
-	        position.x - rad, position.z - rad, rad * 2))
+	    position.x - rad, position.z - rad, rad * 2))
 		return;
 
 	delayedload(m);
 
 	int xs, ys;
@@ -107,30 +107,30 @@
 	if (!OUTBORD(ix, iy)) {
 		struct sqr *s = S(ix, iy);
 		float ll = 256.0f; // 0.96f;
 		float of = 0.0f;   // 0.1f;
 		light = [OFColor colorWithRed: s->r / ll + of
-		                        green: s->g / ll + of
-		                         blue: s->b / ll + of
-		                        alpha: 1];
+					green: s->g / ll + of
+					 blue: s->b / ll + of
+					alpha: 1.0f];
 	}
 
 	if (teammate) {
 		float red, green, blue;
 		[light getRed: &red green: &green blue: &blue alpha: NULL];
 		light = [OFColor colorWithRed: red * 0.6f
-		                        green: green * 0.7f
-		                         blue: blue * 1.2f
-		                        alpha: 1];
+					green: green * 0.7f
+					 blue: blue * 1.2f
+					alpha: 1.0f];
 	}
 
 	[m renderWithLight: light
-	             frame: frame
-	             range: range
-	          position: position
-	               yaw: yaw
-	             pitch: pitch
-	             scale: scale
-	             speed: speed
-	              snap: snap
-	          basetime: basetime];
+		     frame: frame
+		     range: range
+		  position: position
+		       yaw: yaw
+		     pitch: pitch
+		     scale: scale
+		     speed: speed
+		      snap: snap
+		  basetime: basetime];
 }

Index: src/renderparticles.m
==================================================================
--- src/renderparticles.m
+++ src/renderparticles.m
@@ -70,18 +70,17 @@
 		int gr, tex;
 		float sz;
 	} parttypes[] = {
 		{ 0.7f, 0.6f, 0.3f, 2, 3, 0.06f },  // yellow: sparks
 		{ 0.5f, 0.5f, 0.5f, 20, 7, 0.15f }, // grey:   small smoke
-		{ 0.2f, 0.2f, 1.0f, 20, 3,
-		    0.08f },                       // blue:   edit mode entities
-		{ 1.0f, 0.1f, 0.1f, 1, 7, 0.06f }, // red:    blood spats
-		{ 1.0f, 0.8f, 0.8f, 20, 6, 1.2f }, // yellow: fireball1
-		{ 0.5f, 0.5f, 0.5f, 20, 7, 0.6f }, // grey:   big smoke
-		{ 1.0f, 1.0f, 1.0f, 20, 8, 1.2f }, // blue:   fireball2
-		{ 1.0f, 1.0f, 1.0f, 20, 9, 1.2f }, // green:  fireball3
-		{ 1.0f, 0.1f, 0.1f, 0, 7, 0.2f },  // red:    demotrack
+		{ 0.2f, 0.2f, 1.0f, 20, 3, 0.08f }, // blue:   edit mode entities
+		{ 1.0f, 0.1f, 0.1f, 1, 7, 0.06f },  // red:    blood spats
+		{ 1.0f, 0.8f, 0.8f, 20, 6, 1.2f },  // yellow: fireball1
+		{ 0.5f, 0.5f, 0.5f, 20, 7, 0.6f },  // grey:   big smoke
+		{ 1.0f, 1.0f, 1.0f, 20, 8, 1.2f },  // blue:   fireball2
+		{ 1.0f, 1.0f, 1.0f, 20, 9, 1.2f },  // green:  fireball3
+		{ 1.0f, 0.1f, 0.1f, 0, 7, 0.2f },   // red:    demotrack
 	};
 
 	int numrender = 0;
 
 	for (struct particle *p, **pp = &parlist; (p = *pp) != NULL;) {

Index: src/rendertext.m
==================================================================
--- src/rendertext.m
+++ src/rendertext.m
@@ -138,11 +138,11 @@
 draw_textf(OFConstantString *format, int left, int top, int gl_num, ...)
 {
 	va_list arguments;
 	va_start(arguments, gl_num);
 	OFString *str = [[OFString alloc] initWithFormat: format
-	                                       arguments: arguments];
+					       arguments: arguments];
 	va_end(arguments);
 	draw_text(str, left, top, gl_num);
 }
 
 void

Index: src/rndmap.m
==================================================================
--- src/rndmap.m
+++ src/rndmap.m
@@ -14,17 +14,14 @@
 }
 
 float
 smoothednoise(int x, int y, int seed)
 {
-	float corners =
-	    (noise(x - 1, y - 1, seed) + noise(x + 1, y - 1, seed) +
-	        noise(x - 1, y + 1, seed) + noise(x + 1, y + 1, seed)) /
-	    16;
+	float corners = (noise(x - 1, y - 1, seed) + noise(x + 1, y - 1, seed) +
+	    noise(x - 1, y + 1, seed) + noise(x + 1, y + 1, seed)) / 16;
 	float sides = (noise(x - 1, y, seed) + noise(x + 1, y, seed) +
-	                  noise(x, y - 1, seed) + noise(x, y + 1, seed)) /
-	    8;
+	    noise(x, y - 1, seed) + noise(x, y + 1, seed)) / 8;
 	float center = noise(x, y, seed) / 4;
 	return corners + sides + center;
 }
 
 float
@@ -76,15 +73,13 @@
 	for (int x = b->x; x <= b->x + b->xs; x++) {
 		for (int y = b->y; y <= b->y + b->ys; y++) {
 			struct sqr *s = S(x, y);
 			if (!SOLID(s) && x != b->x + b->xs && y != b->y + b->ys)
 				s->type = FHF;
-			s->vdelta =
-			    (int)(perlinnoise_2D(x / ((float)scale) + seed,
-			              y / ((float)scale) + seed, 1000, 0.01f) *
-			            50 +
-			        25);
+			s->vdelta = (int)(perlinnoise_2D(
+			    x / ((float)scale) + seed,
+			    y / ((float)scale) + seed, 1000, 0.01f) * 50 + 25);
 			if (s->vdelta > 128)
 				s->vdelta = 0;
 		}
 	}
 }

Index: src/savegamedemo.m
==================================================================
--- src/savegamedemo.m
+++ src/savegamedemo.m
@@ -162,13 +162,13 @@
 	char buf[8];
 	gzread(f, buf, 8);
 	if (strncmp(buf, "CUBESAVE", 8))
 		goto out;
 	if (gzgetc(f) != islittleendian)
-		goto out; // not supporting save->load accross
-		          // incompatible architectures simpifies things
-		          // a LOT
+		// not supporting save->load accross incompatible architectures
+		// simpifies things a LOT
+		goto out;
 	if (gzgeti() != SAVEGAMEVERSION ||
 	    gzgeti() != DynamicEntity.serializedSize)
 		goto out;
 	gzread(f, mapname, _MAXDEFSTR);
 	nextmode = gzgeti();
@@ -176,11 +176,11 @@
 	// have updated
 	changemap(@(mapname));
 	return;
 out:
 	conoutf(@"aborting: savegame/demo from a different version of "
-	        @"cube or cpu architecture");
+	    @"cube or cpu architecture");
 	stop();
 }
 
 COMMAND(loadgame, ARG_1STR, (^ (OFString *name) {
 	OFString *path = [OFString stringWithFormat:
@@ -193,11 +193,11 @@
 void
 loadgameout()
 {
 	stop();
 	conoutf(@"loadgame incomplete: savegame from a different version of "
-	        @"this map");
+	    @"this map");
 }
 
 void
 loadgamerest()
 {
@@ -379,28 +379,28 @@
 }
 
 VAR(demodelaymsec, 0, 120, 500);
 
 // spline interpolation
-#define catmulrom(z, a, b, c, s, dest)                                  \
-	{                                                               \
-		OFVector3D t1 = OFSubtractVectors3D(b, z);              \
-		t1 = OFMultiplyVector3D(t1, 0.5f);                      \
-                                                                        \
-		OFVector3D t2 = OFSubtractVectors3D(c, a);              \
-		t2 = OFMultiplyVector3D(t2, 0.5f);                      \
-                                                                        \
-		float s2 = s * s;                                       \
-		float s3 = s * s2;                                      \
-                                                                        \
+#define catmulrom(z, a, b, c, s, dest)					\
+	{								\
+		OFVector3D t1 = OFSubtractVectors3D(b, z);		\
+		t1 = OFMultiplyVector3D(t1, 0.5f);			\
+									\
+		OFVector3D t2 = OFSubtractVectors3D(c, a);		\
+		t2 = OFMultiplyVector3D(t2, 0.5f);			\
+									\
+		float s2 = s * s;					\
+		float s3 = s * s2;					\
+									\
 		dest = OFMultiplyVector3D(a, 2 * s3 - 3 * s2 + 1);      \
 		OFVector3D t = OFMultiplyVector3D(b, -2 * s3 + 3 * s2); \
-		dest = OFAddVectors3D(dest, t);                         \
-		t1 = OFMultiplyVector3D(t1, s3 - 2 * s2 + s);           \
-		dest = OFAddVectors3D(dest, t1);                        \
-		t2 = OFMultiplyVector3D(t2, s3 - s2);                   \
-		dest = OFAddVectors3D(dest, t2);                        \
+		dest = OFAddVectors3D(dest, t);				\
+		t1 = OFMultiplyVector3D(t1, s3 - 2 * s2 + s);		\
+		dest = OFAddVectors3D(dest, t1);			\
+		t2 = OFMultiplyVector3D(t2, s3 - s2);			\
+		dest = OFAddVectors3D(dest, t2);			\
 	}
 
 void
 fixwrap(DynamicEntity *a, DynamicEntity *b)
 {
@@ -451,13 +451,12 @@
 			}
 			// FIXME: set more client state here
 		}
 
 		// insert latest copy of player into history
-		if (extras &&
-		    (playerhistory.count == 0 ||
-		        playerhistory.lastObject.lastUpdate != playbacktime)) {
+		if (extras && (playerhistory.count == 0 ||
+		    playerhistory.lastObject.lastUpdate != playbacktime)) {
 			Player *d = [target copy];
 			d.lastUpdate = playbacktime;
 
 			if (playerhistory == nil)
 				playerhistory = [[OFMutableArray alloc] init];

Index: src/server.m
==================================================================
--- src/server.m
+++ src/server.m
@@ -397,14 +397,14 @@
 }
 
 int nonlocalclients = 0;
 int lastconnect = 0;
 
+// main server update, called from cube main loop in sp, or dedicated server
+// loop
 void
-serverslice(int seconds,
-    unsigned int timeout) // main server update, called from cube main loop in
-                          // sp, or dedicated server loop
+serverslice(int seconds, unsigned int timeout)
 {
 	// spawn entities when timer reached
 	[sents enumerateObjectsUsingBlock:
 	    ^ (ServerEntity *e, size_t i, bool *stop) {
 		if (e.spawnsecs && (e.spawnsecs -= seconds - lastsec) <= 0) {
@@ -470,13 +470,12 @@
 			c.type = ST_TCPIP;
 			c.peer = event.peer;
 			c.peer->data = (void *)(clients.count - 1);
 			char hn[1024];
 			c.hostname = (enet_address_get_host(
-			                  &c.peer->address, hn, sizeof(hn)) == 0
-			        ? @(hn)
-			        : @"localhost");
+			    &c.peer->address, hn, sizeof(hn)) == 0
+			    ? @(hn) : @"localhost");
 			[OFStdOut writeFormat: @"client connected (%@)\n",
 					       c.hostname];
 			send_welcome(lastconnect = clients.count - 1);
 			break;
 		}

Index: src/sound.m
==================================================================
--- src/sound.m
+++ src/sound.m
@@ -55,18 +55,18 @@
 
 	stopsound();
 
 	if (soundvol && musicvol) {
 		name = [name stringByReplacingOccurrencesOfString: @"\\"
-		                                       withString: @"/"];
+						       withString: @"/"];
 		OFString *path = [OFString stringWithFormat:
 		    @"packages/%@", name];
 		OFIRI *IRI = [Cube.sharedInstance.gameDataIRI
 		    IRIByAppendingPathComponent: path];
 
 		if ((mod = Mix_LoadMUS(
-		         IRI.fileSystemRepresentation.UTF8String)) != NULL) {
+		    IRI.fileSystemRepresentation.UTF8String)) != NULL) {
 			Mix_PlayMusic(mod, -1);
 			Mix_VolumeMusic((musicvol * MAXVOL) / 255);
 		}
 	}
 }))

Index: src/tools.h
==================================================================
--- src/tools.h
+++ src/tools.h
@@ -16,14 +16,14 @@
 
 #define max(a, b) (((a) > (b)) ? (a) : (b))
 #define min(a, b) (((a) < (b)) ? (a) : (b))
 #define rnd(max) (rand() % (max))
 #define rndreset() (srand(1))
-#define rndtime()                                            \
-	{                                                    \
-		for (int i = 0; i < (lastmillis & 0xF); i++) \
-			rnd(i + 1);                          \
+#define rndtime()						\
+	{							\
+		for (int i = 0; i < (lastmillis & 0xF); i++)	\
+			rnd(i + 1);				\
 	}
 
 #ifndef OF_WINDOWS
 # define __cdecl
 #endif

Index: src/world.m
==================================================================
--- src/world.m
+++ src/world.m
@@ -159,12 +159,11 @@
 								// rendering
 								// large mips
 								// next to hfs
 								fh -=
 								    o[i]->vdelta /
-								        4 +
-								    2;
+								    4 + 2;
 							if (o[i]->type == CHF)
 								// FIXME: needs
 								// to somehow
 								// take into
 								// account
@@ -171,12 +170,11 @@
 								// middle
 								// vertices on
 								// higher mips
 								ch +=
 								    o[i]->vdelta /
-								        4 +
-								    2;
+								    4 + 2;
 						}
 						if (fh < floor)
 							// take lowest floor and
 							// highest ceil, so we
 							// never have to see
@@ -212,43 +210,38 @@
 					    o[i]->floor != o[3]->floor ||
 					    o[i]->ceil != o[3]->ceil ||
 					    o[i]->ftex != o[3]->ftex ||
 					    o[i]->ctex != o[3]->ctex ||
 					    abs(o[i + 1]->r - o[0]->r) >
-					        lighterr ||
+					    lighterr ||
 					    abs(o[i + 1]->g - o[0]->g) >
-					        lighterr ||
+					    lighterr ||
 					    abs(o[i + 1]->b - o[0]->b) >
-					        lighterr ||
+					    lighterr ||
 					    o[i]->utex != o[3]->utex ||
 					    o[i]->wtex != o[3]->wtex)
 						goto c;
 				}
 
 				// can make a perfect mip out of a hf if slopes
 				// lie on one line
 				if (r->type == CHF || r->type == FHF) {
 					if (o[0]->vdelta - o[1]->vdelta !=
-					        o[1]->vdelta -
-					            SWS(w, x + 2, y, ws)
-					                ->vdelta ||
+					    o[1]->vdelta -
+					    SWS(w, x + 2, y, ws)->vdelta ||
 					    o[0]->vdelta - o[2]->vdelta !=
-					        o[2]->vdelta -
-					            SWS(w, x + 2, y + 2, ws)
-					                ->vdelta ||
+					    o[2]->vdelta -
+					    SWS(w, x + 2, y + 2, ws)->vdelta ||
 					    o[0]->vdelta - o[3]->vdelta !=
-					        o[3]->vdelta -
-					            SWS(w, x, y + 2, ws)
-					                ->vdelta ||
+					    o[3]->vdelta -
+					    SWS(w, x, y + 2, ws)->vdelta ||
 					    o[3]->vdelta - o[2]->vdelta !=
-					        o[2]->vdelta -
-					            SWS(w, x + 2, y + 1, ws)
-					                ->vdelta ||
+					    o[2]->vdelta -
+					    SWS(w, x + 2, y + 1, ws)->vdelta ||
 					    o[1]->vdelta - o[2]->vdelta !=
-					        o[2]->vdelta -
-					            SWS(w, x + 1, y + 2, ws)
-					                ->vdelta)
+					    o[2]->vdelta -
+					    SWS(w, x + 1, y + 2, ws)->vdelta)
 						goto c;
 				}
 			}
 			{
 				// if any of the constituents is not perfect,

Index: src/worldio.m
==================================================================
--- src/worldio.m
+++ src/worldio.m
@@ -168,12 +168,12 @@
 // miniscule map sizes.
 
 void
 save_world(OFString *mname)
 {
-	resettagareas(); // wouldn't be able to reproduce tagged areas
-	                 // otherwise
+	// wouldn't be able to reproduce tagged areas otherwise
+	resettagareas();
 	voptimize();
 	toptimize();
 	if (mname.length == 0)
 		mname = getclientmap();
 	setnames(mname);
@@ -201,20 +201,20 @@
 			gzwrite(f, &tmp, sizeof(struct persistent_entity));
 		}
 	}
 	struct sqr *t = NULL;
 	int sc = 0;
-#define spurge                          \
-	while (sc) {                    \
-		gzputc(f, 255);         \
-		if (sc > 255) {         \
-			gzputc(f, 255); \
-			sc -= 255;      \
-		} else {                \
-			gzputc(f, sc);  \
-			sc = 0;         \
-		}                       \
+#define spurge				\
+	while (sc) {			\
+		gzputc(f, 255);		\
+		if (sc > 255) {		\
+			gzputc(f, 255);	\
+			sc -= 255;	\
+		} else {		\
+			gzputc(f, sc);	\
+			sc = 0;		\
+		}			\
 	}
 	for (int k = 0; k < cubicsize; k++) {
 		struct sqr *s = &world[k];
 #define c(f) (s->f == t->f)
 		// 4 types of blocks, to compress a bit:
@@ -260,13 +260,14 @@
 
 COMMAND(savemap, ARG_1STR, ^ (OFString *mname) {
 	save_world(mname);
 })
 
+// still supports all map formats that have existed since the earliest cube
+// betas!
 void
-load_world(OFString *mname) // still supports all map formats that have existed
-                            // since the earliest cube betas!
+load_world(OFString *mname)
 {
 	stopifrecording();
 	cleardlights();
 	pruneundos(0);
 	setnames(mname);

Index: src/worldlight.m
==================================================================
--- src/worldlight.m
+++ src/worldlight.m
@@ -40,15 +40,12 @@
 		stepl /= lightscale;
 
 		// coloured light version, special case because most lights are
 		// white
 		if (light.attr3 || light.attr4) {
-			int dimness = rnd(
-			    (255 -
-			        (light.attr2 + light.attr3 + light.attr4) / 3) /
-			        16 +
-			    1);
+			int dimness = rnd((255 - (light.attr2 + light.attr3 +
+			    light.attr4) / 3) / 16 + 1);
 			x += stepx * dimness;
 			y += stepy * dimness;
 
 			if (OUTBORD(x >> PRECBITS, y >> PRECBITS))
 				return;
@@ -146,23 +143,24 @@
 // median filter, smooths out random noise in light and makes it more mipable
 void
 postlightarea(const struct block *a)
 {
 	// assumes area not on edge of world
-	for (int x = 0; x < a->xs; x++)
+	for (int x = 0; x < a->xs; x++) {
 		for (int y = 0; y < a->ys; y++) {
 			struct sqr *s = S(x + a->x, y + a->y);
-#define median(m)                                                            \
-	s->m =                                                               \
-	    (s->m * 2 + SW(s, 1, 0)->m * 2 + SW(s, 0, 1)->m * 2 +            \
-	        SW(s, -1, 0)->m * 2 + SW(s, 0, -1)->m * 2 + SW(s, 1, 1)->m + \
-	        SW(s, 1, -1)->m + SW(s, -1, 1)->m + SW(s, -1, -1)->m) /      \
-	    14; // median is 4/2/1 instead
+
+			// median is 4/2/1 instead
+#define median(m)							 \
+	s->m = (s->m * 2 + SW(s, 1, 0)->m * 2 + SW(s, 0, 1)->m * 2 +	 \
+	    SW(s, -1, 0)->m * 2 + SW(s, 0, -1)->m * 2 + SW(s, 1, 1)->m + \
+	    SW(s, 1, -1)->m + SW(s, -1, 1)->m + SW(s, -1, -1)->m) / 14;
 			median(r);
 			median(g);
 			median(b);
 		}
+	}
 
 	remip(a, 0);
 }
 
 void

Index: src/worldocull.m
==================================================================
--- src/worldocull.m
+++ src/worldocull.m
@@ -36,15 +36,16 @@
 	for (int i = 0; i < NUMRAYS; i++) {
 		float angle = i * PI2 / NUMRAYS;
 		// try to avoid tracing ray if outside of frustrum
 		// apitch must be bigger if fov > 120
 		if ((apitch > 45 || (angle < byaw && angle > syaw) ||
-		        (angle < byaw - PI2 && angle > syaw - PI2) ||
-		        (angle < byaw + PI2 && angle > syaw + PI2)) &&
+		    (angle < byaw - PI2 && angle > syaw - PI2) ||
+		    (angle < byaw + PI2 && angle > syaw + PI2)) &&
 		    !OUTBORD(vx, vy) && !SOLID(S((int)vx, (int)vy))) {
 			float ray = i * 8 / (float)NUMRAYS;
 			float dx, dy;
+
 			if (ray > 1 && ray < 3) {
 				dx = -(ray - 2);
 				dy = 1;
 			} else if (ray >= 3 && ray < 5) {
 				dx = -1;
@@ -54,10 +55,11 @@
 				dy = -1;
 			} else {
 				dx = 1;
 				dy = ray > 4 ? ray - 8 : ray;
 			}
+
 			float sx = vx;
 			float sy = vy;
 			for (;;) {
 				sx += dx;
 				sy += dy;
@@ -123,75 +125,78 @@
 	// spans, based on its most left and right points on the border from the
 	// viewer pov... I see no easier way to do this than this silly code
 	// below
 
 	float h, l;
-	if (cx <= vx) // ABDFG
-	{
-		if (cx + csize < vx) // ADF
-		{
-			if (cy <= vy) // AD
-			{
+	if (cx <= vx) {
+		// ABDFG
+		if (cx + csize < vx) {
+			// ADF
+			if (cy <= vy) {
+				// AD
 				if (cy + csize < vy) {
+					// A
 					h = ca(-(cx - vx), -(cy + csize - vy)) +
 					    4;
 					l = ca(-(cx + csize - vx), -(cy - vy)) +
 					    4;
-				} // A
-				else {
+				} else {
+					// D
 					h = ma(-(cx + csize - vx),
-					        -(cy + csize - vy)) +
-					    4;
-					l = ma(-(cx + csize - vx), -(cy - vy)) +
-					    4;
-				} // D
+					    -(cy + csize - vy)) + 4;
+					l = ma(-(cx + csize - vx),
+					    -(cy - vy)) + 4;
+				}
 			} else {
+				// F
 				h = ca(cy + csize - vy, -(cx + csize - vx)) + 2;
 				l = ca(cy - vy, -(cx - vx)) + 2;
-			} // F
-		} else { // BG
+			}
+		} else {
+			// BG
 			if (cy <= vy) {
 				if (cy + csize < vy) {
+					// B
 					h = ma(-(cy + csize - vy), cx - vx) + 6;
 					l = ma(-(cy + csize - vy),
-					        cx + csize - vx) +
-					    6;
-				} // B
-				else
+					    cx + csize - vx) + 6;
+				} else
 					return 0;
 			} else {
+				// G
 				h = ma(cy - vy, -(cx + csize - vx)) + 2;
 				l = ma(cy - vy, -(cx - vx)) + 2;
-			} // G
+			}
 		}
-	} else // CEH
-	{
-		if (cy <= vy) // CE
-		{
+	} else {
+		// CEH
+		if (cy <= vy) {
+			// CE
 			if (cy + csize < vy) {
+				// C
 				h = ca(-(cy - vy), cx - vx) + 6;
 				l = ca(-(cy + csize - vy), cx + csize - vx) + 6;
-			} // C
-			else {
+			} else {
+				// E
 				h = ma(cx - vx, cy - vy);
 				l = ma(cx - vx, cy + csize - vy);
-			} // E
+			}
 		} else {
+			// H
 			h = ca(cx + csize - vx, cy - vy);
 			l = ca(cx - vx, cy + csize - vy);
-		} // H
+		}
 	}
 	// get indexes into occlusion map from angles
 	int si = h * (NUMRAYS / 8) + NUMRAYS;
 	int ei = l * (NUMRAYS / 8) + NUMRAYS + 1;
 	if (ei <= si)
 		ei += NUMRAYS;
 
-	for (int i = si; i <= ei; i++) {
+	for (int i = si; i <= ei; i++)
 		if (dist < rdist[i & (NUMRAYS - 1)])
 			// if any value in this segment of the occlusion map is
 			// further away then cube is not occluded
 			return 0;
-	}
 
 	return 1; // cube is entirely occluded
 }

Index: src/worldrender.m
==================================================================
--- src/worldrender.m
+++ src/worldrender.m
@@ -123,13 +123,13 @@
 {
 	struct sqr *w = wmip[mip];
 	int sz = ssize >> mip;
 	int vxx = ((int)vx + (1 << mip) / 2) >> mip;
 	int vyy = ((int)vy + (1 << mip) / 2) >> mip;
-	int lx =
-	    vxx - lodleft; // these mark the rect inside the current rest that
-	                   // we want to render using a lower mip level
+	// these mark the rect inside the current rest that we want to render
+	// using a lower mip level
+	int lx = vxx - lodleft;
 	int ly = vyy - lodtop;
 	int rx = vxx + lodright;
 	int ry = vyy + lodbot;
 
 	float fsize = (float)(1 << mip);
@@ -137,11 +137,11 @@
 	for (int ox = x; ox < xs; ox++) {
 		// first collect occlusion information for this block
 		for (int oy = y; oy < ys; oy++) {
 			SWS(w, ox, oy, sz)->occluded =
 			    isoccluded(player1.origin.x, player1.origin.y,
-			        (float)(ox << mip), (float)(oy << mip), fsize);
+			    (float)(ox << mip), (float)(oy << mip), fsize);
 		}
 	}
 
 	int pvx = (int)vx >> mip;
 	int pvy = (int)vy >> mip;
@@ -159,23 +159,23 @@
 	// (occlusion at higher mip levels is a big time saver!). during the
 	// first loop (ceil) we collect cubes that lie within the lower mip rect
 	// and are also deferred, and render them recursively. Anything left
 	// (perfect mips and higher lods) we render here.
 
-#define LOOPH                                                          \
-	{                                                              \
-		for (int xx = x; xx < xs; xx++)                        \
-			for (int yy = y; yy < ys; yy++) {              \
-				struct sqr *s = SWS(w, xx, yy, sz);    \
-				if (s->occluded == 1)                  \
-					continue;                      \
-				if (s->defer && !s->occluded && mip && \
-				    xx >= lx && xx < rx && yy >= ly && \
+#define LOOPH								\
+	{								\
+		for (int xx = x; xx < xs; xx++)				\
+			for (int yy = y; yy < ys; yy++) {		\
+				struct sqr *s = SWS(w, xx, yy, sz);	\
+				if (s->occluded == 1)			\
+					continue;			\
+				if (s->defer && !s->occluded && mip &&	\
+				    xx >= lx && xx < rx && yy >= ly &&	\
 				    yy < ry)
-#define LOOPD                             \
-	struct sqr *t = SWS(s, 1, 0, sz); \
-	struct sqr *u = SWS(s, 1, 1, sz); \
+#define LOOPD					\
+	struct sqr *t = SWS(s, 1, 0, sz);	\
+	struct sqr *u = SWS(s, 1, 1, sz);	\
 	struct sqr *v = SWS(s, 0, 1, sz);
 
 	LOOPH // ceils
 	{
 		int start = yy;