home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 8 / amigaformatcd08.iso / screenplay / utilities / scott / source / source.lha / AMIGA5.C next >
C/C++ Source or Header  |  1996-10-30  |  24KB  |  904 lines
  1. /*
  2.  *  AMIGA Libs & Functions for Scott-Free
  3.  *
  4.  *  ===================================================================
  5.  *
  6.  *  Version History AMIGA:
  7.  *  Ver ,     Date,     Author, Comment
  8.  *  -------------------------------------------------------------------
  9.  *  1.0 , 28/07/96, Andreas Aumayr, First public release
  10.  *  1.1 , 16/08/96, Andreas Aumayr, Added ToolType support & font prefs
  11.  *  1.2 , 30/08/96, Andreas Aumayr, ASL-FR for Load/Save/Datafile
  12.  *  1.3 , 08/09/96, Andreas Aumayr, Menus, loads of minor enhancements,
  13.  *                                  'real' command history, more TTs
  14.  *  1.4 , 17/09/96, Andreas Aumayr, Public screen support, more TTs, ..
  15.  *  ___________________________________________________________________
  16.  */
  17.  
  18. #define  MAX_HIST 20
  19. #define  MAX_LL   40
  20.  
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24. #include <ctype.h>
  25. #include <stdarg.h>
  26. #include <time.h>
  27.  
  28. #include <intuition/intuition.h>
  29. #include <graphics/gfxbase.h>
  30. #include <workbench/workbench.h>
  31. #include <libraries/dos.h>
  32. #include <libraries/dosextens.h>
  33. #include <dos/exall.h>
  34. #include <utility/tagitem.h>
  35. #include <libraries/asl.h>
  36. #include <libraries/gadtools.h>
  37. #include <workbench/startup.h>
  38. #include <libraries/amigaguide.h>
  39. #include "gui.c"
  40.  
  41. void * MemAlloc(int size);
  42. void Make_FFP(char *file, char *dir);
  43. void LoadDatabase(FILE *f, int loud);
  44. BOOL LoadGame(char *name);
  45. void OutReset();
  46. void OutBuf(char *buffer);
  47. void OutputNumber(int a);
  48. void SaveBody(FILE *f);
  49. void LoadBody(FILE *f);
  50. BOOL SaveRestart();
  51. BOOL LoadRestart();
  52. void Look();
  53. int  PerformActions(int vb,int no);
  54. void main(int argc, char *argv[]);
  55.  
  56. struct IntuitionBase *IntuitionBase;
  57. struct GfxBase *GfxBase;
  58. ULONG  DiskfontBase;
  59. ULONG  IconBase;
  60. ULONG  Dos_Base;
  61. ULONG  UtilityBase;
  62. ULONG  AslBase;
  63. ULONG  GadToolsBase;
  64. ULONG  AmigaGuideBase;
  65. struct Screen *WBscreen = NULL;
  66. struct Window *PBwin;
  67. struct Window *act_w_hdl;
  68. APTR   WBvisinfo = NULL;
  69. struct TextFont *textfont = NULL;
  70. char   save_game[32] = "";
  71. char   save_dir[256] = "";
  72. char   FFP[256];
  73.  
  74. char   hist[MAX_HIST][MAX_LL+1];
  75. int    hist_pos=0,hist_fill=0;
  76.  
  77. struct Menu *menu = NULL;
  78. char   Version[] = "$VER: AMIGA SCOTT-Free V1.52, 29/10/1996";
  79. char   GameInfoStr[256] = "";
  80.  
  81. struct WBStartup *WBMessage;
  82. struct MsgPort *OldUserPort;
  83. BOOL   WBSTART = FALSE;
  84. BOOL   RESTART = TRUE;
  85. char   restart_file[42] = "RAM:";
  86. BPTR   restart_lock;
  87.  
  88. struct NewAmigaGuide scott_guide = {NULL};
  89.  
  90. /// close_libs
  91. void close_libs(void)
  92. {
  93.         if (GadToolsBase) CloseLibrary(GadToolsBase);
  94.         if (AslBase) CloseLibrary(AslBase);
  95.         if (UtilityBase) CloseLibrary(UtilityBase);
  96.         if (Dos_Base) CloseLibrary(Dos_Base);
  97.         if (IconBase) CloseLibrary(IconBase);
  98.         if (DiskfontBase) CloseLibrary(DiskfontBase);
  99.         if (GfxBase) CloseLibrary(GfxBase);
  100.         if (IntuitionBase) CloseLibrary(IntuitionBase);
  101.         if (AmigaGuideBase) CloseLibrary(AmigaGuideBase);
  102. }///
  103.  
  104. /// open_libs
  105. BOOL open_libs(void)
  106. {
  107.                 IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",37);
  108.                 if (IntuitionBase == NULL) {
  109.                         printf("Problems opening Intuition-Lib!\n");
  110.                         return(FALSE);
  111.                 }
  112.                 GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",37);
  113.                 if (GfxBase == NULL) {
  114.                         printf("Problems opening GFX-Lib!\n");
  115.                         return(FALSE);
  116.                 }
  117.                 DiskfontBase = OpenLibrary("diskfont.library",0);
  118.                 if (DiskfontBase == 0) {
  119.                         EasyRequest(NULL,&Library,NULL,"DiskFont");
  120.                         return(FALSE);
  121.                 }
  122.                 IconBase = OpenLibrary("icon.library",0);
  123.                 if (IconBase == 0) {
  124.                         printf("Problems opening Icon-Lib!\n");
  125.                         return(FALSE);
  126.                 }
  127.                 Dos_Base = OpenLibrary("dos.library",0);
  128.                 if (Dos_Base == 0) {
  129.                         printf("Problems opening DOS-Lib!\n");
  130.                         return(FALSE);
  131.                 }
  132.                 UtilityBase = OpenLibrary("utility.library",0);
  133.                 if (UtilityBase == 0) {
  134.                         printf("Problems opening Utility-Lib!\n");
  135.                         return(FALSE);
  136.                 }
  137.                 AslBase = OpenLibrary("asl.library",0);
  138.                 if (AslBase == 0) {
  139.                         EasyRequest(NULL,&Library,NULL,"ASL");
  140.                         return(FALSE);
  141.                 }
  142.                 GadToolsBase = OpenLibrary("gadtools.library",36);
  143.                 if (GadToolsBase == 0) {
  144.                         printf("Problems opening GadTools-Lib!\n");
  145.                         return(FALSE);
  146.                 }
  147.                 AmigaGuideBase = OpenLibrary("amigaguide.library",0);
  148.                 return(TRUE);
  149. }///
  150.  
  151. /// close_all
  152. void close_all(void)
  153. {
  154.         //ClearMenuStrip(act_w_hdl);
  155.         if (restart_lock) {
  156.             UnLock(restart_lock);
  157.             DeleteFile(restart_file);
  158.         }
  159.         if (menu) FreeMenus(menu);
  160.         if (WBvisinfo) FreeVisualInfo(WBvisinfo);
  161.         if (WBscreen) UnlockPubScreen(NULL,WBscreen);
  162.         if (textfont) CloseFont(textfont);
  163.         if (act_hdl) {
  164.             act_w_hdl->UserPort = OldUserPort;
  165.             Close(act_hdl);
  166.         }
  167.         if (env_hdl) Close(env_hdl);
  168.         close_libs();
  169. }///
  170.  
  171. /// MemAlloc
  172. void * MemAlloc(int size)
  173. {
  174.     void *t = (void *) malloc(size);
  175.     if (t == NULL) {
  176.         printf("\nUnable to get some mem! Terminating.\n");
  177.         EasyRequest(NULL,&NoMem,NULL,NULL);
  178.         close_all();
  179.         exit(128);
  180.     }
  181.     return(t);
  182. }///
  183.  
  184. /// Open_CON
  185. struct FileHandle *Open_CON(char *type, int left_off, int top_off, int width, int height, char *title, char *flags, char *cscreen)
  186. {
  187.     sprintf(str_buf,"%s:%d/%d/%d/%d/%s/%s/SCREEN %s",type,left_off,top_off,width,height,title,flags,cscreen);
  188.     CON_handle = (struct FileHandle *) Open(str_buf,MODE_NEWFILE);
  189.     if (!CON_handle) {
  190.         printf("Failed to open console window '%s'!\n",title);
  191.         EasyRequest(NULL,&ConFail,NULL,title);
  192.         close_all();
  193.         exit(99);
  194.     }
  195.     else return(CON_handle);
  196. }///
  197.  
  198. ///dyn_strings
  199. void * dyn_strings(char *cont, BYTE add)
  200. {
  201.         void *mem_ptr;
  202.  
  203.         if (cont && strlen(cont)) {
  204.                 mem_ptr = MemAlloc(strlen(cont)+1+add);
  205.                 strcpy(mem_ptr,cont);
  206.                 //printf("MemPtr: |%s| at %ld\n",mem_ptr,mem_ptr);
  207.                 return(mem_ptr);
  208.         }
  209.         return(NULL);
  210. }///
  211.  
  212. ///Get_TT
  213. BOOL Get_TT(char *file_name, UWORD *font_size, char **font_name, char *data_file, char *data_dir, char **cscreen)
  214. {
  215.         char    **tt_base,*fn,file_dir[256] = "";
  216.         struct  DiskObject *diskobj = NULL;
  217.         BOOL    tandy = FALSE;
  218.         BYTE    lw;
  219.         //char    GuideName[32];
  220.  
  221.         if (WBSTART) {
  222.             NameFromLock(WBMessage->sm_ArgList->wa_Lock,file_dir,255);
  223.             Make_FFP(file_name,file_dir);
  224.         }
  225.         else strcpy(FFP,file_name);
  226.  
  227.         //strcpy(GuideName,file_name);
  228.         //strcat(GuideName,".guide");
  229.         if (AmigaGuideBase) scott_guide.nag_Name = "Scott.guide";
  230.  
  231.         if ((diskobj = (struct DiskObject *) GetDiskObject(FFP))) {
  232.                 tt_base = diskobj->do_ToolTypes;
  233.                 fn = (char *) FindToolType(tt_base,"FONT_NAME");
  234.                 if (fn) {
  235.                         *font_name = dyn_strings(fn,5);
  236.                         strcat(*font_name,".font");
  237.                         *font_size = (UWORD) abs(atoi((char *) FindToolType(tt_base,"FONT_SIZE")));
  238.                 }
  239.                 *cscreen = dyn_strings((char *) FindToolType(tt_base,"CUSTOMSCREEN"),0);
  240.                 strncpy(data_file,(char *) FindToolType(tt_base,"ADV_DATAFILE"),31);
  241.                 Make_FFP((char *) FindToolType(tt_base,"ADV_DIR"),file_dir);
  242.                 strncpy(data_dir,FFP,255);
  243.                 strncpy(save_game,(char *) FindToolType(tt_base,"SAVE_GAME"),31);
  244.                 //if (strcmp(save_game,"") == 0) strcat(strncpy(save_game,data_file,strlen(data_file)-4),".save");
  245.                 Make_FFP((char *) FindToolType(tt_base,"SAVE_DIR"),file_dir);
  246.                 strncpy(save_dir,FFP,255);
  247.                 lw = (BYTE) abs(atoi((char *) FindToolType(tt_base,"LINEWIDTH")));
  248.                 if ((lw > 0) && (lw <= 99)) Width = lw;
  249.                 if (Strnicmp(FindToolType(tt_base,"TANDYFLAG"),"ON",2) == 0) tandy = TRUE;
  250.                 //printf("|%s|, |%s|, |%s|, |%s|, |%s,%d|, |%s|\n",save_game,save_dir,data_file,data_dir,*font_name,*font_size,*cscreen);
  251.                 FreeDiskObject(diskobj);
  252.         }
  253.         else {
  254.             *font_name = dyn_strings("",0);
  255.             *cscreen   = dyn_strings("",0);
  256.         }
  257.         return(tandy);
  258. }///
  259.  
  260. /// Get_Font
  261. void Get_Font(UWORD font_ysize, char *font_name)
  262. {
  263.         struct TextAttr textattr;
  264.  
  265.         textattr.ta_Name =  font_name;
  266.         textattr.ta_YSize = font_ysize;
  267.         textattr.ta_Style = FS_NORMAL;
  268.         textattr.ta_Flags = FPF_DISKFONT|FPF_DESIGNED;
  269.         if ((textfont = (struct TextFont *) OpenDiskFont(&textattr))) {
  270.             if (textfont->tf_Flags & FPF_PROPORTIONAL) {
  271.                 EasyRequest(NULL,&NoProp,NULL,textfont->tf_Message.mn_Node.ln_Name);
  272.                 close_all();
  273.                 Exit(50);
  274.             }
  275.         }
  276. }///
  277.  
  278. /// Set_NewFont
  279. void Set_NewFont(void)
  280. {
  281.         struct Window *win, *env_w_hdl = NULL;
  282.  
  283.         win = WBscreen->FirstWindow;
  284.         do {
  285.                 if (strncmp(win->Title,"Environment",11) == 0) env_w_hdl = win;
  286.                 if (strncmp(win->Title,"SCOTT-Free AMIGA",16) == 0) act_w_hdl = win;
  287.                 if ((env_w_hdl) && (act_w_hdl)) break;
  288.         } while ((win = win->NextWindow));
  289.  
  290.         if (textfont) {
  291.             SetFont(act_w_hdl->RPort,textfont);
  292.             SetFont(env_w_hdl->RPort,textfont);
  293.         }
  294. }///
  295.  
  296. /// Make_FFP
  297. void Make_FFP(char *file, char *dir)
  298. {
  299.   strcpy(FFP,dir);
  300.   AddPart(FFP,file,256);
  301. }///
  302.  
  303. /// Get_FileList
  304. /*
  305. void Get_FileList(char *dir, char **dfile_names, BYTE *cnt, BYTE mode)
  306. {
  307.     BPTR    dir_lock;
  308.     struct  FileInfoBlock *dfib;
  309.     APTR    pat;
  310.     char    dname[256];
  311.     static BYTE cc = 0;
  312.  
  313.     if ((dir_lock = Lock(dir,SHARED_LOCK))) {
  314.         if ((dfib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
  315.             if (Examine(dir_lock,dfib)) {
  316.                 pat = MemAlloc(12);
  317.                 ParsePatternNoCase("#?.dat",pat,12);
  318.                 while(ExNext(dir_lock,dfib)) {
  319.                     if (dfib->fib_DirEntryType == ST_USERDIR) {
  320.                         strcpy(dname,dir);
  321.                         AddPart(dname,dfib->fib_FileName,256);
  322.                         switch (mode) {
  323.                           case 0:
  324.                             Get_FileList(dname,NULL,cnt,0);
  325.                             break;
  326.                           case 1:
  327.                             Get_FileList(dname,dfile_names,NULL,1);
  328.                             break;
  329.                           default:
  330.                             break;
  331.                         }
  332.                     }
  333.                     if (dfib->fib_DirEntryType == ST_FILE && MatchPatternNoCase(pat,dfib->fib_FileName)) {
  334.                         switch (mode) {
  335.                           case 0:
  336.                             (*cnt)++;
  337.                             break;
  338.                           case 1:
  339.                             Make_FFP(dfib->fib_FileName,dir);
  340.                             dfile_names[cc++] = dyn_strings(FFP,0);
  341.                             break;
  342.                           default:
  343.                             break;
  344.                         }
  345.                     }
  346.                 }
  347.                 free(pat);
  348.             }
  349.             FreeDosObject(DOS_FIB,dfib);
  350.         }
  351.         UnLock(dir_lock);
  352.     }
  353. }*/
  354. ///
  355.  
  356. ///Open_ASL
  357. BOOL Open_ASL(char *file_name, char *dir_name, UBYTE mode)
  358. {
  359.    struct TagItem *ASLTags;
  360.    struct FileRequester *FileRequester;
  361.    LONG   areq;
  362.  
  363.    FileRequester = (struct FileRequester *) AllocAslRequest(ASL_FileRequest,NULL);
  364.    if (FileRequester == NULL) return(FALSE);
  365.    ASLTags = (struct TagItem *) AllocateTagItems(7);
  366.    if (ASLTags == NULL) {
  367.            FreeFileRequest(FileRequester);
  368.            return(FALSE);
  369.    }
  370.    ASLTags[0].ti_Tag = ASLFR_InitialPattern;
  371.    ASLTags[0].ti_Data = (ULONG) "#?.save";
  372.    if (mode == 2) ASLTags[0].ti_Data = (ULONG) "#?.dat";
  373.    ASLTags[1].ti_Tag = ASLFR_Flags1;
  374.    ASLTags[1].ti_Data = FRF_DOPATTERNS;
  375.    if (mode == 1) ASLTags[1].ti_Data = FRF_DOPATTERNS|FRF_DOSAVEMODE;
  376.    ASLTags[2].ti_Tag = ASLFR_TitleText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
  377.    ASLTags[2].ti_Data = (ULONG) "Restore Save-Game";
  378.    if (mode == 1) ASLTags[2].ti_Data = (ULONG) "Save Game as ...";
  379.    if (mode == 2) ASLTags[2].ti_Data = (ULONG) "Choose Adventure-DataFile";
  380.    ASLTags[3].ti_Tag = ASLFR_InitialFile;
  381.    ASLTags[3].ti_Data = (ULONG) file_name;
  382.    ASLTags[4].ti_Tag = ASLFR_InitialDrawer;
  383.    ASLTags[4].ti_Data = (ULONG) dir_name;
  384.    ASLTags[5].ti_Tag = ASLFR_PositiveText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
  385.    ASLTags[5].ti_Data = (ULONG) "Load";
  386.    if (mode == 1) ASLTags[5].ti_Data = (ULONG) "Save";
  387.    if (mode == 2) ASLTags[5].ti_Data = (ULONG) "Play";
  388.    ASLTags[6].ti_Tag = TAG_DONE;
  389.    if ((areq = AslRequest(FileRequester,ASLTags))) {
  390.                 strcpy(file_name,FileRequester->fr_File);
  391.                 strcpy(dir_name,FileRequester->fr_Drawer);
  392.                 //printf("Dir, File: %s, %s\n",FileRequester->fr_File,FileRequester->fr_Drawer);
  393.    }
  394.    FreeTagItems(ASLTags);
  395.    FreeFileRequest(FileRequester);
  396.    if (areq) return(TRUE);
  397.    return(FALSE); // Cancel pressed or ASL-problem
  398. }///
  399.  
  400. /// Get_FileSize
  401. LONG Get_FileSize(BPTR file_lock)
  402. {
  403.         struct  FileInfoBlock *ffib;
  404.  
  405.         if ((ffib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
  406.                 if (Examine(file_lock,ffib)) {
  407.                         printf("Name: %s\nSize: %d\n",ffib->fib_FileName,ffib->fib_Size);
  408.                 }
  409.                 FreeDosObject(DOS_FIB,ffib);
  410.                 return(ffib->fib_Size);
  411.         }
  412.         return(0);
  413. }///
  414.  
  415. /// Show_FileList
  416. /*
  417. void Show_FileList(char *dir)
  418. {
  419.         char **dfile_names;
  420.         BYTE i,cnt = 0;
  421.  
  422.         Get_FileList(dir,NULL,&cnt,0);
  423.         dfile_names = (char **) MemAlloc(sizeof(char *) * cnt);
  424.         Get_FileList(dir,dfile_names,NULL,1);
  425.         for (i=0;i<=cnt-1;i++) {
  426.                 printf("%2d: %10.*s [%s]\n",i,(int)strlen(FilePart(dfile_names[i]))-4,FilePart(dfile_names[i]),dfile_names[i]);
  427.         }
  428.         if (cnt > 0) for (i=0;i<=cnt-1;i++) free(dfile_names[cnt]);
  429.         free(dfile_names);
  430. }*/
  431. ///
  432.  
  433. /// Open_File
  434. FILE * Open_File(char * file_name)
  435. {
  436.     FILE    *f;
  437.  
  438.     if ((f = fopen(file_name,"r")) == NULL) {
  439.         perror(file_name);
  440.         EasyRequest(NULL,&FError,NULL,file_name);
  441.         close_libs();
  442.         exit(1);
  443.     }
  444.     strcat(restart_file,(char *)FilePart(file_name));
  445.     strcat(restart_file,".res");
  446.     return(f);
  447. }///
  448.  
  449. /// Get_AdvFile
  450. FILE * Get_AdvFile(char *data_file, char *data_dir)
  451. {
  452.     BPTR    lock;
  453.  
  454.     if (strcmp(data_file,"") == 0) strcpy(data_file,".dat");
  455.     Make_FFP(data_file,data_dir);
  456.     while ((lock = Lock(FFP,SHARED_LOCK)) == NULL) {
  457.         if (Open_ASL(data_file,data_dir,2) == FALSE) {
  458.             close_all();
  459.             exit(64);
  460.         }
  461.         Make_FFP(data_file,data_dir);
  462.     }
  463.  
  464.     //Get_FileSize(lock);
  465.     UnLock(lock);
  466.     return(Open_File(FFP));
  467. }///
  468.  
  469. /// Init_Win
  470. void Init_Win(struct FileHandle *win, BYTE fg, BYTE bg)
  471. {
  472.         CON_handle = win;
  473.         clrsys();
  474.         background(bg);
  475.         textcolor(fg,bg);
  476.         cursor(FALSE);
  477. }///
  478.  
  479. /// Open_Wins
  480. void Open_Wins(WORD s_width, WORD s_height, BYTE Width, UWORD fy_size, char **font_name, char *cscreen)
  481. {
  482.         WORD    w_height_env,w_height_act,w_width,w_left,w_top;
  483.         UWORD   fx_size;
  484.         struct  Window *win;
  485.  
  486.         if (fy_size) Get_Font(fy_size,*font_name);
  487.         free(*font_name);
  488.         free(font_name);
  489.         if (textfont) fx_size = (UWORD) textfont->tf_XSize;
  490.         else {
  491.             win = WBscreen->FirstWindow;
  492.             fx_size = win->IFont->tf_XSize;
  493.             fy_size = win->IFont->tf_YSize;
  494.         }
  495.         w_width = (WORD) (Width * fx_size + (BYTE) WBscreen->WBorLeft + (BYTE) WBscreen->WBorRight);
  496.         w_height_env = (WORD) (TopHeight * fy_size + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 1);
  497.         w_height_act = (WORD) (BottomHeight * fy_size + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 2);
  498.         w_left = (WORD) (s_width - w_width) / 2;
  499.         w_top = (WORD) (s_height - w_height_env - w_height_act) / 2;
  500.         if ((w_width > s_width) || ((w_height_env+w_height_act) > s_height)) {
  501.             EasyRequest(NULL,&BigWins,NULL,NULL);
  502.             close_libs();
  503.             exit(20);
  504.         }
  505.         env_hdl = Open_CON("RAW",w_left,w_top,w_width,w_height_env,"Environment","NOSIZE",cscreen);
  506.         act_hdl = Open_CON("CON",w_left,w_top+w_height_env,w_width,w_height_act,"SCOTT-Free AMIGA","NOSIZE/CLOSE",cscreen);
  507.         Set_NewFont();
  508.         Init_Win(env_hdl,WHITE,BLUE);
  509.         Init_Win(act_hdl,BLACK,GREY);
  510.  
  511.         scott_guide.nag_Screen = act_w_hdl->WScreen;
  512.         OldUserPort = act_w_hdl->UserPort;
  513.         act_w_hdl->UserPort = 0;
  514.         ModifyIDCMP(act_w_hdl,MENUPICK|RAWKEY|VANILLAKEY|CLOSEWINDOW);
  515.         menu = (struct Menu *) CreateMenus(newmenu,TAG_DONE);
  516.         LayoutMenus(menu,WBvisinfo,TAG_DONE);
  517.         SetMenuStrip(act_w_hdl,menu);
  518. }///
  519.  
  520. /// Size_Wins
  521. void Size_Wins(BOOL tandy)
  522. {
  523.         if (tandy) {
  524.                 Width = 64;
  525.                 TopHeight = 11;
  526.                 BottomHeight = 13;
  527.                 Options|=TRS80_STYLE;
  528.         }
  529.         else {
  530.                 if (Width == 0) Width = 80;
  531.                 TopHeight = 10;
  532.                 BottomHeight = 15;
  533.         }
  534. }///
  535.  
  536. /// Init_PB
  537. /*
  538. APTR Init_PB(WORD s_width, WORD s_height)
  539. {
  540.         APTR    pbar = NULL;
  541.  
  542.         PBwin  = (struct Window *) OpenWindowTags(NULL,WA_Title,"Loading Adventure ...",
  543.                          WA_Width,250,WA_Height,50,WA_DepthGadget,TRUE,WA_DragBar,TRUE,WA_Activate,TRUE,
  544.                          WA_IDCMP,IDCMP_REFRESHWINDOW|IDCMP_INTUITICKS,WA_Left,(s_width-250)/2,
  545.                          WA_Top,(s_height-50)/2,TAG_DONE);
  546.         //pbar = (APTR) CreatePBar(PB_VisualInfo,WBvisinfo,PB_LeftEdge,5,PB_TopEdge,15,
  547.         //       PB_Width,200,PB_Height,13,PB_BarColour,BLUE,PB_Window,PBwin,TAG_DONE);
  548.  
  549.         //ClearPBar(pbar);
  550.         
  551.         return(pbar);
  552. }*/
  553. ///
  554.  
  555. /// Update_PB
  556. /*
  557. void Update_PB(APTR pbar, BYTE val)
  558. {
  559.         BYTE     i;
  560.  
  561.         for (i=1;i<=100;i++) {
  562.                 Delay(25);
  563.                 //UpdatePBar(pbar,PB_NewValue,i,TAG_DONE);
  564.         }
  565.         //UpdatePBar(pbar,PB_NewValue,val,TAG_DONE);
  566. }*/
  567. ///
  568.  
  569. /// Close_PB
  570. /*
  571. void Close_PB(APTR pbar)
  572. {
  573.         Delay(50);
  574.         //FreePBar(pbar);
  575.         CloseWindow(PBwin);
  576. }*/
  577. ///
  578.  
  579. /// Init
  580. void Init(char *prog_name, char *adv_file, char *save_file)
  581. {
  582.     UWORD   fy_size = 0;
  583.     WORD    s_height,s_width;
  584.     char    data_file[32] = "",data_dir[256] = "";
  585.     char    **font_name = (char **) MemAlloc(sizeof(char *));
  586.     char    **cscreen = (char **) MemAlloc(sizeof(char *));
  587.     FILE    *f;
  588.  
  589.     if (open_libs() == FALSE) {
  590.         close_libs();
  591.         exit(255);
  592.     }
  593.  
  594.     Size_Wins(Get_TT(prog_name,&fy_size,font_name,data_file,data_dir,cscreen));
  595.     if (Options & TRS80_STYLE) Size_Wins(TRUE);
  596.  
  597.     if ((WBscreen = (struct Screen *) LockPubScreen(*cscreen)) == NULL) WBscreen = (struct Screen *) LockPubScreen("Workbench");
  598.     if (WBscreen) {
  599.         if ((WBvisinfo  = (APTR) GetVisualInfo(WBscreen,NULL))) {
  600.  
  601.             s_height   = (WORD) WBscreen->Height;
  602.             s_width    = (WORD) WBscreen->Width;
  603.  
  604.             if (strcmp(adv_file,"") != NULL) {
  605.                 f = Open_File(adv_file);
  606.                 strcpy(data_file,adv_file);
  607.             }
  608.             else f = Get_AdvFile(data_file,data_dir);
  609.  
  610.             //Show_FileList(data_dir);
  611.                 
  612.             Open_Wins(s_width,s_height,Width,fy_size,font_name,*cscreen);
  613.             free(*cscreen);
  614.             free(cscreen);
  615.             
  616.             OutReset();
  617.             OutBuf("AMIGA SCOTT-Free Version 1.52, 7-11/1996\n");
  618.             OutBuf("© Andreas Aumayr, Anden@highnet.co.at\n\n");
  619.             OutBuf("Based on SCOTT-Free UNIX/DOS V1.14b, © Alan Cox\n\n");
  620.             OutBuf("Loading adventure data file ...  ");
  621.  
  622.             LoadDatabase(f,(Options&DEBUGGING)?1:0);
  623.             
  624.             fclose(f);
  625.             OutBuf("Finished.\n\n");
  626.  
  627.             if (SaveRestart()) {
  628.                 OffMenu(act_w_hdl,63649);
  629.                 RESTART = FALSE;
  630.             }
  631.  
  632.             if (strcmp(save_file,"") != NULL) LoadGame(save_file);
  633.             else if (strcmp(save_game,"") != NULL) {
  634.                 Make_FFP(save_game,save_dir);
  635.                 LoadGame(FFP);
  636.             }
  637.             else {
  638.                 strncpy(save_game,data_file,strlen(data_file)-4);
  639.                 strcat(save_game,".save");
  640.             }
  641.             return;
  642.         }
  643.         printf("\nProblems getting Visual Info for screen '%s'!\n",*cscreen);
  644.         close_all();
  645.     }
  646.     printf("\nProblems locking custom screen '%s'\n",*cscreen);
  647.     close_libs();
  648. }///
  649.  
  650. /// Menu_Handle
  651. BOOL Menu_Handle(int code, char *command)
  652. {
  653.     //strcpy(command,"");
  654.     if (MENUNUM(code) != MENUNULL) {
  655.         switch(MENUNUM(code)) {
  656.             case 0:
  657.                 switch(ITEMNUM(code)) {
  658.                     case 0:
  659.                         EasyRequest(NULL,&About,NULL,NULL);
  660.                         return(FALSE);
  661.                         break;
  662.                     case 2:
  663.                         if (AmigaGuideBase) {
  664.                             CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
  665.                         }
  666.                         return(FALSE);
  667.                         break;
  668.                     case 4:
  669.                         if (EasyRequest(NULL,&Quit,NULL,"")) {
  670.                             close_all();
  671.                             exit(0);
  672.                         }
  673.                         return(FALSE);
  674.                         break;
  675.                 }
  676.                 break;
  677.             case 1:
  678.                 switch(ITEMNUM(code)) {
  679.                     case 0:
  680.                         EasyRequest(NULL,&GameInfo,NULL,GameInfoStr);
  681.                         return(FALSE);
  682.                         break;
  683.                     case 2:
  684.                         strcpy(command,"!RESTORE");
  685.                         WriteCON("!RESTORE\n");
  686.                         return(TRUE);
  687.                         break;
  688.                     case 3:
  689.                         strcpy(command,"SAVE GAME");
  690.                         WriteCON("SAVE GAME\n");
  691.                         return(TRUE);
  692.                         break;
  693.                     case 5:
  694.                         LoadRestart();
  695.                         OutReset();
  696.                         WriteCON(CLRSCR);
  697.                         PerformActions(0,0);
  698.                         Look();
  699.                         strcpy(command,"");
  700.                         return(TRUE);
  701.                         break;
  702.                 }
  703.                 break;
  704.             case 2:
  705.                 switch(ITEMNUM(code)) {
  706.                     case 0:
  707.                         strcpy(command,"LOOK");
  708.                         WriteCON("LOOK\n");
  709.                         return(TRUE);
  710.                         break;
  711.                     case 1:
  712.                         strcpy(command,"INVENTORY");
  713.                         WriteCON("INVENTORY\n");
  714.                         return(TRUE);
  715.                         break;
  716.                     case 2:
  717.                         strcpy(command,"GET ALL");
  718.                         WriteCON("GET ALL\n");
  719.                         return(TRUE);
  720.                         break;
  721.                     case 4:
  722.                         strcpy(command,"SCORE");
  723.                         WriteCON("SCORE\n");
  724.                         return(TRUE);
  725.                         break;
  726.                 }
  727.                 break;
  728.         }
  729.     }
  730.     return(FALSE);
  731. }///
  732.  
  733. /// LineInput2
  734. void LineInput2(char *command)
  735. {
  736.     USHORT      code;
  737.     ULONG       class;
  738.     struct      IntuiMessage *mess;
  739.     char        buf[MAX_LL+1],ncom[MAX_LL+1];
  740.     int         len=0,c_pos=0,h_pos=0;
  741.     // struct      AmigaGuideMsg *amsg;
  742.  
  743.     /*while ((amsg = (struct AmigaGuideMsg *) GetAmigaGuideMsg(Guide_hdl))) {
  744.  
  745.         ReplyAmigaGuideMsg(amsg);
  746.     } */
  747.  
  748.     h_pos = hist_pos;
  749.     do {
  750.         WaitPort(act_w_hdl->UserPort);
  751.         while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
  752.             class = mess->Class;
  753.             code  = mess->Code;
  754.             GT_ReplyIMsg(mess);
  755.             switch (class) {
  756.                 case IDCMP_VANILLAKEY:
  757.                     if ((code >=32) && (code <=126)) {
  758.                         if (len < MAX_LL) {
  759.                             if (len != c_pos) {
  760.                                 strcpy(buf,&hist[hist_pos][c_pos]);
  761.                                 hist[hist_pos][c_pos] = code;
  762.                                 hist[hist_pos][c_pos+1] = 0;
  763.                                 strcat(&hist[hist_pos][0],buf);
  764.                                 sprintf(buf,"%s%c",INS_CHAR,code);
  765.                                 WriteCON(buf);
  766.                             }
  767.                             else {
  768.                                 hist[hist_pos][c_pos] = code;
  769.                                 sprintf(buf,"%c",code);
  770.                                 WriteCON(buf);
  771.                             }
  772.                             len++;
  773.                             c_pos++;
  774.                         }
  775.                         break;
  776.                     }
  777.                     switch (code) {
  778.                         case 8:
  779.                             if (c_pos > 0) {
  780.                                 WriteCON(CURSOR_LEFT);
  781.                                 WriteCON(DEL_CHAR);
  782.                                 if (len != c_pos) {
  783.                                     strcpy(buf,&hist[hist_pos][c_pos]);
  784.                                     hist[hist_pos][c_pos-1] = 0;
  785.                                     strcat(&hist[hist_pos][0],buf);
  786.                                 }
  787.                                 c_pos--;
  788.                                 len--;
  789.                             }
  790.                             break;
  791.                         case 127:
  792.                             if ((c_pos > 0) && (c_pos < len)) {
  793.                                 WriteCON(DEL_CHAR);
  794.                                 if (len != c_pos+1) {
  795.                                     strcpy(buf,&hist[hist_pos][c_pos+1]);
  796.                                     hist[hist_pos][c_pos] = 0;
  797.                                     strcat(&hist[hist_pos][0],buf);
  798.                                 }
  799.                                 len--;
  800.                             }
  801.                             break;
  802.                     }
  803.  
  804.                 case IDCMP_RAWKEY:
  805.                     switch (code) {
  806.                         case 10:
  807.                         case 13:
  808.                             hist[hist_pos][len] = 0;
  809.                             strcpy(command,&hist[hist_pos][0]);
  810.                             hist_pos++;
  811.                             if (hist_pos >= MAX_HIST) hist_pos = 0;
  812.                             if (hist_fill < MAX_HIST-1) hist_fill++;
  813.                             WriteCON("\n");
  814.                             return;
  815.                             break;
  816.                         case 76:
  817.                             h_pos--;
  818.                             if (h_pos < 0) h_pos = hist_fill;
  819.                             if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
  820.                             else strcpy(ncom,"");
  821.                             c_pos = len = strlen(ncom);
  822.                             gotoxy(22,BottomHeight);
  823.                             sprintf(buf,"%s%s",CLREOL,ncom);
  824.                             WriteCON(buf);
  825.                             strcpy(&hist[hist_pos][0],ncom);
  826.                             break;
  827.                         case 77:
  828.                             h_pos++;
  829.                             if (h_pos > hist_fill) h_pos = 0;
  830.                             if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
  831.                             else strcpy(ncom,"");
  832.                             c_pos = len = strlen(ncom);
  833.                             gotoxy(22,BottomHeight);
  834.                             sprintf(buf,"%s%s",CLREOL,ncom);
  835.                             WriteCON(buf);
  836.                             strcpy(&hist[hist_pos][0],ncom);
  837.                             break;
  838.                         case 78:
  839.                             if (c_pos < len) {
  840.                                 WriteCON(CURSOR_RIGHT);
  841.                                 c_pos++;
  842.                             }
  843.                             break;
  844.                         case 79:
  845.                             if (c_pos > 0) {
  846.                                 WriteCON(CURSOR_LEFT);
  847.                                 c_pos--;
  848.                             }
  849.                             break;
  850.                         case 95:
  851.                             if (AmigaGuideBase) {
  852.                                 CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
  853.                             }
  854.                             break;
  855.                         default:
  856.                             break;
  857.                     }
  858.                     break;
  859.  
  860.                 case IDCMP_MENUPICK:
  861.                     if (Menu_Handle(code,command)) {
  862.                         strcpy(&hist[hist_pos][0],command);
  863.                         WriteCON(command);
  864.                         hist_pos++;
  865.                         if (hist_pos >= MAX_HIST) hist_pos = 0;
  866.                         if (hist_fill < MAX_HIST-1) hist_fill++;
  867.                         return;
  868.                     }
  869.                     break;
  870.  
  871.                 case IDCMP_CLOSEWINDOW:
  872.                     if (EasyRequest(NULL,&Quit,NULL,NULL)) {
  873.                         close_all();
  874.                         exit(0);
  875.                         return;
  876.                     }
  877.                     break;
  878.             }
  879.         }
  880.     } while (1);
  881. }///
  882.  
  883. ///KeyInput
  884. USHORT KeyInput(void)
  885. {
  886.     USHORT      code;
  887.     ULONG       class;
  888.     struct      IntuiMessage *mess;
  889.  
  890.     do {
  891.         WaitPort(act_w_hdl->UserPort);
  892.         while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
  893.             class = mess->Class;
  894.             code  = mess->Code;
  895.             GT_ReplyIMsg(mess);
  896.             switch (class) {
  897.                 case IDCMP_VANILLAKEY:
  898.                     if ((code >=32) && (code <=126)) return(code);
  899.             }
  900.         }
  901.     } while (1);
  902. }///
  903.  
  904.