mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-27 14:02:19 +00:00
1473 lines
46 KiB
C#
1473 lines
46 KiB
C#
using zword = System.UInt16;
|
|
using zbyte = System.Byte;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
using Frotz;
|
|
using Frotz.Generic;
|
|
using Frotz.Constants;
|
|
using Frotz.Other;
|
|
|
|
using System.Diagnostics;
|
|
|
|
using Frotz.Screen;
|
|
|
|
using FrotzNet.Frotz.Other;
|
|
|
|
namespace Frotz
|
|
{
|
|
|
|
|
|
public static class os_
|
|
{
|
|
public static bool debug_mode = false;
|
|
private static int _historyPos = 0;
|
|
// TODO This really needs to get wired up when a new game is started
|
|
private static List<String> _history = new List<string>();
|
|
|
|
private static void debug(string text)
|
|
{
|
|
if (debug_mode)
|
|
{
|
|
List<string> debugtext = new List<string>();
|
|
if (File.Exists("debug.log"))
|
|
debugtext = new List<string>(File.ReadAllLines("debug.log"));
|
|
debugtext.Add(text);
|
|
File.WriteAllLines("debug.log", debugtext.ToArray());
|
|
}
|
|
}
|
|
|
|
// TODO Rename these
|
|
private static long makeid(byte a, byte b, byte c, byte d)
|
|
{
|
|
return ((long)(((a) << 24) | ((b) << 16) | ((c) << 8) | (d)));
|
|
}
|
|
|
|
private static long makeid(byte[] buffer, int offset)
|
|
{
|
|
return makeid(buffer[offset], buffer[offset + 1], buffer[offset + 2], buffer[offset + 3]);
|
|
}
|
|
|
|
|
|
public static Blorb.Blorb _blorbFile = null; // TODO Make this static again, or something
|
|
|
|
private static IZScreen _screen;
|
|
|
|
public static void SetScreen(IZScreen Screen)
|
|
{
|
|
if (_screen != null)
|
|
{
|
|
_screen.KeyPressed = null;
|
|
}
|
|
|
|
_screen = Screen;
|
|
_screen.KeyPressed = new EventHandler<ZKeyPressEventArgs>(_screen_KeyPressed);
|
|
}
|
|
|
|
private static void addTestKeys()
|
|
{
|
|
//entries.Enqueue(' ');
|
|
//enqueue_word("ne");
|
|
//enqueue_word("look at sundial");
|
|
}
|
|
|
|
static void _screen_KeyPressed(object sender, ZKeyPressEventArgs e)
|
|
{
|
|
entries.Enqueue(e.KeyPressed);
|
|
debug($"Queued character \"{e.KeyPressed}\"");
|
|
}
|
|
private static void OnFatalError(String Message)
|
|
{
|
|
_screen.HandleFatalError(Message);
|
|
debug($"[FATAL ERROR] {Message}");
|
|
}
|
|
|
|
private static void enqueue_word(String word)
|
|
{
|
|
foreach (Char c in word)
|
|
{
|
|
entries.Enqueue(c);
|
|
}
|
|
entries.Enqueue(CharCodes.ZC_RETURN);
|
|
}
|
|
|
|
public static Queue<zword> entries = new Queue<zword>();
|
|
|
|
public static void fail(string message)
|
|
{
|
|
_screen.HandleFatalError(message);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Interface to the Frotz core
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
* os_beep
|
|
*
|
|
* Play a beep sound. Ideally, the sound should be high- (number == 1)
|
|
* or low-pitched (number == 2).
|
|
*
|
|
*/
|
|
public static void beep(int number)
|
|
{
|
|
#if !SILVERLIGHT
|
|
if (number == 1)
|
|
{
|
|
Console.Beep(800, 200);
|
|
}
|
|
else
|
|
{
|
|
Console.Beep(392, 200);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* os_display_char
|
|
*
|
|
* Display a character of the current font using the current colours and
|
|
* text style. The cursor moves to the next position. Printable codes are
|
|
* all ASCII values from 32 to 126, ISO Latin-1 characters from 160 to
|
|
* 255, ZC_GAP (gap between two sentences) and ZC_INDENT (paragraph
|
|
* indentation), and Unicode characters above 255. The screen should not
|
|
* be scrolled after printing to the bottom right corner.
|
|
*
|
|
*/
|
|
public static void display_char(zword c)
|
|
{
|
|
if (c == CharCodes.ZC_INDENT)
|
|
{
|
|
display_char(' ');
|
|
display_char(' ');
|
|
display_char(' ');
|
|
}
|
|
else if (c == CharCodes.ZC_GAP)
|
|
{
|
|
display_char(' ');
|
|
display_char(' ');
|
|
}
|
|
else if (IsValidChar(c))
|
|
{
|
|
_screen.DisplayChar((char)c);
|
|
}
|
|
debug($"Displaying char {(char)c}.");
|
|
}
|
|
|
|
/*
|
|
* os_display_string
|
|
*
|
|
* Pass a string of characters to os_display_char.
|
|
*
|
|
*/
|
|
public static void display_string(zword[] s, int start)
|
|
{
|
|
zword c;
|
|
|
|
for (int i = start; i < s.Length && s[i] != 0; i++)
|
|
{
|
|
c = s[i];
|
|
if (c == CharCodes.ZC_NEW_FONT || c == CharCodes.ZC_NEW_STYLE)
|
|
{
|
|
int arg = s[++i];
|
|
if (c == CharCodes.ZC_NEW_FONT)
|
|
{
|
|
set_font(arg);
|
|
}
|
|
else if (c == CharCodes.ZC_NEW_STYLE)
|
|
{
|
|
set_text_style(arg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
display_char(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void display_string(String s)
|
|
{
|
|
zword[] word = new zword[s.Length];
|
|
for (int i = 0; i < s.Length; i++)
|
|
{
|
|
word[i] = s[i];
|
|
}
|
|
display_string(word, 0);
|
|
}
|
|
|
|
/*
|
|
* os_erase_area
|
|
*
|
|
* Fill a rectangular area of the screen with the current background
|
|
* colour. Top left coordinates are (1,1). The cursor does not move.
|
|
*
|
|
* The final argument gives the window being changed, -1 if only a
|
|
* portion of a window is being erased, or -2 if the whole screen is
|
|
* being erased.
|
|
*
|
|
*/
|
|
public static void erase_area(int top, int left, int bottom, int right, int win)
|
|
{
|
|
if (win == -2)
|
|
{
|
|
_screen.Clear();
|
|
}
|
|
else if (win == 1)
|
|
{
|
|
_screen.ClearArea(top, left, bottom, right);
|
|
}
|
|
else
|
|
{
|
|
_screen.ClearArea(top, left, bottom, right);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_fatal
|
|
*
|
|
* Display error message and stop interpreter.
|
|
*
|
|
*/
|
|
public static void fatal(string s)
|
|
{
|
|
OnFatalError(s);
|
|
}
|
|
|
|
/*
|
|
* os_font_data
|
|
*
|
|
* Return true if the given font is available. The font can be
|
|
*
|
|
* TEXT_FONT
|
|
* PICTURE_FONT
|
|
* GRAPHICS_FONT
|
|
* FIXED_WIDTH_FONT
|
|
*
|
|
* The font size should be stored in "height" and "width". If
|
|
* the given font is unavailable then these values must _not_
|
|
* be changed.
|
|
*
|
|
*/
|
|
public static bool font_data(int font, ref zword height, ref zword width)
|
|
{
|
|
return _screen.GetFontData(font, ref height, ref width);
|
|
}
|
|
|
|
/*
|
|
* os_read_file_name
|
|
*
|
|
* Return the name of a file. Flag can be one of:
|
|
*
|
|
* FILE_SAVE - Save game file
|
|
* FILE_RESTORE - Restore game file
|
|
* FILE_SCRIPT - Transcript file
|
|
* FILE_RECORD - Command file for recording
|
|
* FILE_PLAYBACK - Command file for playback
|
|
* FILE_SAVE_AUX - Save auxiliary ("preferred settings") file
|
|
* FILE_LOAD_AUX - Load auxiliary ("preferred settings") file
|
|
*
|
|
* The length of the file name is limited by MAX_FILE_NAME. Ideally
|
|
* an interpreter should open a file requester to ask for the file
|
|
* name. If it is unable to do that then this function should call
|
|
* print_string and read_string to ask for a file name.
|
|
*
|
|
*/
|
|
public static bool read_file_name(out string file_name, string default_name, FileTypes flag)
|
|
{
|
|
String fileName = "";
|
|
switch (flag)
|
|
{
|
|
case FileTypes.FILE_SAVE:
|
|
fileName = _screen.OpenNewOrExistingFile(FastMem.save_name, "Choose save game file", "Save Files (*.sav)|*.sav", ".sav");
|
|
break;
|
|
case FileTypes.FILE_RESTORE:
|
|
fileName = _screen.OpenExistingFile(FastMem.save_name, "Choose save game to restore", "Save Files (*.sav)|*.sav");
|
|
break;
|
|
case FileTypes.FILE_SCRIPT:
|
|
fileName = _screen.OpenNewOrExistingFile(General.DEFAULT_SCRIPT_NAME, "Choose Script File", "Script File (*.scr)|*.scr", ".scr");
|
|
break;
|
|
case FileTypes.FILE_RECORD:
|
|
fileName = _screen.OpenNewOrExistingFile(default_name, "Choose File to Record To", "Record File(*.rec)|*.rec", ".rec");
|
|
break;
|
|
case FileTypes.FILE_PLAYBACK:
|
|
fileName = _screen.OpenExistingFile(default_name, "Choose File to playback from", "Record File(*.rec)|*.rec");
|
|
break;
|
|
case FileTypes.FILE_SAVE_AUX:
|
|
case FileTypes.FILE_LOAD_AUX:
|
|
fail("Need to implement other types of files");
|
|
break;
|
|
}
|
|
|
|
if (fileName != null)
|
|
{
|
|
file_name = fileName;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
file_name = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_init_screen
|
|
*
|
|
* Initialise the IO interface. Prepare screen and other devices
|
|
* (mouse, sound card). Set various OS depending story file header
|
|
* entries:
|
|
*
|
|
* h_config (aka flags 1)
|
|
* h_flags (aka flags 2)
|
|
* h_screen_cols (aka screen width in characters)
|
|
* h_screen_rows (aka screen height in lines)
|
|
* h_screen_width
|
|
* h_screen_height
|
|
* h_font_height (defaults to 1)
|
|
* h_font_width (defaults to 1)
|
|
* h_default_foreground
|
|
* h_default_background
|
|
* h_interpreter_number
|
|
* h_interpreter_version
|
|
* h_user_name (optional; not used by any game)
|
|
*
|
|
* Finally, set reserve_mem to the amount of memory (in bytes) that
|
|
* should not be used for multiple undo and reserved for later use.
|
|
*
|
|
*/
|
|
public static void init_screen()
|
|
{
|
|
// TODO Really need to clean this up
|
|
|
|
main.h_interpreter_number = 4;
|
|
|
|
// Set the configuration
|
|
if (main.h_version == ZMachine.V3)
|
|
{
|
|
main.h_config |= ZMachine.CONFIG_SPLITSCREEN;
|
|
main.h_config |= ZMachine.CONFIG_PROPORTIONAL;
|
|
// TODO Set Tandy bit here if appropriate
|
|
}
|
|
if (main.h_version >= ZMachine.V4)
|
|
{
|
|
main.h_config |= ZMachine.CONFIG_BOLDFACE;
|
|
main.h_config |= ZMachine.CONFIG_EMPHASIS;
|
|
main.h_config |= ZMachine.CONFIG_FIXED;
|
|
main.h_config |= ZMachine.CONFIG_TIMEDINPUT;
|
|
}
|
|
if (main.h_version >= ZMachine.V5)
|
|
main.h_config |= ZMachine.CONFIG_COLOUR;
|
|
if (main.h_version == ZMachine.V6)
|
|
{
|
|
if (_blorbFile != null)
|
|
{
|
|
main.h_config |= ZMachine.CONFIG_PICTURES;
|
|
main.h_config |= ZMachine.CONFIG_SOUND;
|
|
}
|
|
}
|
|
//theApp.CopyUsername();
|
|
|
|
main.h_interpreter_version = (byte)'F';
|
|
if (main.h_version == ZMachine.V6)
|
|
{
|
|
main.h_default_background = ZColor.BLACK_COLOUR;
|
|
main.h_default_foreground = ZColor.WHITE_COLOUR;
|
|
// TODO Get the defaults from the application itself
|
|
}
|
|
else
|
|
{
|
|
main.h_default_foreground = 1;
|
|
main.h_default_background = 1;
|
|
}
|
|
|
|
// Clear out the input queue incase a quit left characters
|
|
entries.Clear();
|
|
|
|
// TODO Set font to be default fixed width font
|
|
|
|
_metrics = _screen.GetScreenMetrics();
|
|
System.Diagnostics.Debug.WriteLine("Metrics:" + _metrics.WindowSize.Height + ":" + _metrics.WindowSize.Width);
|
|
|
|
// TODO Make these numbers match the types (remove the casts)
|
|
|
|
main.h_screen_width = (zword)_metrics.WindowSize.Width;
|
|
main.h_screen_height = (zword)_metrics.WindowSize.Height;
|
|
|
|
main.h_screen_cols = (zbyte)_metrics.Columns;
|
|
main.h_screen_rows = (zbyte)_metrics.Rows;
|
|
|
|
main.h_font_width = (zbyte)_metrics.FontSize.Width;
|
|
main.h_font_height = (zbyte)_metrics.FontSize.Height;
|
|
|
|
// Check for sound
|
|
if ((main.h_version == ZMachine.V3) && ((main.h_flags & ZMachine.OLD_SOUND_FLAG) != 0))
|
|
{
|
|
// TODO Config sound here if appropriate
|
|
}
|
|
else if ((main.h_version >= ZMachine.V4) && ((main.h_flags & ZMachine.SOUND_FLAG) != 0))
|
|
{
|
|
// TODO Config sound here if appropriate
|
|
}
|
|
|
|
if (main.h_version >= ZMachine.V5)
|
|
{
|
|
ushort mask = 0;
|
|
if (main.h_version == ZMachine.V6) mask |= ZMachine.TRANSPARENT_FLAG;
|
|
|
|
// Mask out any unsupported bits in the extended flags
|
|
main.hx_flags &= mask;
|
|
|
|
// TODO Set fore & back color here if apporpriate
|
|
// hx_fore_colour =
|
|
// hx_back_colour =
|
|
}
|
|
|
|
|
|
String name = main.story_name;
|
|
// Set default filenames
|
|
|
|
FastMem.save_name = String.Format("{0}.sav", name);
|
|
Files.script_name = String.Format("{0}.log", name);
|
|
Files.command_name = String.Format("{0}.rec", name);
|
|
FastMem.auxilary_name = String.Format("{0}.aux", name);
|
|
|
|
addTestKeys();
|
|
}
|
|
|
|
/*
|
|
* os_more_prompt
|
|
*
|
|
* Display a MORE prompt, wait for a keypress and remove the MORE
|
|
* prompt from the screen.
|
|
*
|
|
*/
|
|
public static void more_prompt()
|
|
{
|
|
display_string("[MORE]");
|
|
_screen.RefreshScreen();
|
|
|
|
while (entries.Count == 0)
|
|
{
|
|
//System.Threading.Thread.Sleep(100);
|
|
}
|
|
entries.Dequeue();
|
|
|
|
_screen.RemoveChars(6);
|
|
_screen.RefreshScreen();
|
|
}
|
|
|
|
/*
|
|
* os_process_arguments
|
|
*
|
|
* Handle command line switches. Some variables may be set to activate
|
|
* special features of Frotz:
|
|
*
|
|
* option_attribute_assignment
|
|
* option_attribute_testing
|
|
* option_context_lines
|
|
* option_object_locating
|
|
* option_object_movement
|
|
* option_left_margin
|
|
* option_right_margin
|
|
* option_ignore_errors
|
|
* option_piracy
|
|
* option_undo_slots
|
|
* option_expand_abbreviations
|
|
* option_script_cols
|
|
*
|
|
* The global pointer "story_name" is set to the story file name.
|
|
*
|
|
*/
|
|
public static byte[] preloadedFileData;
|
|
public static bool process_arguments(string[] args)
|
|
{
|
|
byte[] filedata;
|
|
String fileName = null;
|
|
if (preloadedFileData != null)
|
|
{
|
|
main.story_name = "game";
|
|
main.story_data = preloadedFileData;
|
|
}
|
|
else if (args.Length == 0)
|
|
{
|
|
fileName = _screen.SelectGameFile(out filedata);
|
|
if (fileName != null)
|
|
{
|
|
main.story_name = fileName;
|
|
main.story_data = filedata;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
main.story_name = args[0];
|
|
FileStream fs = new FileStream(args[0], FileMode.Open);
|
|
main.story_data = new zbyte[fs.Length];
|
|
fs.Read(main.story_data, 0, main.story_data.Length);
|
|
fs.Close();
|
|
}
|
|
|
|
|
|
Err.err_report_mode = ErrorCodes.ERR_REPORT_NEVER;
|
|
|
|
//'
|
|
//// Set default filenames
|
|
//String filename = main.story_name;
|
|
//var fi = new System.IO.FileInfo(main.story_name);
|
|
//if (fi.Exists)
|
|
//{
|
|
// String name = fi.FullName.Substring(0, fi.FullName.Length - fi.Extension.Length);
|
|
|
|
// FastMem.save_name = String.Format("{0}.sav", name);
|
|
// Files.script_name = String.Format("{0}.log", name);
|
|
// Files.command_name = String.Format("{0}.rec", name);
|
|
// FastMem.auxilary_name = String.Format("{0}.aux", name);
|
|
//}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* os_read_line
|
|
*
|
|
* Read a line of input from the keyboard into a buffer. The buffer
|
|
* may already be primed with some text. In this case, the "initial"
|
|
* text is already displayed on the screen. After the input action
|
|
* is complete, the function returns with the terminating key value.
|
|
* The length of the input should not exceed "max" characters plus
|
|
* an extra 0 terminator.
|
|
*
|
|
* Terminating keys are the return key (13) and all function keys
|
|
* (see the Specification of the Z-machine) which are accepted by
|
|
* the is_terminator function. Mouse clicks behave like function
|
|
* keys except that the mouse position is stored in global variables
|
|
* "mouse_x" and "mouse_y" (top left coordinates are (1,1)).
|
|
*
|
|
* Furthermore, Frotz introduces some special terminating keys:
|
|
*
|
|
* ZC_HKEY_PLAYBACK (Alt-P)
|
|
* ZC_HKEY_RECORD (Alt-R)
|
|
* ZC_HKEY_SEED (Alt-S)
|
|
* ZC_HKEY_UNDO (Alt-U)
|
|
* ZC_HKEY_RESTART (Alt-N, "new game")
|
|
* ZC_HKEY_QUIT (Alt-X, "exit game")
|
|
* ZC_HKEY_DEBUG (Alt-D)
|
|
* ZC_HKEY_HELP (Alt-H)
|
|
*
|
|
* If the timeout argument is not zero, the input gets interrupted
|
|
* after timeout/10 seconds (and the return value is 0).
|
|
*
|
|
* The complete input line including the cursor must fit in "width"
|
|
* screen units.
|
|
*
|
|
* The function may be called once again to continue after timeouts,
|
|
* misplaced mouse clicks or hot keys. In this case the "continued"
|
|
* flag will be set. This information can be useful if the interface
|
|
* implements input line history.
|
|
*
|
|
* The screen is not scrolled after the return key was pressed. The
|
|
* cursor is at the end of the input line when the function returns.
|
|
*
|
|
* Since Frotz 2.2 the helper function "completion" can be called
|
|
* to implement word completion (similar to tcsh under Unix).
|
|
*
|
|
*/
|
|
public static zword read_line(int max, zword[] buf, int timeout, int width, bool continued)
|
|
{
|
|
|
|
// ZC_SINGLE_CLICK || ZC_DOUBLE_CLICK
|
|
|
|
// case VK_DELETE:
|
|
// case VK_HOME:
|
|
// case VK_END:
|
|
// case VK_TAB:
|
|
|
|
List<BufferChars> _buffer = new List<BufferChars>();
|
|
|
|
_screen.RefreshScreen();
|
|
|
|
for (int i = 0; i < buf.Length; i++)
|
|
{
|
|
buf[i] = 0;
|
|
}
|
|
|
|
int background;
|
|
int foreground;
|
|
|
|
_screen.GetColor(out foreground, out background);
|
|
_screen.SetInputColor();
|
|
|
|
_screen.SetInputMode(true, true);
|
|
|
|
ZPoint p = _screen.GetCursorPosition();
|
|
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
if (main.abort_game_loop == true)
|
|
{
|
|
return CharCodes.ZC_RETURN;
|
|
}
|
|
|
|
while (entries.Count == 0)
|
|
{
|
|
if (main.abort_game_loop == true)
|
|
{
|
|
return CharCodes.ZC_RETURN;
|
|
}
|
|
|
|
//System.Threading.Thread.Sleep(10);
|
|
}
|
|
zword c = entries.Dequeue();
|
|
|
|
switch (c)
|
|
{
|
|
case CharCodes.ZC_HKEY_HELP:
|
|
case CharCodes.ZC_HKEY_DEBUG:
|
|
case CharCodes.ZC_HKEY_PLAYBACK:
|
|
case CharCodes.ZC_HKEY_RECORD:
|
|
|
|
case CharCodes.ZC_HKEY_SEED:
|
|
case CharCodes.ZC_HKEY_UNDO:
|
|
case CharCodes.ZC_HKEY_RESTART:
|
|
case CharCodes.ZC_HKEY_QUIT:
|
|
return c;
|
|
}
|
|
|
|
if (c == CharCodes.ZC_SINGLE_CLICK || c == CharCodes.ZC_DOUBLE_CLICK)
|
|
{
|
|
// Just discard mouse clicks here
|
|
continue;
|
|
}
|
|
else if (c == CharCodes.ZC_ARROW_UP)
|
|
{
|
|
clearInputAndShowHistory(1, _buffer);
|
|
}
|
|
else if (c == CharCodes.ZC_ARROW_DOWN)
|
|
{
|
|
clearInputAndShowHistory(-1, _buffer);
|
|
}
|
|
else if (c == CharCodes.ZC_ARROW_LEFT)
|
|
{
|
|
}
|
|
else if (c == CharCodes.ZC_ARROW_RIGHT)
|
|
{
|
|
}
|
|
else if (c == CharCodes.ZC_RETURN || c == '\n' || c == '\r')
|
|
{
|
|
var sb = new System.Text.StringBuilder();
|
|
|
|
foreach (BufferChars bc in _buffer)
|
|
{
|
|
sb.Append((char)bc.Char);
|
|
}
|
|
_history.Insert(0, sb.ToString());
|
|
_historyPos = 0;
|
|
return CharCodes.ZC_RETURN;
|
|
}
|
|
else if (c == CharCodes.ZC_BACKSPACE)
|
|
{
|
|
if (_buffer.Count > 0)
|
|
{
|
|
BufferChars bc = _buffer[_buffer.Count - 1];
|
|
_buffer.Remove(bc);
|
|
|
|
p.X -= bc.Width;
|
|
_screen.SetCursorPosition(p.X, p.Y);
|
|
|
|
_screen.RemoveChars(1);
|
|
_screen.RefreshScreen();
|
|
}
|
|
}
|
|
else if (c == '\t')
|
|
{
|
|
var sb = new System.Text.StringBuilder();
|
|
|
|
foreach (BufferChars bc in _buffer)
|
|
{
|
|
sb.Append((char)bc.Char);
|
|
}
|
|
|
|
String temp = sb.ToString();
|
|
String word;
|
|
int result = Text.completion(temp, out word);
|
|
if (result == 0)
|
|
{
|
|
foreach (char c1 in word)
|
|
{
|
|
entries.Enqueue(c1);
|
|
}
|
|
entries.Enqueue(' ');
|
|
}
|
|
else if (result == 1)
|
|
{
|
|
beep(0);
|
|
}
|
|
else
|
|
{
|
|
beep(1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// buf[pos++] = c;
|
|
|
|
int w = _screen.GetStringWidth(((char)c).ToString(), new CharDisplayInfo(ZFont.TEXT_FONT, ZStyles.NORMAL_STYLE, -1, -1));
|
|
p.X += w;
|
|
_screen.SetCursorPosition(p.X, p.Y);
|
|
|
|
_buffer.Add(new BufferChars(c, w));
|
|
|
|
_screen.addInputChar((char)c);
|
|
|
|
_screen.RefreshScreen();
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_screen.SetColor(foreground, background);
|
|
_screen.SetInputMode(false, false);
|
|
|
|
for (int i = 0; i < _buffer.Count; i++)
|
|
{
|
|
buf[i] = _buffer[i].Char;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void clearInputAndShowHistory(int direction, List<BufferChars> _buffer)
|
|
{
|
|
if (direction > 0)
|
|
{
|
|
if (_historyPos + direction > _history.Count)
|
|
{
|
|
beep(0);
|
|
return;
|
|
}
|
|
_historyPos++;
|
|
}
|
|
|
|
if (direction < 0)
|
|
{
|
|
if (_historyPos + direction < 0)
|
|
{
|
|
beep(0);
|
|
return;
|
|
}
|
|
_historyPos--;
|
|
}
|
|
|
|
// TODO Check if it's in bounds, and show history. If it would be out of bounds, beep!
|
|
for (int i = 0; i < _buffer.Count; i++)
|
|
{
|
|
entries.Enqueue(CharCodes.ZC_BACKSPACE);
|
|
}
|
|
|
|
if (_historyPos > 0)
|
|
{
|
|
String temp = _history[_historyPos - 1];
|
|
foreach (char c1 in temp)
|
|
{
|
|
entries.Enqueue(c1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool _setCursorPositionCalled = false;
|
|
static ZPoint _newCursorPosition = new ZPoint(0, 0);
|
|
|
|
/*
|
|
* os_read_key
|
|
*
|
|
* Read a single character from the keyboard (or a mouse click) and
|
|
* return it. Input aborts after timeout/10 seconds.
|
|
*
|
|
*/
|
|
public static zword read_key(int timeout, bool cursor)
|
|
{
|
|
_screen.RefreshScreen();
|
|
|
|
_screen.SetInputMode(true, true);
|
|
|
|
if (_setCursorPositionCalled == false)
|
|
{
|
|
set_cursor(_newCursorPosition.Y, _newCursorPosition.X);
|
|
}
|
|
|
|
ZPoint p = _screen.GetCursorPosition();
|
|
|
|
try
|
|
{
|
|
//#if SILVERLIGHT
|
|
|
|
// var sw = new WiredPrairie.Silverlight.Stopwatch();
|
|
//#else
|
|
// System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
|
|
//#endif
|
|
// sw.Start();
|
|
while (true)
|
|
{
|
|
do
|
|
{
|
|
if (main.abort_game_loop == true)
|
|
{
|
|
return CharCodes.ZC_RETURN;
|
|
}
|
|
|
|
lock (entries)
|
|
{
|
|
|
|
if (entries.Count > 0) break;
|
|
//if (sw.Elapsed.TotalSeconds > timeout / 10 && timeout > 0)
|
|
// return CharCodes.ZC_TIME_OUT;
|
|
}
|
|
//System.Threading.Thread.Sleep(10);
|
|
|
|
} while (true);
|
|
|
|
lock (entries)
|
|
{
|
|
_setCursorPositionCalled = false;
|
|
zword c = entries.Dequeue();
|
|
|
|
int width = _screen.GetStringWidth(((char)c).ToString(),
|
|
new CharDisplayInfo(ZFont.FIXED_WIDTH_FONT, ZStyles.NORMAL_STYLE, 1, 1));
|
|
// _screen.SetCursorPosition(p.X + width, p.Y);
|
|
|
|
_newCursorPosition = new ZPoint(p.X + width, p.Y);
|
|
|
|
return c;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_screen.SetInputMode(false, false);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* os_read_mouse
|
|
*
|
|
* Store the mouse position in the global variables "mouse_x" and
|
|
* "mouse_y", the code of the last clicked menu in "menu_selected"
|
|
* and return the mouse buttons currently pressed.
|
|
*
|
|
*/
|
|
internal static zword read_mouse()
|
|
{
|
|
// return 0;
|
|
os_.fail("Need to implement mouse handling");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* os_menu
|
|
*
|
|
* Add to or remove a menu item. Action can be:
|
|
* MENU_NEW - Add a new menu with the given title
|
|
* MENU_ADD - Add a new menu item with the given text
|
|
* MENU_REMOVE - Remove the menu at the given index
|
|
*
|
|
*/
|
|
public static void menu(int action, int menu, zword[] text)
|
|
{
|
|
fail("os_menu not yet handled");
|
|
}
|
|
|
|
|
|
/*
|
|
* os_reset_screen
|
|
*
|
|
* Reset the screen before the program ends.
|
|
*
|
|
*/
|
|
public static void reset_screen()
|
|
{
|
|
_screen.Clear();
|
|
|
|
set_text_style(0);
|
|
|
|
_screen.RefreshScreen();
|
|
}
|
|
|
|
/*
|
|
* os_scroll_area
|
|
*
|
|
* Scroll a rectangular area of the screen up (units > 0) or down
|
|
* (units < 0) and fill the empty space with the current background
|
|
* colour. Top left coordinates are (1,1). The cursor stays put.
|
|
*
|
|
*/
|
|
public static void scroll_area(int top, int left, int bottom, int right, int units)
|
|
{
|
|
// TODO This version can scroll better
|
|
|
|
if (left > 1 || right < _metrics.Rows)
|
|
{
|
|
_screen.ScrollArea(top, bottom, left, right, units);
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Debug.Assert(units > 0);
|
|
_screen.ScrollLines(top, bottom - top + 1, units);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_set_colour
|
|
*
|
|
* Set the foreground and background colours which can be:
|
|
*
|
|
* 1
|
|
* BLACK_COLOUR
|
|
* RED_COLOUR
|
|
* GREEN_COLOUR
|
|
* YELLOW_COLOUR
|
|
* BLUE_COLOUR
|
|
* MAGENTA_COLOUR
|
|
* CYAN_COLOUR
|
|
* WHITE_COLOUR
|
|
* TRANSPARENT_COLOUR
|
|
*
|
|
* Amiga only:
|
|
*
|
|
* LIGHTGREY_COLOUR
|
|
* MEDIUMGREY_COLOUR
|
|
* DARKGREY_COLOUR
|
|
*
|
|
* There may be more colours in the range from 16 to 255; see the
|
|
* remarks about os_peek_colour.
|
|
*
|
|
*/
|
|
public static void set_colour(int new_foreground, int new_background)
|
|
{
|
|
_screen.SetColor(new_foreground, new_background);
|
|
}
|
|
|
|
/*
|
|
* os_from_true_culour
|
|
*
|
|
* Given a true colour, return an appropriate colour index.
|
|
*
|
|
*/
|
|
public static zword from_true_colour(zword colour)
|
|
{
|
|
return TrueColorStuff.GetColourIndex(TrueColorStuff.RGB5ToTrue(colour));
|
|
}
|
|
|
|
/*
|
|
* os_to_true_colour
|
|
*
|
|
* Given a colour index, return the appropriate true colour.
|
|
*
|
|
*/
|
|
public static zword to_true_colour(int index)
|
|
{
|
|
return TrueColorStuff.TrueToRGB5(TrueColorStuff.GetColour(index));
|
|
}
|
|
|
|
/*
|
|
* os_set_cursor
|
|
*
|
|
* Place the text cursor at the given coordinates. Top left is (1,1).
|
|
*
|
|
*/
|
|
public static void set_cursor(int row, int col)
|
|
{
|
|
_setCursorPositionCalled = true;
|
|
// TODO Need to migrate these variables to a better location
|
|
_screen.SetCursorPosition(col, row);
|
|
}
|
|
|
|
/*
|
|
* os_set_font
|
|
*
|
|
* Set the font for text output. The interpreter takes care not to
|
|
* choose fonts which aren't supported by the interface.
|
|
*
|
|
*/
|
|
public static void set_font(int new_font)
|
|
{
|
|
_screen.SetFont(new_font);
|
|
}
|
|
|
|
/*
|
|
* os_set_text_style
|
|
*
|
|
* Set the current text style. Following flags can be set:
|
|
*
|
|
* REVERSE_STYLE
|
|
* BOLDFACE_STYLE
|
|
* EMPHASIS_STYLE (aka underline aka italics)
|
|
* FIXED_WIDTH_STYLE
|
|
*
|
|
*/
|
|
public static void set_text_style(int new_style)
|
|
{
|
|
_screen.SetTextStyle(new_style);
|
|
}
|
|
|
|
/*
|
|
* os_string_width
|
|
*
|
|
* Calculate the length of a word in screen units. Apart from letters,
|
|
* the word may contain special codes:
|
|
*
|
|
* ZC_NEW_STYLE - next character is a new text style
|
|
* ZC_NEW_FONT - next character is a new font
|
|
*
|
|
*/
|
|
public static int string_width(zword[] s)
|
|
{
|
|
return string_width(s, 0);
|
|
}
|
|
|
|
public static int string_width(zword[] s, int pos)
|
|
{
|
|
var sb = new System.Text.StringBuilder();
|
|
int font = -1;
|
|
int style = -1;
|
|
|
|
bool lateChange = false; // TODO This is testing code to determine if there are ever font changes mid word
|
|
zword c;
|
|
int width = 0;
|
|
for (int i = pos; i < s.Length && s[i] != 0; i++)
|
|
{
|
|
c = s[i];
|
|
if (c == CharCodes.ZC_NEW_FONT || c == CharCodes.ZC_NEW_STYLE)
|
|
{
|
|
i++;
|
|
if (width == 0)
|
|
{
|
|
if (c == CharCodes.ZC_NEW_FONT) font = s[i];
|
|
if (c == CharCodes.ZC_NEW_STYLE) style = s[i];
|
|
}
|
|
else
|
|
{
|
|
lateChange = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sb.Append((char)c);
|
|
width++;
|
|
if (lateChange == true)
|
|
{
|
|
// _screen.DisplayMessage("Characters after a late change!", "Message");
|
|
}
|
|
}
|
|
}
|
|
|
|
int temp = _screen.GetStringWidth(sb.ToString(), new CharDisplayInfo(font, style, 0, 0));
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
/*
|
|
* os_char_width
|
|
*
|
|
* Return the length of the character in screen units.
|
|
*
|
|
*/
|
|
public static int char_width(zword c)
|
|
{
|
|
return _metrics.FontSize.Width;
|
|
}
|
|
|
|
/*
|
|
* os_check_unicode
|
|
*
|
|
* Return with bit 0 set if the Unicode character can be
|
|
* displayed, and bit 1 if it can be input.
|
|
*
|
|
*
|
|
*/
|
|
public static zword check_unicode(int font, zword c)
|
|
{
|
|
// TODO Just return 1 since almost all modern fonts should be able to handle this
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* os_peek_colour
|
|
*
|
|
* Return the colour of the screen unit below the cursor. (If the
|
|
* interface uses a text mode, it may return the background colour
|
|
* of the character at the cursor position instead.) This is used
|
|
* when text is printed on top of pictures. Note that this coulor
|
|
* need not be in the standard set of Z-machine colours. To handle
|
|
* this situation, Frotz entends the colour scheme: Colours above
|
|
* 15 (and below 256) may be used by the interface to refer to non
|
|
* standard colours. Of course, os_set_colour must be able to deal
|
|
* with these colours.
|
|
*
|
|
*/
|
|
public static zword peek_colour()
|
|
{
|
|
return _screen.PeekColor();
|
|
}
|
|
|
|
/*
|
|
* os_picture_data
|
|
*
|
|
* Return true if the given picture is available. If so, store the
|
|
* picture width and height in the appropriate variables. Picture
|
|
* number 0 is a special case: Write the highest legal picture number
|
|
* and the picture file release number into the height and width
|
|
* variables respectively when this picture number is asked for.
|
|
*
|
|
*/
|
|
public static bool picture_data(int picture, out int height, out int width)
|
|
{
|
|
if (_blorbFile != null)
|
|
{
|
|
if (picture == 0)
|
|
{
|
|
height = -1;
|
|
width = -_blorbFile.ReleaseNumber;
|
|
foreach (var p in _blorbFile.Pictures.Keys)
|
|
{
|
|
if (p > height)
|
|
{
|
|
height = p;
|
|
width = _blorbFile.ReleaseNumber;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
byte[] buffer = _blorbFile.Pictures[picture].Image;
|
|
if (buffer.Length == 8)
|
|
{ // TODO This is a bit of a hack, it would be better to handle this upfront so there is no guess work
|
|
width = (int)makeid(buffer, 0) * _metrics.Scale;
|
|
height = (int)makeid(buffer, 4) * _metrics.Scale;
|
|
}
|
|
else
|
|
{
|
|
ZSize size = _screen.GetImageInfo(buffer);
|
|
height = size.Height;
|
|
width = size.Width;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
height = 0;
|
|
width = 0;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* os_draw_picture
|
|
*
|
|
* Display a picture at the given coordinates.
|
|
*
|
|
*/
|
|
public static void draw_picture(int picture, int y, int x)
|
|
{
|
|
if (_blorbFile != null && _blorbFile.Pictures.ContainsKey(picture))
|
|
{
|
|
_screen.DrawPicture(picture, _blorbFile.Pictures[picture].Image, y, x);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_random_seed
|
|
*
|
|
* Return an appropriate random seed value in the range from 0 to
|
|
* 32767, possibly by using the current system time.
|
|
*
|
|
*/
|
|
public static int random_seed()
|
|
{
|
|
if (DebugState.IsActive)
|
|
{
|
|
return DebugState.RandomSeed();
|
|
}
|
|
else
|
|
{
|
|
System.Random r = new System.Random();
|
|
return r.Next() & 32767;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_restart_game
|
|
*
|
|
* This routine allows the interface to interfere with the process of
|
|
* restarting a game at various stages:
|
|
*
|
|
* RESTART_BEGIN - restart has just begun
|
|
* RESTART_WPROP_SET - window properties have been initialised
|
|
* RESTART_END - restart is complete
|
|
*
|
|
*/
|
|
public static void restart_game(int stage)
|
|
{
|
|
// Show Beyond Zork's title screen
|
|
if ((stage == ZMachine.RESTART_BEGIN) && (main.story_id == Story.BEYOND_ZORK))
|
|
{
|
|
int w, h;
|
|
if (os_.picture_data(1, out h, out w))
|
|
{
|
|
|
|
os_.draw_picture(1, 1, 1);
|
|
os_.read_key(0, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_path_open
|
|
*
|
|
* Open a file in the current directory.
|
|
* -- Szurgot: Changed this to return a Memory stream, and also has Blorb Logic.. May need to refine
|
|
* -- Changed this again to take a byte[] to allow the data to be loaded further up the chain
|
|
*/
|
|
public static MemoryStream path_open(byte[] story_data)
|
|
{
|
|
// System.IO.FileInfo fi = new System.IO.FileInfo(FileName);
|
|
if (story_data.Length < 4)
|
|
{
|
|
throw new ArgumentException("story_data isn't long enough");
|
|
}
|
|
else
|
|
{
|
|
if (story_data[0] == (char)'F' && story_data[1] == (byte)'O' &&
|
|
story_data[2] == (byte)'R' && story_data[3] == (byte)'M') {
|
|
_blorbFile = Blorb.BlorbReader.ReadBlorbFile(story_data);
|
|
|
|
return new System.IO.MemoryStream(_blorbFile.ZCode);
|
|
}
|
|
else
|
|
{
|
|
//FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
|
|
//byte[] buffer = new byte[fs.Length];
|
|
//fs.Read(buffer, 0, buffer.Length);
|
|
//fs.Close();
|
|
|
|
#if !SILVERLIGHT
|
|
String temp = Path.ChangeExtension(main.story_name, "blb");
|
|
_blorbFile = null;
|
|
|
|
if (File.Exists(temp))
|
|
{
|
|
var s = File.OpenRead(temp);
|
|
byte[] buffer = new zbyte[s.Length];
|
|
s.Read(buffer, 0, buffer.Length);
|
|
s.Close();
|
|
var tempB = Blorb.BlorbReader.ReadBlorbFile(buffer);
|
|
_blorbFile = tempB;
|
|
}
|
|
#endif
|
|
return new MemoryStream(story_data);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_finish_with_sample
|
|
*
|
|
* Remove the current sample from memory (if any).
|
|
*
|
|
*/
|
|
public static void finish_with_sample(int number)
|
|
{
|
|
_screen.FinishWithSample(number);
|
|
}
|
|
|
|
/*
|
|
* os_prepare_sample
|
|
*
|
|
* Load the given sample from the disk.
|
|
*
|
|
*/
|
|
public static void prepare_sample(int number)
|
|
{
|
|
_screen.PrepareSample(number);
|
|
}
|
|
|
|
/*
|
|
* os_start_sample
|
|
*
|
|
* Play the given sample at the given volume (ranging from 1 to 8 and
|
|
* 255 meaning a default volume). The sound is played once or several
|
|
* times in the background (255 meaning forever). The end_of_sound
|
|
* function is called as soon as the sound finishes, passing in the
|
|
* eos argument.
|
|
*
|
|
*/
|
|
public static void start_sample(int number, int volume, int repeats, zword eos)
|
|
{
|
|
// TODO Refine this a little better to wait for the end and then trigger
|
|
_screen.StartSample(number, volume, repeats, eos);
|
|
|
|
Sound.end_of_sound(eos);
|
|
}
|
|
|
|
/*
|
|
* os_stop_sample
|
|
*
|
|
* Turn off the current sample.
|
|
*
|
|
*/
|
|
public static void stop_sample(int number)
|
|
{
|
|
_screen.StopSample(number);
|
|
}
|
|
|
|
/*
|
|
* os_scrollback_char
|
|
*
|
|
* Write a character to the scrollback buffer.
|
|
*
|
|
*/
|
|
public static void scrollback_char(zword c)
|
|
{
|
|
// TODO Implement scrollback
|
|
}
|
|
|
|
/*
|
|
* os_scrollback_erase
|
|
*
|
|
* Remove characters from the scrollback buffer.
|
|
*
|
|
*/
|
|
public static void scrollback_erase(int erase)
|
|
{
|
|
// TODO Implement scrollback
|
|
}
|
|
|
|
/*
|
|
* os_tick
|
|
*
|
|
* Called after each opcode.
|
|
*
|
|
*/
|
|
static int os_tick_count = 0;
|
|
public static void tick()
|
|
{
|
|
// Check for completed sounds
|
|
if (++os_tick_count > 1000)
|
|
{
|
|
os_tick_count = 0;
|
|
// TODO Implement sound at some point :)
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_buffer_screen
|
|
*
|
|
* Set the screen buffering mode, and return the previous mode.
|
|
* Possible values for mode are:
|
|
*
|
|
* 0 - update the display to reflect changes when possible
|
|
* 1 - do not update the display
|
|
* -1 - redraw the screen, do not change the mode
|
|
*
|
|
*/
|
|
public static int buffer_screen(int mode)
|
|
{
|
|
fail("os_buffer_screen is not yet implemented");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* os_wrap_window
|
|
*
|
|
* Return non-zero if the window should have text wrapped.
|
|
*
|
|
*/
|
|
public static int wrap_window(int win)
|
|
{
|
|
bool shouldWrap = _screen.ShouldWrap();
|
|
if (shouldWrap == true)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* os_window_height
|
|
*
|
|
* Called when the height of a window is changed.
|
|
*
|
|
*/
|
|
public static void set_window_size(int win, Frotz.Other.ZWindow wp)
|
|
{
|
|
_screen.SetWindowSize(win, wp.y_pos, wp.x_pos, wp.y_size, wp.x_size);
|
|
}
|
|
|
|
/*
|
|
* set_active_window
|
|
* Called to set the output window (I hope)
|
|
*
|
|
*/
|
|
public static void set_active_window(int win)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine("Setting Window:" + win);
|
|
_screen.SetActiveWindow(win);
|
|
}
|
|
|
|
// New Variables go here //
|
|
private static ScreenMetrics _metrics;
|
|
|
|
private static bool IsValidChar(zword c)
|
|
{
|
|
if (c >= CharCodes.ZC_ASCII_MIN && c <= CharCodes.ZC_ASCII_MAX)
|
|
return true;
|
|
if (c >= CharCodes.ZC_LATIN1_MIN && c <= CharCodes.ZC_LATIN1_MAX)
|
|
return true;
|
|
if (c >= 0x100)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public static void game_started()
|
|
{
|
|
_screen.StoryStarted(main.story_name, _blorbFile);
|
|
}
|
|
|
|
public static void mouse_moved(int x, int y) {
|
|
main.mouse_x = (ushort)x;
|
|
main.mouse_y = (ushort)y;
|
|
|
|
}
|
|
|
|
public static byte[] GetStoryFile()
|
|
{
|
|
return FastMem.storyData;
|
|
}
|
|
}
|
|
|
|
internal class BufferChars
|
|
{
|
|
internal ushort Char { get; private set; }
|
|
internal int Width { get; private set; }
|
|
|
|
internal BufferChars(ushort Char, int Width)
|
|
{
|
|
this.Char = Char;
|
|
this.Width = Width;
|
|
}
|
|
}
|
|
}
|