/*
 *  AMIGA Libs & Functions for Scott-Free
 *
 *  ===================================================================
 *
 *  Version History AMIGA:
 *  Ver ,     Date,     Author, Comment
 *  -------------------------------------------------------------------
 *  1.0 , 28/07/96, Andreas Aumayr, First public release
 *  1.1 , 16/08/96, Andreas Aumayr, Added ToolType support & font prefs
 *  1.2 , 30/08/96, Andreas Aumayr, ASL-FR for Load/Save/Datafile
 *  1.3 , 08/09/96, Andreas Aumayr, Menus, loads of minor enhancements,
 *                                  'real' command history, more TTs
 *  1.4 , 17/09/96, Andreas Aumayr, Public screen support, more TTs, ..
 *  ___________________________________________________________________
 */

#define  MAX_HIST 20
#define  MAX_LL   40

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#include <time.h>

#include <intuition/intuition.h>
#include <graphics/gfxbase.h>
#include <workbench/workbench.h>
#include <libraries/dos.h>
#include <libraries/dosextens.h>
#include <dos/exall.h>
#include <utility/tagitem.h>
#include <libraries/asl.h>
#include <libraries/gadtools.h>
#include <workbench/startup.h>
#include <libraries/amigaguide.h>
#include "gui.c"

void * MemAlloc(int size);
void Make_FFP(char *file, char *dir);
void LoadDatabase(FILE *f, int loud);
BOOL LoadGame(char *name);
void OutReset();
void OutBuf(char *buffer);
void OutputNumber(int a);
void SaveBody(FILE *f);
void LoadBody(FILE *f);
BOOL SaveRestart();
BOOL LoadRestart();
void Look();
int  PerformActions(int vb,int no);
void main(int argc, char *argv[]);

struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;
ULONG  DiskfontBase;
ULONG  IconBase;
ULONG  Dos_Base;
ULONG  UtilityBase;
ULONG  AslBase;
ULONG  GadToolsBase;
ULONG  AmigaGuideBase;
struct Screen *WBscreen = NULL;
struct Window *PBwin;
struct Window *act_w_hdl;
APTR   WBvisinfo = NULL;
struct TextFont *textfont = NULL;
char   save_game[32] = "";
char   save_dir[256] = "";
char   FFP[256];

char   hist[MAX_HIST][MAX_LL+1];
int    hist_pos=0,hist_fill=0;

struct Menu *menu = NULL;
char   Version[] = "$VER: AMIGA SCOTT-Free V1.52, 29/10/1996";
char   GameInfoStr[256] = "";

struct WBStartup *WBMessage;
struct MsgPort *OldUserPort;
BOOL   WBSTART = FALSE;
BOOL   RESTART = TRUE;
char   restart_file[42] = "RAM:";
BPTR   restart_lock;

struct NewAmigaGuide scott_guide = {NULL};

/// close_libs
void close_libs(void)
{
		if (GadToolsBase) CloseLibrary(GadToolsBase);
		if (AslBase) CloseLibrary(AslBase);
		if (UtilityBase) CloseLibrary(UtilityBase);
		if (Dos_Base) CloseLibrary(Dos_Base);
		if (IconBase) CloseLibrary(IconBase);
		if (DiskfontBase) CloseLibrary(DiskfontBase);
		if (GfxBase) CloseLibrary(GfxBase);
		if (IntuitionBase) CloseLibrary(IntuitionBase);
		if (AmigaGuideBase) CloseLibrary(AmigaGuideBase);
}///

/// open_libs
BOOL open_libs(void)
{
				IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",37);
				if (IntuitionBase == NULL) {
						printf("Problems opening Intuition-Lib!\n");
						return(FALSE);
				}
				GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",37);
				if (GfxBase == NULL) {
						printf("Problems opening GFX-Lib!\n");
						return(FALSE);
				}
				DiskfontBase = OpenLibrary("diskfont.library",0);
				if (DiskfontBase == 0) {
						EasyRequest(NULL,&Library,NULL,"DiskFont");
						return(FALSE);
				}
				IconBase = OpenLibrary("icon.library",0);
				if (IconBase == 0) {
						printf("Problems opening Icon-Lib!\n");
						return(FALSE);
				}
				Dos_Base = OpenLibrary("dos.library",0);
				if (Dos_Base == 0) {
						printf("Problems opening DOS-Lib!\n");
						return(FALSE);
				}
				UtilityBase = OpenLibrary("utility.library",0);
				if (UtilityBase == 0) {
						printf("Problems opening Utility-Lib!\n");
						return(FALSE);
				}
				AslBase = OpenLibrary("asl.library",0);
				if (AslBase == 0) {
						EasyRequest(NULL,&Library,NULL,"ASL");
						return(FALSE);
				}
				GadToolsBase = OpenLibrary("gadtools.library",36);
				if (GadToolsBase == 0) {
						printf("Problems opening GadTools-Lib!\n");
						return(FALSE);
				}
				AmigaGuideBase = OpenLibrary("amigaguide.library",0);
				return(TRUE);
}///

/// close_all
void close_all(void)
{
		//ClearMenuStrip(act_w_hdl);
		if (restart_lock) {
			UnLock(restart_lock);
			DeleteFile(restart_file);
		}
		if (menu) FreeMenus(menu);
		if (WBvisinfo) FreeVisualInfo(WBvisinfo);
		if (WBscreen) UnlockPubScreen(NULL,WBscreen);
		if (textfont) CloseFont(textfont);
		if (act_hdl) {
			act_w_hdl->UserPort = OldUserPort;
			Close(act_hdl);
		}
		if (env_hdl) Close(env_hdl);
		close_libs();
}///

/// MemAlloc
void * MemAlloc(int size)
{
	void *t = (void *) malloc(size);
	if (t == NULL) {
		printf("\nUnable to get some mem! Terminating.\n");
		EasyRequest(NULL,&NoMem,NULL,NULL);
		close_all();
		exit(128);
	}
	return(t);
}///

/// Open_CON
struct FileHandle *Open_CON(char *type, int left_off, int top_off, int width, int height, char *title, char *flags, char *cscreen)
{
	sprintf(str_buf,"%s:%d/%d/%d/%d/%s/%s/SCREEN %s",type,left_off,top_off,width,height,title,flags,cscreen);
	CON_handle = (struct FileHandle *) Open(str_buf,MODE_NEWFILE);
	if (!CON_handle) {
		printf("Failed to open console window '%s'!\n",title);
		EasyRequest(NULL,&ConFail,NULL,title);
		close_all();
		exit(99);
	}
	else return(CON_handle);
}///

///dyn_strings
void * dyn_strings(char *cont, BYTE add)
{
		void *mem_ptr;

		if (cont && strlen(cont)) {
				mem_ptr = MemAlloc(strlen(cont)+1+add);
				strcpy(mem_ptr,cont);
				//printf("MemPtr: |%s| at %ld\n",mem_ptr,mem_ptr);
				return(mem_ptr);
		}
		return(NULL);
}///

///Get_TT
BOOL Get_TT(char *file_name, UWORD *font_size, char **font_name, char *data_file, char *data_dir, char **cscreen)
{
		char    **tt_base,*fn,file_dir[256] = "";
		struct  DiskObject *diskobj = NULL;
		BOOL    tandy = FALSE;
		BYTE    lw;
		//char    GuideName[32];

		if (WBSTART) {
			NameFromLock(WBMessage->sm_ArgList->wa_Lock,file_dir,255);
			Make_FFP(file_name,file_dir);
		}
		else strcpy(FFP,file_name);

		//strcpy(GuideName,file_name);
		//strcat(GuideName,".guide");
		if (AmigaGuideBase) scott_guide.nag_Name = "Scott.guide";

		if ((diskobj = (struct DiskObject *) GetDiskObject(FFP))) {
				tt_base = diskobj->do_ToolTypes;
				fn = (char *) FindToolType(tt_base,"FONT_NAME");
				if (fn) {
						*font_name = dyn_strings(fn,5);
						strcat(*font_name,".font");
						*font_size = (UWORD) abs(atoi((char *) FindToolType(tt_base,"FONT_SIZE")));
				}
				*cscreen = dyn_strings((char *) FindToolType(tt_base,"CUSTOMSCREEN"),0);
				strncpy(data_file,(char *) FindToolType(tt_base,"ADV_DATAFILE"),31);
				Make_FFP((char *) FindToolType(tt_base,"ADV_DIR"),file_dir);
				strncpy(data_dir,FFP,255);
				strncpy(save_game,(char *) FindToolType(tt_base,"SAVE_GAME"),31);
				//if (strcmp(save_game,"") == 0) strcat(strncpy(save_game,data_file,strlen(data_file)-4),".save");
				Make_FFP((char *) FindToolType(tt_base,"SAVE_DIR"),file_dir);
				strncpy(save_dir,FFP,255);
				lw = (BYTE) abs(atoi((char *) FindToolType(tt_base,"LINEWIDTH")));
				if ((lw > 0) && (lw <= 99)) Width = lw;
				if (Strnicmp(FindToolType(tt_base,"TANDYFLAG"),"ON",2) == 0) tandy = TRUE;
				//printf("|%s|, |%s|, |%s|, |%s|, |%s,%d|, |%s|\n",save_game,save_dir,data_file,data_dir,*font_name,*font_size,*cscreen);
				FreeDiskObject(diskobj);
		}
		else {
			*font_name = dyn_strings("",0);
			*cscreen   = dyn_strings("",0);
		}
		return(tandy);
}///

/// Get_Font
void Get_Font(UWORD font_ysize, char *font_name)
{
		struct TextAttr textattr;

		textattr.ta_Name =  font_name;
		textattr.ta_YSize = font_ysize;
		textattr.ta_Style = FS_NORMAL;
		textattr.ta_Flags = FPF_DISKFONT|FPF_DESIGNED;
		if ((textfont = (struct TextFont *) OpenDiskFont(&textattr))) {
			if (textfont->tf_Flags & FPF_PROPORTIONAL) {
				EasyRequest(NULL,&NoProp,NULL,textfont->tf_Message.mn_Node.ln_Name);
				close_all();
				Exit(50);
			}
		}
}///

/// Set_NewFont
void Set_NewFont(void)
{
		struct Window *win, *env_w_hdl = NULL;

		win = WBscreen->FirstWindow;
		do {
				if (strncmp(win->Title,"Environment",11) == 0) env_w_hdl = win;
				if (strncmp(win->Title,"SCOTT-Free AMIGA",16) == 0) act_w_hdl = win;
				if ((env_w_hdl) && (act_w_hdl)) break;
		} while ((win = win->NextWindow));

		if (textfont) {
			SetFont(act_w_hdl->RPort,textfont);
			SetFont(env_w_hdl->RPort,textfont);
		}
}///

/// Make_FFP
void Make_FFP(char *file, char *dir)
{
  strcpy(FFP,dir);
  AddPart(FFP,file,256);
}///

/// Get_FileList
/*
void Get_FileList(char *dir, char **dfile_names, BYTE *cnt, BYTE mode)
{
	BPTR    dir_lock;
	struct  FileInfoBlock *dfib;
	APTR    pat;
	char    dname[256];
	static BYTE cc = 0;

	if ((dir_lock = Lock(dir,SHARED_LOCK))) {
		if ((dfib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
			if (Examine(dir_lock,dfib)) {
				pat = MemAlloc(12);
				ParsePatternNoCase("#?.dat",pat,12);
				while(ExNext(dir_lock,dfib)) {
					if (dfib->fib_DirEntryType == ST_USERDIR) {
						strcpy(dname,dir);
						AddPart(dname,dfib->fib_FileName,256);
						switch (mode) {
						  case 0:
							Get_FileList(dname,NULL,cnt,0);
							break;
						  case 1:
							Get_FileList(dname,dfile_names,NULL,1);
							break;
						  default:
							break;
						}
					}
					if (dfib->fib_DirEntryType == ST_FILE && MatchPatternNoCase(pat,dfib->fib_FileName)) {
						switch (mode) {
						  case 0:
							(*cnt)++;
							break;
						  case 1:
							Make_FFP(dfib->fib_FileName,dir);
							dfile_names[cc++] = dyn_strings(FFP,0);
							break;
						  default:
							break;
						}
					}
				}
				free(pat);
			}
			FreeDosObject(DOS_FIB,dfib);
		}
		UnLock(dir_lock);
	}
}*/
///

///Open_ASL
BOOL Open_ASL(char *file_name, char *dir_name, UBYTE mode)
{
   struct TagItem *ASLTags;
   struct FileRequester *FileRequester;
   LONG   areq;

   FileRequester = (struct FileRequester *) AllocAslRequest(ASL_FileRequest,NULL);
   if (FileRequester == NULL) return(FALSE);
   ASLTags = (struct TagItem *) AllocateTagItems(7);
   if (ASLTags == NULL) {
		   FreeFileRequest(FileRequester);
		   return(FALSE);
   }
   ASLTags[0].ti_Tag = ASLFR_InitialPattern;
   ASLTags[0].ti_Data = (ULONG) "#?.save";
   if (mode == 2) ASLTags[0].ti_Data = (ULONG) "#?.dat";
   ASLTags[1].ti_Tag = ASLFR_Flags1;
   ASLTags[1].ti_Data = FRF_DOPATTERNS;
   if (mode == 1) ASLTags[1].ti_Data = FRF_DOPATTERNS|FRF_DOSAVEMODE;
   ASLTags[2].ti_Tag = ASLFR_TitleText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
   ASLTags[2].ti_Data = (ULONG) "Restore Save-Game";
   if (mode == 1) ASLTags[2].ti_Data = (ULONG) "Save Game as ...";
   if (mode == 2) ASLTags[2].ti_Data = (ULONG) "Choose Adventure-DataFile";
   ASLTags[3].ti_Tag = ASLFR_InitialFile;
   ASLTags[3].ti_Data = (ULONG) file_name;
   ASLTags[4].ti_Tag = ASLFR_InitialDrawer;
   ASLTags[4].ti_Data = (ULONG) dir_name;
   ASLTags[5].ti_Tag = ASLFR_PositiveText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
   ASLTags[5].ti_Data = (ULONG) "Load";
   if (mode == 1) ASLTags[5].ti_Data = (ULONG) "Save";
   if (mode == 2) ASLTags[5].ti_Data = (ULONG) "Play";
   ASLTags[6].ti_Tag = TAG_DONE;
   if ((areq = AslRequest(FileRequester,ASLTags))) {
				strcpy(file_name,FileRequester->fr_File);
				strcpy(dir_name,FileRequester->fr_Drawer);
				//printf("Dir, File: %s, %s\n",FileRequester->fr_File,FileRequester->fr_Drawer);
   }
   FreeTagItems(ASLTags);
   FreeFileRequest(FileRequester);
   if (areq) return(TRUE);
   return(FALSE); // Cancel pressed or ASL-problem
}///

/// Get_FileSize
LONG Get_FileSize(BPTR file_lock)
{
		struct  FileInfoBlock *ffib;

		if ((ffib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
				if (Examine(file_lock,ffib)) {
						printf("Name: %s\nSize: %d\n",ffib->fib_FileName,ffib->fib_Size);
				}
				FreeDosObject(DOS_FIB,ffib);
				return(ffib->fib_Size);
		}
		return(0);
}///

/// Show_FileList
/*
void Show_FileList(char *dir)
{
		char **dfile_names;
		BYTE i,cnt = 0;

		Get_FileList(dir,NULL,&cnt,0);
		dfile_names = (char **) MemAlloc(sizeof(char *) * cnt);
		Get_FileList(dir,dfile_names,NULL,1);
		for (i=0;i<=cnt-1;i++) {
				printf("%2d: %10.*s [%s]\n",i,(int)strlen(FilePart(dfile_names[i]))-4,FilePart(dfile_names[i]),dfile_names[i]);
		}
		if (cnt > 0) for (i=0;i<=cnt-1;i++) free(dfile_names[cnt]);
		free(dfile_names);
}*/
///

/// Open_File
FILE * Open_File(char * file_name)
{
	FILE    *f;

	if ((f = fopen(file_name,"r")) == NULL) {
		perror(file_name);
		EasyRequest(NULL,&FError,NULL,file_name);
		close_libs();
		exit(1);
	}
	strcat(restart_file,(char *)FilePart(file_name));
	strcat(restart_file,".res");
	return(f);
}///

/// Get_AdvFile
FILE * Get_AdvFile(char *data_file, char *data_dir)
{
	BPTR    lock;

	if (strcmp(data_file,"") == 0) strcpy(data_file,".dat");
	Make_FFP(data_file,data_dir);
	while ((lock = Lock(FFP,SHARED_LOCK)) == NULL) {
		if (Open_ASL(data_file,data_dir,2) == FALSE) {
			close_all();
			exit(64);
		}
		Make_FFP(data_file,data_dir);
	}

	//Get_FileSize(lock);
	UnLock(lock);
	return(Open_File(FFP));
}///

/// Init_Win
void Init_Win(struct FileHandle *win, BYTE fg, BYTE bg)
{
		CON_handle = win;
		clrsys();
		background(bg);
		textcolor(fg,bg);
		cursor(FALSE);
}///

/// Open_Wins
void Open_Wins(WORD s_width, WORD s_height, BYTE Width, UWORD fy_size, char **font_name, char *cscreen)
{
		WORD    w_height_env,w_height_act,w_width,w_left,w_top;
		UWORD   fx_size;
		struct  Window *win;

		if (fy_size) Get_Font(fy_size,*font_name);
		free(*font_name);
		free(font_name);
		if (textfont) fx_size = (UWORD) textfont->tf_XSize;
		else {
			win = WBscreen->FirstWindow;
			fx_size = win->IFont->tf_XSize;
			fy_size = win->IFont->tf_YSize;
		}
		w_width = (WORD) (Width * fx_size + (BYTE) WBscreen->WBorLeft + (BYTE) WBscreen->WBorRight);
		w_height_env = (WORD) (TopHeight * fy_size + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 1);
		w_height_act = (WORD) (BottomHeight * fy_size + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 2);
		w_left = (WORD) (s_width - w_width) / 2;
		w_top = (WORD) (s_height - w_height_env - w_height_act) / 2;
		if ((w_width > s_width) || ((w_height_env+w_height_act) > s_height)) {
			EasyRequest(NULL,&BigWins,NULL,NULL);
			close_libs();
			exit(20);
		}
		env_hdl = Open_CON("RAW",w_left,w_top,w_width,w_height_env,"Environment","NOSIZE",cscreen);
		act_hdl = Open_CON("CON",w_left,w_top+w_height_env,w_width,w_height_act,"SCOTT-Free AMIGA","NOSIZE/CLOSE",cscreen);
		Set_NewFont();
		Init_Win(env_hdl,WHITE,BLUE);
		Init_Win(act_hdl,BLACK,GREY);

		scott_guide.nag_Screen = act_w_hdl->WScreen;
		OldUserPort = act_w_hdl->UserPort;
		act_w_hdl->UserPort = 0;
		ModifyIDCMP(act_w_hdl,MENUPICK|RAWKEY|VANILLAKEY|CLOSEWINDOW);
		menu = (struct Menu *) CreateMenus(newmenu,TAG_DONE);
		LayoutMenus(menu,WBvisinfo,TAG_DONE);
		SetMenuStrip(act_w_hdl,menu);
}///

/// Size_Wins
void Size_Wins(BOOL tandy)
{
		if (tandy) {
				Width = 64;
				TopHeight = 11;
				BottomHeight = 13;
				Options|=TRS80_STYLE;
		}
		else {
				if (Width == 0) Width = 80;
				TopHeight = 10;
				BottomHeight = 15;
		}
}///

/// Init_PB
/*
APTR Init_PB(WORD s_width, WORD s_height)
{
		APTR    pbar = NULL;

		PBwin  = (struct Window *) OpenWindowTags(NULL,WA_Title,"Loading Adventure ...",
						 WA_Width,250,WA_Height,50,WA_DepthGadget,TRUE,WA_DragBar,TRUE,WA_Activate,TRUE,
						 WA_IDCMP,IDCMP_REFRESHWINDOW|IDCMP_INTUITICKS,WA_Left,(s_width-250)/2,
						 WA_Top,(s_height-50)/2,TAG_DONE);
		//pbar = (APTR) CreatePBar(PB_VisualInfo,WBvisinfo,PB_LeftEdge,5,PB_TopEdge,15,
		//       PB_Width,200,PB_Height,13,PB_BarColour,BLUE,PB_Window,PBwin,TAG_DONE);

		//ClearPBar(pbar);
		
		return(pbar);
}*/
///

/// Update_PB
/*
void Update_PB(APTR pbar, BYTE val)
{
		BYTE     i;

		for (i=1;i<=100;i++) {
				Delay(25);
				//UpdatePBar(pbar,PB_NewValue,i,TAG_DONE);
		}
		//UpdatePBar(pbar,PB_NewValue,val,TAG_DONE);
}*/
///

/// Close_PB
/*
void Close_PB(APTR pbar)
{
		Delay(50);
		//FreePBar(pbar);
		CloseWindow(PBwin);
}*/
///

/// Init
void Init(char *prog_name, char *adv_file, char *save_file)
{
	UWORD   fy_size = 0;
	WORD    s_height,s_width;
	char    data_file[32] = "",data_dir[256] = "";
	char    **font_name = (char **) MemAlloc(sizeof(char *));
	char    **cscreen = (char **) MemAlloc(sizeof(char *));
	FILE    *f;

	if (open_libs() == FALSE) {
		close_libs();
		exit(255);
	}

	Size_Wins(Get_TT(prog_name,&fy_size,font_name,data_file,data_dir,cscreen));
	if (Options & TRS80_STYLE) Size_Wins(TRUE);

	if ((WBscreen = (struct Screen *) LockPubScreen(*cscreen)) == NULL) WBscreen = (struct Screen *) LockPubScreen("Workbench");
	if (WBscreen) {
		if ((WBvisinfo  = (APTR) GetVisualInfo(WBscreen,NULL))) {

			s_height   = (WORD) WBscreen->Height;
			s_width    = (WORD) WBscreen->Width;

			if (strcmp(adv_file,"") != NULL) {
				f = Open_File(adv_file);
				strcpy(data_file,adv_file);
			}
			else f = Get_AdvFile(data_file,data_dir);

			//Show_FileList(data_dir);
				
			Open_Wins(s_width,s_height,Width,fy_size,font_name,*cscreen);
			free(*cscreen);
			free(cscreen);
			
			OutReset();
			OutBuf("AMIGA SCOTT-Free Version 1.52, 7-11/1996\n");
			OutBuf("© Andreas Aumayr, Anden@highnet.co.at\n\n");
			OutBuf("Based on SCOTT-Free UNIX/DOS V1.14b, © Alan Cox\n\n");
			OutBuf("Loading adventure data file ...  ");

			LoadDatabase(f,(Options&DEBUGGING)?1:0);
			
			fclose(f);
			OutBuf("Finished.\n\n");

			if (SaveRestart()) {
				OffMenu(act_w_hdl,63649);
				RESTART = FALSE;
			}

			if (strcmp(save_file,"") != NULL) LoadGame(save_file);
			else if (strcmp(save_game,"") != NULL) {
				Make_FFP(save_game,save_dir);
				LoadGame(FFP);
			}
			else {
				strncpy(save_game,data_file,strlen(data_file)-4);
				strcat(save_game,".save");
			}
			return;
		}
		printf("\nProblems getting Visual Info for screen '%s'!\n",*cscreen);
		close_all();
	}
	printf("\nProblems locking custom screen '%s'\n",*cscreen);
	close_libs();
}///

/// Menu_Handle
BOOL Menu_Handle(int code, char *command)
{
	//strcpy(command,"");
	if (MENUNUM(code) != MENUNULL) {
		switch(MENUNUM(code)) {
			case 0:
				switch(ITEMNUM(code)) {
					case 0:
						EasyRequest(NULL,&About,NULL,NULL);
						return(FALSE);
						break;
					case 2:
						if (AmigaGuideBase) {
							CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
						}
						return(FALSE);
						break;
					case 4:
						if (EasyRequest(NULL,&Quit,NULL,"")) {
							close_all();
							exit(0);
						}
						return(FALSE);
						break;
				}
				break;
			case 1:
				switch(ITEMNUM(code)) {
					case 0:
						EasyRequest(NULL,&GameInfo,NULL,GameInfoStr);
						return(FALSE);
						break;
					case 2:
						strcpy(command,"!RESTORE");
						WriteCON("!RESTORE\n");
						return(TRUE);
						break;
					case 3:
						strcpy(command,"SAVE GAME");
						WriteCON("SAVE GAME\n");
						return(TRUE);
						break;
					case 5:
						LoadRestart();
						OutReset();
						WriteCON(CLRSCR);
						PerformActions(0,0);
						Look();
						strcpy(command,"");
						return(TRUE);
						break;
				}
				break;
			case 2:
				switch(ITEMNUM(code)) {
					case 0:
						strcpy(command,"LOOK");
						WriteCON("LOOK\n");
						return(TRUE);
						break;
					case 1:
						strcpy(command,"INVENTORY");
						WriteCON("INVENTORY\n");
						return(TRUE);
						break;
					case 2:
						strcpy(command,"GET ALL");
						WriteCON("GET ALL\n");
						return(TRUE);
						break;
					case 4:
						strcpy(command,"SCORE");
						WriteCON("SCORE\n");
						return(TRUE);
						break;
				}
				break;
		}
	}
	return(FALSE);
}///

/// LineInput2
void LineInput2(char *command)
{
	USHORT      code;
	ULONG       class;
	struct      IntuiMessage *mess;
	char        buf[MAX_LL+1],ncom[MAX_LL+1];
	int         len=0,c_pos=0,h_pos=0;
	// struct      AmigaGuideMsg *amsg;

	/*while ((amsg = (struct AmigaGuideMsg *) GetAmigaGuideMsg(Guide_hdl))) {

		ReplyAmigaGuideMsg(amsg);
	} */

	h_pos = hist_pos;
	do {
		WaitPort(act_w_hdl->UserPort);
		while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
			class = mess->Class;
			code  = mess->Code;
			GT_ReplyIMsg(mess);
			switch (class) {
				case IDCMP_VANILLAKEY:
					if ((code >=32) && (code <=126)) {
						if (len < MAX_LL) {
							if (len != c_pos) {
								strcpy(buf,&hist[hist_pos][c_pos]);
								hist[hist_pos][c_pos] = code;
								hist[hist_pos][c_pos+1] = 0;
								strcat(&hist[hist_pos][0],buf);
								sprintf(buf,"%s%c",INS_CHAR,code);
								WriteCON(buf);
							}
							else {
								hist[hist_pos][c_pos] = code;
								sprintf(buf,"%c",code);
								WriteCON(buf);
							}
							len++;
							c_pos++;
						}
						break;
					}
					switch (code) {
						case 8:
							if (c_pos > 0) {
								WriteCON(CURSOR_LEFT);
								WriteCON(DEL_CHAR);
								if (len != c_pos) {
									strcpy(buf,&hist[hist_pos][c_pos]);
									hist[hist_pos][c_pos-1] = 0;
									strcat(&hist[hist_pos][0],buf);
								}
								c_pos--;
								len--;
							}
							break;
						case 127:
							if ((c_pos > 0) && (c_pos < len)) {
								WriteCON(DEL_CHAR);
								if (len != c_pos+1) {
									strcpy(buf,&hist[hist_pos][c_pos+1]);
									hist[hist_pos][c_pos] = 0;
									strcat(&hist[hist_pos][0],buf);
								}
								len--;
							}
							break;
					}

				case IDCMP_RAWKEY:
					switch (code) {
						case 10:
						case 13:
							hist[hist_pos][len] = 0;
							strcpy(command,&hist[hist_pos][0]);
							hist_pos++;
							if (hist_pos >= MAX_HIST) hist_pos = 0;
							if (hist_fill < MAX_HIST-1) hist_fill++;
							WriteCON("\n");
							return;
							break;
						case 76:
							h_pos--;
							if (h_pos < 0) h_pos = hist_fill;
							if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
							else strcpy(ncom,"");
							c_pos = len = strlen(ncom);
							gotoxy(22,BottomHeight);
							sprintf(buf,"%s%s",CLREOL,ncom);
							WriteCON(buf);
							strcpy(&hist[hist_pos][0],ncom);
							break;
						case 77:
							h_pos++;
							if (h_pos > hist_fill) h_pos = 0;
							if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
							else strcpy(ncom,"");
							c_pos = len = strlen(ncom);
							gotoxy(22,BottomHeight);
							sprintf(buf,"%s%s",CLREOL,ncom);
							WriteCON(buf);
							strcpy(&hist[hist_pos][0],ncom);
							break;
						case 78:
							if (c_pos < len) {
								WriteCON(CURSOR_RIGHT);
								c_pos++;
							}
							break;
						case 79:
							if (c_pos > 0) {
								WriteCON(CURSOR_LEFT);
								c_pos--;
							}
							break;
						case 95:
							if (AmigaGuideBase) {
								CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
							}
							break;
						default:
							break;
					}
					break;

				case IDCMP_MENUPICK:
					if (Menu_Handle(code,command)) {
						strcpy(&hist[hist_pos][0],command);
						WriteCON(command);
						hist_pos++;
						if (hist_pos >= MAX_HIST) hist_pos = 0;
						if (hist_fill < MAX_HIST-1) hist_fill++;
						return;
					}
					break;

				case IDCMP_CLOSEWINDOW:
					if (EasyRequest(NULL,&Quit,NULL,NULL)) {
						close_all();
						exit(0);
						return;
					}
					break;
			}
		}
	} while (1);
}///

///KeyInput
USHORT KeyInput(void)
{
	USHORT      code;
	ULONG       class;
	struct      IntuiMessage *mess;

	do {
		WaitPort(act_w_hdl->UserPort);
		while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
			class = mess->Class;
			code  = mess->Code;
			GT_ReplyIMsg(mess);
			switch (class) {
				case IDCMP_VANILLAKEY:
					if ((code >=32) && (code <=126)) return(code);
			}
		}
	} while (1);
}///