Cube  Diff

		};
	});
}

int selh = 0;
bool selset = false;

#define loopselxy(b)                                                           \
	{                                                                      \
		makeundo();                                                    \
		loop(x, sel.xs) loop(y, sel.ys)                                \
		{                                                              \
			sqr *s = S(sel.x + x, sel.y + y);                      \
			b;                                                     \
		};                                                             \
		remip(sel);                                                    \
#define loopselxy(b)                                      \
	{                                                 \
		makeundo();                               \
		loop(x, sel.xs) loop(y, sel.ys)           \
		{                                         \
			sqr *s = S(sel.x + x, sel.y + y); \
			b;                                \
		}                                         \
		remip(sel);                               \
	}

int cx, cy, ch;

int curedittex[] = {-1, -1, -1};

bool dragging = false;

	int bsize = ssize - MINBORD;
	if (sel.xs + sel.x > bsize)
		sel.xs = bsize - sel.x;
	if (sel.ys + sel.y > bsize)
		sel.ys = bsize - sel.y;
	if (sel.xs <= 0 || sel.ys <= 0)
		selset = false;
};
}

bool
noteditmode()
{
	correctsel();
	if (!editmode)
		conoutf(@"this function is only allowed in edit mode");
	return !editmode;
}

bool
noselection()
{
	if (!selset)
		conoutf(@"no selection");
	return !selset;
}

#define EDITSEL                                                                \
	if (noteditmode() || noselection())                                    \
#define EDITSEL                             \
	if (noteditmode() || noselection()) \
		return;
#define EDITSELMP                                                              \
	if (noteditmode() || noselection() || multiplayer())                   \
#define EDITSELMP                                            \
	if (noteditmode() || noselection() || multiplayer()) \
		return;
#define EDITMP                                                                 \
	if (noteditmode() || multiplayer())                                    \
#define EDITMP                              \
	if (noteditmode() || multiplayer()) \
		return;

void
selectpos(int x, int y, int xs, int ys)
{
	block s = {x, y, xs, ys};
	sel = s;
	selh = 0;
	correctsel();
};
}

void
makesel()
{
	block s = {min(lastx, cx), min(lasty, cy), abs(lastx - cx) + 1,
	    abs(lasty - cy) + 1};
	sel = s;
	selh = max(lasth, ch);
	correctsel();
	if (selset)
		rtex = *S(sel.x, sel.y);
};
}

VAR(flrceil, 0, 0, 2);

float
sheight(
    sqr *s, sqr *t, float z) // finds out z height when cursor points at wall
{
	return !flrceil // z-s->floor<s->ceil-z
	           ? (s->type == FHF ? s->floor - t->vdelta / 4.0f
	    ? (s->type == FHF ? s->floor - t->vdelta / 4.0f : (float)s->floor)
	                             : (float)s->floor)
	           : (s->type == CHF ? s->ceil + t->vdelta / 4.0f
	    : (s->type == CHF ? s->ceil + t->vdelta / 4.0f : (float)s->ceil);
	                             : (float)s->ceil);
};
}

void
cursorupdate() // called every frame from hud
{
	flrceil = ((int)(player1->pitch >= 0)) * 2;

	volatile float x =

		ch = (int)ih;
	};

	if (selset) {
		linestyle(GRIDS, 0xFF, 0x40, 0x40);
		box(sel, (float)selh, (float)selh, (float)selh, (float)selh);
	};
};
}

vector<block *> undos;    // unlimited undo
VARP(undomegs, 0, 1, 10); // bounded by n megs

void
pruneundos(int maxremain) // bound memory
{
	int t = 0;
	loopvrev(undos)
	{
		t += undos[i]->xs * undos[i]->ys * sizeof(sqr);
		if (t > maxremain)
			free(undos.remove(i));
	};
};
	}
}

void
makeundo()
{
	undos.add(blockcopy(sel));
	pruneundos(undomegs << 20);
};
}

void
editundo()
{
	EDITMP;
	if (undos.empty()) {
		conoutf(@"nothing more to undo");

void
copy()
{
	EDITSELMP;
	if (copybuf)
		free(copybuf);
	copybuf = blockcopy(sel);
};
}

void
paste()
{
	EDITMP;
	if (!copybuf) {
		conoutf(@"nothing to paste");

			uchar *p = hdr.texlists[i];
			int t = p[c];
			for (int a = c - 1; a >= 0; a--)
				p[a + 1] = p[a];
			p[0] = t;
			curedittex[i] = -1;
		};
	};
};
	}
}

void
editdrag(bool isdown)
{
	if (dragging = isdown) {
		lastx = cx;
		lasty = cy;
		lasth = ch;
		selset = false;
		tofronttex();
	};
	makesel();
};
}

// the core editing function. all the *xy functions perform the core operations
// and are also called directly from the network, the function below it is
// strictly triggered locally. They all have very similar structure.

void
editheightxy(bool isfloor, int amount, block &sel)
{
	loopselxy(
	    if (isfloor) {
		    s->floor += amount;
		    if (s->floor >= s->ceil)
			    s->floor = s->ceil - 1;
	    } else {
		    s->ceil += amount;
		    if (s->ceil <= s->floor)
			    s->ceil = s->floor + 1;
	    });
};
}

void
editheight(int flr, int amount)
{
	EDITSEL;
	bool isfloor = flr == 0;
	editheightxy(isfloor, amount, sel);

	        case 2:
		        s->ctex = t;
		        break;
	        case 3:
		        s->utex = t;
		        break;
	});
};
}

void
edittex(int type, int dir)
{
	EDITSEL;
	if (type < 0 || type > 3)
		return;
	if (type != lasttype) {
		tofronttex();
		lasttype = type;
	};
	int atype = type == 3 ? 1 : type;
	int i = curedittex[atype];
	i = i < 0 ? 0 : i + dir;
	curedittex[atype] = i = min(max(i, 0), 255);
	int t = lasttex = hdr.texlists[atype][i];
	edittexxy(type, t, sel);
	addmsg(1, 7, SV_EDITT, sel.x, sel.y, sel.xs, sel.ys, type, t);
};
}

void
replace()
{
	EDITSELMP;
	loop(x, ssize) loop(y, ssize)
	{

				s->ctex = lasttex;
			break;
		case 3:
			if (s->utex == rtex.utex)
				s->utex = lasttex;
			break;
		};
	};
	}
	block b = {0, 0, ssize, ssize};
	remip(b);
};
}

void
edittypexy(int type, block &sel)
{
	loopselxy(s->type = type);
};
}

void
edittype(int type)
{
	EDITSEL;
	if (type == CORNER &&
	    (sel.xs != sel.ys || sel.xs == 3 || sel.xs > 4 && sel.xs != 8 ||

		if (isfloor)
			s->floor = low;
		else
			s->ceil = hi;
		if (s->floor >= s->ceil)
			s->floor = s->ceil - 1;
	});
};
}

void
equalize(int flr)
{
	bool isfloor = flr == 0;
	EDITSEL;
	editequalisexy(isfloor, sel);
	addmsg(1, 6, SV_EDITE, sel.x, sel.y, sel.xs, sel.ys, isfloor);
}
COMMAND(equalize, ARG_1INT)

void
setvdeltaxy(int delta, block &sel)
{
	loopselxy(s->vdelta = max(s->vdelta + delta, 0));
	remipmore(sel);
};
}

void
setvdelta(int delta)
{
	EDITSEL;
	setvdeltaxy(delta, sel);
	addmsg(1, 6, SV_EDITD, sel.x, sel.y, sel.xs, sel.ys, delta);
};
}

const int MAXARCHVERT = 50;
int archverts[MAXARCHVERT][MAXARCHVERT];
bool archvinit = false;

void
archvertex(int span, int vert, int delta)
{
	if (!archvinit) {
		archvinit = true;
		loop(s, MAXARCHVERT) loop(v, MAXARCHVERT) archverts[s][v] = 0;
	};
	if (span >= MAXARCHVERT || vert >= MAXARCHVERT || span < 0 || vert < 0)
		return;
	archverts[span][vert] = delta;
};
}

void
arch(int sidedelta, int _a)
{
	EDITSELMP;
	sel.xs++;
	sel.ys++;
	if (sel.xs > MAXARCHVERT)
		sel.xs = MAXARCHVERT;
	if (sel.ys > MAXARCHVERT)
		sel.ys = MAXARCHVERT;
	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);
};
}

void
slope(int xd, int yd)
{
	EDITSELMP;
	int off = 0;
	if (xd < 0)
		off -= xd * sel.xs;
	if (yd < 0)
		off -= yd * sel.ys;
	sel.xs++;
	sel.ys++;
	loopselxy(s->vdelta = xd * x + yd * y + off);
	remipmore(sel);
};
}

void
perlin(int scale, int seed, int psize)
{
	EDITSELMP;
	sel.xs++;
	sel.ys++;
	makeundo();
	sel.xs--;
	sel.ys--;
	perlinarea(sel, scale, seed, psize);
	sel.xs++;
	sel.ys++;
	remipmore(sel);
	sel.xs--;
	sel.ys--;
};
}

VARF(
    fullbright, 0, 0, 1, if (fullbright) {
	    if (noteditmode())
		    return;
	    loopi(mipsize) world[i].r = world[i].g = world[i].b = 176;
    };);

void
edittag(int tag)
{
	EDITSELMP;
	loopselxy(s->tag = tag);
};
}

void
newent(OFString *what, OFString *a1, OFString *a2, OFString *a3, OFString *a4)
{
	EDITSEL;
	@autoreleasepool {
		newentity(sel.x, sel.y, (int)player1->o.z, what,