mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-21 01:08:25 +00:00
591 lines
16 KiB
C++
591 lines
16 KiB
C++
/* 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 2
|
||
* 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, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||
*
|
||
*/
|
||
|
||
/*
|
||
* This code is based on the original source code of Lord Avalot d'Argent version 1.3.
|
||
* Copyright (c) 1994-1995 Mike, Mark and Thomas Thurman.
|
||
*/
|
||
|
||
/* GYRO It all revolves around this bit! */
|
||
|
||
#include "avalanche/avalanche.h"
|
||
|
||
#include "avalanche/gyro2.h"
|
||
#include "avalanche/pingo2.h"
|
||
#include "avalanche/scrolls2.h"
|
||
#include "avalanche/lucerna2.h"
|
||
#include "avalanche/visa2.h"
|
||
#include "avalanche/acci2.h"
|
||
#include "avalanche/trip6.h"
|
||
|
||
#include "common/textconsole.h"
|
||
#include "common/file.h"
|
||
|
||
#include "common/random.h"
|
||
|
||
//#include "dropdown.h"
|
||
//#include "basher.h"
|
||
|
||
namespace Avalanche {
|
||
|
||
const char *Gyro::vernum = "1.30";
|
||
const char *Gyro::copyright = "1995";
|
||
|
||
|
||
const mp Gyro::mps[9] = {
|
||
{
|
||
// 1 - up-arrow
|
||
{ {65151, 64575, 64575, 63519, 63519, 61455, 61455, 57351, 57351, 49155, 49155, 64575, 64575, 64575, 64575, 64575},
|
||
{0, 384, 384, 960, 960, 2016, 2016, 4080, 4080, 8184, 384, 384, 384, 384, 384, 0}
|
||
},
|
||
8,
|
||
0
|
||
},
|
||
|
||
{
|
||
// 2 - screwdriver
|
||
{ {8191, 4095, 2047, 34815, 50175, 61951, 63743, 64543, 65039, 65031, 65027, 65281, 65408, 65472, 65505, 65523},
|
||
{0, 24576, 28672, 12288, 2048, 1024, 512, 256, 224, 176, 216, 96, 38, 10, 12, 0}
|
||
},
|
||
0,
|
||
0
|
||
},
|
||
|
||
{
|
||
// 3 - right-arrow
|
||
{ {65535, 65535, 64639, 64543, 7, 1, 0, 1, 7, 64543, 64639, 65535, 65535, 65535, 65535, 65535},
|
||
{0, 0, 0, 384, 480, 32760, 32766, 32760, 480, 384, 0, 0, 0, 0, 0, 0}
|
||
},
|
||
15,
|
||
6
|
||
},
|
||
|
||
{
|
||
// 4 - fletch
|
||
{ {255, 511, 1023, 2047, 1023, 4607, 14591, 31871, 65031, 65283, 65281, 65280, 65280, 65409, 65473, 65511},
|
||
{0, 10240, 20480, 24576, 26624, 17408, 512, 256, 128, 88, 32, 86, 72, 20, 16, 0}
|
||
},
|
||
0,
|
||
0
|
||
},
|
||
|
||
{
|
||
// 5 - hourglass
|
||
{ {0, 0, 0, 34785, 50115, 61455, 61455, 63519, 63519, 61839, 61455, 49155, 32769, 0, 0, 0},
|
||
{0, 32766, 16386, 12300, 2064, 1440, 1440, 576, 576, 1056, 1440, 3024, 14316, 16386, 32766, 0}
|
||
},
|
||
8,
|
||
7
|
||
},
|
||
|
||
{
|
||
// 6 - TTHand
|
||
{ {62463, 57855, 57855, 57855, 57471, 49167, 32769, 0, 0, 0, 0, 32768, 49152, 57344, 61441, 61443},
|
||
{3072, 4608, 4608, 4608, 4992, 12912, 21070, 36937, 36873, 36865, 32769, 16385, 8193, 4097, 2050, 4092}
|
||
},
|
||
4,
|
||
0
|
||
},
|
||
|
||
{
|
||
// 7- Mark's crosshairs
|
||
{ {65535, 65151, 65151, 65151, 65151, 0, 65151, 65151, 65151, 65151, 65535, 65535, 65535, 65535, 65535, 65535},
|
||
{0, 384, 384, 384, 384, 65535, 384, 384, 384, 384, 0, 0, 0, 0, 0, 0}
|
||
},
|
||
8,
|
||
5
|
||
},
|
||
|
||
{
|
||
// 8- I-beam
|
||
{ {65535, 65535, 63631, 63503, 63503, 65087, 65087, 65087, 65087, 65087, 63503, 63503, 63631, 65535, 65535, 65535},
|
||
{0, 0, 0, 864, 128, 128, 128, 128, 128, 128, 128, 864, 0, 0, 0, 0}
|
||
},
|
||
8,
|
||
7
|
||
},
|
||
|
||
{
|
||
// 9 - question mark
|
||
{ {511, 1023, 2047, 31, 15, 8199, 32647, 65415, 63503, 61471, 61503, 61695, 63999, 63999, 61695, 61695},
|
||
{65024, 33792, 34816, 34784, 40976, 57224, 32840, 72, 1936, 2080, 2496, 2304, 1536, 1536, 2304, 3840}
|
||
},
|
||
0,
|
||
0
|
||
}
|
||
};
|
||
|
||
const Common::String Gyro::lads[17] = {
|
||
"Avalot", "Spludwick", "Crapulus", "Dr. Duck", "Malagauche", "Friar Tuck",
|
||
"Robin Hood", "Cwytalot", "du Lustie", "the Duke of Cardiff", "Dogfood",
|
||
"A trader", "Ibythneth", "Ayles", "Port", "Spurge", "Jacques"
|
||
};
|
||
|
||
const Common::String Gyro::lasses[4] =
|
||
{"Arkata", "Geida", "<EFBFBD>", "the Wise Woman"};
|
||
|
||
const char Gyro::ladchar[] = "ASCDMTRwLfgeIyPu";
|
||
|
||
const char Gyro::lasschar[] = "kG<EFBFBD>o";
|
||
|
||
const int32 Gyro::catamap[8][8] = {
|
||
/* Geida's room */
|
||
/* 1 2 3 | 4 5 6 7 8*/
|
||
{0x204, 0x200, 0xd0f0, 0xf0ff, 0xff, 0xd20f, 0xd200, 0x200},
|
||
{0x50f1, 0x20ff, 0x2ff, 0xff, 0xe0ff, 0x20ff, 0x200f, 0x7210},
|
||
{0xe3f0, 0xe10f, 0x72f0, 0xff, 0xe0ff, 0xff, 0xff, 0x800f},
|
||
{0x2201, 0x2030, 0x800f, 0x220, 0x20f, 0x30, 0xff, 0x23f}, /* >> Oubliette */
|
||
{0x5024, 0xf3, 0xff, 0x200f, 0x22f0, 0x20f, 0x200, 0x7260},
|
||
{0xf0, 0x2ff, 0xe2ff, 0xff, 0x200f, 0x50f0, 0x72ff, 0x201f},
|
||
{0xf6, 0x220f, 0x22f0, 0x30f, 0xf0, 0x20f, 0x8200, 0x2f0}, /* <<< In here */
|
||
{0x34, 0x200f, 0x51f0, 0x201f, 0xf1, 0x50ff, 0x902f, 0x2062}
|
||
};
|
||
/* vv Stairs trap. */
|
||
|
||
const char Gyro::spludwick_order[3] = {onion, ink, mushroom};
|
||
|
||
const quasiped_type Gyro::quasipeds[16] = {
|
||
{2, lightgray, 19, brown, pdogfood}, /* A: Dogfood (screen 19). */
|
||
{3, green, 19, white, pibythneth}, /* B: Ibythneth (screen 19). */
|
||
{3, white, 1, magenta, parkata}, /* C: Arkata (screen 1). */
|
||
{3, black, 23, red, 177}, /* D: Hawk (screen 23). */
|
||
{3, lightgreen, 50, brown, ptrader}, /* E: Trader (screen 50). */
|
||
{6, yellow, 42, red, pavalot}, /* F: Avvy, tied up (scr.42) */
|
||
{2, blue, 16, white, payles}, /* G: Ayles (screen 16). */
|
||
{2, brown, 7, white, pjacques}, /* H: Jacques (screen 7). */
|
||
{2, lightgreen, 47, green, pspurge}, /* I: Spurge (screen 47). */
|
||
{3, yellow, 47, red, pavalot}, /* J: Avalot (screen 47). */
|
||
{2, lightgray, 23, black, pdulustie}, /* K: du Lustie (screen 23). */
|
||
{2, yellow, 27, red, pavalot}, /* L: Avalot (screen 27). */
|
||
{3, white, 27, red, 177}, /* M: Avaroid (screen 27). */
|
||
{4, lightgray, 19, darkgray, pmalagauche}, /*N: Malagauche (screen 19). */
|
||
{5, lightmagenta, 47, red, pport}, /* O: Port (screen 47). */
|
||
{2, lightgreen, 51, darkgray, pdrduck}
|
||
}; /*P: Duck (screen 51). */
|
||
|
||
const char Gyro::keys[] = "QWERTYUIOP[]";
|
||
|
||
const uint16 Gyro::notes[12] = {196, 220, 247, 262, 294, 330, 350, 392, 440, 494, 523, 587};
|
||
|
||
const tunetype Gyro::tune = {
|
||
higher, higher, lower, same, higher, higher, lower, higher, higher, higher,
|
||
lower, higher, higher,
|
||
same, higher, lower, lower, lower, lower, higher, higher, lower, lower, lower,
|
||
lower, same, lower, higher, same, lower, higher
|
||
};
|
||
|
||
byte Gyro::whereis[29] = {
|
||
/* The Lads */
|
||
r__yours, /* Avvy */
|
||
r__spludwicks, /* Spludwick */
|
||
r__outsideyours, /* Crapulus */
|
||
r__ducks, /* Duck - r__DucksRoom's not defined yet. */
|
||
r__argentpub, /* Malagauche */
|
||
r__robins, /* Friar Tuck. */
|
||
177, /* Robin Hood - can't meet him at the start. */
|
||
r__brummieroad, /* Cwytalot */
|
||
r__lustiesroom, /* Baron du Lustie. */
|
||
r__outsidecardiffcastle, /* The Duke of Cardiff. */
|
||
r__argentpub, /* Dogfood */
|
||
r__outsideducks, /* Trader */
|
||
r__argentpub, /* Ibythneth */
|
||
r__aylesoffice, /* Ayles */
|
||
r__nottspub, /* Port */
|
||
r__nottspub, /* Spurge */
|
||
r__musicroom, /* Jacques */
|
||
0, 0, 0, 0, 0, 0, 0, 0,
|
||
/* The Lasses */
|
||
r__yours, /* Arkata */
|
||
r__geidas, /* Geida */
|
||
177, /* nobody allocated here! */
|
||
r__wisewomans /* The Wise Woman. */
|
||
};
|
||
|
||
const Common::String Gyro::things[numobjs] = {
|
||
"Wine", "Money-bag", "Bodkin", "Potion", "Chastity belt",
|
||
"Crossbow bolt", "Crossbow", "Lute", "Pilgrim's badge", "Mushroom", "Key",
|
||
"Bell", "Scroll", "Pen", "Ink", "Clothes", "Habit", "Onion"
|
||
};
|
||
|
||
const char Gyro::thingchar[] = "WMBParCLguKeSnIohn"; /* V=Vinegar */
|
||
|
||
const Common::String Gyro::better[numobjs] = {
|
||
"some wine", "your money-bag", "your bodkin", "a potion", "a chastity belt",
|
||
"a crossbow bolt", "a crossbow", "a lute", "a pilgrim's badge", "a mushroom",
|
||
"a key", "a bell", "a scroll", "a pen", "some ink", "your clothes", "a habit",
|
||
"an onion"
|
||
};
|
||
|
||
const char Gyro::betterchar[] = "WMBParCLguKeSnIohn";
|
||
|
||
Gyro::Gyro(AvalancheEngine *vm) : interrogation(0), oncandopageswap(true) {
|
||
_vm = vm;
|
||
|
||
/* Needed because of Lucerna::load_also() */
|
||
for (int fv = 0; fv < 31; fv++) {
|
||
for (int ff = 0; ff < 2; ff++)
|
||
also[fv][ff] = 0;
|
||
}
|
||
dna.total_time = 0;
|
||
}
|
||
|
||
Gyro::~Gyro() {
|
||
for (byte i = 0; i < 9; i++) {
|
||
digit[i].free();
|
||
rwlite[i].free();
|
||
}
|
||
digit[9].free();
|
||
}
|
||
|
||
Common::String Gyro::strf(int32 x) {
|
||
Common::String q = Common::String::format("%d", x);
|
||
return q;
|
||
}
|
||
|
||
void Gyro::newpointer(byte id) {
|
||
if (id == cmp)
|
||
return;
|
||
cmp = id;
|
||
|
||
load_a_mouse(id);
|
||
}
|
||
|
||
void Gyro::wait() {
|
||
newpointer(5);
|
||
}
|
||
|
||
void Gyro::on() {
|
||
warning("STUB: Gyro::on()");
|
||
}
|
||
|
||
void Gyro::off() {
|
||
warning("STUB: Gyro::off()");
|
||
}
|
||
|
||
void Gyro::xycheck() {
|
||
warning("STUB: Gyro::xycheck()");
|
||
}
|
||
|
||
void Gyro::check() {
|
||
warning("STUB: Gyro::check()");
|
||
}
|
||
|
||
void Gyro::note(uint16 hertz) {
|
||
warning("STUB: Gyro::note()");
|
||
}
|
||
|
||
void Gyro::blip() {
|
||
warning("STUB: Gyro::blip()");
|
||
}
|
||
|
||
void Gyro::shadow(int16 x1, int16 y1, int16 x2, int16 y2, byte hc, byte sc) {
|
||
warning("STUB: Gyro::shadow()");
|
||
}
|
||
|
||
void Gyro::shbox(int16 x1, int16 y1, int16 x2, int16 y2, Common::String t) {
|
||
warning("STUB: Gyro::shbox()");
|
||
}
|
||
|
||
void Gyro::newgame() {
|
||
for (byte gm = 0; gm < numtr; gm++) {
|
||
if (_vm->_trip->tr[gm].quick)
|
||
_vm->_trip->tr[gm].done();
|
||
}
|
||
// Deallocate sprite. Sorry, beta testers!
|
||
|
||
_vm->_trip->tr[0].init(0, true, _vm->_trip);
|
||
alive = true;
|
||
|
||
score = 0;
|
||
/*for gd:=0 to 5 do which[gd]:=1;*/
|
||
memset(&_vm->_gyro->dna, 0, sizeof(dnatype));
|
||
_vm->_scrolls->natural();
|
||
_vm->_lucerna->mousepage(0);
|
||
dna.spare_evening = "answer a questionnaire";
|
||
dna.like2drink = "beer";
|
||
|
||
dna.pence = 30; /* 2/6 */ dna.rw = stopped;
|
||
dna.wearing = clothes;
|
||
dna.obj[money - 1] = true;
|
||
dna.obj[bodkin - 1] = true;
|
||
dna.obj[bell - 1] = true;
|
||
dna.obj[clothes - 1] = true;
|
||
|
||
thinks = 2;
|
||
_vm->_lucerna->objectlist();
|
||
ontoolbar = false;
|
||
seescroll = false;
|
||
|
||
ppos[0][1] = -177;
|
||
_vm->_trip->tr[0].appear(300,117,right); // Needed to initialize Avalot.
|
||
//for (gd = 0; gd <= 30; gd++) for (gm = 0; gm <= 1; gm++) also[gd][gm] = nil;
|
||
/* fillchar(previous^,sizeof(previous^),#0); { blank out array } */
|
||
him = 254;
|
||
her = 254;
|
||
it = 254;
|
||
last_person = 254; /* = Pardon? */
|
||
dna.pass_num = _vm->_rnd->getRandomNumber(30) + 1; //Random(30) + 1;
|
||
after_the_scroll = false;
|
||
dna.user_moves_avvy = false;
|
||
doing_sprite_run = false;
|
||
dna.avvy_in_bed = true;
|
||
enid_filename = "";
|
||
|
||
for (byte gd = 0; gd <= 1; gd++) {
|
||
cp = 1 - cp;
|
||
_vm->_trip->getback();
|
||
}
|
||
|
||
_vm->_lucerna->enterroom(1, 1);
|
||
_vm->_trip->new_game_for_trippancy();
|
||
_vm->_lucerna->showscore();
|
||
|
||
_vm->_dropdown->setupMenu();
|
||
_vm->_lucerna->clock_lucerna();
|
||
_vm->_lucerna->sprite_run();
|
||
}
|
||
|
||
void Gyro::click() {
|
||
warning("STUB: Gyro::click()");
|
||
}
|
||
|
||
void Gyro::slowdown() {
|
||
warning("STUB: Gyro::slowdown()");
|
||
}
|
||
|
||
bool Gyro::flagset(char x) {
|
||
for (uint16 i = 0; i < flags.size(); i++) {
|
||
if (flags[i] == x)
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
void Gyro::force_numlock() {
|
||
if ((locks & numlockCode) > 0)
|
||
locks -= numlockCode;
|
||
}
|
||
|
||
bool Gyro::pennycheck(uint16 howmuchby) {
|
||
dna.pence -= howmuchby;
|
||
if (dna.pence < 0) {
|
||
_vm->_visa->dixi('Q', 2); // "You are now denariusless!"
|
||
_vm->_lucerna->gameover();
|
||
return false;
|
||
} else
|
||
return true;
|
||
}
|
||
|
||
// There'll may be problems with calling these functions because of the conversion of the arrays!!!
|
||
// Keep an eye open!
|
||
Common::String Gyro::getname(byte whose) {
|
||
if (whose < 175)
|
||
return lads[whose - 150];
|
||
else
|
||
return lasses[whose - 175];
|
||
}
|
||
|
||
// Keep an eye open! ^
|
||
byte Gyro::getnamechar(byte whose) {
|
||
if (whose < 175)
|
||
return ladchar[whose - 150];
|
||
else
|
||
return lasschar[whose - 175];
|
||
}
|
||
|
||
// Keep an eye open! ^^
|
||
Common::String Gyro::get_thing(byte which) {
|
||
Common::String get_thing_result;
|
||
switch (which) {
|
||
case wine:
|
||
switch (dna.winestate) {
|
||
case 1:
|
||
case 4:
|
||
get_thing_result = things[which - 1];
|
||
break;
|
||
case 3:
|
||
get_thing_result = "Vinegar";
|
||
break;
|
||
}
|
||
break;
|
||
case onion:
|
||
if (dna.rotten_onion)
|
||
get_thing_result = "rotten onion";
|
||
else
|
||
get_thing_result = things[which - 1];
|
||
break;
|
||
default:
|
||
get_thing_result = things[which - 1];
|
||
}
|
||
return get_thing_result;
|
||
}
|
||
|
||
// Keep an eye open! ^^^
|
||
char Gyro::get_thingchar(byte which) {
|
||
char get_thingchar_result;
|
||
switch (which) {
|
||
case wine:
|
||
if (dna.winestate == 3)
|
||
get_thingchar_result = 'V'; /* Vinegar */
|
||
else
|
||
get_thingchar_result = thingchar[which - 1];
|
||
break;
|
||
default:
|
||
get_thingchar_result = thingchar[which - 1];
|
||
}
|
||
return get_thingchar_result;
|
||
}
|
||
|
||
// Keep an eye open! ^^^^
|
||
Common::String Gyro::get_better(byte which) {
|
||
Common::String get_better_result;
|
||
if (which > 150)
|
||
which -= 149;
|
||
|
||
switch (which) {
|
||
case wine:
|
||
switch (dna.winestate) {
|
||
case 0:
|
||
case 1:
|
||
case 4:
|
||
get_better_result = better[which - 1];
|
||
break;
|
||
case 3:
|
||
get_better_result = "some vinegar";
|
||
break;
|
||
}
|
||
break;
|
||
case onion:
|
||
if (dna.rotten_onion)
|
||
get_better_result = "a rotten onion";
|
||
else if (dna.onion_in_vinegar)
|
||
get_better_result = "a pickled onion (in the vinegar)";
|
||
else
|
||
get_better_result = better[which - 1];
|
||
break;
|
||
default:
|
||
if ((which < numobjs) && (which > 0))
|
||
get_better_result = better[which - 1];
|
||
else
|
||
get_better_result = "";
|
||
}
|
||
return get_better_result;
|
||
}
|
||
|
||
|
||
Common::String Gyro::f5_does() {
|
||
Common::String f5_does_result;
|
||
switch (dna.room) {
|
||
case r__yours: {
|
||
if (!dna.avvy_is_awake)
|
||
return Common::String(_vm->_acci->kVerbCodeWake) + "WWake up";
|
||
else if (dna.avvy_in_bed)
|
||
return Common::String(_vm->_acci->kVerbCodeStand) + "GGet up";
|
||
}
|
||
break;
|
||
case r__insidecardiffcastle:
|
||
if (dna.standing_on_dais)
|
||
return Common::String(_vm->_acci->kVerbCodeClimb) + "CClimb down";
|
||
else
|
||
return Common::String(_vm->_acci->kVerbCodeClimb) + "CClimb up";
|
||
break;
|
||
case r__nottspub:
|
||
if (dna.sitting_in_pub)
|
||
return Common::String(_vm->_acci->kVerbCodeStand) + "SStand up";
|
||
else
|
||
return Common::String(_vm->_acci->kVerbCodeSit) + "SSit down";
|
||
break;
|
||
case r__musicroom:
|
||
if (_vm->_trip->infield(7))
|
||
return Common::String(_vm->_acci->kVerbCodePlay) + "PPlay the harp";
|
||
break;
|
||
}
|
||
|
||
return Common::String(_vm->_acci->kPardon); /* If all else fails... */
|
||
}
|
||
|
||
void Gyro::load_a_mouse(byte which) {
|
||
Common::File f;
|
||
|
||
if (!f.open("mice.avd")) {
|
||
warning("AVALANCHE: Gyro: File not found: mice.avd");
|
||
return;
|
||
}
|
||
|
||
::Graphics::Surface cursor;
|
||
cursor.create(16, 32, ::Graphics::PixelFormat::createFormatCLUT8());
|
||
cursor.fillRect(Common::Rect(0, 0, 16, 32), 255);
|
||
|
||
|
||
// The AND mask.
|
||
f.seek(mouse_size * 2 * (which - 1) + 134);
|
||
|
||
::Graphics::Surface mask = _vm->_graphics->loadPictureGraphic(f);
|
||
|
||
for (byte j = 0; j < mask.h; j++)
|
||
for (byte i = 0; i < mask.w; i++)
|
||
for (byte k = 0; k < 2; k++)
|
||
if (*(byte *)mask.getBasePtr(i, j) == 0)
|
||
*(byte *)cursor.getBasePtr(i, j * 2 + k) = 0;
|
||
|
||
mask.free();
|
||
|
||
// The OR mask.
|
||
f.seek(mouse_size * 2 * (which - 1) + 134 * 2);
|
||
|
||
mask = _vm->_graphics->loadPictureGraphic(f);
|
||
|
||
for (byte j = 0; j < mask.h; j++)
|
||
for (byte i = 0; i < mask.w; i++)
|
||
for (byte k = 0; k < 2; k++) {
|
||
byte pixel = *(byte *)mask.getBasePtr(i, j);
|
||
if (pixel != 0)
|
||
*(byte *)cursor.getBasePtr(i, j * 2 + k) = pixel;
|
||
}
|
||
|
||
mask.free();
|
||
|
||
f.close();
|
||
|
||
|
||
|
||
CursorMan.replaceCursor(cursor.pixels, 16, 32, mps[which - 1].horzhotspot, mps[which - 1].verthotspot * 2, 255, false);
|
||
|
||
cursor.free();
|
||
}
|
||
|
||
void Gyro::background(byte x) {
|
||
warning("STUB: Gyro::background()");
|
||
}
|
||
|
||
void Gyro::hang_around_for_a_while() {
|
||
for (byte i = 0; i < 28; i++)
|
||
slowdown();
|
||
}
|
||
|
||
bool Gyro::mouse_near_text() {
|
||
return (my > 144) && (my < 188);
|
||
}
|
||
|
||
} // End of namespace Avalanche
|