#include <Carbon/Carbon.h>
#include <cstring>
#include <cstdio>

//#include "item.h"

#include "boe.global.h"

#include "classes.h"
#include "boe.graphics.h"
#include "boe.newgraph.h"
#include "boe.graphutil.h"
#include "boe.monster.h"
#include "dlgtool.h"
#include "boe.locutils.h"
#include "boe.fields.h"
#include "boe.text.h"
#include "graphtool.h"
#include "soundtool.h"
#include "gamma.h"
#include "mathutil.h"
#include "dlgutil.h"

#include "boe.party.h"
#include "boe.town.h"
#include "boe.items.h"
#include "boe.dlgutil.h"
#include "boe.infodlg.h"

extern WindowPtr mainPtr;
extern Rect	windRect;
extern short stat_window,give_delays;
extern eGameMode overall_mode;
extern short current_spell_range,town_type;
extern bool in_startup_mode,anim_onscreen,play_sounds,frills_on,startup_loaded,party_in_memory;
extern short anim_step;
extern ter_num_t combat_terrain[64][64];
extern effect_pat_type current_pat;
extern bool web,crate,barrel,fire_barrier,force_barrier,quickfire,force_wall,fire_wall,antimagic,scloud,ice_wall,blade_wall;
extern Point ul;
extern location pc_pos[6],pc_dir[6],center;
extern short which_combat_type,current_pc;
extern bool monsters_going,boom_anim_active,skip_boom_delay;
extern 	PicHandle	spell_pict;
extern short current_ground;
extern short num_targets_left;
extern location spell_targets[8];
extern short display_mode;
extern ControlHandle text_sbar,item_sbar,shop_sbar;
extern GWorldPtr bg_gworld;
extern Rect sbar_rect,item_sbar_rect,shop_sbar_rect,startup_top;
extern Rect talk_area_rect, word_place_rect;
extern Rect map_pat[];
extern Point store_anim_ul;
extern long register_flag;
extern long ed_flag,ed_key;
extern bool fast_bang;
extern Rect	bg[];
extern KeyMap key_state;
extern bool fry_startup;
extern cScenario scenario;
extern cUniverse univ;
extern GWorldPtr spec_scen_g;
extern DialogPtr modeless_dialogs[18];
extern bool modeless_exists[18];
extern bool show_startup_splash;

RgnHandle clip_region;

PaletteHandle new_palette,old_palette,wank_palette;
//***********************
Rect		menuBarRect;
short		menuBarHeight;
RgnHandle	originalGrayRgn, newGrayRgn, underBarRgn;

short terrain_there[9][9]; // this is an optimization variabel. Keeps track of what terrain
	// is in the terrain spot, so things don't get redrawn. 
	// 0 - 299 just terrain graphic in place
	// 300 - blackness
	// -1 - nothign worth saving

long anim_ticks = 0;

// 0 - terrain   1 - buttons   2 - pc stats 
// 3 - item stats   4 - text bar   5 - text area (not right)
Rect win_from_rects[6] = {{0,0,351,279},{0,0,37,258},{0,0,115,288},{0,0,143,288},{0,0,21,279},{0,0,0,288}};
Rect win_to_rects[6] = {{5,5,356,284},{383,5,420,263},{0,0,116,271},{0,0,144,271},{358,5,379,284},{0,0,138,256}};

// 0 - title  1 - button  2 - credits  3 - base button
Rect startup_from[4] = {{0,0,274,602},{274,0,322,301},{0,301,67,579},{274,301,314,341}}; ////
extern Rect startup_button[6];
	
//	Rect trim_rects[8] = {{0,0,5,28},{31,0,36,28},{0,0,36,5},{0,24,36,28},
//						{0,0,5,5},{0,24,5,28},{31,24,36,28},{31,0,36,5}};

Rect	top_left_rec = {0,0,36,28};
short which_graphic_index[6] = {50,50,50,50,50,50};

char combat_graphics[5] = {28,29,36,79,2};
short debug_nums[6] = {0,0,0,0,0,0};					     
short remember_tiny_text = 300; // Remembers what's in the tiny text-bar, to prevent redrawing.
	// 50 indicates area name, other number indicates which-rect.
	// Add 200 if last mess. was in town

char light_area[13][13];
char unexplored_area[13][13];

// Declare the graphics
GWorldPtr status_gworld = NULL;
GWorldPtr invenbtn_gworld = NULL;
GWorldPtr vehicle_gworld = NULL;
GWorldPtr pc_stats_gworld = NULL;
GWorldPtr item_stats_gworld = NULL;
GWorldPtr text_area_gworld = NULL;
GWorldPtr terrain_screen_gworld = NULL;
GWorldPtr text_bar_gworld = NULL;
GWorldPtr orig_text_bar_gworld = NULL;
GWorldPtr buttons_gworld = NULL;
GWorldPtr items_gworld = NULL;
GWorldPtr tiny_obj_gworld = NULL;
GWorldPtr fields_gworld = NULL;
GWorldPtr boom_gworld = NULL;
GWorldPtr roads_gworld = NULL;
GWorldPtr map_gworld = NULL;
GWorldPtr small_ter_gworld = NULL;
GWorldPtr missiles_gworld = NULL;
GWorldPtr dlogpics_gworld = NULL;
GWorldPtr anim_gworld = NULL;
GWorldPtr talkfaces_gworld = NULL;
GWorldPtr pc_gworld = NULL;
GWorldPtr monst_gworld[NUM_MONST_SHEETS] = {0};
GWorldPtr terrain_gworld[NUM_TER_SHEETS] = {0};

// Startup graphics, will die when play starts
GWorldPtr startup_gworld = NULL;
GWorldPtr startup_button_orig = NULL;
GWorldPtr startup_button_g = NULL;
GWorldPtr anim_mess = NULL;

bool has_run_anim = false,currently_loading_graphics = false;
//short anim_step = 0;
//short overall_anim_step = 0;

Rect main_win_rect = {0,0,410,250};
Rect main_win2_source_rect = {0,0,410,265};
Rect main_win2_rect = {0,250,410,515};

Rect tiny_world_1_source_rect = {0,0,190,145},
	tiny_world_1_rect = {195,242,385,475};

Rect share_mess_source_rect = {0,0,59,120},
	share_mess_rect = {120,384,179,504};
//Rect start_buttons_source_rect = {0,0,180,180},
//	start_buttons_rect = {224,30,405,210};
Rect start_buttons_source_rect = {0,0,186,190},
	start_buttons_rect = {214,30,400,220};

// Array to store which spots have been seen. Time-saver for drawing fields
char spot_seen[9][9];

char anim_str[60];
location anim_str_loc;

PatHandle bw_pats[15];

extern short combat_posing_monster , current_working_monster ; // 0-5 PC 100 + x - monster x
bool supressing_some_spaces = false;
location ok_space[4] = {loc(),loc(),loc(),loc()};
	PicHandle	hold_pict;
	PictInfo p,p2;



void init_dialogs(){
	cd_init_dialogs(
		&anim_gworld,
		&talkfaces_gworld,
		&items_gworld,
		&tiny_obj_gworld,
		&pc_gworld,
		&dlogpics_gworld,
		monst_gworld,
		terrain_gworld,
		&small_ter_gworld,
		&fields_gworld,
		&pc_stats_gworld,
		&item_stats_gworld,
		NULL,
		&spec_scen_g
	);
	cd_register_event_filter(869,pick_prefab_scen_event_filter);
	cd_register_event_filter(947,pick_a_scen_event_filter);
	cd_register_event_filter(958,tip_of_day_event_filter);
	cd_register_event_filter(960,talk_notes_event_filter);
	cd_register_event_filter(961,adventure_notes_event_filter);
	cd_register_event_filter(962,journal_event_filter);
	cd_register_event_filter(987,display_item_event_filter);
	cd_register_event_filter(988,pick_trapped_monst_event_filter);
	cd_register_event_filter(989,edit_party_event_filter);
	cd_register_event_filter(991,display_pc_event_filter);
	cd_register_event_filter(996,display_alchemy_event_filter);
	cd_register_event_filter(997,display_help_event_filter);
	cd_register_event_filter(998,display_pc_item_event_filter);
	cd_register_event_filter(999,display_monst_event_filter);
	cd_register_event_filter(1010,spend_xp_event_filter );
	cd_register_event_filter(1012,get_num_of_items_event_filter );
	cd_register_event_filter(1013,pick_race_abil_event_filter );
	cd_register_event_filter(1014,sign_event_filter );
	cd_register_event_filter(873,get_text_response_event_filter );
	cd_register_event_filter(1017,get_text_response_event_filter );
	cd_register_event_filter(1018,select_pc_event_filter );
	cd_register_event_filter(1019,give_pc_info_event_filter);
	cd_register_event_filter(1047,alch_choice_event_filter);
	cd_register_event_filter(1050,pc_graphic_event_filter);
	cd_register_event_filter(1051,pc_name_event_filter);
	cd_register_event_filter(1073,give_reg_info_event_filter );
	cd_register_event_filter(1075,do_registration_event_filter );
	cd_register_event_filter(1096,display_spells_event_filter );
	cd_register_event_filter(1097,display_skills_event_filter );
	cd_register_event_filter(1098,pick_spell_event_filter );
	cd_register_event_filter(1099,prefs_event_filter );
	cd_register_default_event_filter(fancy_choice_dialog_event_filter);
}

void adjust_window_mode()
{
	Rect r;

	if (display_mode == 5) {
		ul.h = 14; ul.v = 2;
		SizeWindow(mainPtr,605,430, true);
		MoveWindow(mainPtr,(windRect.right - 573) / 2,(windRect.bottom - 430) / 2 + 20,true);
		GetWindowPortBounds(mainPtr, &r);
	}
	else {
			MoveWindow(mainPtr,-6,-6,true);	
			SizeWindow(mainPtr,windRect.right + 12, windRect.bottom + 12, true);
			switch (display_mode) {
				case 0: ul.h = (windRect.right - 560) / 2; ul.v = (windRect.bottom - 422) / 2 + 14; break;
				case 1:	ul.h = 10; ul.v = 28; break;
				case 2: ul.h = windRect.right - 570 - 6; ul.v = 28;	break; // was 560. not 570
				case 3: ul.h = 10; ul.v = windRect.bottom - 422	- 6; break;
				case 4: ul.h = windRect.right - 570 - 6; ul.v = windRect.bottom - 422	- 6; break;
				}

			}
	create_clip_region();
	undo_clip();
	if (overall_mode != MODE_STARTUP) { // TODO: This is odd - fix it
		if (in_startup_mode == true)
			draw_startup(0);
		if (in_startup_mode == false)
			//refresh_screen(0); 
			redraw_screen();
		}
	if (text_sbar != NULL) {
		MoveControl(text_sbar,ul.h + 546,ul.v + 283);
		MoveControl(item_sbar,ul.h + 546,ul.v + 146);
		MoveControl(shop_sbar,ul.h + 258,ul.v + 67);
		}
}


void plop_fancy_startup()
{
	GWorldPtr	pict_to_draw;
	short i,j;
	
	GDHandle md;
	
	Rect whole_window,from_rect;
	Rect logo_from = {0,0,350,350};
	Rect intro_from = {0,0,483,643};
	GDHandle	mainScreen;
	
	// store current gray region that displays
	// menu bar and the current height of the menu bar
//	originalGrayRgn 	= LMGetGrayRgn(); 		
//	menuBarHeight	= LMGetMBarHeight(); 	

	// calculate the rect of the menu bar to test 
	// if mouse down is in if desired
	mainScreen 			= GetMainDevice();
	menuBarRect 			= (**mainScreen).gdRect;
	menuBarRect.bottom 	= menuBarHeight;
	
	md = GetMainDevice();
	
	if (fry_startup == false)  { // TODO: What on earth is this for?
		//color_pat = GetCTable(72);
		//old_palette = NewPalette(256,color_pat,pmTolerant + pmExplicit,0x0000);
		//GetPictInfo(pict_to_draw,&p2,1,256,0,0);
		//old_palette = NewPalette(256,color_pat,pmTolerant + pmExplicit,0x0000);
		//old_palette = NewPalette(256,p2.theColorTable,pmTolerant + pmExplicit,0x0000);
		//NSetPalette(mainPtr,old_palette,pmAllUpdates);
		//ActivatePalette(mainPtr);

		/*HLock((Handle) md);
		hPixMap = (*md)->gdPMap;
		HLock((Handle)hPixMap);
		hColorTable = (*hPixMap)->pmTable;
		old_palette = NewPalette(256,hColorTable,pmTolerant + pmExplicit,0x0000);
		HUnlock((Handle)hPixMap);
		HUnlock((Handle) md); */
		wank_palette = NewPalette(256,NULL,pmTolerant + pmExplicit,0x0000);

		//HideMenuBar();
		/*
		GetPort(&oldPort);
		GetDeskTopGrafPort(&wMgrPort);
		SetPort(wMgrPort);
		oldClip = NewRgn();
		GetClip(oldClip);
		ClipRect(&wMgrPort->portRect);
		r = wMgrPort->portRect;
		GetForeColor(&store_color);
		ForeColor(blackColor);
		r.bottom = LMGetMBarHeight();
		PaintRect(&r);
		RGBForeColor(&store_color);
		SetClip(oldClip);
		DisposeRgn(oldClip);
		SetPort(oldPort);
		*/
		}
	
//	for (i = 0;i < 8; i++)
//		OffsetRect(&trim_rects[i],61,37);
	for (i = 0; i < 9; i++)
		for (j = 0; j < 9; j++)
			terrain_there[i][j] = -1;
			
	OffsetRect(&win_to_rects[5],TEXT_WIN_UL_X,TEXT_WIN_UL_Y);
	OffsetRect(&win_to_rects[2],PC_WIN_UL_X,PC_WIN_UL_Y);
	OffsetRect(&win_to_rects[3],ITEM_WIN_UL_X,ITEM_WIN_UL_Y);
		
	GetWindowPortBounds(mainPtr, &whole_window);
//	whole_window = mainPtr->portRect;
	ForeColor(blackColor);
	PaintRect(&whole_window);
	
	OffsetRect(&logo_from,(whole_window.right - logo_from.right) / 2,(whole_window.bottom - logo_from.bottom) / 2);
//	pict_to_draw = GetPicture(3001); // TODO: Read from file instead
//	DrawPicture(pict_to_draw, &logo_from);
//	ReleaseResource((Handle) pict_to_draw);
	pict_to_draw = load_pict("spidlogo.png");
	GetPortBounds(pict_to_draw,&from_rect);
	rect_draw_some_item(pict_to_draw, from_rect, logo_from,ul);
	DisposeGWorld(pict_to_draw);
	
	RgnHandle wholeRegion = NewRgn();
	GetWindowRegion(mainPtr, kWindowContentRgn, wholeRegion);
	QDFlushPortBuffer(GetWindowPort(mainPtr), wholeRegion);
	
	
	play_sound(-95);

	//Delay(30,&dummy);

//	for (i = 0; i < 14; i++) 
//	    bg[i] = GetPixPat (128 + i);
//	for (i = 0; i < 25; i++) 
//	    map_pat[i] = GetPixPat (200 + i);

	// Do bulk of graphics loading!!!

	Set_up_win();

	init_startup();
	
	int delay = 220;
	if(show_startup_splash){
		//init_anim(0);
		//pict_to_draw = GetPicture(3000); // TODO: Read from file instead

		if (fry_startup == false) {
			//for(i=100; i >= 0; i-=2) DoOneGammaFade(md, i);
		
//			PaintRect(&whole_window);
//			// load and switch to new palette
//			GetPictInfo(pict_to_draw,&p,2,256,0,0);
//			new_palette = p.thePalette;
//			SetPalette(mainPtr,new_palette,false);
//			ActivatePalette(mainPtr);
// reerase menu
/*	GetPort(&oldPort);
	GetDeskTopGrafPort(&wMgrPort);
	SetPort(wMgrPort);
	oldClip = NewRgn();
	GetClip(oldClip);
	ClipRect(&wMgrPort->portRect);
	r = wMgrPort->portRect;
	GetForeColor(&store_color);
	ForeColor(blackColor);
	r.bottom = LMGetMBarHeight();
	PaintRect(&r);
	RGBForeColor(&store_color);
	SetClip(oldClip);
	DisposeRgn(oldClip);
	SetPort(oldPort);	*/
		}
// menu erased
	
		PaintRect(&whole_window);
		OffsetRect(&intro_from,(whole_window.right - intro_from.right) / 2,(whole_window.bottom - intro_from.bottom) / 2);
//		DrawPicture(pict_to_draw, &intro_from);
		//		ReleaseResource((Handle) pict_to_draw);	
		pict_to_draw = load_pict("startsplash.png");
		GetPortBounds(pict_to_draw,&from_rect);
		rect_draw_some_item(pict_to_draw, from_rect, intro_from,ul);
		DisposeGWorld(pict_to_draw);

//	NSetPalette(mainPtr,old_palette,pmAllUpdates);
//	ActivatePalette(mainPtr);
	} else delay = 60;
	QDFlushPortBuffer(GetWindowPort(mainPtr), wholeRegion);
	if (fry_startup == false) {
		
		play_sound(-22);
		EventRecord event;
		WaitNextEvent(mDownMask + keyDownMask + mUpMask,&event,delay,NULL);
	}
	
	DisposeRgn(wholeRegion);
}

void fancy_startup_delay()
{

	GDHandle md;
	PaletteHandle default_palette;
	
	md = GetMainDevice();
	
	if (fry_startup == false){
		//ShowMenuBar();
//		LMSetGrayRgn( originalGrayRgn );	
		SetPalette(mainPtr,wank_palette,false);
		ActivatePalette(mainPtr);
		default_palette = GetPalette((WindowPtr) -1);
		NSetPalette(mainPtr,default_palette,pmAllUpdates);
		ActivatePalette(mainPtr);
		RestoreDeviceClut(md);
//		NSetPalette(mainPtr,old_palette,pmAllUpdates);
//		ActivatePalette(mainPtr);
//		DisposePalette(p.thePalette);
		}
	
	// OK try this ... destroy and recreate window.
	/*DisposeWindow(mainPtr);
	mainPtr = GetNewCWindow(128,NULL,IN_FRONT);
	SetPort(mainPtr);						/* set window to current graf port 
	text_sbar = NewControl(mainPtr,&sbar_rect,tit,false,58,0,58,scrollBarProc,1);
	item_sbar = NewControl(mainPtr,&item_sbar_rect,tit,false,0,0,16,scrollBarProc,2);
	shop_sbar = NewControl(mainPtr,&shop_sbar_rect,tit,false,0,0,16,scrollBarProc,3);
	adjust_window_mode();
	RestoreDeviceClut(GetMainDevice()); */
	
	TextFace(0);
	
	draw_startup(0);

	
	FlushEvents(mDownMask,0);				
	FlushEvents(keyDownMask,0);
}

void init_startup()
{
	startup_loaded = true;
	startup_gworld = load_pict("startup.png");
	startup_button_orig = load_pict("startbut.png");
	startup_button_g = load_pict("startbut.png");
	anim_mess = load_pict("startanim.png");
}

void init_animation()
{}

void next_animation_step() 
{}


void draw_startup(short but_type)
{
	Rect to_rect;
	Rect r1 = {-1000,-1000,5,1000},r2 = {-1000,-1000,1000,5},r3 = {418,-1000,2000,1000},
		r4 = {-1000,579,1000,2500};
	short i;
	GrafPtr old_port;
	
	if (startup_loaded == false)
		return;
	
	GetPort(&old_port);	
	SetPort(GetWindowPort(mainPtr));
	r1.bottom = ul.v + 5;
	tileImage(r1,bg_gworld,bg[4]);
	r2.right = ul.h - 13;
	tileImage(r2,bg_gworld,bg[4]);
	r3.top += ul.v + 5;
	tileImage(r3,bg_gworld,bg[4]);
	r4.left += ul.h - 13;
	tileImage(r4,bg_gworld,bg[4]);
	to_rect = startup_from[0];
	OffsetRect(&to_rect,-13,5);
	rect_draw_some_item(startup_gworld,startup_from[0],to_rect,ul);
	to_rect = startup_top;
	OffsetRect(&to_rect,ul.h,ul.v);
	//PaintRect(&to_rect);
	
	for (i = 0; i < 5; i++) {
		rect_draw_some_item(startup_gworld,startup_from[1],startup_button[i],ul);
		draw_start_button(i,but_type);
		}
	draw_startup_anim();
	
	draw_startup_stats();
	SetPort(old_port);
}

void draw_startup_anim()
{
	static short startup_anim_pos = 43; // was a global variable, but since it's only used in this function I moved it here
	Rect anim_to = {4,1,44,276},anim_from;
	Rect anim_size = {0,0,48,301};
	
	anim_from = anim_to;
	OffsetRect(&anim_from,-1,-4 + startup_anim_pos);
	startup_anim_pos = (startup_anim_pos + 1) % 542;
	rect_draw_some_item(startup_button_orig,anim_size,startup_button_g,anim_size);
	rect_draw_some_item(anim_mess,anim_from,startup_button_g,anim_to,transparent);
	rect_draw_some_item(startup_button_g,anim_size,startup_button[5],ul);
}

void draw_startup_stats()
{
	Rect from_rect,to_rect,party_to = {0,0,36,28},pc_rect,frame_rect;
	short i;
	Str255 str;
	
	TextFont(dungeon_font_num);
	TextFace(0);
	TextSize(24);

	to_rect = startup_top;
	OffsetRect(&to_rect, 20 - 18, 35);

	ForeColor(whiteColor);

	if (party_in_memory == false) {
		TextSize(20);
		OffsetRect(&to_rect,175,40);
		char_win_draw_string(mainPtr,to_rect,"No Party in Memory",0,18,ul);
		}
	if (party_in_memory == true) {
		frame_rect = startup_top;
		InsetRect(&frame_rect,50,50);
		frame_rect.top += 30;
		ForeColor(whiteColor);
		OffsetRect(&frame_rect,ul.h - 9,ul.v + 10);
		FrameRect(&frame_rect);

		OffsetRect(&to_rect,203,37);
		char_win_draw_string(mainPtr,to_rect,"Your party:",0,18,ul);
		TextSize(12);	
		TextFace(bold);
		TextFont(geneva_font_num);
		for (i = 0; i < 6; i++) {
			pc_rect = startup_top;
			pc_rect.right = pc_rect.left + 300;
			pc_rect.bottom = pc_rect.top + 79;
			OffsetRect(&pc_rect,60 + 232 * (i / 3) - 9,95 + 45 * (i % 3));
			
			if (univ.party[i].main_status > 0) {
				from_rect = calc_rect(2 * (univ.party[i].which_graphic / 8), univ.party[i].which_graphic % 8);
				to_rect = party_to,
				OffsetRect(&to_rect,pc_rect.left,pc_rect.top);
				rect_draw_some_item(pc_gworld,from_rect,to_rect,ul,transparent);

				TextSize(14);	
				OffsetRect(&pc_rect,35,0);
				char_win_draw_string(mainPtr,pc_rect,(char*)univ.party[i].name.c_str(),0,18,ul);
				OffsetRect(&to_rect,pc_rect.left + 8,pc_rect.top + 8);
				
				}
			TextSize(12);	
			OffsetRect(&pc_rect,12,16);
			switch (univ.party[i].main_status) {
				case MAIN_STATUS_ALIVE:
					switch (univ.party[i].race) {
						case RACE_HUMAN: sprintf((char *) str,"Level %d Human",univ.party[i].level); break;
						case RACE_NEPHIL: sprintf((char *) str,"Level %d Nephilim",univ.party[i].level); break;
						case RACE_SLITH: sprintf((char *) str,"Level %d Slithzerikai",univ.party[i].level); break;
						case RACE_VAHNATAI: sprintf((char *) str,"Level %d Vahnatai",univ.party[i].level); break;
						case RACE_REPTILE: sprintf((char *) str,"Level %d Reptile",univ.party[i].level); break;
						case RACE_BEAST: sprintf((char *) str,"Level %d Beast",univ.party[i].level); break;
						case RACE_IMPORTANT: sprintf((char *) str,"Level %d V.I.P.",univ.party[i].level); break;
						case RACE_MAGE: sprintf((char *) str,"Level %d Human Mage",univ.party[i].level); break;
						case RACE_PRIEST: sprintf((char *) str,"Level %d Human Priest",univ.party[i].level); break;
						case RACE_HUMANOID: sprintf((char *) str,"Level %d Humanoid",univ.party[i].level); break;
						case RACE_DEMON: sprintf((char *) str,"Level %d Demon",univ.party[i].level); break;
						case RACE_UNDEAD: sprintf((char *) str,"Level %d Undead",univ.party[i].level); break;
						case RACE_GIANT: sprintf((char *) str,"Level %d Giant",univ.party[i].level); break;
						case RACE_SLIME: sprintf((char *) str,"Level %d Slime",univ.party[i].level); break;
						case RACE_STONE: sprintf((char *) str,"Level %d Golem",univ.party[i].level); break;
						case RACE_BUG: sprintf((char *) str,"Level %d Bug",univ.party[i].level); break;
						case RACE_DRAGON: sprintf((char *) str,"Level %d Dragon",univ.party[i].level); break;
						case RACE_MAGICAL: sprintf((char *) str,"Level %d Magical Creature",univ.party[i].level); break;
						case RACE_PLANT: sprintf((char *) str,"Level %d Plant",univ.party[i].level); break;
						case RACE_BIRD: sprintf((char *) str,"Level %d Bird",univ.party[i].level); break;
						default: sprintf((char *) str,"Level %d *ERROR INVALID RACE*",univ.party[i].level); break;
						}
					char_win_draw_string(mainPtr,pc_rect,(char *) str,0,18,ul);
					OffsetRect(&pc_rect,0,13);
					sprintf((char *) str,"Health %d, Spell pts. %d",
						univ.party[i].max_health,univ.party[i].max_sp);
					char_win_draw_string(mainPtr,pc_rect,(char *) str,0,18,ul);
					break;
				case MAIN_STATUS_DEAD:
					char_win_draw_string(mainPtr,pc_rect,"Dead",0,18,ul);
					break;
				case MAIN_STATUS_DUST:
					char_win_draw_string(mainPtr,pc_rect,"Dust",0,18,ul);
					break;
				case MAIN_STATUS_STONE:
					char_win_draw_string(mainPtr,pc_rect,"Stone",0,18,ul);
					break;
				case MAIN_STATUS_FLED:
					char_win_draw_string(mainPtr,pc_rect,"Fled",0,18,ul);
					break;
				default: //absent, and all variations thereof; do nothing
					break;
				}
			}
		}
	
	TextFont(geneva_font_num);
	TextSize(10);	
	TextFace(bold);
	pc_rect = startup_from[0];
	OffsetRect(&pc_rect,5,5);
	pc_rect.top = pc_rect.bottom - 25;
	pc_rect.left = pc_rect.right - 300;
	char_win_draw_string(mainPtr,pc_rect,"Copyright 1997, All Rights Reserved, v1.0.2",0,18,ul);
		
	ForeColor(blackColor);
}



void draw_start_button(short which_position,short which_button)
{
	Rect from_rect,to_rect;
	char *button_labels[] = {"Load Game","Make New Party","How To Order",
		"Start Scenario","Custom Scenario","Quit"};
	RGBColor base_color = {0,0,14472};
	//RGBColor lit_color = {0,0,14472},base_color = {0,0,43144};
	
	from_rect = startup_from[3];
	OffsetRect(&from_rect, (which_button > 0) ? 40 : 0,0);
	to_rect = startup_button[which_position];
	to_rect.left += 4; to_rect.top += 4;
	to_rect.right = to_rect.left + 40;
	to_rect.bottom = to_rect.top + 40;
	rect_draw_some_item(startup_gworld,from_rect,to_rect,ul);
	
	TextFont(dungeon_font_num);
	TextFace(0);
	TextSize(24);
	to_rect = startup_button[which_position];
	//to_rect.left += 80;
	OffsetRect(&to_rect, 10, 10);
	if (which_button == 5)
		which_button = 4;
	base_color.blue = 14472 + (12288 * which_button);
	RGBForeColor(&base_color);
	if (which_position == 3)
		OffsetRect(&to_rect,-7,0);
	char_win_draw_string(mainPtr,to_rect,(char *) button_labels[which_position],1,18,ul);
	ForeColor(blackColor);
	TextFont(geneva_font_num);
	TextFace(bold);
	TextSize(10);
	
}

void main_button_click(short mode,Rect button_rect)
{
	const BitMap *	store2;

	store2 = GetPortBitMapForCopyBits(GetWindowPort(mainPtr));

	OffsetRect(&button_rect,ul.h,ul.v);
	ClipRect(&button_rect);

	draw_buttons(1);
	if (play_sounds == true)
		play_sound(37);
		else FlushAndPause(5);
	draw_buttons(0);			
	undo_clip();
}

void arrow_button_click(Rect button_rect)
{
	const BitMap *	store2;
	
	store2 = GetPortBitMapForCopyBits(GetWindowPort(mainPtr));

	OffsetRect(&button_rect,ul.h,ul.v);
	ClipRect(&button_rect);
	
	refresh_stat_areas(1);
	if (play_sounds == true)
		play_sound(37);
		else FlushAndPause(5);
	refresh_stat_areas(0);
	undo_clip();
}


void reload_startup()////
{
	if (startup_loaded == true)
		return;
	
	HideWindow(GetDialogWindow(modeless_dialogs[5])); 
	modeless_exists[5] = false;				
	SelectWindow(mainPtr);
	SetPort(GetWindowPort(mainPtr));
	init_startup();

	startup_loaded = true;
	//load_main_screen();
}

void end_startup()
{
	if (startup_loaded == false)
		return;

	DisposeGWorld(startup_gworld);
	DisposeGWorld(startup_button_orig);
	DisposeGWorld(startup_button_g);
	DisposeGWorld(anim_mess);

	startup_loaded = false;
	load_main_screen();
}

// This loads the graphics at the top of the game.
void Set_up_win ()
{
	QDErr err;
	Rect temp_rect = {0,0,0,280},map_world_rect;
	Rect map_rect = {0,0,384,384};
	Rect pc_rect = {0,0,216,113};
	GrafPtr old_port;
	GWorldPtr temp_gworld;
	Str255 fn1 = "\pGeneva";
	Str255 fn2 = "\pDungeon Bold";
	Str255 fn3 = "\pPalatino";
	short i;
	Rect r;
	
	
	GetFNum(fn1,&geneva_font_num);
	if (geneva_font_num == 0)
		GetFNum(fn3,&geneva_font_num);
	GetFNum(fn2,&dungeon_font_num);
	if (dungeon_font_num == 0)
		GetFNum(fn3,&dungeon_font_num);
	
	terrain_screen_gworld = load_pict("terscreen.png");

	for (i = 0; i < 7; i++)
		bw_pats[i] = GetPattern(128 + i * 2);


	// Create and initialize map gworld
	err = NewGWorld(&map_gworld,  0 /*8*/,&map_rect, NULL, NULL, kNativeEndianPixMap);
	if (err != 0) {
		play_sound(2,3);
		ExitToShell();		
		}
		else {		
		GetPort(&old_port);
		SetPort(map_gworld);
		GetPortBounds(map_gworld,&map_world_rect);
		ForeColor(whiteColor);
		PaintRect(&map_world_rect);
		ForeColor(blackColor);
		SetPort(old_port);
		}

}

void load_main_screen()
{
	if (invenbtn_gworld != NULL)
		return;
	
	invenbtn_gworld = load_pict("invenbtns.png");
	pc_stats_gworld = load_pict("statarea.png");
	item_stats_gworld = load_pict("inventory.png");
	text_area_gworld = load_pict("transcript.png");
	text_bar_gworld = load_pict("textbar.png");
	orig_text_bar_gworld = load_pict("textbar.png");
	buttons_gworld = load_pict("buttons.png");
   
	set_gworld_fonts(geneva_font_num);
	
	create_clip_region();
}

void create_clip_region()
{
	short i;
	Rect store_rect;
	Rect scrollbar_rect;

	DisposeRgn(clip_region);
	clip_region = NewRgn();
	OpenRgn();

	Rect tempRect;
	GetWindowPortBounds(mainPtr,&tempRect);
	FrameRect(&tempRect);
	for (i = 0; i < 6; i++) {
		store_rect = win_to_rects[i];
		OffsetRect(&store_rect,ul.h,ul.v);
		if ((is_out()) || (is_town()) || (is_combat()) ||
			(i == 2) || (i == 3) || (i == 5))
				FrameRect(&store_rect);
		}
	if ((overall_mode == MODE_TALKING) || (overall_mode == MODE_SHOPPING) ){
		store_rect = talk_area_rect;
		OffsetRect(&store_rect,ul.h,ul.v);
		FrameRect(&store_rect);
		}
	scrollbar_rect = sbar_rect;
	OffsetRect(&scrollbar_rect,ul.h ,ul.v);
	FrameRect(&scrollbar_rect);
	scrollbar_rect = item_sbar_rect;
	OffsetRect(&scrollbar_rect,ul.h ,ul.v);
	FrameRect(&scrollbar_rect);

	CloseRgn(clip_region);
	
}

void set_gworld_fonts(short font_num)
{
	GrafPtr old_port;

	GetPort(&old_port);	
	SetPort(GetWindowPort(mainPtr));
	TextFont(font_num);
	TextFace(bold);
	TextSize(10);
	SetPort(pc_stats_gworld);
	TextFont(font_num);
	TextFace(bold);
	TextSize(10);
	SetPort(item_stats_gworld);
	TextFont(font_num);
	TextFace(bold);
	TextSize(10);
	SetPort(text_area_gworld);
	TextFont(font_num);
	TextFace(bold);
	TextSize(10);
	SetPort(text_bar_gworld);
	TextFont(font_num);
	TextFace(bold);
	TextSize(10);
	SetPort(old_port);	
}

void draw_main_screen()
{
	if (overall_mode == MODE_TALKING) {
		put_background();
		}
		else {
			rect_draw_some_item (terrain_screen_gworld, win_from_rects[0], win_to_rects[0],ul);
 
			draw_buttons(0);
			if (overall_mode == MODE_COMBAT)
				draw_pcs(pc_pos[current_pc],1);
			if (overall_mode == MODE_FANCY_TARGET)
				draw_targets(center);	
			}	
	draw_text_area(0);
	ShowControl(text_sbar);
	Draw1Control(text_sbar);
	ShowControl(item_sbar);
	Draw1Control(item_sbar);
	if (overall_mode == MODE_SHOPPING) {
		ShowControl(shop_sbar);
		Draw1Control(shop_sbar);
		}
		else HideControl(shop_sbar);

}

// redraw_screen does the very first redraw, and any full redraw
void redraw_screen(){
	if(in_startup_mode)
		draw_startup(0);
	else{
		switch (overall_mode) {
			case MODE_TALKING:
				put_background();
				refresh_talking();
				break;
			case MODE_SHOPPING:
				put_background();
				refresh_shopping();
				break;
			default:
				draw_main_screen();
				draw_terrain(0);
				draw_text_bar(1);
				if (overall_mode == MODE_COMBAT)
					draw_pcs(pc_pos[current_pc],1);
				if (overall_mode == MODE_FANCY_TARGET)
					draw_targets(center);
				break;
		}
		put_pc_screen();
		put_item_screen(stat_window,0);
		print_buf();
		ShowControl(text_sbar);
		Draw1Control(text_sbar);
		ShowControl(item_sbar);
		Draw1Control(item_sbar);
		if (overall_mode == MODE_SHOPPING) {
			ShowControl(shop_sbar);
			Draw1Control(shop_sbar);
		}
		else HideControl(shop_sbar);
	}
}

void put_background()
{
	Rect bg_pict;

	if (is_out()) {
		if (univ.party.outdoor_corner.x >= 7)
			bg_pict = bg[0]; 
			else bg_pict = bg[10];
		}
	else if (is_combat()) {
		if (univ.party.outdoor_corner.x >= 7)
			bg_pict = bg[2]; 
			else bg_pict = bg[4];
		}
	else {
		if (univ.town->lighting_type > 0) {
			if (univ.party.outdoor_corner.x >= 7)
				bg_pict = bg[1]; 
				else bg_pict = bg[9]; 
			}
			else if ((univ.party.outdoor_corner.x >= 7) && (univ.town.num != 21)) // TODO: What's so special about town 21?
				bg_pict = bg[8]; 
				else bg_pict = bg[13]; 
		}
	tileImage(clip_region,bg_gworld,bg_pict);
	ShowControl(text_sbar);
	Draw1Control(text_sbar);
	ShowControl(item_sbar);
	Draw1Control(item_sbar);
}

void draw_buttons(short mode)
//mode; // 0 - regular   1 - button action
{
	PixMapHandle store_source;
	const BitMap * store_dest;
	Rect	source_rect = {0,0,37,258}, dest_rec;
	CGrafPtr	origPort;
	GDHandle	origDev;
	GWorldPtr	buttons_to_draw;
	bool spec_draw = false;
	
	if (mode == 1) {
		spec_draw = true;
		mode -= 100;
		}
		
	GetGWorld (&origPort, &origDev);

	store_dest = GetPortBitMapForCopyBits(GetWindowPort(mainPtr));
 
	buttons_to_draw = buttons_gworld;

	store_source = GetPortPixMap(buttons_to_draw);
	if (is_combat()) { // TODO: Draw buttons one at a time instead of singly
		source_rect.top += 37;
		source_rect.bottom += 37;
		}
	if (is_town()) {
		source_rect.top += 74;
		source_rect.bottom += 74;
		}
	
	dest_rec = win_to_rects[1];
	OffsetRect(&dest_rec,ul.h,ul.v);
		
	if (spec_draw == true)
		ForeColor(blueColor);
	CopyBits ( (BitMap *) *store_source ,
				store_dest ,
				&source_rect, &dest_rec, 
				0, NULL);
				//((spec_draw == false) ? 0 : addOver) , NULL);
	if (spec_draw == true)
		ForeColor(blackColor);

	SetGWorld (origPort, origDev);	
	put_background();

}

// In general, refreshes any area that has text in it, the stat areas, the text bar
void draw_text_area(short mode)
//short mode unused
{
	refresh_stat_areas(0);

	draw_text_bar(0);
}

void reset_text_bar()
{
remember_tiny_text = 300;
}


void draw_text_bar(short mode)
//short mode; // 0 - no redraw  1 - forced
{
	//short num_rect[3] = {12,10,4}; // Why? Just... why?
	short i;
	location loc;
	string combat_string;
	
	loc = (is_out()) ? global_to_local(univ.party.p_loc) : univ.town.p_loc;

	if (mode == 1)
		remember_tiny_text = 500;	   
	if ((PSD[SDF_PARTY_STEALTHY] > 0)    || (PSD[SDF_PARTY_FLIGHT] > 0) ||
		(PSD[SDF_PARTY_DETECT_LIFE] > 0) || (PSD[SDF_PARTY_FIREWALK] > 0) )
		remember_tiny_text = 500;
	if (is_out()) {
		for (i = 0; i < 8; i++)
			if (loc.in(univ.out.outdoors[univ.party.i_w_c.x][univ.party.i_w_c.y].info_rect[i])) 
				if ((remember_tiny_text == i) && (mode == 0))
					return;
					else {
						put_text_bar(univ.out.outdoors[univ.party.i_w_c.x][univ.party.i_w_c.y].out_strs(i + 1));
						remember_tiny_text = i;
						return;
						}
		if (remember_tiny_text != 50 + univ.party.i_w_c.x + univ.party.i_w_c.y) {
			put_text_bar((char *) univ.out.outdoors[univ.party.i_w_c.x][univ.party.i_w_c.y].out_strs(0));
			remember_tiny_text = 50 + univ.party.i_w_c.x + univ.party.i_w_c.y;
			}
		}
	if (is_town()) {
		for (i = 0; i < 16; i++)
			if (loc.in(univ.town->room_rect(i))) 
				if ((remember_tiny_text == 200 + i) && (mode == 0))
					return;
					else {
						put_text_bar(univ.town->town_strs(i + 1));
						remember_tiny_text = 200 + i;
						return;
						}
		if (remember_tiny_text != 250) {
			put_text_bar((char *) univ.town->town_strs(0)); ////
			remember_tiny_text = 250;
			}
	
		}
	if ((is_combat()) && (current_pc < 6) && (monsters_going == false)) {
		std::ostringstream sout;
		sout << univ.party[current_pc].name << " (ap: " << univ.party[current_pc].ap << ')';
		combat_string = sout.str();
		put_text_bar((char *) combat_string.c_str());
		remember_tiny_text = 500;
		}
	if ((is_combat()) && (monsters_going == true))	// Print bar for 1st monster with >0 ap -
	   // that is monster that is going
	   for (i = 0; i < univ.town->max_monst(); i++)
	   	if ((univ.town.monst[i].active > 0) && (univ.town.monst[i].ap > 0)) {
	   		combat_string = print_monster_going(univ.town.monst[i].number,univ.town.monst[i].ap);
			put_text_bar((char *) combat_string.c_str());
			remember_tiny_text = 500;
			i = 400;	   
	   }
}

void put_text_bar(char *str)
{
	GrafPtr old_port;
	char status_str[60];
	short xpos = 205;
	
	
	rect_draw_some_item (orig_text_bar_gworld, win_from_rects[4], text_bar_gworld, win_from_rects[4]);
	GetPort(&old_port);	
	SetPort(text_bar_gworld);
	ForeColor(whiteColor);
	MoveTo(5,14);
	drawstring(str);

	if (monsters_going == false) {
		if (PSD[SDF_PARTY_STEALTHY] > 0) {
			MoveTo(xpos,14);
			sprintf((char *) status_str,"Stealth");
			drawstring(status_str);
			xpos -= 60;
			}
		if (PSD[SDF_PARTY_FLIGHT] > 0) {
			MoveTo(xpos,14);
			sprintf((char *) status_str,"Flying");
			drawstring(status_str);
			xpos -= 60;
			}
		if (PSD[SDF_PARTY_DETECT_LIFE] > 0) {
			MoveTo(xpos,14);
			sprintf((char *) status_str,"Detect Life");
			drawstring(status_str);
			xpos -= 60;
			}
		if (PSD[SDF_PARTY_FIREWALK] > 0) {
			MoveTo(xpos,14);
			sprintf((char *) status_str,"Firewalk");
			drawstring(status_str);
			xpos -= 60;
			}
		}

	ForeColor(blackColor);
	SetPort(old_port);
	rect_draw_some_item (text_bar_gworld, win_from_rects[4], win_to_rects[4],ul);
}

// this is used for determinign whether to round off walkway corners
// right now, trying a restrictive rule (just cave floor and grass, mainly)
bool is_nature(char x, char y, unsigned char ground_t)
{
	ter_num_t ter_type;
	
	ter_type = coord_to_ter((short) x,(short) y);
	return ground_t == scenario.ter_types[ter_type].ground_type;
}

ter_num_t get_ground_from_ter(ter_num_t ter){
	return get_ter_from_ground(scenario.ter_types[ter].ground_type);
}

ter_num_t get_ter_from_ground(unsigned char ground){
	for(int i = 0; i < 256; i++)
		if(scenario.ter_types[i].ground_type == ground)
			return i;
	return 0;
}

void draw_terrain(short	mode)
//mode ... if 1, don't place on screen after redoing
// if 2, only redraw over active monst
{
	char q,r;
	location where_draw;
	location sector_p_in,view_loc;
	char can_draw;
	ter_num_t spec_terrain;
	bool off_terrain = false,draw_frills = true;
	short i,j;
	GrafPtr old_port;
	
	if(overall_mode == MODE_TALKING || overall_mode == MODE_SHOPPING || overall_mode == MODE_STARTUP)
		return;
	
	if (mode == 2) {
		if (current_working_monster < 0) return;
		supressing_some_spaces = true;
		for (i = 0; i < 4; i++) ok_space[i].x = -1;
		if (current_working_monster >= 100) {
			for (i = 0; i < univ.town.monst[current_working_monster - 100].x_width; i++)
				for (j = 0; j < univ.town.monst[current_working_monster - 100].y_width; j++) {
					ok_space[i + 2 * j].x = univ.town.monst[current_working_monster - 100].cur_loc.x + i;
					ok_space[i + 2 * j].y = univ.town.monst[current_working_monster - 100].cur_loc.y + j;
					ok_space[i + 2 * j].x = ok_space[i + 2 * j].x - center.x + 4;
					ok_space[i + 2 * j].y = ok_space[i + 2 * j].y - center.y + 4;
					}
			}
		if (current_working_monster < 6) {
			ok_space[0] = pc_pos[current_working_monster];
			ok_space[0].x = ok_space[0].x - center.x + 4;
			ok_space[0].y = ok_space[0].y - center.y + 4;	
			}
		mode = 0;
		}

	GetPort(&old_port);	
	SetPort(GetWindowPort(mainPtr));
	
	for (i = 0; i < 13; i++)
		for (j = 0; j < 13; j++) {
			light_area[i][j] = 0;
			unexplored_area[i][j] = 0;
			}
	
			
	sector_p_in.x = univ.party.outdoor_corner.x + univ.party.i_w_c.x;
	sector_p_in.y = univ.party.outdoor_corner.y + univ.party.i_w_c.y;

	anim_ticks++;
	anim_onscreen = false;

	if (is_town())
		view_loc = univ.town.p_loc;
	if (is_combat())
		view_loc = pc_pos[(current_pc < 6) ? current_pc : first_active_pc()];
	
	for (i = 0; i < 13; i++)
		for (j = 0; j < 13; j++) {
			where_draw =  (is_out()) ? univ.party.p_loc : center;
			where_draw.x += i - 6;
			where_draw.y += j - 6;
			if (!(is_out())) 
				light_area[i][j] = (is_town()) ? pt_in_light(view_loc,where_draw) : combat_pt_in_light(where_draw);
			if (!(is_out()) && ((where_draw.x < 0) || (where_draw.x > univ.town->max_dim() - 1) 
				|| (where_draw.y < 0) || (where_draw.y > univ.town->max_dim() - 1))) 
					unexplored_area[i][j] = 0;
				else unexplored_area[i][j] = 1 - is_explored(where_draw.x,where_draw.y);
			}

	for (q = 0; q < 9; q++) {
		for (r = 0; r < 9; r++) {
			where_draw = (is_out()) ? univ.party.p_loc : center;
			where_draw.x += q - 4;
			where_draw.y += r - 4;
			off_terrain = false;
			
			draw_frills = true;
			if (!(is_out()) && ((where_draw.x < 0) || (where_draw.x > univ.town->max_dim() - 1) 
								|| (where_draw.y < 0) || (where_draw.y > univ.town->max_dim() - 1))) {
				draw_frills = false;
				// Warning - this section changes where_draw
				if (where_draw.x < 0)
					where_draw.x = -1;
				if (where_draw.x > univ.town->max_dim() - 1)
					where_draw.x = univ.town->max_dim();
				if (where_draw.y < 0)
					where_draw.y = -1;
				if (where_draw.y > univ.town->max_dim() - 1) 
					where_draw.y = univ.town->max_dim();
				if (can_see(view_loc,where_draw,0) < 5)
					can_draw = 1;
				else can_draw = 0;
				spec_terrain = 0;
			}
			else if (is_out()) {
				if ((where_draw.x < 0) || (where_draw.x > 95) 
					|| (where_draw.y < 0) || (where_draw.y > 95))
					can_draw = 0;
				else {
					spec_terrain = univ.out[where_draw.x][where_draw.y];
					can_draw = univ.out.out_e[where_draw.x][where_draw.y];
				}
			}
			else if (is_combat()) {
				spec_terrain = combat_terrain[where_draw.x][where_draw.y];
				can_draw = (((is_explored(where_draw.x,where_draw.y)) ||
								  (which_combat_type == 0) || (monsters_going == true) || (overall_mode != MODE_COMBAT))
								 && (party_can_see(where_draw) < 6)) ? 1 : 0;
			}
			else {
				spec_terrain = univ.town->terrain(where_draw.x,where_draw.y);
				can_draw = is_explored(where_draw.x,where_draw.y);
				
				if (can_draw > 0) {
					if (pt_in_light(univ.town.p_loc,where_draw) == false)
						can_draw = 0;
				}
				if ((overall_mode == MODE_LOOK_TOWN) && (can_draw == 0))
					can_draw = (party_can_see(where_draw) < 6) ? 1 : 0;
			}
			spot_seen[q][r] = can_draw;
			
			if ((can_draw != 0) && (overall_mode != MODE_RESTING)) { // if can see, not a pit, and not resting
				if (is_combat()) anim_ticks = 0;
				
				eTrimType trim = scenario.ter_types[spec_terrain].trim_type;
				
				// Finally, draw this terrain spot
				if(trim == TRIM_WALKWAY){
					int trim = -1;
					unsigned char ground_t = scenario.ter_types[spec_terrain].trim_ter;
					ter_num_t ground_ter = get_ter_from_ground(ground_t);
					if (!loc_off_act_area(where_draw)) {
						if(is_nature(where_draw.x - 1,where_draw.y,ground_t)){ // check left
							if(is_nature(where_draw.x,where_draw.y - 1,ground_t)){ // check up
								if(is_nature(where_draw.x + 1,where_draw.y,ground_t)){ // check right
									if(is_nature(where_draw.x,where_draw.y + 1,ground_t)) // check down
										trim = 8;
									else trim = 4;
								}else if(is_nature(where_draw.x,where_draw.y + 1,ground_t)) // check down
									trim = 7;
								else trim = 1;
							}else if(is_nature(where_draw.x,where_draw.y + 1,ground_t)){ // check down
								if(is_nature(where_draw.x + 1,where_draw.y,ground_t)) // check right
									trim = 6;
								else trim = 0;
							}
						}else if(is_nature(where_draw.x,where_draw.y - 1,ground_t)){ // check up
							if(is_nature(where_draw.x + 1,where_draw.y,ground_t)){ // check right
								if(is_nature(where_draw.x,where_draw.y + 1,ground_t)) // check down
									trim = 5;
								else trim = 2;
							}
						}else if(is_nature(where_draw.x + 1,where_draw.y,ground_t)){ // check right
							if(is_nature(where_draw.x,where_draw.y + 1,ground_t)) // check down
								trim = 3;
						}
					}
					draw_one_terrain_spot(q,r,trim < 0 ? spec_terrain : ground_ter);
					if(trim >= 0)
						draw_trim(q,r,trim + 50,spec_terrain);
				}else if(trim == TRIM_ROAD || trim == TRIM_N || trim == TRIM_S ||
						 trim == TRIM_W || trim == TRIM_E) {
					draw_one_terrain_spot(q,r,spec_terrain);
					place_road(q,r,where_draw,trim == TRIM_ROAD);
				}else if(spec_terrain == 65535) {
					draw_one_terrain_spot(q,r,-1);
				}else{
					current_ground = get_ground_from_ter(spec_terrain);
					draw_one_terrain_spot(q,r,spec_terrain);
				}
			}
			else {  // Can't see. Place darkness.
				draw_one_terrain_spot(q,r,-1);
			}
			
			if ((can_draw != 0) && (overall_mode != MODE_RESTING) && frills_on && (draw_frills))
				place_trim((short) q,(short) r,where_draw,spec_terrain);
//			if((is_town() && univ.town.is_spot(where_draw.x,where_draw.y)) ||
//			   (is_out() && univ.out.outdoors[univ.party.i_w_c.x][univ.party.i_w_c.y].special_spot[where_draw.x][where_draw.y]))
//				Draw_Some_Item(roads_gworld, calc_rect(6, 0), terrain_screen_gworld, loc(q,r), 1, 0);
			// TODO: Move draw_sfx, draw_items, draw_fields, draw_spec_items, etc to here
			
			if (is_town() || is_combat()) {
				draw_items(where_draw);
			}
			draw_fields(where_draw);
			//draw_monsters(where_draw);
			//draw_vehicles(where_draw);
			//if(is_combat) draw_pcs(where_draw); else draw_party(where_draw);
		}
	}
	
//	if ((overall_mode != MODE_RESTING) && (!is_out())) 
//		draw_sfx();
//		
//	// Now place items
//	if ((overall_mode > MODE_OUTDOORS) && (overall_mode != MODE_LOOK_OUTDOORS) && (overall_mode != MODE_RESTING))
//		draw_items();		
//		
//	// Now place fields
//	if ((overall_mode != MODE_RESTING) && (!is_out())) {
//		draw_fields();
//		draw_spec_items();
//		}
//
	// Not camping. Place misc. stuff
	if (overall_mode != MODE_RESTING) {
		if (is_out())
			draw_outd_boats(univ.party.p_loc);
			else if ((is_town()) || (which_combat_type == 1))
				draw_town_boat(center);		
		draw_monsters();
		}

	if ((overall_mode < MODE_COMBAT) || (overall_mode == MODE_LOOK_OUTDOORS) || ((overall_mode == MODE_LOOK_TOWN) && (point_onscreen(univ.town.p_loc,center) == true))
		|| (overall_mode == MODE_RESTING))
		draw_party_symbol(mode,center);
		else if (overall_mode != MODE_LOOK_TOWN)
			draw_pcs(center,0);
	
	// Now do the light mask thing
	apply_light_mask();
	apply_unseen_mask();
	
	if (mode == 0) {
		redraw_terrain();
		draw_text_bar(0);
		if ((overall_mode >= MODE_COMBAT) && (overall_mode != MODE_LOOK_OUTDOORS) && (overall_mode != MODE_LOOK_TOWN) && (overall_mode != MODE_RESTING))
			draw_pcs(center,1);
		if (overall_mode == MODE_FANCY_TARGET)
			draw_targets(center);
	}
	SetPort(old_port);
	supressing_some_spaces = false;
}


ter_num_t get_ground_for_shore(ter_num_t ter){
	if(scenario.ter_types[ter].block_horse) return current_ground;
	else if(scenario.ter_types[ter].blockage > 2) return current_ground;
	else return ter;
}

void place_trim(short q,short r,location where,ter_num_t ter_type)
{
	bool at_top = false,at_bot = false,at_left = false,at_right = false;
	location targ;
	
	// FIrst quick check ... if a pit or barrier in outdoor combat, no trim
	if ((is_combat()) && (which_combat_type == 0) && (ter_type == 90))
		return;
	if (PSD[SDF_NO_SHORE_FRILLS] > 0)
		return;
		
	targ.x = q;
	targ.y = r;
	if (supressing_some_spaces && (targ != ok_space[0]) && (targ != ok_space[1]) &&
		(targ != ok_space[2]) && (targ != ok_space[3]))
			return;
	
					
	if (where.x == 0)
		at_left = true;
	if (where.y == 0)
		at_top = true;
	if ((overall_mode == MODE_OUTDOORS) || (overall_mode == MODE_LOOK_OUTDOORS)) {
		if (where.x == 95)
			at_right = true;
		if (where.y == 95)
			at_bot = true;
		}
		else {
		if (where.x == univ.town->max_dim())
			at_right = true;
		if (where.y == univ.town->max_dim())
			at_bot = true;
		}
		
	// First, trim for fluids
	if(is_fluid(ter_type)){
		short trim = get_fluid_trim(where, ter_type);
		if (trim != 0) {
			ter_num_t shore;
			if (trim & 2){ // upper right
				shore = coord_to_ter(where.x + 1, where.y - 1);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,5,shore);
			}if (trim & 8){ // lower right
				shore = coord_to_ter(where.x + 1, where.y + 1);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,7,shore);
			}if (trim & 32){ // lower left
				shore = coord_to_ter(where.x - 1, where.y + 1);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,6,shore);
			}if (trim & 128){ // upper left
				shore = coord_to_ter(where.x - 1, where.y - 1);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,4,shore);
			}if (trim & 1){ // top
				shore = coord_to_ter(where.x, where.y - 1);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,2,shore);
			}if (trim & 4){ // right
				shore = coord_to_ter(where.x + 1, where.y);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,1,shore);
			}if (trim & 16){ // bottom
				shore = coord_to_ter(where.x, where.y + 1);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,3,shore);
			}if (trim & 64){ // left
				shore = coord_to_ter(where.x - 1, where.y);
				shore = get_ground_for_shore(shore);
				draw_trim(q,r,0,shore);
			}
		}
	}
	
	if(is_wall(ter_type) && !at_top && !at_bot && !at_left && !at_right){
	//if (((ter_type >= 100) && (ter_type <= 137)) && (at_top == false) &&
	//	(at_bot == false) && (at_left == false) && (at_right == false)) {
		ter_num_t to_left = coord_to_ter(where.x - 1,where.y);
		ter_num_t above = coord_to_ter(where.x,where.y - 1);
		ter_num_t to_right = coord_to_ter(where.x + 1,where.y);
		ter_num_t below = coord_to_ter(where.x,where.y + 1);
		if (is_wall(to_left) && is_wall(above) && is_ground(to_right) && is_ground(below))
			draw_trim(q,r,11,to_right);
		
		if (is_wall(to_left) && is_wall(below) && is_ground(to_right) && is_ground(above))
			draw_trim(q,r,9,to_right);
		
		if (is_wall(to_right) && is_wall(above) && is_ground(to_left) && is_ground(below))
			draw_trim(q,r,10,to_left);
			
		if (is_wall(to_right) && is_wall(below) && is_ground(to_left) && is_ground(above))
			draw_trim(q,r,8,to_left);		
			
		if (is_ground(to_left) && is_ground(above) && is_ground(to_right) && is_wall(below)) {
			draw_trim(q,r,8,to_right);
			draw_trim(q,r,9,to_right);
		}

		if (is_wall(to_left) && is_ground(below) && is_ground(to_right) && is_ground(above)) {
			draw_trim(q,r,9,to_right);
			draw_trim(q,r,11,to_right);
		}

		if (is_ground(to_right) && is_wall(above) && is_ground(to_left) && is_ground(below)) {
			draw_trim(q,r,10,to_left);
			draw_trim(q,r,11,to_left);
		}

		if (is_wall(to_right) && is_ground(below) && is_ground(to_left) && is_ground(above)) {
			draw_trim(q,r,8,to_left);
			draw_trim(q,r,10,to_left);
		}
		
		if (is_ground(to_right) && is_ground(below) && is_ground(to_left) && is_ground(above)) {
			draw_trim(q,r,8,to_left);
			draw_trim(q,r,9,to_right);
			draw_trim(q,r,10,to_left);
			draw_trim(q,r,11,to_right);
		}
	//	}
	}
}

void draw_trim(short q,short r,short which_trim,ter_num_t ground_ter)
//which_trim is 3 -> drawing wall trim -> might shift down if ground is grass
//short which_mode;  // 0 top 1 bottom 2 left 3 right 4 up left 5 up right 6 down right 7 down left
{
	// which_trim
	// 0 - left, 1 - right, 2 - top, 3 - bottom, 4 - tl, 5 - tr, 6 - bl, 7 - br
	// 8 - wall tl, 9 - wall tr, 10 - wall bl, 11 - wall br
	// 50 - walkway bl, 51 - walkway tl, 52 - walkway tr, 53 - walkway br
	// 54 - walkway top, 55 - walkway right, 56 - walkway bottom, 57 - walkway left
	// 58 - lone walkway
	Rect from_rect = {0,0,36,28},to_rect,mask_rect;
	GWorldPtr from_gworld;
	static Rect trim_rects[] = {
		{0,0,36,14}, {0,0,36,14},
		{0,0,18,28}, {0,0,18,28},
		{0,0,18,14}, {0,0,18,14}, {0,0,18,14}, {0,0,18,14},
		{0,0,18,14}, {0,0,18,14}, {0,0,18,14}, {0,0,18,14},
	};
	static Rect walkway_rects[] = {
		{0,0,36,28}, {0,0,36,28}, {0,0,36,28}, {0,0,36,28},
		{0,0,36,28}, {0,0,36,28}, {0,0,36,28}, {0,0,36,28},
		{0,0,36,28},
	};
	static bool inited = false;
	if(!inited){
		inited = true;
		OffsetRect(&trim_rects[1],14,0);
		OffsetRect(&trim_rects[2],28,0);
		OffsetRect(&trim_rects[3],28,18);
		OffsetRect(&trim_rects[4],56,0);
		OffsetRect(&trim_rects[5],70,0);
		OffsetRect(&trim_rects[6],56,18);
		OffsetRect(&trim_rects[7],70,18);
		OffsetRect(&trim_rects[8],84,0);
		OffsetRect(&trim_rects[9],98,0);
		OffsetRect(&trim_rects[10],84,18);
		OffsetRect(&trim_rects[11],98,18);
		int i;
		for(i = 0; i < 12; i++) OffsetRect(&trim_rects[i],112,36);
		for(i = 0; i < 8 ; i++) OffsetRect(&walkway_rects[i],(i%4)*28,(i/4)*36);
		OffsetRect(&walkway_rects[8],196,0);
	}
	RGBColor	test_color = {0,0,0}, store_color;

	if (frills_on == false)
		return;
		
	// if current ground is grass, forget trim
//	if ((current_ground == 2) && (which_trim < 3))
//		return; 

	terrain_there[q][r] = -1;
	GetBackColor(&store_color);
	RGBBackColor(&test_color);
		
//	from_rect.left = 28 * which_trim + trim_rects[which_mode].left;
//	from_rect.right = 28 * which_trim + trim_rects[which_mode].right;
//	from_rect.top = trim_rects[which_mode].top;
//	from_rect.bottom = trim_rects[which_mode].bottom;
//	
//	if ((which_trim == 3) && (current_ground == 2)) // trim corner walls with grass instead of cave floor
//		OffsetRect(&from_rect,0,36);
	unsigned short pic = scenario.ter_types[ground_ter].picture;
	if(pic < 400){
		from_gworld = terrain_gworld[pic / 50];
		pic %= 50;
		OffsetRect(&from_rect,28 * (pic % 10), 36 * (pic / 10));
	}else if(pic < 1000){
		from_gworld = anim_gworld;
		pic %= 400;
		OffsetRect(&from_rect,112 * (pic / 5),36 * (pic % 5));
	}else{
		from_gworld = spec_scen_g;
		pic %= 1000;
		from_rect = get_custom_rect(pic);
	}
	if(which_trim < 50) mask_rect = trim_rects[which_trim];
	else mask_rect = walkway_rects[which_trim - 50];
	to_rect = coord_to_rect(q,r);
//	to_rect.right = to_rect.left + trim_rects[which_mode].right;
//	to_rect.left = to_rect.left + trim_rects[which_mode].left;
//	to_rect.bottom = to_rect.top + trim_rects[which_mode].bottom;
//	to_rect.top = to_rect.top + trim_rects[which_mode].top;
	//	OffsetRect(&to_rect,-61,-37);
	if(which_trim == 0 || which_trim == 4 || which_trim == 6 || which_trim == 8 || which_trim == 10){
		from_rect.right -= 14;
		to_rect.right -= 14;
	}else if(which_trim == 1 || which_trim == 5 || which_trim == 7 || which_trim == 9 || which_trim == 11){
		from_rect.left += 14;
		to_rect.left += 14;
	}
	if(which_trim == 2 || which_trim == 4 || which_trim == 5 || which_trim == 8 || which_trim == 9){
		from_rect.bottom -= 18;
		to_rect.bottom -= 18;
	}else if(which_trim == 3 || which_trim == 6 || which_trim == 7 || which_trim == 10 || which_trim == 11){
		from_rect.top += 18;
		to_rect.top += 18;
	}

	PixMapHandle from_bits = GetPortPixMap(from_gworld);
	PixMapHandle mask_bits = GetPortPixMap(roads_gworld);
	PixMapHandle to_bits = GetPortPixMap(terrain_screen_gworld);
	LockPixels(to_bits);
	LockPixels(mask_bits);
	LockPixels(from_bits);
	CopyDeepMask ((BitMap*) *from_bits,
				  (BitMap*) *mask_bits,
				  (BitMap*) *to_bits,
				  &from_rect, &mask_rect, &to_rect,
				  transparent, NULL
	);
	UnlockPixels(from_bits);
	UnlockPixels(mask_bits);
	UnlockPixels(to_bits);

	RGBBackColor(&store_color);
}


bool extend_road_terrain(ter_num_t ter)
{
	eTrimType trim = scenario.ter_types[ter].trim_type;
	eTerSpec spec = scenario.ter_types[ter].special;
	ter_num_t flag = scenario.ter_types[ter].flag1.u;
	if(trim == TRIM_ROAD || trim == TRIM_CITY || trim == TRIM_WALKWAY)
		return true;
	if(spec == TER_SPEC_BRIDGE)
		return true;
	if(spec == TER_SPEC_TOWN_ENTRANCE && trim != TRIM_NONE)
		return true; // cave entrance, most likely
	if(spec == TER_SPEC_UNLOCKABLE || spec == TER_SPEC_CHANGE_WHEN_STEP_ON)
		return true; // closed door, possibly locked; or closed portcullis
	if(spec == TER_SPEC_CHANGE_WHEN_USED && scenario.ter_types[flag].special == TER_SPEC_CHANGE_WHEN_STEP_ON && scenario.ter_types[flag].flag1.u == ter)
		return true; // open door (I think) TODO: Verify this works
	if(spec == TER_SPEC_LOCKABLE)
		return true; // open portcullis (most likely)
	if(trim == TRIM_N || trim == TRIM_S || trim == TRIM_W || trim == TRIM_E)
		return true; // connect roads to trim boundaries
	return false;
}

bool connect_roads(ter_num_t ter){
	eTrimType trim = scenario.ter_types[ter].trim_type;
	eTerSpec spec = scenario.ter_types[ter].special;
	if(trim == TRIM_ROAD || trim == TRIM_CITY)
		return true;
	if(spec == TER_SPEC_TOWN_ENTRANCE && trim != TRIM_NONE)
		return true; // cave entrance, most likely
	return false;
}

void place_road(short q,short r,location where, bool here)
{
	location draw_loc;
	ter_num_t ter;
	Rect to_rect;
	//Rect road_rects[2] = {{76,112,80,125},{72,144,90,148}}; // 0 - rl partial  1 - ud partial
	static const Rect road_rects[4] = {
		{4,112,8,125},	// horizontal partial
		{0,144,18,148},	// vertical partial
		{0,112,4,140},	// horizontal full
		{0,140,36,144},	// vertical full
	};
	//Rect road_dest_rects[4] = {{0,12,18,16},{16,15,20,28},{18,12,36,16},{16,0,20,13}}; // top right bottom left
	static const Rect road_dest_rects[6] = {
		{0,12,18,16},	// top
		{16,15,20,28},	// right
		{18,12,36,16},	// bottom
		{16,0,20,13},	// left
		{0,12,36,16},	// top + bottom
		{16,0,20,28},	// right + left
	};
	draw_loc.x = q;
	draw_loc.y = r;
	
	terrain_there[q][r] = -1;
	
	if(here){
		if (where.y > 0)
			ter = coord_to_ter(where.x,where.y - 1);
		if ((where.y == 0) || extend_road_terrain(ter)) {
			to_rect = road_dest_rects[0];
			OffsetRect(&to_rect,13 + q * 28,13 + r * 36);
			rect_draw_some_item (roads_gworld, road_rects[1], terrain_screen_gworld, to_rect);
		}
		
		if (((is_out()) && (where.x < 96)) || (!(is_out()) && (where.x < univ.town->max_dim() - 1)))
			ter = coord_to_ter(where.x + 1,where.y);
		if (((is_out()) && (where.x == 96)) || (!(is_out()) && (where.x == univ.town->max_dim() - 1)) 
			|| extend_road_terrain(ter)) {
			to_rect = road_dest_rects[1];
			OffsetRect(&to_rect,13 + q * 28,13 + r * 36);
			rect_draw_some_item (roads_gworld, road_rects[0], terrain_screen_gworld, to_rect);
		}
		
		if (((is_out()) && (where.y < 96)) || (!(is_out()) && (where.y < univ.town->max_dim() - 1)))
			ter = coord_to_ter(where.x,where.y + 1);
		if (((is_out()) && (where.y == 96)) || (!(is_out()) && (where.y == univ.town->max_dim() - 1)) 
			|| extend_road_terrain(ter)) {
			to_rect = road_dest_rects[2];
			OffsetRect(&to_rect,13 + q * 28,13 + r * 36);
			rect_draw_some_item (roads_gworld, road_rects[1], terrain_screen_gworld, to_rect);
		}
		
		if (where.x > 0)
			ter = coord_to_ter(where.x - 1,where.y);
		if ((where.x == 0) || extend_road_terrain(ter)) {
			to_rect = road_dest_rects[3];
			OffsetRect(&to_rect,13 + q * 28,13 + r * 36);
			rect_draw_some_item (roads_gworld, road_rects[0], terrain_screen_gworld, to_rect);
		}
	}else{
		bool horz = false, vert = false;
		if (where.y > 0)
			ter = coord_to_ter(where.x,where.y - 1);
		if ((where.y == 0) || connect_roads(ter))
			vert = true;
		
		if (((is_out()) && (where.x < 96)) || (!(is_out()) && (where.x < univ.town->max_dim() - 1)))
			ter = coord_to_ter(where.x + 1,where.y);
		if (((is_out()) && (where.x == 96)) || (!(is_out()) && (where.x == univ.town->max_dim() - 1)) 
			|| connect_roads(ter))
			horz = true;
		
		if(vert){
			if (((is_out()) && (where.y < 96)) || (!(is_out()) && (where.y < univ.town->max_dim() - 1)))
				ter = coord_to_ter(where.x,where.y + 1);
			if (((is_out()) && (where.y == 96)) || (!(is_out()) && (where.y == univ.town->max_dim() - 1)) 
				|| connect_roads(ter))
				vert = true;
			else vert = false;
		}
		
		if(horz){
			if (where.x > 0)
				ter = coord_to_ter(where.x - 1,where.y);
			if ((where.x == 0) || connect_roads(ter)) 
				horz = true;
			else horz = false;
		}
		
		if(horz){
			to_rect = road_dest_rects[5];
			OffsetRect(&to_rect,13 + q * 28,13 + r * 36);
			rect_draw_some_item (roads_gworld, road_rects[2], terrain_screen_gworld, to_rect);
		}
		if(vert){
			to_rect = road_dest_rects[4];
			OffsetRect(&to_rect,13 + q * 28,13 + r * 36);
			rect_draw_some_item (roads_gworld, road_rects[3], terrain_screen_gworld, to_rect);
		}
	}
}

void draw_rest_screen()
{
	eGameMode store_mode;

	store_mode = overall_mode;
	overall_mode = MODE_RESTING;
	draw_terrain(0);
	overall_mode = store_mode ;
}

void boom_space(location where,short mode,short type,short damage,short sound)
// if mode is 100, force
//short type; // 0 - flame 1 - magic 2 - poison 3 - blood 4 - cold
	// 10s digit indicates sound  0 - normal ouch  1 - small sword  2 - loud sword
	// 3 - pole  4 - club  5 - fireball hit  6 - squish  7 - cold
	// 8 - acid  9 - claw  10 - bite  11 - slime  12 - zap  13 - missile hit
{
	location where_draw(4,4);
	Rect source_rect = {0,0,36,28},text_rect,dest_rect = {13,13,49,41},big_to = {13,13,337,265},store_rect;
	short del_len;
	char dam_str[20];
	short x_adj = 0,y_adj = 0,which_m;
	short sound_to_play[20] = {97,69,70,71,72, 73,55,75,42,86,
			87,88,89,98,0, 0,0,0,0,0};

	//sound_key = type / 10;
	//type = type % 10;
	
//	if ((cartoon_happening == true) && (anim_step < 140))
//		return;
	if ((mode != 100) && (party_can_see(where) == 6))
		return;
	if ((type < 0) || (type > 4))
		return;
	if ((boom_anim_active == true) && (type != 3))
		return;
	if ((PSD[SDF_NO_FRILLS] > 0) && fast_bang)
		return;
	if (is_out())
		return;
			
	// Redraw terrain in proper position
	if ((((point_onscreen(center,where) == false) && (overall_mode >= MODE_COMBAT)) || (overall_mode == MODE_OUTDOORS))
		) {
		play_sound(sound_to_play[sound]);

		return;
		}
		else if (is_combat()) {
			if (which_combat_type == 1)
				draw_terrain(0);
				else draw_terrain(0);
			}
			else if (fast_bang < 2) {
				draw_terrain(0);
				if (fast_bang == 1)
					fast_bang = 2;
				}

	where_draw.x = where.x - center.x + 4;
	where_draw.y = where.y - center.y + 4;
//	source_rect.left += 28 * type;
//	source_rect.right += 28 * type;
	
	// adjust for possible big monster
	which_m = monst_there(where);
	if (which_m < 90) {
		x_adj += 14 * (univ.town.monst[which_m].x_width - 1);
		y_adj += 18 * (univ.town.monst[which_m].y_width - 1);
		}
	OffsetRect(&dest_rect,where_draw.x * 28,where_draw.y * 36);
	source_rect = store_rect = dest_rect;
	OffsetRect(&dest_rect,x_adj,y_adj);
	SectRect(&dest_rect,&big_to,&dest_rect);

	OffsetRect(&dest_rect,win_to_rects[0].left,win_to_rects[0].top);

	OffsetRect(&source_rect,-1 * store_rect.left + 28 * type,-1 * store_rect.top);
	rect_draw_some_item(boom_gworld,source_rect,dest_rect,ul,transparent);
	
	if ((dest_rect.right - dest_rect.left >= 28) && (dest_rect.bottom - dest_rect.top >= 36)) {
		sprintf((char *) dam_str,"%d",damage);
		TextSize(10);
		TextFace(bold);
		//text_rect = coord_to_rect(where_draw.x,where_draw.y);
		//OffsetRect(&text_rect,x_adj,y_adj);
		text_rect = dest_rect;
		text_rect.top += 10;
		if ((damage < 10) && (dest_rect.right - dest_rect.left > 19))
			text_rect.left += 10;
		OffsetRect(&text_rect,-4,-5);
		char_win_draw_string(mainPtr,text_rect,(char *) dam_str,1,10,ul);
		TextSize(0);
		TextFace(0);
		}
		play_sound((skip_boom_delay?-1:1)*sound_to_play[sound]);
		if ((sound == 6) && (fast_bang == 0) && (!skip_boom_delay))
			FlushAndPause(12);

	
	if (fast_bang == 0 && !skip_boom_delay) {
		del_len = PSD[SDF_GAME_SPEED] * 3 + 4;
		if (play_sounds == false)
			FlushAndPause(del_len);
		}
	redraw_terrain();
	if ((overall_mode >= MODE_COMBAT/*9*/) && (overall_mode != MODE_LOOK_OUTDOORS) && (overall_mode != MODE_LOOK_TOWN) && (overall_mode != MODE_RESTING))
		draw_pcs(center,1);	
}
	

void draw_pointing_arrows() 
{
	//Rect sources[4] = {{65,46,73,54},{56,46,64,54},{56,37,64,45},{65,37,73,45}};
	Rect sources[4] = {
		{352,58,360,76}, // up
		{352,20,360,38}, // left
		{352,01,360,19}, // down
		{352,39,360,57}  // right
	};
	Rect dests[8] = {{7,100,15,108},{7,170,15,178},{140,7,148,15},{212,7,220,15},
		{346,100,354,108},{346,170,354,178},{140,274,148,282},{212,274,220,282}};
	short i;
	
	if ((monsters_going == true) || /*(overall_mode <= MODE_TOWN) ||*/ (overall_mode <= MODE_COMBAT)
		|| (overall_mode == MODE_LOOK_OUTDOORS)) 
			return;
	for (i = 0; i < 4; i++) {
		rect_draw_some_item (terrain_screen_gworld,sources[i],dests[i * 2],ul,transparent);
		rect_draw_some_item (terrain_screen_gworld,sources[i],dests[i * 2 + 1],ul,transparent);
		}
}

void redraw_terrain()
{
	Rect to_rect;
	
	to_rect = win_to_rects[0];
	rect_draw_some_item (terrain_screen_gworld, win_from_rects[0], to_rect,ul);


	// Now place arrows
	draw_pointing_arrows();
	

}


void draw_targets(location center)
{
	Rect source_rect = {74,36,85,47},dest_rect;
	short i = 0;

	if (party_toast() == true)
		return;

	for (i = 0; i < 8; i++)
		if ((spell_targets[i].x != 120) && (point_onscreen(center,spell_targets[i]) == true)) {
			dest_rect = coord_to_rect(spell_targets[i].x - center.x + 4,spell_targets[i].y - center.y + 4);
			//OffsetRect(&dest_rect,5,5);
			//InsetRect(&dest_rect,8,12);
			rect_draw_some_item (roads_gworld,calc_rect(6,0),dest_rect,ul,transparent);
			}
}

void frame_space(location where,short mode,short width,short height)
//mode;  // 0 - red   1 - green
{
	location where_put;
	Rect to_frame;
	
	if (point_onscreen(center,where) == false)
		return;

	where_put.x = 4 + where.x - center.x;
	where_put.y = 4 + where.y - center.y;
	
	to_frame.top = 18 + where_put.y * 36;
	to_frame.left = 18 + where_put.x * 28;
	to_frame.bottom = 54 + where_put.y * 36 + 36 * (height - 1);
	to_frame.right = 46 + where_put.x * 28 + 28 * (width - 1);				
	OffsetRect(&to_frame, ul.h,ul.v);
					
	ForeColor((mode == 0) ? redColor : greenColor);
	FrameRoundRect(&to_frame,8,8);
	ForeColor(blackColor);	

}


void erase_spot(short i,short j)
{
	Rect to_erase;
	
	to_erase = coord_to_rect(i,j);
	EraseRect(&to_erase);
	
}


void undo_clip()
{
	Rect overall_rect;
	GrafPtr cur_port;

	GetPort(&cur_port);	
	GetPortBounds(cur_port,&overall_rect);
	ClipRect(&overall_rect);
}



void draw_targeting_line(Point where_curs)
{
	location which_space,store_loc;
	short i,j,k,l;
	Rect redraw_rect,redraw_rect2,terrain_rect = {0,0,351,279},target_rect;
	location from_loc;
	Rect on_screen_terrain_area = {23, 23, 346, 274};
	
	if (overall_mode >= MODE_COMBAT)
		from_loc = pc_pos[current_pc];
		else from_loc = univ.town.p_loc;
	if ((overall_mode == MODE_SPELL_TARGET) || (overall_mode == MODE_FIRING) || (overall_mode == MODE_THROWING) || (overall_mode == MODE_FANCY_TARGET)
	  || ((overall_mode == MODE_TOWN_TARGET) && (current_pat.pattern[4][4] != 0))) {
		GlobalToLocal(&where_curs);	
		
		OffsetRect(&on_screen_terrain_area,ul.h,ul.v);
		if (PtInRect (where_curs, &on_screen_terrain_area) == true) {
		// && (point_onscreen(center,pc_pos[current_pc]) == true)){		
			i = (where_curs.h - 23 - ul.h) / 28;
			j = (where_curs.v - 23 - ul.v) / 36;
			which_space.x = center.x + (short) i - 4;
			which_space.y = center.y + (short) j - 4;
			
			k = (short) (from_loc.x - center.x + 4);
			l = (short) (from_loc.y - center.y + 4);
			k = (k * 28) + 32 + ul.h;
			l = (l * 36) + 36 + ul.v;
			
			if ((can_see(from_loc,which_space,0) < 5) 
			 && (dist(from_loc,which_space) <= current_spell_range)) {
			 	InsetRect(&terrain_rect,13,13); 
			 	OffsetRect(&terrain_rect,5 + ul.h,5 + ul.v);
				ClipRect(&terrain_rect);
				PenMode (patXor);
				PenSize(2,2);
				MoveTo(where_curs.h,where_curs.v);
				LineTo(k,l);
				
				redraw_rect.left = min(where_curs.h,k) - 4;
				redraw_rect.right = max(where_curs.h,k) + 4;
				redraw_rect.top = min(where_curs.v,l) - 4;
				redraw_rect.bottom = max(where_curs.v,l) + 4;
				SectRect(&redraw_rect,&terrain_rect,&redraw_rect2);
				
				// Now place targeting pattern
				for (i = 0; i < 9; i++)
					for (j = 0; j < 9; j++) {
						store_loc.x = center.x + i - 4;
						store_loc.y = center.y + j - 4;
						if ((abs(store_loc.x - which_space.x) <= 4) && 
							(abs(store_loc.y - which_space.y) <= 4) && 
							(current_pat.pattern[store_loc.x - which_space.x + 4][store_loc.y - which_space.y + 4] != 0)) {
								target_rect.left = 13 + BITMAP_WIDTH * i + 5 + ul.h;
								target_rect.right = target_rect.left + BITMAP_WIDTH;
								target_rect.top = 13 + BITMAP_HEIGHT * j + 5 + ul.v;
								target_rect.bottom = target_rect.top + BITMAP_HEIGHT;
								FrameRect(&target_rect);
								InsetRect(&target_rect,-5,-5);
								UnionRect(&target_rect,&redraw_rect2,&redraw_rect2);
								
								// Now place number of shots left, if drawing center of target
								if ((overall_mode == MODE_FANCY_TARGET) && (store_loc.x - which_space.x + 4 == 4)
								 && (store_loc.y - which_space.y + 4 == 4)) {
									ForeColor(whiteColor);
									MoveTo(((target_rect.left + target_rect.right) / 2) - 3,
									 (target_rect.top + target_rect.bottom) / 2);
									DrawChar((char) (num_targets_left + 48));
									ForeColor(blackColor);
									}
								
								}
						}
											
				FlushAndPause(4);
				
				InsetRect(&redraw_rect2,-5,-5);	
				redraw_partial_terrain(redraw_rect2);
				PenNormal();
				undo_clip();
				if (is_combat())
					draw_pcs(center,1);
					else draw_party_symbol(0,center);
				if (overall_mode == MODE_FANCY_TARGET)
					draw_targets(center);	
				}
			}
	}
}


bool party_toast()
{
	short i;
	
	for (i = 0; i < 6; i++)
		if (univ.party[i].main_status == 1)
			return false;
	return true;
}

void redraw_partial_terrain(Rect redraw_rect)
{
	Rect from_rect;

	from_rect = redraw_rect;
	OffsetRect(&from_rect,-1 * ul.h,-1 * ul.v);

	// as rect_draw_some_item will shift redraw_rect before drawing, we need to compensate
	OffsetRect(&redraw_rect,-1 * ul.h + 5,-1 * ul.v + 5);
	
	rect_draw_some_item(terrain_screen_gworld,from_rect,redraw_rect,ul);

}

void FlushAndPause(unsigned long ticks)
{
	RgnHandle portRegion = NewRgn();
	GrafPtr port;
	GetPort(&port);
	GetPortVisibleRegion(port,portRegion);
	QDFlushPortBuffer(port,portRegion);
	DisposeRgn(portRegion);
	
	unsigned long dummy;
	Delay(ticks,&dummy);
}

/*
void HideMenuBar( void )
{
	GDHandle		mainScreen;
	Rect			mainScreenBounds;
	RgnHandle		mainScreenRgn;
	GrafPtr			windowPort;
	GrafPtr			oldPort;
	WindowPtr		frontWindow;
	
	// get the gdhandle of the main screen which
	// is the screen with the menubar
	mainScreen = GetMainDevice();
	mainScreenBounds = ( *mainScreen )->gdRect;
	
	// get new region encompassing entire screen
	// including area under menu bar and corners
	mainScreenRgn 	= NewRgn();
	newGrayRgn 		= NewRgn();
	underBarRgn 	= NewRgn();
	RectRgn( mainScreenRgn, &mainScreenBounds );
//	UnionRgn( mainScreenRgn, originalGrayRgn, newGrayRgn );
	DiffRgn( newGrayRgn, originalGrayRgn, underBarRgn );
	DisposeRgn( mainScreenRgn );
	
	// Set gray region to entire screen
//	LMSetGrayRgn( newGrayRgn );
	
	GetPort( &oldPort );
	GetWMgrPort( &windowPort );
	SetPort( windowPort );
	SetClip( newGrayRgn );
	
	// redraw the desktop to draw over the menu bar
	PaintOne( nil, newGrayRgn );
	
	// in case any part of a window is covered
	// redraw it and recalculate the visible region
	frontWindow = FrontWindow();
	PaintOne( ( WindowRef )frontWindow, underBarRgn );
	PaintBehind( ( WindowRef )frontWindow, underBarRgn );
	CalcVis( ( WindowRef )frontWindow );
	CalcVisBehind( ( WindowRef )frontWindow, underBarRgn );
	
	// set menu bar height to 0
	LMSetMBarHeight( 0 );
	
	// Restore the port
	SetPort( oldPort );
	
}//HideMenuBar
*/
/*
void ShowMenuBar( void )
{
	WindowPtr	frontWindow;
	GrafPtr		windowPort;
	GrafPtr		oldPort;
	
	// Reset the menu bar height
//	LMSetMBarHeight( menuBarHeight );
	
	// Restore the original gray region
//	LMSetGrayRgn( originalGrayRgn );
	
	frontWindow = FrontWindow();
	CalcVis( frontWindow );
	CalcVisBehind(frontWindow, newGrayRgn );
	
	// Reset the clipping regions of the window mgr port
	GetPort( &oldPort );
	GetWMgrPort( &windowPort );
	SetPort( windowPort );
	SetClip( newGrayRgn );
	SetPort( oldPort );

	// Redraw the menu bar
	HiliteMenu( 0 );
	DrawMenuBar();	
}
*/
/*
void HideShowMenuBar( )
{
	GDHandle	mainScreen;
	
	// store current gray region that displays
	// menu bar and the current height of the menu bar
	originalGrayRgn 	= LMGetGrayRgn(); 		
	menuBarHeight	= LMGetMBarHeight(); 	

	// calculate the rect of the menu bar to test 
	// if mouse down is in if desired
	mainScreen 			= GetMainDevice();
	menuBarRect 			= (**mainScreen).gdRect;
	menuBarRect.bottom 	= menuBarHeight;

	HideMenuBar();
		
	while( !Button() );

	ShowMenuBar();
	
	// restore the original gray region to 
	// make the menu bar visible
	LMSetGrayRgn( originalGrayRgn );	
}	

*/