Initial commit

engines/glk/scott/seas_of_blood.cpp

@@ -0,0 +1,859 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * Based on ScottFree interpreter version 1.14 developed by Swansea
+ * University Computer Society without disassembly of any other game
+ * drivers, only of game databases as permitted by EEC law (for purposes
+ * of compatibility).
+ *
+ * Licensed under GPLv2
+ *
+ * https://github.com/angstsmurf/spatterlight/tree/master/terps/scott
+ */
+
+#include "glk/scott/scott.h"
+#include "glk/scott/saga_draw.h"
+#include "glk/scott/resource.h"
+#include "glk/scott/decompress_text.h"
+#include "glk/scott/seas_of_blood.h"
+
+namespace Glk {
+namespace Scott {
+
+#define VICTORY 0
+#define LOSS 1
+#define DRAW 2
+#define FLEE 3
+#define ERROR 99
+
+int getEnemyStats(int *strike, int *stamina, int *boatFlag);
+void battleLoop(int enemy, int strike, int stamina, int boatFlag);
+void swapStaminaAndCrewStrength(void);
+void bloodBattle(void);
+
+void adventureSheet(void) {
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(_G(_bottomWindow)));
+	g_scott->glk_set_style(style_Preformatted);
+	g_scott->output("\nADVENTURE SHEET\n\n");
+	g_scott->output("SKILL      :");
+	g_scott->outputNumber(9);
+	g_scott->output("      STAMINA      :");
+	g_scott->outputNumber(_G(_counters)[3]);
+	g_scott->output("\nLOG        :");
+	g_scott->outputNumber(_G(_counters)[6]);
+	if (_G(_counters)[6] < 10)
+		g_scott->output("      PROVISIONS   :");
+	else
+		g_scott->output("     PROVISIONS   :"); // one less space!
+	g_scott->outputNumber(_G(_counters)[5]);
+	g_scott->output("\nCREW STRIKE:");
+	g_scott->outputNumber(9);
+	g_scott->output("      CREW STRENGTH:");
+	g_scott->outputNumber(_G(_counters)[7]);
+	g_scott->output("\n\n * * * * * * * * * * * * * * * * * * * * *\n\n");
+	g_scott->listInventory();
+	g_scott->output("\n");
+	g_scott->glk_set_style(style_Normal);
+}
+
+void bloodAction(int p) {
+	switch (p) {
+	case 0:
+		break;
+	case 1:
+		// Update LOG
+		_G(_counters)[6]++;
+		break;
+	case 2:
+		// Battle
+		g_scott->look();
+		g_scott->output("You are attacked \n");
+		g_scott->output("<HIT ENTER> \n");
+		g_scott->hitEnter();
+		bloodBattle();
+		break;
+	default:
+		error("bloodAction: Unhandled special action %d", p);
+		break;
+	}
+}
+
+void mirrorLeftHalf(void) {
+	for (int line = 0; line < 12; line++) {
+		for (int col = 32; col > 16; col--) {
+			_G(_buffer)[line * 32 + col - 1][8] = _G(_buffer)[line * 32 + (32 - col)][8];
+			for (int pixrow = 0; pixrow < 8; pixrow++)
+				_G(_buffer)[line * 32 + col - 1][pixrow] = _G(_buffer)[line * 32 + (32 - col)][pixrow];
+			flip(_G(_buffer)[line * 32 + col - 1]);
+		}
+	}
+}
+
+void replaceColour(uint8_t before, uint8_t after) {
+
+	// I don't think any of the data has bit 7 set,
+	// so masking it is probably unnecessary, but this is what
+	// the original code does.
+	uint8_t beforeink = before & 7;
+	uint8_t afterink = after & 7;
+	uint8_t inkmask = 0x07;
+
+	uint8_t beforepaper = beforeink << 3;
+	uint8_t afterpaper = afterink << 3;
+	uint8_t papermask = 0x38;
+
+	for (int j = 0; j < 384; j++) {
+		if ((_G(_buffer)[j][8] & inkmask) == beforeink) {
+			_G(_buffer)[j][8] = (_G(_buffer)[j][8] & ~inkmask) | afterink;
+		}
+
+		if ((_G(_buffer)[j][8] & papermask) == beforepaper) {
+			_G(_buffer)[j][8] = (_G(_buffer)[j][8] & ~papermask) | afterpaper;
+		}
+	}
+}
+
+void drawColour(uint8_t x, uint8_t y, uint8_t colour, uint8_t length) {
+	for (int i = 0; i < length; i++) {
+		_G(_buffer)[y * 32 + x + i][8] = colour;
+	}
+}
+
+void makeLight(void) {
+	for (int i = 0; i < 384; i++) {
+		_G(_buffer)[i][8] = _G(_buffer)[i][8] | 0x40;
+	}
+}
+
+void flipImage(void) {
+
+	uint8_t mirror[384][9];
+
+	for (int line = 0; line < 12; line++) {
+		for (int col = 32; col > 0; col--) {
+			for (int pixrow = 0; pixrow < 9; pixrow++)
+				mirror[line * 32 + col - 1][pixrow] = _G(_buffer)[line * 32 + (32 - col)][pixrow];
+			flip(mirror[line * 32 + col - 1]);
+		}
+	}
+
+	memcpy(_G(_buffer), mirror, 384 * 9);
+}
+
+void drawObjectImage(uint8_t x, uint8_t y) {
+	for (int i = 0; i < _G(_gameHeader)->_numItems; i++) {
+		if (_G(_items)[i]._flag != MY_LOC)
+			continue;
+		if (_G(_items)[i]._location != MY_LOC)
+			continue;
+		drawSagaPictureAtPos(_G(_items)[i]._image, x, y);
+		_G(_shouldDrawObjectImages) = 0;
+	}
+}
+
+void drawBlood(int loc) {
+	memset(_G(_buffer), 0, 384 * 9);
+	uint8_t *ptr = _G(_bloodImageData);
+	for (int i = 0; i < loc; i++) {
+		while (*(ptr) != 0xff)
+			ptr++;
+		ptr++;
+	}
+	while (ptr < _G(_bloodImageData) + 2010) {
+		switch (*ptr) {
+		case 0xff:
+			if (loc == 13) {
+				_G(_buffer)[8 * 32 + 18][8] = _G(_buffer)[8 * 32 + 18][8] & ~0x40;
+				_G(_buffer)[8 * 32 + 17][8] = _G(_buffer)[8 * 32 + 17][8] & ~0x40;
+
+				_G(_buffer)[8 * 32 + 9][8] = _G(_buffer)[8 * 32 + 9][8] & ~0x40;
+				_G(_buffer)[8 * 32 + 10][8] = _G(_buffer)[8 * 32 + 10][8] & ~0x40;
+			}
+			return;
+		case 0xfe:
+			mirrorLeftHalf();
+			break;
+		case 0xfD:
+			replaceColour(*(ptr + 1), *(ptr + 2));
+			ptr += 2;
+			break;
+		case 0xfc: // Draw colour: x, y, attribute, length
+			drawColour(*(ptr + 1), *(ptr + 2), *(ptr + 3), *(ptr + 4));
+			ptr = ptr + 4;
+			break;
+		case 0xfb: // Make all screen colours bright
+			makeLight();
+			break;
+		case 0xfa: // Flip entire image horizontally
+			flipImage();
+			break;
+		case 0xf9: // Draw object image (if present) at x, y
+			drawObjectImage(*(ptr + 1), *(ptr + 2));
+			ptr = ptr + 2;
+			break;
+		default: // else draw image *ptr at x, y
+			drawSagaPictureAtPos(*ptr, *(ptr + 1), *(ptr + 2));
+			ptr = ptr + 2;
+		}
+		ptr++;
+	}
+}
+
+void seasOfBloodRoomImage(void) {
+	_G(_shouldDrawObjectImages) = 1;
+	drawBlood(MY_LOC);
+	for (int ct = 0; ct <= _G(_gameHeader)->_numItems; ct++)
+		if (_G(_items)[ct]._image && _G(_shouldDrawObjectImages)) {
+			if ((_G(_items)[ct]._flag & 127) == MY_LOC && _G(_items)[ct]._location == MY_LOC) {
+				g_scott->drawImage(_G(_items)[ct]._image);
+			}
+		}
+	drawSagaPictureFromBuffer();
+}
+
+//static void SOBPrint(winid_t w, const char *fmt, ...)
+//#ifdef __GNUC__
+//	__attribute__((__format__(__printf__, 2, 3)))
+//#endif
+//	;
+
+static void SOBPrint(winid_t w, const char *fmt, ...) {
+	va_list ap;
+	char msg[2048];
+
+	int size = sizeof msg;
+
+	va_start(ap, fmt);
+	vsnprintf(msg, size, fmt, ap);
+	va_end(ap);
+
+	g_scott->glk_put_string_stream(g_scott->glk_window_get_stream(w), msg);
+}
+
+glui32 optimalDicePixelSize(glui32 *width, glui32 *height) {
+	int idealWidth = 8;
+	int idealHeight = 8;
+
+	*width = idealWidth;
+	*height = idealHeight;
+	int multiplier = 1;
+	uint graphwidth, graphheight;
+	g_scott->glk_window_get_size(_G(_leftDiceWin), &graphwidth, &graphheight);
+	multiplier = graphheight / idealHeight;
+	if ((glui32)(idealWidth * multiplier) > graphwidth)
+		multiplier = graphwidth / idealWidth;
+
+	if (multiplier < 2)
+		multiplier = 2;
+
+	multiplier = multiplier / 2;
+
+	*width = idealWidth * multiplier;
+	*height = idealHeight * multiplier;
+
+	return multiplier;
+}
+
+static void drawBorder(winid_t win) {
+	uint width, height;
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+	g_scott->glk_window_get_size(win, &width, &height);
+	height--;
+	width -= 2;
+	g_scott->glk_window_move_cursor(win, 0, 0);
+	g_scott->glk_put_char_uni(0x250F); // Top left corner
+	for (glui32 i = 1; i < width; i++)
+		g_scott->glk_put_char_uni(0x2501); // Top
+	g_scott->glk_put_char_uni(0x2513);     // Top right corner
+	for (glui32 i = 1; i < height; i++) {
+		g_scott->glk_window_move_cursor(win, 0, i);
+		g_scott->glk_put_char_uni(0x2503);
+		g_scott->glk_window_move_cursor(win, width, i);
+		g_scott->glk_put_char_uni(0x2503);
+	}
+	g_scott->glk_window_move_cursor(win, 0, height);
+	g_scott->glk_put_char_uni(0x2517);
+	for (glui32 i = 1; i < width; i++)
+		g_scott->glk_put_char_uni(0x2501);
+	g_scott->glk_put_char_uni(0x251B);
+}
+
+static void redrawStaticText(winid_t win, int boatFlag) {
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+	g_scott->glk_window_move_cursor(win, 2, 4);
+
+	if (boatFlag) {
+		g_scott->glk_put_string("STRIKE  :\n");
+		g_scott->glk_window_move_cursor(win, 2, 5);
+		g_scott->glk_put_string("CRW STR :");
+	} else {
+		g_scott->glk_put_string("SKILL   :\n");
+		g_scott->glk_window_move_cursor(win, 2, 5);
+		g_scott->glk_put_string("STAMINA :");
+	}
+
+	if (win == _G(_battleRight)) {
+		uint width;
+		g_scott->glk_window_get_size(_G(_battleRight), &width, 0);
+		g_scott->glk_window_move_cursor(_G(_battleRight), width - 6, 1);
+		g_scott->glk_put_string("YOU");
+	}
+}
+
+static void redrawBattleScreen(int boatFlag) {
+	uint graphwidth, graphheight;
+	glui32 optimal_width, optimal_height;
+
+	g_scott->glk_window_get_size(_G(_leftDiceWin), &graphwidth, &graphheight);
+
+	_G(_dicePixelSize) = optimalDicePixelSize(&optimal_width, &optimal_height);
+	_G(_diceXOffset) = (graphwidth - optimal_width) / 2;
+	_G(_diceYOffset) = (graphheight - optimal_height - _G(_dicePixelSize)) / 2;
+
+	drawBorder(_G(_topWindow));
+	drawBorder(_G(_battleRight));
+
+	redrawStaticText(_G(_topWindow), boatFlag);
+	redrawStaticText(_G(_battleRight), boatFlag);
+}
+
+static void setupBattleScreen(int boatFlag) {
+	winid_t parent = g_scott->glk_window_get_parent(_G(_topWindow));
+	g_scott->glk_window_set_arrangement(parent, winmethod_Above | winmethod_Fixed, 7, _G(_topWindow));
+
+	g_scott->glk_window_clear(_G(_topWindow));
+	g_scott->glk_window_clear(_G(_bottomWindow));
+	_G(_battleRight) = g_scott->glk_window_open(_G(_topWindow), winmethod_Right | winmethod_Proportional,
+								  50, wintype_TextGrid, 0);
+
+	_G(_leftDiceWin) = g_scott->glk_window_open(_G(_topWindow), winmethod_Right | winmethod_Proportional,
+								  30, wintype_Graphics, 0);
+	_G(_rightDiceWin) = g_scott->glk_window_open(_G(_battleRight), winmethod_Left | winmethod_Proportional, 30,
+								   wintype_Graphics, 0);
+
+	// Set the graphics window background to match the top window background, best as we can, and clear the window.
+	 
+	if (g_scott->glk_style_measure(_G(_topWindow), style_Normal, stylehint_BackColor,
+						  &_G(_backgroundColour))) {
+		g_scott->glk_window_set_background_color(_G(_leftDiceWin), _G(_backgroundColour));
+		g_scott->glk_window_set_background_color(_G(_rightDiceWin), _G(_backgroundColour));
+
+		g_scott->glk_window_clear(_G(_leftDiceWin));
+		g_scott->glk_window_clear(_G(_rightDiceWin));
+	}
+
+	if (_G(_palChosen) == C64B)
+		_G(_diceColour) = 0x5f48e9;
+	else
+		_G(_diceColour) = 0xff0000;
+
+	redrawBattleScreen(boatFlag);
+}
+
+void bloodBattle(void) {
+	int enemy, strike, stamina, boatFlag;
+	enemy = getEnemyStats(&strike, &stamina, &boatFlag); // Determine their stats
+	if (enemy == 0) {
+		error("Seas of blood battle: No enemy in location?\n");
+		return;
+	}
+	setupBattleScreen(boatFlag);
+	battleLoop(enemy, strike, stamina, boatFlag); // Into the battle loops
+	if (boatFlag)
+		swapStaminaAndCrewStrength(); // Switch back stamina - crew strength
+	g_scott->glk_window_close(_G(_leftDiceWin), nullptr);
+	g_scott->glk_window_close(_G(_rightDiceWin), nullptr);
+	g_scott->glk_window_close(_G(_battleRight), nullptr);
+	g_scott->closeGraphicsWindow();
+	g_scott->openGraphicsWindow();
+	seasOfBloodRoomImage();
+}
+
+int getEnemyStats(int *strike, int *stamina, int *boatFlag) {
+	int enemy, i = 0;
+	while (i < 124) {
+		enemy = _G(_enemyTable)[i];
+		if (_G(_items)[enemy]._location == MY_LOC) {
+			i++;
+			*strike = _G(_enemyTable)[i++];
+			*stamina = _G(_enemyTable)[i++];
+			*boatFlag = _G(_enemyTable)[i];
+			if (*boatFlag) {
+				swapStaminaAndCrewStrength(); // Switch stamina - crew strength
+			}
+
+			return enemy;
+		}
+		i = i + 4; // Skip to next entry
+	}
+	return 0;
+}
+
+void drawRect(winid_t win, int32_t x, int32_t y, int32_t width, int32_t height,
+			   int32_t color) {
+	g_scott->glk_window_fill_rect(win, color, x * _G(_dicePixelSize) + _G(_diceXOffset),
+						 y * _G(_dicePixelSize) + _G(_diceYOffset),
+						 width * _G(_dicePixelSize), height * _G(_dicePixelSize));
+}
+
+void drawGraphicalDice(winid_t win, int number) {
+	// The eye-less dice backgrounds consist of two rectangles on top of each
+	// other
+	drawRect(win, 1, 2, 7, 5, _G(_diceColour));
+	drawRect(win, 2, 1, 5, 7, _G(_diceColour));
+
+	switch (number + 1) {
+	case 1:
+		drawRect(win, 4, 4, 1, 1, _G(_backgroundColour));
+		break;
+	case 2:
+		drawRect(win, 2, 6, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 2, 1, 1, _G(_backgroundColour));
+		break;
+	case 3:
+		drawRect(win, 2, 6, 1, 1, _G(_backgroundColour));
+		drawRect(win, 4, 4, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 2, 1, 1, _G(_backgroundColour));
+		break;
+	case 4:
+		drawRect(win, 2, 6, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 2, 1, 1, _G(_backgroundColour));
+		drawRect(win, 2, 2, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 6, 1, 1, _G(_backgroundColour));
+		break;
+	case 5:
+		drawRect(win, 2, 6, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 2, 1, 1, _G(_backgroundColour));
+		drawRect(win, 2, 2, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 6, 1, 1, _G(_backgroundColour));
+		drawRect(win, 4, 4, 1, 1, _G(_backgroundColour));
+		break;
+	case 6:
+		drawRect(win, 2, 6, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 2, 1, 1, _G(_backgroundColour));
+		drawRect(win, 2, 2, 1, 1, _G(_backgroundColour));
+		drawRect(win, 2, 4, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 4, 1, 1, _G(_backgroundColour));
+		drawRect(win, 6, 6, 1, 1, _G(_backgroundColour));
+		break;
+	default:
+		break;
+	}
+}
+
+void updateDice(int ourTurn, int leftDice, int rightDice) {
+	leftDice--;
+	rightDice--;
+	g_scott->glk_window_clear(_G(_leftDiceWin));
+	g_scott->glk_window_clear(_G(_rightDiceWin));
+
+	_G(_diceXOffset) = _G(_diceXOffset) - _G(_dicePixelSize);
+	drawGraphicalDice(_G(_leftDiceWin), leftDice);
+	_G(_diceXOffset) = _G(_diceXOffset) + _G(_dicePixelSize);
+	drawGraphicalDice(_G(_rightDiceWin), rightDice);
+
+	winid_t win = ourTurn ? _G(_battleRight) : _G(_topWindow);
+
+	g_scott->glk_window_move_cursor(win, 2, 1);
+
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+
+	g_scott->glk_put_char_uni(0x2680 + leftDice);
+	g_scott->glk_put_char('+');
+	g_scott->glk_put_char_uni(0x2680 + rightDice);
+
+	g_scott->glk_window_move_cursor(win, 2, 2);
+	SOBPrint(win, "%d %d", leftDice + 1, rightDice + 1);
+}
+
+void printSum(int ourTurn, int sum, int strike) {
+	winid_t win = ourTurn ? _G(_battleRight) : _G(_topWindow);
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+
+	g_scott->glk_window_move_cursor(win, 6, 1);
+
+	SOBPrint(win, "+ %d = %d", strike, sum);
+
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(_G(_battleRight)));
+	g_scott->glk_window_move_cursor(_G(_battleRight), 6, 1);
+	g_scott->glk_put_string("+ 9 = ");
+}
+
+void updateResult(int ourTurn, int strike, int stamina, int boatFlag) {
+	winid_t win = ourTurn ? _G(_battleRight) : _G(_topWindow);
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+
+	g_scott->glk_window_move_cursor(win, 2, 4);
+
+	if (boatFlag) {
+		SOBPrint(win, "STRIKE  : %d\n", strike);
+		g_scott->glk_window_move_cursor(win, 2, 5);
+		SOBPrint(win, "CRW STR : %d", stamina);
+	} else {
+		SOBPrint(win, "SKILL   : %d\n", strike);
+		g_scott->glk_window_move_cursor(win, 2, 5);
+		SOBPrint(win, "STAMINA : %d", stamina);
+	}
+}
+
+void clearResult(void) {
+	winid_t win = _G(_topWindow);
+
+	uint width;
+	for (int j = 0; j < 2; j++) {
+		g_scott->glk_window_get_size(win, &width, 0);
+		g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+
+		g_scott->glk_window_move_cursor(win, 11, 1);
+		for (int i = 0; i < 10; i++)
+			g_scott->glk_put_string(" ");
+		drawBorder(win);
+		win = _G(_battleRight);
+	}
+}
+
+void clearStamina(void) {
+	winid_t win = _G(_topWindow);
+
+	uint width;
+	for (int j = 0; j < 2; j++) {
+		g_scott->glk_window_get_size(win, &width, 0);
+		g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(win));
+
+		g_scott->glk_window_move_cursor(win, 11, 5);
+		for (int i = 0; i < (int)width - 13; i++)
+			g_scott->glk_put_string(" ");
+		drawBorder(win);
+		win = _G(_battleRight);
+	}
+}
+
+static void rearrangeBattleDisplay(int strike, int stamina, int boatFlag) {
+	g_scott->updateSettings();
+	g_scott->glk_cancel_char_event(_G(_topWindow));
+	g_scott->closeGraphicsWindow();
+	g_scott->glk_window_close(_G(_battleRight), nullptr);
+	g_scott->glk_window_close(_G(_leftDiceWin), nullptr);
+	g_scott->glk_window_close(_G(_rightDiceWin), nullptr);
+	seasOfBloodRoomImage();
+	setupBattleScreen(boatFlag);
+	updateResult(0, strike, stamina, boatFlag);
+	updateResult(1, 9, _G(_counters)[3], boatFlag);
+	drawBorder(_G(_topWindow));
+	drawBorder(_G(_battleRight));
+	redrawStaticText(_G(_topWindow), boatFlag);
+	redrawStaticText(_G(_battleRight), boatFlag);
+	g_scott->glk_request_char_event(_G(_topWindow));
+}
+
+int rollDice(int strike, int stamina, int boatFlag) {
+	clearResult();
+	redrawStaticText(_G(_battleRight), boatFlag);
+
+	g_scott->glk_request_timer_events(60);
+	int rolls = 0;
+	int ourTurn = 0;
+	int leftDice = 1 + g_scott->getRandomNumber(100) % 6;
+	int rightDice = 1 + g_scott->getRandomNumber(100) % 6;
+	int ourResult;
+	int theirResult = 0;
+	int theirDiceStopped = 0;
+
+	event_t event;
+	int enemyRolls = 20 + g_scott->getRandomNumber(100) % 10;
+	g_scott->glk_cancel_char_event(_G(_topWindow));
+	g_scott->glk_request_char_event(_G(_topWindow));
+
+	g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(_G(_bottomWindow)));
+	g_scott->glk_put_string("Their throw");
+
+	int delay = 60;
+
+	while (!g_vm->shouldQuit()) {
+		g_scott->glk_select(&event);
+		if (event.type == evtype_Timer) {
+			if (theirDiceStopped) {
+				g_scott->glk_request_timer_events(60);
+				theirDiceStopped = 0;
+				printSum(ourTurn, theirResult, strike);
+				ourTurn = 1;
+				g_scott->glk_window_clear(_G(_bottomWindow));
+				g_scott->glk_cancel_char_event(_G(_topWindow));
+				g_scott->glk_request_char_event(_G(_topWindow));
+				g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(_G(_bottomWindow)));
+				g_scott->glk_put_string("Your throw\n");
+				g_scott->glk_put_string("<ENTER> to stop dice");
+				if (!boatFlag)
+					g_scott->glk_put_string("    <X> to run");
+			} else if (ourTurn == 0) {
+				g_scott->glk_request_timer_events(delay);
+			}
+
+			rolls++;
+
+			if (rolls % 2)
+				leftDice = 1 + g_scott->getRandomNumber(100) % 6;
+			else
+				rightDice = 1 + g_scott->getRandomNumber(100) % 6;
+
+			updateDice(ourTurn, leftDice, rightDice);
+			if (ourTurn == 0 && rolls == enemyRolls) {
+				g_scott->glk_window_clear(_G(_bottomWindow));
+				theirResult = leftDice + rightDice + strike;
+				SOBPrint(_G(_bottomWindow), "Their result: %d + %d + %d = %d\n", leftDice,
+						 rightDice, strike, theirResult);
+				g_scott->glk_request_timer_events(1000);
+				theirDiceStopped = 1;
+			}
+		}
+
+		if (event.type == evtype_CharInput) {
+			if (ourTurn && (event.val1 == keycode_Return)) {
+				updateDice(ourTurn, leftDice, rightDice);
+				ourResult = leftDice + rightDice + 9;
+				printSum(ourTurn, ourResult, 9);
+				if (theirResult > ourResult) {
+					return LOSS;
+				} else if (ourResult > theirResult) {
+					return VICTORY;
+				} else {
+					return DRAW;
+				}
+			} else if (MY_LOC != 1 && (event.val1 == 'X' || event.val1 == 'x')) {
+				MY_LOC = _G(_savedRoom);
+				return FLEE;
+			} else {
+				g_scott->glk_request_char_event(_G(_topWindow));
+			}
+		}
+		if (event.type == evtype_Arrange) {
+			rearrangeBattleDisplay(strike, stamina, boatFlag);
+		}
+	}
+	return ERROR;
+}
+
+void battleHitEnter(int strike, int stamina, int boatFlag) {
+	g_scott->glk_request_char_event(_G(_bottomWindow));
+	event_t ev;
+	int result = 0;
+	do {
+		g_scott->glk_select(&ev);
+		if (ev.type == evtype_CharInput) {
+			if (ev.val1 == keycode_Return) {
+				result = 1;
+			} else {
+				g_scott->glk_request_char_event(_G(_bottomWindow));
+			}
+		}
+
+		if (ev.type == evtype_Arrange) {
+			rearrangeBattleDisplay(strike, stamina, boatFlag);
+		}
+
+	} while (result == 0 && !g_vm->shouldQuit());
+}
+
+void battleLoop(int enemy, int strike, int stamina, int boatFlag) {
+	updateResult(0, strike, stamina, boatFlag);
+	updateResult(1, 9, _G(_counters)[3], boatFlag);
+	do {
+		int result = rollDice(strike, stamina, boatFlag);
+		g_scott->glk_cancel_char_event(_G(_topWindow));
+		g_scott->glk_window_clear(_G(_bottomWindow));
+		clearStamina();
+		g_scott->glk_stream_set_current(g_scott->glk_window_get_stream(_G(_bottomWindow)));
+		if (result == LOSS) {
+			_G(_counters)[3] -= 2;
+
+			if (_G(_counters)[3] <= 0) {
+				SOBPrint(_G(_bottomWindow), "%s\n",
+						 boatFlag ? "THE BANSHEE HAS BEEN SUNK!"
+								  : "YOU HAVE BEEN KILLED!");
+				_G(_counters)[3] = 0;
+				_G(_bitFlags) |= (1 << 6);
+				_G(_counters)[7] = 0;
+			} else {
+				SOBPrint(_G(_bottomWindow), "%s", _G(_battleMessages)[1 + g_scott->getRandomNumber(100) % 5 + 16 * boatFlag]);
+			}
+		} else if (result == VICTORY) {
+			stamina -= 2;
+			if (stamina <= 0) {
+				g_scott->glk_put_string("YOU HAVE WON!\n");
+				_G(_bitFlags) &= ~(1 << 6);
+				stamina = 0;
+			} else {
+				SOBPrint(_G(_bottomWindow), "%s", _G(_battleMessages)[6 + g_scott->getRandomNumber(100) % 5 + 16 * boatFlag]);
+			}
+		} else if (result == FLEE) {
+			_G(_bitFlags) |= (1 << 6);
+			MY_LOC = _G(_savedRoom);
+			return;
+		} else {
+			SOBPrint(_G(_bottomWindow), "%s", _G(_battleMessages)[11 + g_scott->getRandomNumber(100) % 5 + 16 * boatFlag]);
+		}
+
+		g_scott->glk_put_string("\n\n");
+
+		if (_G(_counters)[3] > 0 && stamina > 0) {
+			g_scott->glk_put_string("<ENTER> to roll dice");
+			if (!boatFlag)
+				g_scott->glk_put_string("    <X> to run");
+		}
+
+		updateResult(0, strike, stamina, boatFlag);
+		updateResult(1, 9, _G(_counters)[3], boatFlag);
+
+		battleHitEnter(strike, stamina, boatFlag);
+		g_scott->glk_window_clear(_G(_bottomWindow));
+	} while (stamina > 0 && _G(_counters)[3] > 0 && !g_vm->shouldQuit());
+}
+
+void swapStaminaAndCrewStrength(void) {
+	uint8_t temp = _G(_counters)[7]; // Crew strength
+	_G(_counters)[7] = _G(_counters)[3];  // Stamina
+	_G(_counters)[3] = temp;
+}
+
+int loadExtraSeasOfBloodData(void) {
+	_G(_drawToBuffer) = 1;
+
+	int offset;
+
+	offset = 0x47b7 + _G(_fileBaselineOffset);
+
+	uint8_t *ptr = seekToPos(_G(_entireFile), offset);
+
+	int ct;
+
+	for (ct = 0; ct < 124; ct++) {
+		_G(_enemyTable)[ct] = *(ptr++);
+		if (_G(_enemyTable)[ct] == 0xff)
+			break;
+	}
+
+	ptr = seekToPos(_G(_entireFile), 0x71DA + _G(_fileBaselineOffset));
+
+	for (int i = 0; i < 32; i++) {
+		_G(_battleMessages)[i] = decompressText(ptr, i);
+	}
+
+	offset = 0x7af5 - 16357 + _G(_fileBaselineOffset);
+
+	int data_length = 2010;
+
+	_G(_bloodImageData) = new uint8_t[data_length];
+	ptr = seekToPos(_G(_entireFile), offset);
+	for (int i = 0; i < data_length; i++)
+		_G(_bloodImageData)[i] = *(ptr++);
+
+	for (int i = I_DONT_UNDERSTAND; i <= THATS_BEYOND_MY_POWER; i++)
+		_G(_sys)[i] = _G(_systemMessages)[4 - I_DONT_UNDERSTAND + i];
+
+	for (int i = YOU_ARE; i <= HIT_ENTER; i++)
+		_G(_sys)[i] = _G(_systemMessages)[13 - YOU_ARE + i];
+
+	_G(_sys)[OK] = _G(_systemMessages)[2];
+	_G(_sys)[PLAY_AGAIN] = _G(_systemMessages)[3];
+	_G(_sys)[YOURE_CARRYING_TOO_MUCH] = _G(_systemMessages)[27];
+
+	_G(_items)[125]._text = "A loose plank";
+	_G(_items)[125]._autoGet = "PLAN";
+
+	return 0;
+}
+
+int loadExtraSeasOfBlood64Data(void) {
+	_G(_drawToBuffer) = 1;
+
+	int offset;
+
+	offset = 0x3fee + _G(_fileBaselineOffset);
+	uint8_t *ptr;
+
+	ptr = seekToPos(_G(_entireFile), offset);
+
+	int ct;
+	for (ct = 0; ct < 124; ct++) {
+		_G(_enemyTable)[ct] = *(ptr++);
+		if (_G(_enemyTable)[ct] == 0xff)
+			break;
+	}
+
+	offset = 0x82f6 + _G(_fileBaselineOffset);
+	ptr = seekToPos(_G(_entireFile), offset);
+
+	for (int i = 0; i < 32; i++) {
+		_G(_battleMessages)[i] = decompressText(ptr, i);
+	}
+
+	offset = 0x5299 + _G(_fileBaselineOffset);
+
+	int data_length = 2010;
+
+	_G(_bloodImageData) = new uint8_t[data_length];
+
+	ptr = seekToPos(_G(_entireFile), offset);
+	for (int i = 0; i < data_length; i++) {
+		_G(_bloodImageData)[i] = *(ptr++);
+	}
+
+	SysMessageType messagekey[] = {
+		NORTH,
+		SOUTH,
+		EAST,
+		WEST,
+		UP,
+		DOWN,
+		EXITS,
+		YOU_SEE,
+		YOU_ARE,
+		YOU_CANT_GO_THAT_WAY,
+		OK,
+		WHAT_NOW,
+		HUH,
+		YOU_HAVE_IT,
+		YOU_HAVENT_GOT_IT,
+		DROPPED,
+		TAKEN,
+		INVENTORY,
+		YOU_DONT_SEE_IT,
+		THATS_BEYOND_MY_POWER,
+		DIRECTION,
+		YOURE_CARRYING_TOO_MUCH,
+		PLAY_AGAIN,
+		RESUME_A_SAVED_GAME,
+		YOU_CANT_DO_THAT_YET,
+		I_DONT_UNDERSTAND,
+		NOTHING};
+
+	for (int i = 0; i < 27; i++) {
+		_G(_sys)[messagekey[i]] = _G(_systemMessages)[i];
+	}
+
+	return 0;
+}
+
+} // End of namespace Scott
+} // End of namespace Glk
+
+