#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#include <math.h>

#include <SDL.h>
#include <SDL_keysym.h>
#include <SDL_rotozoom.h>
#include <SDL_ttf.h>
#include <SDL_framerate.h>

#include "defs.h"
#include "shared.h"
#include "edit.h"


/* these hold the currently selected sprite/tile types */
tiletype_t *seltile = NULL;
int selsprite = -1;

int modified = B_FALSE;	// has the current level been modified since last save? 


int curworld = 1;
int curlevelnum;

int skipto = -1;

int layer = 1; // which layer we are editting, either 1 or 2
int layertransparent = B_TRUE;

SDL_Surface *whitebox;

SDL_Color red = {255, 0, 0, 0};
SDL_Color black = {0, 0, 0, 0};
SDL_Color blue = {0, 0, 255, 0};
SDL_Color cyan = {0, 255, 255, 0};
SDL_Color white = {255, 255, 255, 0};
SDL_Color grey = {210, 210, 210, 0};
SDL_Color grey2 = {70, 70, 70, 0};
SDL_Color green = {0, 255, 0, 0};
SDL_Color yellow = {255, 255, 0, 0};

int state;

char tempm[BUFLEN];

char statustext[BUFLEN];
SDL_Color *statustextcol = &white;

// for level list mode
int oldy = -1;

int main (int argc, char **argv) {
	Uint8 *keys;
	char filename[BUFLEN];
	int i;
	
	int mb,mx,my;

	curlevelnum = 1;

	levelbg = NULL;

	setfruitinfo();

	datadir = NULL;

	/* handle arguments */
	if (argc >= 2) {
		for (i = 1; i < argc; i++) {
			if (!strcmp(argv[i], "-fs")) {
				printf("Fullscreen mode enabled.\n");
				vidargs |= SDL_FULLSCREEN;
                        } else if (!strcmp(argv[i], "-d")) {
                                if (++i >= argc) {
                                        printf("Missing data dir.\n");
                                        usage();
                                        exit(1);
                                }
                                datadir = strdup(argv[i]);
			} else if (!strcmp(argv[i], "-dump")) {
				dumpinfo();
				exit(1);
			} else if (!strcmp(argv[i], "-l")) {
				if (++i >= argc) {
					printf("Missing level number.\n");
					usage();
					exit(1);
				} 
				skipto = atoi(argv[i]);
				printf("Skipping to level %d.\n",skipto);
			} else {
				usage();
				exit(1);
			}
		}
	}

        if (datadir == NULL) {
                datadir = strdup("data");
        }


        if (loadlevellist()) {
                printf("Error loading level list from levels.dat.\n");
                return 1;
        }

        // is we're skipping to a level, do so now
        if (skipto >= 0) {
                for (i = 0; i <  numlevels; i++) {
                        if (levelentry[i].id == skipto) {
                                curlevelnum = i;
                        }
                }
        }

	/* initialise */
	initglobals();

	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE)==-1) {
		printf("SDL_Init: %s\n", SDL_GetError());
		exit(1);
	}


	atexit(cleanup);

	#ifdef OPENGL
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
	SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
	screen = SDL_SetVideoMode(EDITORW,EDITORH,16,SDL_OPENGLBLIT|vidargs);
	#else
	screen = SDL_SetVideoMode(EDITORW,EDITORH,16,SDL_SWSURFACE|SDL_DOUBLEBUF|vidargs);
	#endif

        /* init tiles */
        if (loadtiletypes("green.tiles")) {
                printf("Cannot initialise tiles\n");
                exit(1);
        }

	if (loadimagesets()) {
		return 1;
	}

	strcpy(statustext, "");
	statustextcol = &white;

	fakeblock.id = T_LAND;
	strcpy(fakeblock.name,"Fake");
	for (i = 0; i < TILEW; i++) {
		fakeblock.lowness[i] = 0;
	}
	fakeblock.solid = S_SOLID;

	sprintf(filename, "%s/newtiles/land.png",datadir);
	fakeblock.img[0] = IMG_Load(filename);
	fakeblock.numframes = 1;
	fakeblock.next = NULL;
	fakeblock.prev = NULL;


	// coloured box surface (for tiles on non-active layer)
	whitebox = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                        TILEW,TILEH,
                                        screen->format->BitsPerPixel, screen->format->Rmask,
                                        screen->format->Gmask,screen->format->Bmask, 0);
	SDL_FillRect(whitebox, NULL, SDL_MapRGB(whitebox->format, 0, 0, 255));
	SDL_SetAlpha(whitebox, SDL_SRCALPHA,100);

	
	
	/* load fonts */
	TTF_Init();
	sprintf(filename, "%s/editfont.ttf",datadir);
	for (i = 1; i < MAXLETTERHEIGHT; i++) {
		font[i] = TTF_OpenFont(filename,i);
		if (!font[i]) {
			printf("Error opening font: %s\n", TTF_GetError());
			return 1;
		}
	}


	state = LS_EDIT;

	if (loadlevel(curworld,curlevelnum, B_TRUE)) {
		return 1;
	}

	modified = B_FALSE;

	seltile = tiletype;

	draweditorlevel();
	drawpalette();
	drawsprites();
	flip();

	timer = 0;

	//player->invuln = INVULNTIME;
	//player->score = 0;

	while (1) {


		/* check for mouse actions */
		mb = SDL_GetMouseState(&mx,&my);
		if (mb & SDL_BUTTON(1)) { // lmb
			if (state == LS_EDIT) {
				if ((mx >= PALX) && (my < SPALY)) { // over tile palette
					tiletype_t *tt;
					int x = PALX,y = PALY;
					seltile = NULL;
					/* get tile number */
					for (tt = tiletype; tt != NULL; tt = tt->next) {
						if (isplacabletile(tt->id)) {
							// is mouse over this one?
							if ((mx >= x) && (my >= y) && (mx <= x+TILEW-1) && (my <= y+TILEH-1)) {
								seltile = tt;
								selsprite = -1;
								break;
							} else {
								// check next one
								x += TILEW;
								if (x >= EDITORW) {
									x = PALX;
									y += TILEH;
								}
							}
						}
					}
					// redraw palette with new selection
					drawpalette();
					setstatustext("", &white);
				} else if ((mx >= PALX) && (my > SPALY)) { // over sprite palette
					int p;
					int x = SPALX, y = SPALY;
					int maxh = 0;
					/* get sprite id */
					selsprite = -1;

					for (p = 0; p < MAXPTYPES; p++) {
						if (isplacablesprite(p)) {
							SDL_Surface *firstimg;
							int w,h;

							/* select images */
							firstimg = imageset[p].img[F_WALK1];
							w = firstimg->w;
							h = firstimg->h;
							if (h > maxh) maxh = h;

							// is mouse over it?
							if ((mx >= x) && (my >= y) && (mx <= x+w-1) && (my <= y+h-1)) {
								selsprite = p;
								seltile = NULL;
								break;
							} else {
								// check next one
								x += w;
								if (x >= EDITORW-TILEW) {
									x = SPALX;
									y += maxh;
									maxh = 0;
								}
							}
						}
					}
					// redraw palette with new selection
					drawpalette();
					setstatustext("", &white);
				} else if (mx < PALX) { // over map
					int x,y;
					if (seltile != NULL) {
						/* place selected tile at mouse pos */
						x = (mx / TILEW);
						y = (my / TILEH);
						if (layer == 1) {
							curlevel->map[y*LEVELW+x] = seltile->uniqid;
							curlevel->tileframe[y*LEVELW+x] = 0;
						} else {
							// if there's nothing at layer1, it goes there
							//if (curlevel->map[y*LEVELW+x] == T_BLANK) {
							//	printf("falling to layer 1\n");
							//	curlevel->map[y*LEVELW+x] = seltile->uniqid;
							//	curlevel->tileframe[y*LEVELW+x] = 0;
							//} else {
								curlevel->map2[y*LEVELW+x] = seltile->uniqid;
							//}
						}
						// redraw tile and sprites 
						draweditortile(screen,x,y);
						drawsprites();

						setmod(B_TRUE);
						setstatustext("", &white);
					} else if (selsprite >= 0) {
						int placed = B_FALSE;

						x = (mx / TILEW);
						y = (my / TILEH);

						/* checks */
						// can only have one player/powerup pos
						if ((selsprite == P_PLAYER) || (selsprite == P_POWERUPPOS)) {
							/* does a player start pos already exist? */
							sprite_t *s;
							for (s = sprite ; s ; s = s->next) {
								if (s->id == selsprite) {
									// if so, just move it
									s->x = x*TILEW+(TILEW/2);
									s->y = y*TILEH+TILEH;
									placed = B_TRUE;
									setmod(B_TRUE);
									// get rid of old sprite
									draweditorlevel();
									drawsprites();
								}
							}
						} else { // is there a monster already there?
							sprite_t *s;
							for (s = sprite ; s ; s = s->next) {
								if (s->id == selsprite) {
									if ((s->x == x*TILEW+(TILEW/2)) && (s->y == y*TILEH+TILEH)) {
										/* don't place it */
										placed = B_TRUE;
									}
								}
							}
						}
				

						if (!placed) {
							if (toggletimer == 0) {
								/* place selected sprite at mouse position 
									(locked to a tile) */
								if (selsprite == P_HELP) {
									addsprite(selsprite, x*TILEW+(TILEW/2),y*TILEH+TILEH,"FILL ME IN" );
								} else {
									addsprite(selsprite, x*TILEW+(TILEW/2),y*TILEH+TILEH,"something" );
								}
								toggletimer = 30;
								setmod(B_TRUE);
								drawsprites();
								sprintf(tempm, "Sprite added at %d,%d",x,y);
								setstatustext(tempm, &white);
							}
						}

					}
				}
			} else if (state == LS_SAVE) {
				// get pos
				int i;
				int lev;
				// get level # at mouse posj
				lev = (my / (EDITTEXT + LLISTPADY));

				if (curlevelnum != lev) {

					// REMOVE CURRENT LEVEL FROM LIST
					for (i = curlevelnum; i < (numlevels-1); i++) {
						levelentry[i] = levelentry[i+1];
					}
					numlevels--;
					if (lev > curlevelnum) {
						lev--;
					}

					// shuffle
					for (i = numlevels; i > lev+1; i--) {
						levelentry[i] = levelentry[i-1];
					}

					// insert current level at correct position (after where we clicked)
					levelentry[lev+1].id = curlevel->id;

					strncpy(levelentry[lev+1].desc, curlevel->name, MIDBUFLEN);
					strncpy(levelentry[lev+1].filename, curlevel->filename, MIDBUFLEN);

					numlevels++;

					curlevelnum = lev + 1;


					/* save out level list */
					savelevellist();

					// redraw
					drawlevellist();

					sprintf(tempm, "Level moved to position %d",curlevelnum);
					setstatustext(tempm, &white);
				}
			}// end if LS_EDIT/LS_SAVE etc
		} // end if LMB


		/* check for keys */
		SDL_PumpEvents();
		keys = SDL_GetKeyState(NULL);



		if (state == LS_EDIT) {
			if (keys[SDLK_1] || keys[SDLK_2]) { // toggle layer
				if (toggletimer == 0) {
					layer = 3 - layer;
					draweditorlevel();
					drawsprites();
					sprintf(tempm, "Now editting layer %d",layer);
					setstatustext(tempm, &green);
					toggletimer = 30;
				}
			}
			if (keys[SDLK_t]) {
				if (toggletimer == 0) {
					if (layertransparent) layertransparent = B_FALSE;
						else layertransparent = B_TRUE;
					draweditorlevel();
					drawsprites();
					sprintf(tempm, "Transparent layers now %s",layertransparent ? "ON" : "OFF");
					setstatustext(tempm, &green);
					toggletimer = 15;
				}
			}
		
			if (keys[SDLK_x]) { // delete monster 
				int donesomething = B_FALSE;
				sprite_t *s, *nextone;

				for (s = sprite ; s ; s = nextone) {
					nextone = s->next;

					/* if mouse is over this sprite */
					if (  (mx >= s->x - (s->img->w/2)) &&
					      (mx <= s->x + (s->img->w/2)) &&
					      (my >= s->y - s->img->h) &&
					      (my <= s->y )) {
						// kill it
						killsprite(s);
						donesomething = B_TRUE;
					}
				}
				if (donesomething)  {
					draweditorlevel();
					drawsprites();
					setmod(B_TRUE);
				}
			}
			if (keys[SDLK_c]) {
				if (toggletimer == 0) {
					clearlevel();
					toggletimer = 30;
				}
			}
			if (keys[SDLK_f]) {
				if (toggletimer == 0) {
					filllevel();
					toggletimer = 30;
				}
			}


			
			/* exit direction */
			if (toggletimer == 0) {
				if (keys[SDLK_h]) {
					curlevel->exitdir = D_LEFT;
					toggletimer = 30;
					setmod(B_TRUE);
					sprintf(tempm, "Exit direction set to DOWN");
					setstatustext(tempm, &white);
				}
				if (keys[SDLK_j]) {
					curlevel->exitdir = D_DOWN;
					toggletimer = 30;
					setmod(B_TRUE);
					sprintf(tempm, "Exit direction set to DOWN");
					setstatustext(tempm, &white);
				}
				if (keys[SDLK_k]) {
					curlevel->exitdir = D_UP;
					toggletimer = 30;
					setmod(B_TRUE);
					sprintf(tempm, "Exit direction set to DOWN");
					setstatustext(tempm, &white);
				}
				if (keys[SDLK_l]) {
					curlevel->exitdir = D_RIGHT;
					toggletimer = 30;
					setmod(B_TRUE);
					sprintf(tempm, "Exit direction set to DOWN");
					setstatustext(tempm, &white);
				}
			}

			/* new level */
			if (keys[SDLK_n]) {
				if (toggletimer == 0) {
					newlevel();
					draweditorlevel();
					drawsprites();
					toggletimer = 30;
					setmod(B_FALSE);
					setstatustext("Created new level.", &white);
				}
			} 

			/* next level */
			if (keys[SDLK_RIGHT]) {
				if (toggletimer == 0) {
					if (curlevelnum < (numlevels-1)) {
						curlevelnum++;
						loadlevel(curworld, curlevelnum, B_TRUE);
						draweditorlevel();
						drawsprites();
						toggletimer = 30;
						setmod(B_FALSE);
						setstatustext("Skipping to next level.", &white);
					}
				}
			} 
			/* prev level */
			if (keys[SDLK_LEFT]) {
				if (toggletimer == 0) {
					if (curlevelnum > 1) {
						curlevelnum--;
						loadlevel(curworld, curlevelnum, B_TRUE);
						draweditorlevel();
						drawsprites();
						toggletimer = 30;
						setmod(B_FALSE);
						setstatustext("Skipping to previous level.", &white);
					}
				}
			} 

			if (keys[SDLK_RETURN]) {
				if (toggletimer == 0) {
					SDL_WM_ToggleFullScreen(screen);
					toggletimer = 50;
				}
			} 
			if (keys[SDLK_q]) {
				return 1;
			} 
		} else if (state == LS_SAVE) {
			if (keys[SDLK_ESCAPE]) {
				state = LS_EDIT;
				draweditorlevel();
				drawsprites();
			} 
		}


		/* levellist  */
		if (keys[SDLK_z]) {
			state = LS_SAVE;
			drawlevellist();
		} 

		/* SAVE LEVEL */
		if (keys[SDLK_s]) {
			if (modified) {
				savelevel(curworld,curlevelnum);
				setmod(B_FALSE);
			}
		} 


		// line to selected position
		if (state == LS_SAVE) {
			char temps[MIDBUFLEN];
			int lev, ypos;
			// get level # at mouse posj
			lev = my / (EDITTEXT + LLISTPADY);
			ypos = lev * (EDITTEXT + LLISTPADY);

			if (oldy != ypos) {
				int textx = EDITMAPW - 200;

				sprintf(temps, "Insert level here");

				// clear old line
				if (oldy != -1) {
					drawline16(screen, LLISTX, oldy, EDITMAPW-LLISTX, oldy, black );
				}

				// clear old text
				writetext(screen, textx, oldy-EDITTEXT, temps, EDITTEXT, &black);

				// draw new line
				drawline16(screen, LLISTX, ypos, EDITMAPW-LLISTX, ypos, green );
				oldy = ypos;

				// draw new text
				writetext(screen, textx, ypos-EDITTEXT, temps, EDITTEXT, &green);
				
			}
	
		}


		flip();
		if (++timer == 100) timer = 0;
		if (toggletimer > 0) toggletimer--;

 	}

	return 0;

}


void cleanup(void) {
	int i;
	for (i = 1; i < MAXLETTERHEIGHT; i++) {
		TTF_CloseFont(font[i]);
	}
	TTF_Quit();
	SDL_Quit();
}

void drawstatus(void) {
	char temps[MIDBUFLEN];
	SDL_Rect area;
	int wid;
	SDL_Color *col;

	// clear status
	area.x = STATUSX;
	area.y = STATUSY;
	area.w = EDITORW;
	area.h = EDITORH-STATUSY;
	SDL_FillRect(screen, &area, SDL_MapRGB(screen->format, 0, 0, 0));

	// show level num
	sprintf(temps, "Level %d",curlevelnum);
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, &white);
	area.x += (wid + STATUSPAD);
	// show level name
	sprintf(temps, "%s",curlevel->filename);
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, &white);
	area.x += (wid + STATUSPAD);
	// show level desc
	sprintf(temps, "\"%s\"",curlevel->name);
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, &blue);
	area.x += (wid + STATUSPAD);
	// show bg file
	sprintf(temps, "bgfile: %s",curlevel->bgfile);
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, &white);
	area.x += (wid + STATUSPAD);
	// show exit dir
	sprintf(temps, "Exit dir: ");
	switch (curlevel->exitdir)  {
		case D_RIGHT: strcat(temps, "RIGHT"); break;
		case D_LEFT: strcat(temps, "LEFT"); break;
		case D_UP: strcat(temps, "UP"); break;
		case D_DOWN: strcat(temps, "DOWN"); break;
		default: strcat(temps, "???"); break;
	}
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, &white);
	area.x += (wid + STATUSPAD);

	// show layer
	///area.x = (EDITMAPW/4)*3; // 3/4 across
	area.x = 0;
	area.y += (EDITTEXT  );

	if (layer == 1) {
		col = &green;
	} else {
		if (layertransparent) {
			col = &grey2;
		} else {
			col = &white;
		}
	}
	sprintf(temps, "Layer 1");
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, col);

	if (layer == 2) {
		col = &green;
	} else {
		if (layertransparent) {
			col = &grey2;
		} else {
			col = &white;
		}
	}
	area.x += (wid + STATUSPAD);
	sprintf(temps, "Layer 2");
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, col);

	// show modified status
	area.x = EDITMAPW - 50;
	sprintf(temps, "MODIFIED");
	if (modified) {
		col = &red;
	} else {
		col = &grey2;
	}
	wid = writetext(screen, area.x, area.y, temps, EDITTEXT, col);

	// Move down
	area.y += (EDITTEXT);
	area.x = 0;

	// status text
	wid = writetext(screen, area.x, area.y, statustext, EDITTEXT, statustextcol);
}


void draweditorlevel(void) {
	int x,y;

	if (temps) {
		SDL_FreeSurface(temps);
		temps = NULL;
	}
	temps = SDL_CreateRGBSurface(SDL_SWSURFACE,
		640, 480 + EDITTEXT*4, 
		screen->format->BitsPerPixel, screen->format->Rmask,
		screen->format->Gmask,screen->format->Bmask,
		screen->format->Amask);

	for (x = 0; x < LEVELW; x++) {
		for (y = 0; y < LEVELH; y++) {
			draweditortile(screen,x,y);
		}
	}

	drawstatus();

	SDL_UpdateRect(screen, 0, 0, EDITORW, EDITORH);
}




void drawsprites(void) {
	sprite_t *s;
	for (s = sprite; s != NULL; s = s->next) {
		drawsprite(s);
	}
}




/*
char tiletochar(int id) {
	switch (id) {
		case T_BLANK: return '0';
		case T_LAND: return '~';
		case T_SLOPEUP: return '/';
		case T_SLOPEDOWN: return '\\';
		case T_FULL: return '*';
		case T_SKY: return '0';
		case T_LADDER: return '=';
		case T_LADDERTOP: return '-';
		case T_RIGHT: return '>';
		case T_LEFT: return '<';
		case T_SPIKES: return '^';
		case T_TELEPORT: return ';';
		case T_TELEPORT2: return ':';
		case T_TELEPORTDEST: return '.';
		case T_WATER: return '}';
		case T_WATERTOP: return '{';
		case T_WATERSPIKES: return '|';
	}

	return '0';
}
*/


void usage(void) {
	printf("usage:  edit [-fs] [-l xx]\n");
	printf("   -fs     Start in full-screen mode.\n");
	printf("   -l xx  Edit level xx.\n");
	printf("\n");
}



void drawpalette(void) {
	tiletype_t *tt;
	SDL_Rect area;
	tiletype_t *bg = gettile(curlevel->bgtileid);
	int p;
	int maxheight;

	/* draw all tiles */
	area.x = PALX;
	area.y = PALY;
	area.w = TILEW;
	area.h = TILEH;
	for (tt = tiletype; tt != NULL; tt = tt->next) {
		if (isplacabletile(tt->id)) {
			/* draw background */
			SDL_BlitSurface(bg->img[0], NULL, screen, &area);
			/* draw tile */
			SDL_BlitSurface(tt->img[0], NULL, screen, &area);
			/* draw selector box */
			if (seltile == tt) {
				drawbox16(screen,area.x,area.y,area.x+area.w-1,area.y+area.h-1,&red,NULL);
				drawbox16(screen,area.x+1,area.y+1,area.x+area.w-2,area.y+area.h-2,&red,NULL);
			}
			/* move on to next position */
			area.x += TILEW;
			if (area.x >= EDITORW) {
				area.x = PALX;
				area.y += TILEH;
			}
		}
	}

	SDL_UpdateRect(screen, PALX,PALY,PALW,PALH);

	/* draw all sprites */
	maxheight = 0;

	area.x = SPALX;
	area.y = SPALY;
	for (p = 0; p < MAXPTYPES; p++) {
		SDL_Surface *firstimg;

		if (isplacablesprite(p)) {
			/* select images */
			firstimg = imageset[p].img[F_WALK1];
			area.w = firstimg->w;
			area.h = firstimg->h;
			if (area.h > maxheight) maxheight = area.h;

			/* clear bg */
			drawbox16(screen,area.x,area.y,area.x+area.w,area.y+area.h,&black,&black);
			/* draw sprite */
			SDL_BlitSurface(firstimg, NULL, screen, &area);
			/* draw selector box */
			if (selsprite == p)  {
				drawbox16(screen,area.x,area.y,  area.x+area.w-1,area.y+area.h-1,&red,NULL);
				drawbox16(screen,area.x+1,area.y+1,  area.x+area.w-2,area.y+area.h-2,&red,NULL);
			}

			/* move to next position */
			area.x += area.w;
			if (area.x >= EDITORW-TILEW) {
				area.x = SPALX;
				area.y += maxheight;
				maxheight = 0;
			}
		}
		
	}
	SDL_UpdateRect(screen, SPALX,SPALY,SPALW,SPALH);
}


int savelevel(int wnum, int lnum) {
	FILE *f;
	int x,y;
	char filename[BUFLEN];

	sprite_t *s;


        sprintf(filename,"%s/world%d/%s",datadir,wnum,levelentry[lnum].filename);

	f = fopen(filename,"wt");
	if (!f) {
		printf("can't open level file '%s'\n",filename);
		return B_TRUE;
	}

	fprintf(f, "bgfile %s\n",level->bgfile);
	fprintf(f, "bg %d\n",level->bgtileid);
	fprintf(f, "hurryup %d\n",level->hurryuptime);

	/* no mappings */
	//fprintf(f, "endmaps\n");

	/* help text */
	fprintf(f, "help\n");
	for (s = sprite; s ; s = s->next) {
		if (s->id == P_HELP) {
			fprintf(f,"%s\n",s->name);
		}
	}
	fprintf(f, "endhelp\n");

	/* monster defs */
	fprintf(f, "monsters\n");
	for (s = sprite; s ; s = s->next) {
		int mx,my;
		char mid;
		//mid = monstertochar(s->id);
		mid = s->id;
		mx = (s->x - (TILEW/2)) / TILEW;
		my = (s->y - TILEH/2) / TILEH;
		fprintf(f,"%d %d %d\n",mid,mx,my);
	}
	fprintf(f, "endmonsters\n");

	/* exit dir */
	fprintf(f, "exitdir %d\n",curlevel->exitdir);

	/* level data */
	for (y = 0; y < LEVELH; y++) {
		for (x = 0; x < LEVELW; x++) {
			fprintf(f, "%d,",level->map[y*LEVELW+x]);
		}
		fprintf(f, "\n");
	}

	fprintf(f, "layer2\n");
	/* 2nd layer data - only where needed */
	for (y = 0; y < LEVELH; y++) {
		for (x = 0; x < LEVELW; x++) {
			if (level->map2[y*LEVELW+x] != T_BLANK) {
				// x,y,tileid
				fprintf(f, "%d,%d,%d\n",x,y,level->map2[y*LEVELW+x]);
			}
		}
	}

	fclose(f);

	sprintf(tempm,"Level saved to '%s'",filename);
	setstatustext(tempm, &green);

	return 0;
}

void filllevel(void) {
	int offset,x,y;

	if (seltile == NULL) {
		setstatustext("No tile selected for fill!",&red);
	} else {
		/* fill level with current tile*/
		for (x = 0; x < LEVELW; x++) {
			for (y = 0; y < LEVELH; y++) {
				offset = y*LEVELW+x;
				curlevel->map[offset] = seltile->uniqid;
				curlevel->map2[offset] = T_BLANK;
				draweditortile(screen,x,y);
			}
		}
	}


	modified = B_TRUE;
}


void clearlevel(void) {
	int offset,x,y;

	/* clear all sprites */
	while (sprite) {
		killsprite(sprite);
	}

	/* clear level */
	for (x = 0; x < LEVELW; x++) {
		for (y = 0; y < LEVELH; y++) {
			offset = y*LEVELW+x;
			if ((x == 0) || (x == LEVELW-1)) {
				curlevel->map[offset] = T_FULL;
			} else if (y == LEVELH-1) {
				curlevel->map[offset] = T_LAND;
			} else {
				curlevel->map[offset] = T_BLANK;
			}
			curlevel->map2[offset] = T_BLANK;
			draweditortile(screen,x,y);
		}
	}


	modified = B_TRUE;
}

int isplacabletile(int tid) {
	switch (tid) {
		case T_TRAMPDOWN:
			return B_FALSE;
	}
	return B_TRUE;
}

int isplacablesprite(int sid) {
	switch (sid) {
		case P_SPEED:
		case P_NUMNETS:
		case P_BIGNET:
		case P_BLACKCLOUD:
		case P_PINKCLOUD:
		case P_SPIT:
		case P_PUFF:
		case P_SMASH:
		case P_BOXING:
		case P_GLOVE:
		case P_DIAMOND:
		case P_FTODIAMOND:
		case P_FTOGEM:
		case P_BOMB:
		case P_SHIELD:
		case P_MACEPOWERUP:
		case P_MACE:
		case P_GEMRED:
		case P_GEMYELLOW:
		case P_GEMPURPLE:
		case P_SPRAY:
		case P_CANNONPOWERUP:
		case P_CANNON:
		case P_TROPHY:
		case P_SNOWMAN:
		case P_RINGSILVER:
		case P_RINGGOLD:
		case P_CLOCK:
		case P_BELL:
		case P_GEMBOOST:
		case P_HELMET:
		case P_PHONE:
		case P_BUBBLE:
		case P_HONEY:
		case P_STARPOWERUP:
		case P_STAR:
		case P_UFO:
		case P_METEOR:
		case P_LIFE:
		case P_BIGSPEED:
		case P_MOVINGCARD:
		case P_FIVECARDS:
			return B_FALSE;
	}

	if (iscard(sid)) {
		return B_FALSE;
	}
	return B_TRUE;
}

// like drawtile but adjusts transparncy based on current layer 
void draweditortile(SDL_Surface *where, int x, int y) {
        SDL_Rect area;
        tiletype_t *tt; 
        int frame;
        int offset;
	SDL_Surface *greyim, *temps;

        if ((x < 0) || (y < 0) || (x >= LEVELW) || (y >= LEVELH)) {
                return;
        }

        area.x = x * TILEW;
        area.y = y * TILEH;
        area.w = TILEW;
        area.h = TILEH;







        /* draw blank tile first */
        tt = gettile(curlevel->bgtileid);
        SDL_BlitSurface(levelbg,  &area, where, &area);

        /* figure out what the layer1 tile is */
        offset = y*LEVELW+x;
        tt = gettile(curlevel->map[offset]);
        frame = curlevel->tileframe[offset];


	// get greyimnal layer1 image
	temps = rotozoomSurfaceXY(tt->img[frame], 0, 1, 1, 0);
	// paste grey one on top
	//SDL_BlitSurface(whitebox, NULL, greyim, NULL);
	SDL_SetAlpha(temps, SDL_SRCALPHA, 50);
	greyim = SDL_DisplayFormat(temps);
	SDL_FreeSurface(temps);
	


        /* now draw real one */
        if (tt->id != curlevel->bgtileid) {
		if (layertransparent && (layer == 2))  { // greyed one
			SDL_BlitSurface(greyim, NULL, where, &area);
		} else {
			SDL_BlitSurface(tt->img[frame], NULL, where, &area);
		}
        }

	SDL_FreeSurface(greyim);

        /* now draw layer2 if it exists */
        if (curlevel->map2[offset] != T_BLANK) {
                tt = gettile(curlevel->map2[offset]);
                if (tt->id != curlevel->bgtileid) {

			// there is a second layer.
			// generate greyed version...
			// get greyimnal layer2 image
			temps = rotozoomSurfaceXY(tt->img[frame], 0, 1, 1, 0);
			// paste grey one on top
			//SDL_BlitSurface(whitebox, NULL, greyim, NULL);
			SDL_SetAlpha(temps, SDL_SRCALPHA, 50);
			greyim = SDL_DisplayFormat(temps);
			SDL_FreeSurface(temps);

			if (layertransparent && (layer == 1))  { // greyed one
				SDL_BlitSurface(greyim, NULL, where, &area);
			} else {
				SDL_BlitSurface(tt->img[frame], NULL, where, &area);
			}

                }

		SDL_FreeSurface(greyim);
        }

}

int writetext(SDL_Surface *where, int x, int y, char *text, int size, SDL_Color *col) {
	SDL_Surface *temps;
	SDL_Rect area;
	int wid;

	if (strlen(text) <= 0) {
		return 0;
	}

	temps = TTF_RenderText_Solid(font[size], text, *col);
	area.x = x;
	area.y = y;
	area.w = 0;
	area.h = 0;

	SDL_BlitSurface(temps, NULL, where, &area);

	wid = temps->w;

	SDL_FreeSurface(temps);
	return wid;

}

void setmod(int yesno)  {
	int oldmod;

	oldmod = modified;
	if (yesno) {
		modified = B_TRUE;
	} else {
		modified = B_FALSE;
	}
	// update status bar
	if (oldmod != modified) {
		drawstatus();
	}
}

void drawlevellist(void) {
	int i;
	char temps[MIDBUFLEN];
	SDL_Rect area;
	SDL_Color *col;

	// clear map
	area.x = 0;
	area.y = 0;
	area.w = EDITMAPW;
	area.h = EDITMAPH;
	SDL_FillRect(screen, &area, SDL_MapRGB(screen->format, 0, 0, 0));

	// draw level list
	area.x = LLISTX;
	area.y = 0;
	area.w = 0;
	area.h = 0;
	for (i =1; i < numlevels; i++) {
		if (i == curlevelnum) {
			col = &green;
		} else {
			col = &white;
		}
		sprintf(temps, "%d. %s (%s)",levelentry[i].id, levelentry[i].desc, levelentry[i].filename);
		writetext(screen, area.x, area.y, temps, EDITTEXT, col);
		area.y += (EDITTEXT + LLISTPADY);
	}
}


void newlevel(void) {
	char tempbuf[BUFLEN];

	curlevelnum = numlevels;

	clearlevel();

	maxlevid++;
	sprintf(tempbuf,"level%d.dat",maxlevid);
	sprintf(curlevel->filename, tempbuf);
	strncpy(levelentry[curlevelnum].filename, tempbuf, MIDBUFLEN);
	sprintf(tempbuf,"NEW LEVEL");
	sprintf(curlevel->name, tempbuf);
	strncpy(levelentry[curlevelnum].desc, tempbuf, MIDBUFLEN);
	curlevel->id = maxlevid;
	levelentry[curlevelnum].id = maxlevid;


	// default
	curlevel->hurryuptime = 30;
	curlevel->exitdir = D_RIGHT;

	sprintf(tempm,"Made new level '%s'\n",levelentry[curlevelnum].filename);
	setstatustext(tempm, &green);

	numlevels++;

	// save list
	savelevellist();
}

void setstatustext(char *text, SDL_Color *col) {
	strncpy(statustext, text, BUFLEN);
	statustextcol = col;
	drawstatus();
}