aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--engines/avalanche/trip6.cpp1491
-rw-r--r--engines/avalanche/trip6.h227
2 files changed, 1718 insertions, 0 deletions
diff --git a/engines/avalanche/trip6.cpp b/engines/avalanche/trip6.cpp
new file mode 100644
index 0000000000..ac0e8d0609
--- /dev/null
+++ b/engines/avalanche/trip6.cpp
@@ -0,0 +1,1491 @@
+/* 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.
+ */
+
+/* TRIP5 Trippancy V */
+
+#include "avalanche/trip6.h"
+#include "common/scummsys.h"
+#include "common/textconsole.h"
+
+#include "avalanche/scrolls2.h"
+#include "avalanche/lucerna2.h"
+#include "avalanche/visa2.h"
+#include "avalanche/gyro2.h"
+#include "avalanche/celer2.h"
+#include "avalanche/sequence2.h"
+#include "avalanche/timeout2.h"
+#include "avalanche/enid2.h"
+
+/*#include "Dropdown.h"*/
+
+
+namespace Avalanche {
+
+ namespace Trip {
+
+ void loadtrip() {
+ byte gm;
+
+ for (gm = 1; gm <= numtr; gm ++) tr[gm].original();
+ for (int i = 0; i < sizeof(aa); aa[i] = 0);
+ }
+
+ byte checkfeet(int16 x1, int16 x2, int16 oy, int16 y, byte yl) {
+ byte a, c;
+ int16 fv, ff;
+
+ /* if not alive then begin checkfeet:=0; exit; end;*/
+ byte checkfeet_result;
+ a = 0;
+
+ warning("STUB: Trip::checkfeet()");
+
+ checkfeet_result = a;
+ return checkfeet_result;
+ }
+
+ byte geida_ped(byte which) {
+ byte geida_ped_result;
+ switch (which) {
+ case 1:
+ geida_ped_result = 7;
+ break;
+ case 2:
+ case 6:
+ geida_ped_result = 8;
+ break;
+ case 3:
+ case 5:
+ geida_ped_result = 9;
+ break;
+ case 4:
+ geida_ped_result = 10;
+ break;
+ }
+ return geida_ped_result;
+ }
+
+ void catamove(byte ped)
+ /* When you enter a new position in the catacombs, this procedure should
+ be called. It changes the Also codes so that they may match the picture
+ on the screen. (Coming soon: It draws up the screen, too.) */
+ {
+
+ warning("Repair array indexes in Trip::catamove()");
+
+ int32 here;
+ uint16 xy_uint16;
+ byte fv, ff;
+
+ /* XY_uint16 is cat_x+cat_y*256. Thus, every room in the
+ catacombs has a different number for it. */
+
+
+
+ xy_uint16 = Gyro::dna.cat_x + Gyro::dna.cat_y * 256;
+ Gyro::dna.geida_spin = 0;
+
+ switch (xy_uint16) {
+ case 1801: { /* Exit catacombs */
+ fliproom(r__lustiesroom, 4);
+ Scrolls::display("Phew! Nice to be out of there!");
+ return;
+ }
+ break;
+ case 1033: { /* Oubliette */
+ fliproom(r__oubliette, 1);
+ Scrolls::display("Oh, NO!\231\2");
+ return;
+ }
+ break;
+ case 4: {
+ fliproom(r__geidas, 1);
+ return;
+ }
+ break;
+ case 2307: {
+ fliproom(r__lusties, 5);
+ Scrolls::display("Oh no... here we go again...");
+ Gyro::dna.user_moves_avvy = false;
+ tr[1].iy = 1;
+ tr[1].ix = 0;
+ return;
+ }
+ break;
+ }
+
+ if (! Gyro::dna.enter_catacombs_from_lusties_room) Lucerna::load(29);
+ here = Gyro::catamap[Gyro::dna.cat_y][Gyro::dna.cat_x];
+
+ switch (here & 0xf) { /* West. */
+ case 0: { /* no connection (wall) */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::nix; /* Door. */
+ Celer::show_one(28);
+ }
+ break;
+ case 0x1: { /* no connection (wall + shield), */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::nix; /* Door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(29); /* ...shield. */
+ }
+ break;
+ case 0x2: { /* wall with door */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::special; /* Door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(30); /* ...door. */
+ }
+ break;
+ case 0x3: { /* wall with door and shield */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::special; /* Door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(30); /* ...door, and... */
+ Celer::show_one(29); /* ...shield. */
+ }
+ break;
+ case 0x4: { /* no connection (wall + window), */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::nix; /* Door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(5); /* ...window. */
+ }
+ break;
+ case 0x5: { /* wall with door and window */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::special; /* Door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(30); /* ...door, and... */
+ Celer::show_one(5); /* ...window. */
+ }
+ break;
+ case 0x6: { /* no connection (wall + torches), */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::nix; /* No door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(7); /* ...torches. */
+ }
+ break;
+ case 0x7: { /* wall with door and torches */
+ Gyro::magics[2].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[13].op = Gyro::special; /* Door. */
+ Celer::show_one(28); /* Wall, plus... */
+ Celer::show_one(30); /* ...door, and... */
+ Celer::show_one(7); /* ...torches. */
+ }
+ break;
+ case 0xf: { /* straight-through corridor. */
+ Gyro::magics[2].op = Gyro::nix; /* Sloping wall. */
+ Gyro::magics[3].op = Gyro::special; /* Straight wall. */
+ }
+ break;
+ }
+
+ /* ---- */
+
+ switch ((here & 0xf0) >> 4) { /* East */
+ case 0: { /* no connection (wall) */
+ Gyro::magics[5].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::nix; /* Door. */
+ Celer::show_one(19);
+ }
+ break;
+ case 0x1: { /* no connection (wall + window), */
+ Gyro::magics[5].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::nix; /* Door. */
+ Celer::show_one(19); /* Wall, plus... */
+ Celer::show_one(20); /* ...window. */
+ }
+ break;
+ case 0x2: { /* wall with door */
+ Gyro::magics[5].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::special; /* Door. */
+ Celer::show_one(19); /* Wall, plus... */
+ Celer::show_one(21); /* ...door. */
+ }
+ break;
+ case 0x3: { /* wall with door and window */
+ Gyro::magics[5].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::special; /* Door. */
+ Celer::show_one(19); /* Wall, plus... */
+ Celer::show_one(20); /* ...door, and... */
+ Celer::show_one(21); /* ...window. */
+ }
+ break;
+ case 0x6: { /* no connection (wall + torches), */
+ Gyro::magics[5].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::nix; /* No door. */
+ Celer::show_one(19); /* Wall, plus... */
+ Celer::show_one(18); /* ...torches. */
+ }
+ break;
+ case 0x7: { /* wall with door and torches */
+ Gyro::magics[5].op = Gyro::bounces; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::nix; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::special; /* Door. */
+ Celer::show_one(19); /* Wall, plus... */
+ Celer::show_one(21); /* ...door, and... */
+ Celer::show_one(18); /* ...torches. */
+ }
+ break;
+ case 0xf: { /* straight-through corridor. */
+ Gyro::magics[5].op = Gyro::nix; /* Sloping wall. */
+ Gyro::magics[6].op = Gyro::special; /* Straight wall. */
+ Gyro::portals[15].op = Gyro::nix; /* Door. */
+ }
+ break;
+ }
+
+ /* ---- */
+
+ switch ((here & 0xf00) >> 8) { /* South */
+ case 0: { /* No connection. */
+ Gyro::magics[7].op = Gyro::bounces;
+ Gyro::magics[12].op = Gyro::bounces;
+ Gyro::magics[13].op = Gyro::bounces;
+ }
+ break;
+ case 0x1: {
+ Celer::show_one(22);
+
+ if ((xy_uint16 == 2051) & (Gyro::dna.geida_follows))
+ Gyro::magics[13].op = Gyro::exclaim;
+ else Gyro::magics[13].op = Gyro::special; /* Right exit south. */
+
+ Gyro::magics[7].op = Gyro::bounces;
+ Gyro::magics[12].op = Gyro::bounces;
+ }
+ break;
+ case 0x2: {
+ Celer::show_one(23);
+ Gyro::magics[7].op = Gyro::special; /* Middle exit south. */
+ Gyro::magics[12].op = Gyro::bounces;
+ Gyro::magics[13].op = Gyro::bounces;
+ }
+ break;
+ case 0x3: {
+ Celer::show_one(24);
+ Gyro::magics[12].op = Gyro::special; /* Left exit south. */
+ Gyro::magics[7].op = Gyro::bounces;
+ Gyro::magics[13].op = Gyro::bounces;
+ }
+ break;
+ }
+
+ switch ((here & 0xf000) >> 12) { /* North */
+ case 0: { /* No connection */
+ Gyro::magics[1].op = Gyro::bounces;
+ Gyro::portals[12].op = Gyro::nix; /* Door. */
+ }
+ break;
+ /* LEFT handles: */
+ /* $1: begin
+ Celer::show_one(4);
+ Gyro::magics[1].op:=Gyro::bounces; { Left exit north. } { Change magic number! }
+ Gyro::portals[12].op:=Gyro::special; { Door. }
+ end;*/
+ case 0x2: {
+ Celer::show_one(4);
+ Gyro::magics[1].op = Gyro::bounces; /* Middle exit north. */
+ Gyro::portals[12].op = Gyro::special; /* Door. */
+ }
+ break;
+ /* $3: begin
+ Celer::show_one(4);
+ Gyro::magics[1].op:=Gyro::bounces; { Right exit north. } { Change magic number! }
+ Gyro::portals[12].op:=Gyro::special; { Door. }
+ end;
+ { RIGHT handles: }
+ $4: begin
+ Celer::show_one(3);
+ Gyro::magics[1].op:=Gyro::bounces; { Left exit north. } { Change magic number! }
+ Gyro::portals[12].op:=Gyro::special; { Door. }
+ end;*/
+ case 0x5: {
+ Celer::show_one(3);
+ Gyro::magics[1].op = Gyro::bounces; /* Middle exit north. */
+ Gyro::portals[12].op = Gyro::special; /* Door. */
+ }
+ break;
+ /* $6: begin
+ Celer::show_one(3);
+ Gyro::magics[1].op:=Gyro::bounces; { Right exit north. }
+ Gyro::portals[12].op:=Gyro::special; { Door. }
+ end;*/
+ /* ARCHWAYS: */
+ case 0x7:
+ case 0x8:
+ case 0x9: {
+ Celer::show_one(6);
+
+ if (((here & 0xf000) >> 12) > 0x7) Celer::show_one(31);
+ if (((here & 0xf000) >> 12) == 0x9) Celer::show_one(32);
+
+ Gyro::magics[1].op = Gyro::special; /* Middle arch north. */
+ Gyro::portals[12].op = Gyro::nix; /* Door. */
+ }
+ break;
+ /* DECORATIONS: */
+ case 0xd: { /* No connection + WINDOW */
+ Gyro::magics[1].op = Gyro::bounces;
+ Gyro::portals[12].op = Gyro::nix; /* Door. */
+ Celer::show_one(14);
+ }
+ break;
+ case 0xe: { /* No connection + TORCH */
+ Gyro::magics[1].op = Gyro::bounces;
+ Gyro::portals[12].op = Gyro::nix; /* Door. */
+ Celer::show_one(8);
+ }
+ break;
+ /* Recessed door: */
+ case 0xf: {
+ Gyro::magics[1].op = Gyro::nix; /* Door to Geida's room. */
+ Celer::show_one(1);
+ Gyro::portals[12].op = Gyro::special; /* Door. */
+ }
+ break;
+ }
+
+ switch (xy_uint16) {
+ case 514:
+ Celer::show_one(17);
+ break; /* [2,2] : "Art Gallery" sign over door. */
+ case 264:
+ Celer::show_one(9);
+ break; /* [8,1] : "The Wrong Way!" sign. */
+ case 1797:
+ Celer::show_one(2);
+ break; /* [5,7] : "Ite Mingite" sign. */
+ case 258:
+ for (fv = 0; fv <= 2; fv ++) { /* [2,1] : Art gallery - pictures */
+ Celer::show_one_at(15, 130 + fv * 120, 70);
+ Celer::show_one_at(16, 184 + fv * 120, 78);
+ }
+ break;
+ case 1287:
+ for (fv = 10; fv <= 13; fv ++) Celer::show_one(fv);
+ break; /* [7,5] : 4 candles. */
+ case 776:
+ Celer::show_one(10);
+ break; /* [8,3] : 1 candle. */
+ case 2049:
+ Celer::show_one(11);
+ break; /* [1,8] : another candle. */
+ case 257: {
+ Celer::show_one(12);
+ Celer::show_one(13);
+ }
+ break; /* [1,1] : the other two. */
+ }
+
+ if ((Gyro::dna.geida_follows) & (ped > 0)) {
+ triptype &with = tr[2];
+
+ if (! with.quick) /* If we don't already have her... */
+ tr[2].init(5, true); /* ...Load Geida. */
+ apped(2, geida_ped(ped));
+ tr[2].call_eachstep = true;
+ tr[2].eachstep = procgeida_procs;
+ }
+ }
+
+ void call_special(uint16 which);
+
+ /* This proc gets called whenever you touch a line defined as Gyro::special. */
+ static void dawndelay() {
+ Timeout::set_up_timer(2, Timeout::procdawn_delay, Timeout::reason_dawndelay);
+ }
+
+ void call_special(uint16 which) {
+ switch (which) {
+ case 1: { /* Gyro::special 1: Room 22: top of stairs. */
+ Celer::show_one(1);
+ Gyro::dna.brummie_stairs = 1;
+ Gyro::magics[10].op = Gyro::nix;
+ Timeout::set_up_timer(10, Timeout::procstairs, Timeout::reason_brummiestairs);
+ stopwalking();
+ Gyro::dna.user_moves_avvy = false;
+ }
+ break;
+ case 2: { /* Gyro::special 2: Room 22: bottom of stairs. */
+ Gyro::dna.brummie_stairs = 3;
+ Gyro::magics[11].op = Gyro::nix;
+ Gyro::magics[12].op = Gyro::exclaim;
+ Gyro::magics[12].data = 5;
+ Gyro::magics[4].op = Gyro::bounces; /* Now works as planned! */
+ stopwalking();
+ Visa::dixi('q', 26);
+ Gyro::dna.user_moves_avvy = true;
+ }
+ break;
+ case 3: { /* Gyro::special 3: Room 71: triggers dart. */
+ tr[1].bounce(); /* Must include that. */
+
+ if (! Gyro::dna.arrow_triggered) {
+ Gyro::dna.arrow_triggered = true;
+ apped(2, 4); /* The dart starts at ped 4, and... */
+ tr[2].walkto(5); /* flies to ped 5. */
+ tr[2].face = 0; /* Only face. */
+ /* Should call some kind of Eachstep procedure which will deallocate
+ the sprite when it hits the wall, and replace it with the chunk
+ graphic of the arrow buried in the plaster. */
+ /* OK! */
+ tr[2].call_eachstep = true;
+ tr[2].eachstep = procarrow_procs;
+ }
+ }
+ break;
+
+ case 4: { /* This is the ghost room link. */
+ Lucerna::dusk();
+ tr[1].turn(right); /* you'll see this after we get back from bootstrap */
+ Timeout::set_up_timer(1, Timeout::procghost_room_phew, Timeout::reason_ghost_room_phew);
+ Enid::back_to_bootstrap(3);
+ }
+ break;
+
+ case 5:
+ if (Gyro::dna.friar_will_tie_you_up) {
+ /* Gyro::special 5: Room 42: touched tree, and get tied up. */
+ Gyro::magics[4].op = Gyro::bounces; /* Boundary effect is now working again. */
+ Visa::dixi('q', 35);
+ tr[1].done();
+ /*tr[1].vanishifstill:=true;*/
+ Celer::show_one(2);
+ Visa::dixi('q', 36);
+ Gyro::dna.tied_up = true;
+ Gyro::dna.friar_will_tie_you_up = false;
+ tr[2].walkto(3);
+ tr[2].vanishifstill = true;
+ tr[2].check_me = true; /* One of them must have Check_Me switched on. */
+ Gyro::whereis[Gyro::pfriartuck] = 177; /* Not here, then. */
+ Timeout::set_up_timer(364, Timeout::prochang_around, Timeout::reason_hanging_around);
+ }
+ break;
+
+ case 6: { /* Gyro::special 6: fall down oubliette. */
+ Gyro::dna.user_moves_avvy = false;
+ tr[1].ix = 3;
+ tr[1].iy = 0;
+ tr[1].face = right;
+ Timeout::set_up_timer(1, Timeout::procfall_down_oubliette, Timeout::reason_falling_down_oubliette);
+ }
+ break;
+
+ case 7: { /* Gyro::special 7: stop falling down oubliette. */
+ tr[1].visible = false;
+ Gyro::magics[10].op = Gyro::nix;
+ stopwalking();
+ Timeout::lose_timer(Timeout::reason_falling_down_oubliette);
+ Lucerna::mblit(12, 80, 38, 160, 3, 0);
+ Lucerna::mblit(12, 80, 38, 160, 3, 1);
+ Scrolls::display("Oh dear, you seem to be down the bottom of an oubliette.");
+ Timeout::set_up_timer(200, Timeout::procmeet_avaroid, Timeout::reason_meeting_avaroid);
+ }
+ break;
+
+ case 8: /* Gyro::special 8: leave du Lustie's room. */
+ if ((Gyro::dna.geida_follows) && (! Gyro::dna.lustie_is_asleep)) {
+ Visa::dixi('q', 63);
+ tr[2].turn(down);
+ tr[2].stopwalk();
+ tr[2].call_eachstep = false; /* Geida */
+ Lucerna::gameover();
+ }
+ break;
+
+ case 9: { /* Gyro::special 9: lose Geida to Robin Hood... */
+ if (! Gyro::dna.geida_follows) return; /* DOESN'T COUNT: no Geida. */
+ tr[2].call_eachstep = false; /* She no longer follows Avvy around. */
+ tr[2].walkto(4); /* She walks to somewhere... */
+ tr[1].done(); /* Lose Avvy. */
+ Gyro::dna.user_moves_avvy = false;
+ Timeout::set_up_timer(40, Timeout::procrobin_hood_and_geida, Timeout::reason_robin_hood_and_geida);
+ }
+ break;
+
+ case 10: { /* Gyro::special 10: transfer north in catacombs. */
+ if ((Gyro::dna.cat_x == 4) && (Gyro::dna.cat_y == 1)) {
+ /* Into Geida's room. */
+ if (Gyro::dna.obj[Gyro::key]) Visa::dixi('q', 62);
+ else {
+ Visa::dixi('q', 61);
+ return;
+ }
+ }
+ Lucerna::dusk();
+ Gyro::dna.cat_y -= 1;
+ catamove(4);
+ if (Gyro::dna.room != r__catacombs) return;
+ Lucerna::delavvy();
+ switch ((Gyro::catamap[Gyro::dna.cat_y][Gyro::dna.cat_x] & 0xf00) >> 8) {
+ case 0x1:
+ apped(1, 12);
+ break;
+ case 0x3:
+ apped(1, 11);
+ break;
+ default:
+ apped(1, 4);
+ }
+ getback();
+ dawndelay();
+ }
+ break;
+ case 11: { /* Gyro::special 11: transfer east in catacombs. */
+ Lucerna::dusk();
+ Gyro::dna.cat_x += 1;
+ catamove(1);
+ if (Gyro::dna.room != r__catacombs) return;
+ Lucerna::delavvy();
+ apped(1, 1);
+ getback();
+ dawndelay();
+ }
+ break;
+ case 12: { /* Gyro::special 12: transfer south in catacombs. */
+ Lucerna::dusk();
+ Gyro::dna.cat_y += 1;
+ catamove(2);
+ if (Gyro::dna.room != r__catacombs) return;
+ Lucerna::delavvy();
+ apped(1, 2);
+ getback();
+ dawndelay();
+ }
+ break;
+ case 13: { /* Gyro::special 13: transfer west in catacombs. */
+ Lucerna::dusk();
+ Gyro::dna.cat_x -= 1;
+ catamove(3);
+ if (Gyro::dna.room != r__catacombs) return;
+ Lucerna::delavvy();
+ apped(1, 3);
+ getback();
+ dawndelay();
+ }
+ break;
+ }
+ }
+
+ void hide_in_the_cupboard();
+
+ void open_the_door(byte whither, byte ped, byte magicnum)
+ /* This slides the door open. (The data really ought to be saved in
+ the Also file, and will be next time. However, for now, they're
+ here.) */
+ {
+ switch (Gyro::dna.room) {
+ case r__outsideyours:
+ case r__outsidenottspub:
+ case r__outsideducks: {
+ Sequence::first_show(1);
+ Sequence::then_show(2);
+ Sequence::then_show(3);
+ }
+ break;
+ case r__insidecardiffcastle: {
+ Sequence::first_show(1);
+ Sequence::then_show(5);
+ }
+ break;
+ case r__avvysgarden:
+ case r__entrancehall:
+ case r__insideabbey: {
+ Sequence::first_show(1);
+ Sequence::then_show(2);
+ }
+ break;
+ case r__musicroom:
+ case r__outsideargentpub: {
+ Sequence::first_show(5);
+ Sequence::then_show(6);
+ }
+ break;
+ case r__lusties:
+ switch (magicnum) {
+ case 14:
+ if (Gyro::dna.avvys_in_the_cupboard) {
+ hide_in_the_cupboard();
+ Sequence::first_show(8);
+ Sequence::then_show(7);
+ Sequence::start_to_close();
+ return;
+ } else {
+ apped(1, 6);
+ tr[1].face = right; /* added by TT 12/3/1995 */
+ Sequence::first_show(8);
+ Sequence::then_show(9);
+ }
+ break;
+ case 12: {
+ Sequence::first_show(4);
+ Sequence::then_show(5);
+ Sequence::then_show(6);
+ }
+ break;
+ }
+ break;
+ }
+
+ Sequence::then_flip(whither, ped);
+ Sequence::start_to_open();
+ }
+
+ void newspeed() {
+ /* Given that you've just changed the speed in triptype.xs, this adjusts
+ ix. */
+ warning("STUB: Trip::newspeed()");
+ }
+
+ triptype *triptype::init(byte spritenum, bool do_check) {
+ warning("STUB: Trip::init()");
+ return this;
+ }
+
+ void triptype::original() {
+ quick = false;
+ whichsprite = 177;
+ }
+
+ void triptype::andexor() {
+ warning("STUB: Trip::andexor()");
+ }
+
+ void triptype::turn(byte whichway) {
+ if (whichway == 8) face = 0;
+ else face = whichway;
+ }
+
+ void triptype::appear(int16 wx, int16 wy, byte wf) {
+ x = (wx / 8) * 8;
+ y = wy;
+ ox[Gyro::cp] = wx;
+ oy[Gyro::cp] = wy;
+ turn(wf);
+ visible = true;
+ ix = 0;
+ iy = 0;
+ }
+
+
+
+
+ bool triptype::collision_check() {
+ byte fv;
+
+ bool collision_check_result;
+ for (fv = 1; fv <= numtr; fv ++)
+ if (tr[fv].quick && (tr[fv].whichsprite != whichsprite) &&
+ ((x + a.xl) > tr[fv].x) &&
+ (x < (tr[fv].x + tr[fv].a.xl)) &&
+ (tr[fv].y == y)) {
+ collision_check_result = true;
+ return collision_check_result;
+ }
+ collision_check_result = false;
+ return collision_check_result;
+ }
+
+ void triptype::walk() {
+ warning("STUB: Trip::walk()");
+ }
+
+ void triptype::bounce() {
+ x = ox[Gyro::cp];
+ y = oy[Gyro::cp];
+ if (check_me) stopwalking();
+ else stopwalk();
+ Gyro::oncandopageswap = false;
+ Lucerna::showrw();
+ Gyro::oncandopageswap = true;
+ }
+
+ int8 sgn(int16 x) {
+ int8 sgn_result;
+ if (x > 0) sgn_result = 1;
+ else if (x < 0) sgn_result = -1;
+ else
+ sgn_result = 0; /* x=0 */
+ return sgn_result;
+ }
+
+ void triptype::walkto(byte pednum) {
+ speed(sgn(Gyro::peds[pednum].x - x) * 4, sgn(Gyro::peds[pednum].y - y));
+ hx = Gyro::peds[pednum].x - a.xl / 2;
+ hy = Gyro::peds[pednum].y - a.yl;
+ homing = true;
+ }
+
+ void triptype::stophoming() {
+ homing = false;
+ }
+
+ void triptype::homestep() {
+ int16 temp;
+
+ if ((hx == x) && (hy == y)) {
+ /* touching the target */
+ stopwalk();
+ return;
+ }
+ ix = 0;
+ iy = 0;
+ if (hy != y) {
+ temp = hy - y;
+ if (temp > 4) iy = 4;
+ else if (temp < -4) iy = -4;
+ else iy = temp;
+ }
+ if (hx != x) {
+ temp = hx - x;
+ if (temp > 4) ix = 4;
+ else if (temp < -4) ix = -4;
+ else ix = temp;
+ }
+ }
+
+ void triptype::speed(int8 xx, int8 yy) {
+ ix = xx;
+ iy = yy;
+ if ((ix == 0) && (iy == 0)) return; /* no movement */
+ if (ix == 0) {
+ /* No horz movement */
+ if (iy < 0) turn(up);
+ else turn(down);
+ } else {
+ if (ix < 0) turn(left);
+ else turn(right);
+ }
+ }
+
+ void triptype::stopwalk() {
+ ix = 0;
+ iy = 0;
+ homing = false;
+ }
+
+ void triptype::chatter() {
+ Gyro::talkx = x + a.xl / 2;
+ Gyro::talky = y;
+ Gyro::talkf = a.fgc;
+ Gyro::talkb = a.bgc;
+ }
+
+ void triptype::set_up_saver(trip_saver_type &v) {
+ v.whichsprite = whichsprite;
+ v.face = face;
+ v.step = step;
+ v.x = x;
+ v.y = y;
+ v.ix = ix;
+ v.iy = iy;
+ v.visible = visible;
+ v.homing = homing;
+ v.check_me = check_me;
+ v.count = count;
+ v.xw = xw;
+ v.xs = xs;
+ v.ys = ys;
+ v.totalnum = totalnum;
+ v.hx = hx;
+ v.hy = hy;
+ v.call_eachstep = call_eachstep;
+ v.eachstep = eachstep;
+ v.vanishifstill = vanishifstill;
+ }
+
+ void triptype::unload_saver(trip_saver_type v) {
+ whichsprite = v.whichsprite;
+ face = v.face;
+ step = v.step;
+ x = v.x;
+ y = v.y;
+ ix = v.ix;
+ iy = v.iy;
+ visible = v.visible;
+ homing = v.homing;
+ check_me = v.check_me;
+ count = v.count;
+ xw = v.xw;
+ xs = v.xs;
+ ys = v.ys;
+ totalnum = v.totalnum;
+ hx = v.hx;
+ hy = v.hy;
+ call_eachstep = v.call_eachstep;
+ eachstep = v.eachstep;
+ vanishifstill = v.vanishifstill;
+ }
+
+ void triptype::savedata(/*untyped_file &f*/) {
+ warning("STUB: Timeout::savedata()");
+ }
+
+ void triptype::loaddata(/*untyped_file &f*/) {
+ warning("STUB: Timeout::loaddata()");
+ }
+
+ triptype *triptype::done() {
+ int16 gd, gm;
+ Common::String xx;
+ byte fv/*,nds*/;
+ byte aa, bb;
+ int32 id;
+ uint16 soa;
+
+ {
+ adxtype &with = a;
+
+ /* nds:=num div seq;*/
+ xw = with.xl / 8;
+ if ((with.xl % 8) > 0) xw += 1;
+ for (aa = 1; aa <= /*nds*seq*/ with.num; aa ++) {
+ totalnum --;
+ free(mani[totalnum]);
+ free(sil[totalnum]); /* <<- Width of a siltype. */
+ }
+ }
+
+ quick = false;
+ whichsprite = 177;
+ return this;
+ }
+
+ getsettype *getsettype::init() {
+ numleft = 0; /* initialise array pointer */
+ return this;
+ }
+
+ void getsettype::remember(Gyro::bytefield r) {
+ numleft ++;
+ warning("STUB: Timeout::getsettype::remember()");
+ gs[numleft] = r;
+ }
+
+ void getsettype::recall(Gyro::bytefield &r) {
+ r = gs[numleft];
+ numleft --;
+ }
+
+ void rwsp(byte t, byte r) {
+ {
+ switch (r) {
+ case up:
+ tr[t].speed(0, -tr[t].ys);
+ break;
+ case down:
+ tr[t].speed(0, tr[t].ys);
+ break;
+ case left:
+ tr[t].speed(-tr[t].xs, 0);
+ break;
+ case right:
+ tr[t].speed(tr[t].xs, 0);
+ break;
+ case ul:
+ tr[t].speed(-tr[t].xs, -tr[t].ys);
+ break;
+ case ur:
+ tr[t].speed(tr[t].xs, -tr[t].ys);
+ break;
+ case dl:
+ tr[t].speed(-tr[t].xs, tr[t].ys);
+ break;
+ case dr:
+ tr[t].speed(tr[t].xs, tr[t].ys);
+ break;
+ }
+ }
+ }
+
+ void apped(byte trn, byte np) {
+ tr[trn].appear(tr[trn].x - tr[trn].a.xl / 2, tr[trn].y - tr[trn].a.yl, Gyro::peds[np].dir);
+ rwsp(trn, Gyro::peds[np].dir);
+ }
+
+
+
+ void getback();
+
+ static Gyro::bytefield r;
+
+ /* function overlap(x1,y1,x2,y2,x3,y3,x4,y4:uint16):bool;
+ begin { By De Morgan's law: }
+ overlap:=(x2>=x3) and (x4>=x1) and (y2>=y3) and (y4>=y1);
+ end;*/
+ /* x1,x2 - as Gyro::bytefield, but *8. y1,y2 - as Gyro::bytefield.
+ x3,y3 = mx,my. x4,y4 = mx+16,my+16. */
+ static bool overlaps_with_mouse() {
+ bool overlaps_with_mouse_result;
+ overlaps_with_mouse_result =
+ (r.x2 * 8 >= Gyro::mx) && (Gyro::mx + 16 >= r.x1 * 8) && (r.y2 >= Gyro::my) && (Gyro::my + 16 >= r.y1);
+ return overlaps_with_mouse_result;
+ }
+
+ void getback() {
+ byte fv;
+ bool endangered;
+
+
+ endangered = false;
+ /* Super_Off;*/
+
+ {
+ while (getset[1 - Gyro::cp].numleft > 0) {
+ getset[1 - Gyro::cp].recall(r);
+
+ /* if overlaps_with_mouse and not endangered then
+ begin
+ endangered:=true;
+ blitfix;
+ Super_Off;
+ end;*/
+
+ Lucerna::mblit(r.x1, r.y1, r.x2, r.y2, 3, 1 - Gyro::cp);
+ }
+ }
+
+ Lucerna::blitfix();
+ /*if endangered then*/ /*Super_On;*/
+ }
+
+ /* Eachstep procedures: */
+ void follow_avvy_y(byte tripnum) {
+ if (tr[1].face == left)
+ return;
+ if (tr[tripnum].homing)
+ tr[tripnum].hy = tr[1].y;
+ else {
+ if (tr[tripnum].y < tr[1].y)
+ tr[tripnum].y += 1;
+ else if (tr[tripnum].y > tr[1].y)
+ tr[tripnum].y -= 1;
+ else
+ return;
+ if (tr[tripnum].ix == 0) {
+ tr[tripnum].step += 1;
+ if (tr[tripnum].step == tr[tripnum].a.seq) tr[tripnum].step = 0;
+ tr[tripnum].count = 0;
+ }
+ }
+ }
+
+ void back_and_forth(byte tripnum) {
+ if (! tr[tripnum].homing) {
+ if (tr[tripnum].face == right)
+ tr[tripnum].walkto(4);
+ else
+ tr[tripnum].walkto(5);
+ }
+ }
+
+ void face_avvy(byte tripnum) {
+ if (! tr[tripnum].homing) {
+ if (tr[1].x >= tr[tripnum].x) tr[tripnum].face = right;
+ else tr[tripnum].face = left;
+ }
+ }
+
+ void arrow_procs(byte tripnum) {
+ byte fv;
+
+ if (tr[tripnum].homing) {
+ /* Arrow is still in flight. */
+ /* We must check whether or not the arrow has collided tr[tripnum] Avvy's head.
+ This is so if: a) the bottom of the arrow is below Avvy's head,
+ b) the left of the arrow is left of the right of Avvy's head, and
+ c) the right of the arrow is right of the left of Avvy's head. */
+ if (((tr[tripnum].y + tr[tripnum].a.yl) >= tr[1].y) /* A */
+ && (tr[tripnum].x <= (tr[1].x + tr[1].a.xl)) /* B */
+ && ((tr[tripnum].x + tr[tripnum].a.xl) >= tr[1].x)) { /* C */
+ /* OK, it's hit him... what now? */
+
+ tr[2].call_eachstep = false; /* prevent recursion. */
+ Visa::dixi('Q', 47); /* Complaint! */
+ tr[tripnum].done(); /* Deallocate the arrow. */
+ /* tr[1].done; { Deallocate normal pic of Avvy. }
+
+ off;
+ for fv:=0 to 1 do
+ begin
+ cp:=1-cp;
+ getback;
+ end;
+ on;*/
+
+ Lucerna::gameover();
+
+ Gyro::dna.user_moves_avvy = false; /* Stop the user from moving him. */
+ Timeout::set_up_timer(55, Timeout::procnaughty_duke, Timeout::reason_naughty_duke);
+ }
+ } else { /* Arrow has hit the wall! */
+ tr[tripnum].done(); /* Deallocate the arrow. */
+ Celer::show_one(3); /* Show pic of arrow stuck into the door. */
+ Gyro::dna.arrow_in_the_door = true; /* So that we can pick it up. */
+ }
+
+ }
+
+ /*procedure Spludwick_procs(tripnum:byte);
+ var fv:byte;
+ begin
+ with tr[tripnum] do
+ if not homing then { We only need to do anything if Spludwick *stops*
+ walking. }
+ with Gyro::dna do
+ begin
+ inc(DogfoodPos);
+ if DogfoodPos=8 then DogfoodPos:=1;
+ walkto(DogfoodPos);
+ end;
+ end;*/
+
+ void grab_avvy(byte tripnum) { /* For Friar Tuck, in Nottingham. */
+ byte fv;
+ int16 tox, toy;
+
+ tox = tr[1].x + 17;
+ toy = tr[1].y - 1;
+ if ((tr[tripnum].x == tox) && (tr[tripnum].y == toy)) {
+ tr[tripnum].call_eachstep = false;
+ tr[tripnum].face = left;
+ tr[tripnum].stopwalk();
+ /* ... whatever ... */
+ } else {
+ /* Still some way to go. */
+ if (tr[tripnum].x < tox) {
+ tr[tripnum].x += 5;
+ if (tr[tripnum].x > tox) tr[tripnum].x = tox;
+ }
+ if (tr[tripnum].y < toy) tr[tripnum].y += 1;
+ tr[tripnum].step += 1;
+ if (tr[tripnum].step == tr[tripnum].a.seq) tr[tripnum].step = 0;
+ }
+ }
+
+
+
+ void geida_procs(byte tripnum);
+
+ static void take_a_step(byte &tripnum) {
+ if (tr[tripnum].ix == 0) {
+ tr[tripnum].step += 1;
+ if (tr[tripnum].step == tr[tripnum].a.seq) tr[tripnum].step = 0;
+ tr[tripnum].count = 0;
+ }
+ }
+
+ static void spin(byte whichway, byte &tripnum) {
+ if (tr[tripnum].face != whichway) {
+ tr[tripnum].face = whichway;
+ if (tr[tripnum].whichsprite == 2) return; /* Not for Spludwick */
+
+ Gyro::dna.geida_spin += 1;
+ Gyro::dna.geida_time = 20;
+ if (Gyro::dna.geida_spin == 5) {
+ Scrolls::display("Steady on, Avvy, you'll make the poor girl dizzy!");
+ Gyro::dna.geida_spin = 0;
+ Gyro::dna.geida_time = 0; /* knock out records */
+ }
+ }
+ }
+
+ void geida_procs(byte tripnum) {
+ if (Gyro::dna.geida_time > 0) {
+ Gyro::dna.geida_time -= 1;
+ if (Gyro::dna.geida_time == 0) Gyro::dna.geida_spin = 0;
+ }
+
+ if (tr[tripnum].y < (tr[1].y - 2)) {
+ /* Geida is further from the screen than Avvy. */
+ spin(down, tripnum);
+ tr[tripnum].iy = 1;
+ tr[tripnum].ix = 0;
+ take_a_step(tripnum);
+ return;
+ } else if (tr[tripnum].y > (tr[1].y + 2)) {
+ /* Avvy is further from the screen than Geida. */
+ spin(up, tripnum);
+ tr[tripnum].iy = -1;
+ tr[tripnum].ix = 0;
+ take_a_step(tripnum);
+ return;
+ }
+
+ tr[tripnum].iy = 0;
+ if (tr[tripnum].x < tr[1].x - tr[1].xs * 8) {
+ tr[tripnum].ix = tr[1].xs;
+ spin(right, tripnum);
+ take_a_step(tripnum);
+ } else if (tr[tripnum].x > tr[1].x + tr[1].xs * 8) {
+ tr[tripnum].ix = -tr[1].xs;
+ spin(left, tripnum);
+ take_a_step(tripnum);
+ } else tr[tripnum].ix = 0;
+ }
+
+ /* That's all... */
+
+ void call_andexors() {
+ byte order[5];
+ byte fv, temp;
+ bool ok;
+
+ for (int i = 0; i < 5; i++)
+ order[i] = 0;
+
+ for (fv = 1; fv <= numtr; fv ++) {
+ if (tr[fv].quick && tr[fv].visible)
+ order[fv] = fv;
+ }
+
+ do {
+ ok = true;
+ for (fv = 1; fv <= 4; fv ++)
+ if (((order[fv] != 0) && (order[fv + 1] != 0))
+ && (tr[order[fv]].y > tr[order[fv + 1]].y)) {
+ /* Swap them! */
+ temp = order[fv];
+ order[fv] = order[fv + 1];
+ order[fv + 1] = temp;
+ ok = false;
+ }
+ } while (!ok);
+
+ for (fv = 1; fv <= 5; fv ++)
+ if (order[fv] > 0)
+ tr[order[fv]].andexor();
+ }
+
+ void trippancy_link() {
+ byte fv;
+
+ if (Gyro::ddmnow | Gyro::ontoolbar | Gyro::seescroll) return;
+ for (fv = 1; fv <= numtr; fv ++) {
+ if (tr[fv].quick)
+ tr[fv].walk();
+ }
+
+ call_andexors();
+ for (fv = 1; fv <= numtr; fv ++) {
+ triptype &with = tr[fv];
+ if (with.quick && with.call_eachstep) {
+ switch (tr[fv].eachstep) {
+ case procfollow_avvy_y :
+ follow_avvy_y(fv);
+ break;
+ case procback_and_forth :
+ back_and_forth(fv);
+ break;
+ case procface_avvy :
+ face_avvy(fv);
+ break;
+ case procarrow_procs :
+ arrow_procs(fv);
+ break;
+ /* PROCSpludwick_procs : spludwick_procs(fv);*/
+ case procgrab_avvy :
+ grab_avvy(fv);
+ break;
+ case procgeida_procs :
+ geida_procs(fv);
+ break;
+ }
+ }
+ }
+ if (mustexclaim) {
+ mustexclaim = false;
+ Visa::dixi('x', saywhat);
+ }
+ }
+
+ void get_back_loretta() {
+ byte fv;
+
+ /* for fv:=1 to numtr do with tr[fv] do if quick then getback;*/
+ for (fv = 1; fv <= numtr; fv ++) if (tr[fv].quick) {
+ getback();
+ return;
+ }
+ /* for fv:=0 to 1 do begin cp:=1-cp; getback; end;*/
+ }
+
+ void stopwalking() {
+ tr[1].stopwalk();
+ Gyro::dna.rw = stopped;
+ if (Gyro::alive)
+ tr[1].step = 1;
+ }
+
+ void tripkey(char dir) {
+ if ((Gyro::ctrl == Gyro::cjoy) | (! Gyro::dna.user_moves_avvy))
+ return;
+
+ {
+ triptype &with = tr[1];
+ {
+ switch (dir) {
+ case 'H':
+ if (Gyro::dna.rw != up) {
+ Gyro::dna.rw = up;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'P':
+ if (Gyro::dna.rw != down) {
+ Gyro::dna.rw = down;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'K':
+ if (Gyro::dna.rw != left) {
+ Gyro::dna.rw = left;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'M':
+ if (Gyro::dna.rw != right) {
+ Gyro::dna.rw = right;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'I':
+ if (Gyro::dna.rw != ur) {
+ Gyro::dna.rw = ur;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'Q':
+ if (Gyro::dna.rw != dr) {
+ Gyro::dna.rw = dr;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'O':
+ if (Gyro::dna.rw != dl) {
+ Gyro::dna.rw = dl;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'G':
+ if (Gyro::dna.rw != ul) {
+ Gyro::dna.rw = ul;
+ rwsp(1, Gyro::dna.rw);
+ } else stopwalking();
+ break;
+ case 'L':
+ stopwalking();
+ break;
+ }
+ }
+ }
+ }
+
+ void readstick() {
+ warning("STUB: Trip::readstick()");
+ }
+
+ void getsetclear() {
+ byte fv;
+
+ for (fv = 0; fv <= 1; fv ++)
+ getset[fv].init();
+ }
+
+ void hide_in_the_cupboard() {
+ const char nowt = 250; /* As in Acci. */
+
+ if (Gyro::dna.avvys_in_the_cupboard) {
+ if (Gyro::dna.wearing == nowt)
+ Scrolls::display("\6AVVY!\22 Get dressed first!");
+ else {
+ tr[1].visible = true;
+ Gyro::dna.user_moves_avvy = true;
+ apped(1, 3); /* Walk out of the cupboard. */
+ Scrolls::display("You leave the cupboard. Nice to be out of there!");
+ Gyro::dna.avvys_in_the_cupboard = false;
+ Sequence::first_show(8);
+ Sequence::then_show(7);
+ Sequence::start_to_close;
+ }
+ } else {
+ /* Not hiding in the cupboard */
+ tr[1].visible = false;
+ Gyro::dna.user_moves_avvy = false;
+ Scrolls::display(Common::String("You walk into the room...\20It seems to be an empty, ") +
+ "but dusty, cupboard. Hmmmm... you leave the door slightly open to " +
+ "avoid suffocation.");
+ Gyro::dna.avvys_in_the_cupboard = true;
+ Celer::show_one(8);
+ }
+ }
+
+
+
+ void fliproom(byte room, byte ped);
+
+ static int16 beforex, beforey;
+
+ static void tidy_after_mouse();
+
+ static void tidy_up(int16 a, int16 b, int16 c, int16 d) {
+ warning("STUB: Trip::tidy_up()");
+ }
+
+
+
+ static void tidy_after_mouse() {
+ tidy_up(beforex, beforey, beforex + 15, beforey + 15);
+ Gyro::xycheck();
+ tidy_up(Gyro::mx, Gyro::my, Gyro::mx + 15, Gyro::my + 15);
+ }
+
+ void fliproom(byte room, byte ped) {
+ byte fv;
+
+
+ if (! Gyro::alive) {
+ /* You can't leave the room if you're dead. */
+ tr[1].ix = 0;
+ tr[1].iy = 0; /* Stop him from moving. */
+ return;
+ }
+
+ if ((ped == 177) && (Gyro::dna.room == r__lusties)) {
+ hide_in_the_cupboard();
+ return;
+ }
+
+ if ((Gyro::dna.jumpstatus > 0) && (Gyro::dna.room == r__insidecardiffcastle)) {
+ /* You can't *jump* out of Cardiff Castle! */
+ tr[1].ix = 0;
+ return;
+ }
+
+ Gyro::xycheck();
+ beforex = Gyro::mx;
+ beforey = Gyro::my;
+
+ Lucerna::exitroom(Gyro::dna.room);
+ Lucerna::dusk();
+ getsetclear();
+
+
+ for (fv = 2; fv <= numtr; fv ++) {
+ if (tr[fv].quick)
+ tr[fv].done();
+ } /* Deallocate sprite */
+
+ if (Gyro::dna.room == r__lustiesroom)
+ Gyro::dna.enter_catacombs_from_lusties_room = true;
+
+ Lucerna::enterroom(room, ped);
+ apped(1, ped);
+ Gyro::dna.enter_catacombs_from_lusties_room = false;
+ Gyro::oldrw = Gyro::dna.rw;
+ Gyro::dna.rw = tr[1].face;
+ Lucerna::showrw;
+
+ for (fv = 0; fv <= 1; fv ++) {
+ Gyro::cp = 1 - Gyro::cp;
+ getback();
+ }
+ Lucerna::dawn;
+
+ /* Tidy up after mouse. I know it's a kludge... */
+ /* tidy_after_mouse;*/
+ }
+
+ bool infield(byte which) {
+ /* returns True if you're within field "which" */
+ int16 yy;
+
+ yy = tr[1].y + tr[1].a.yl;
+
+ return (tr[1].x >= Gyro::fields[which].x1) && (tr[1].x <= Gyro::fields[which].x2)
+ && (yy >= Gyro::fields[which].y1) && (yy <= Gyro::fields[which].y2);
+
+ }
+
+ bool neardoor() { /* returns True if you're near a door! */
+ int16 ux, uy;
+ byte fv;
+ bool nd;
+
+ bool neardoor_result;
+ if (Gyro::numfields < 9) {
+ /* there ARE no doors here! */
+ neardoor_result = false;
+ return neardoor_result;
+ }
+
+ ux = tr[1].x;
+ uy = tr[1].y + tr[1].a.yl;
+
+ nd = false;
+ for (fv = 9; fv <= Gyro::numfields; fv ++) {
+ Gyro::fields[fv];
+
+ if ((ux >= Gyro::fields[fv].x1) && (ux <= Gyro::fields[fv].x2)
+ && (uy >= Gyro::fields[fv].y1) && (uy <= Gyro::fields[fv].y2))
+ nd = true;
+ }
+ return nd;
+ }
+
+ void new_game_for_trippancy() { /* Called by gyro.newgame */
+ tr[1].visible = false;
+ }
+
+ void triptype::save_data_to_mem(uint16 &where) {
+ warning("STUB: Trip::save_data_to_mem()");
+ }
+
+ void triptype::load_data_from_mem(uint16 &where) {
+ warning("STUB: Trip::load_data_from_mem()");
+ }
+
+ } // End of namespace Trip.
+
+} // End of namespace Avalanche.
diff --git a/engines/avalanche/trip6.h b/engines/avalanche/trip6.h
new file mode 100644
index 0000000000..0227bab7b6
--- /dev/null
+++ b/engines/avalanche/trip6.h
@@ -0,0 +1,227 @@
+/* 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.
+ */
+
+/* TRIP5 Trippancy V */
+
+
+#ifndef TRIP6_H
+#define TRIP6_H
+
+
+
+#include "common/scummsys.h"
+#include "common/str.h"
+
+#include "avalanche/gyro2.h"
+
+namespace Avalanche {
+
+ namespace Trip {
+
+ // Call it where Trip is first used.
+ // Procuded to replace the initizalization part of the original Pascal unit.
+ void initialize_trip();
+
+ const int16 maxgetset = 35;
+
+ typedef byte manitype[2049]; // manitype = array[5..2053] of byte;
+ // Be aware!!!
+
+ typedef byte siltype[51][11]; /* 35, 4 */
+
+ struct adxtype { /* Second revision of ADX type */
+ Common::String name; /* name of character */
+ Common::String comment; /* comment */
+ byte num; /* number of pictures */
+ byte xl, yl; /* x & y lengths of pictures */
+ byte seq; /* how many in one stride */
+ uint16 size; /* the size of one picture */
+ byte fgc, bgc; /* foreground & background bubble colours */
+ byte accinum; /* the number according to Acci (1=Avvy, etc.) */
+ };
+
+ struct trip_saver_type {
+ byte whichsprite;
+ byte face;
+ byte step;
+ int16 x;
+ int16 y;
+ int8 ix;
+ int8 iy;
+ bool visible;
+ bool homing;
+ bool check_me;
+ byte count;
+ byte xw, xs, ys;
+ byte totalnum;
+ int16 hx;
+ int16 hy;
+ bool call_eachstep;
+ byte eachstep;
+ bool vanishifstill;
+ };
+
+ class triptype {
+ public:
+ adxtype a; /* vital statistics */
+ byte face, step;
+ int16 x, y; /* current xy coords */
+ int16 ox[2], oy[2]; /* last xy coords */
+ int8 ix, iy; /* amount to move sprite by, each step */
+ manitype *mani[24];
+ siltype *sil[24];
+ byte whichsprite;
+ bool quick, visible, homing, check_me;
+ int16 hx, hy; /* homing x & y coords */
+ byte count; /* counts before changing step */
+ byte xw; /* x-width in bytes */
+ byte xs, ys; /* x & y speed */
+ byte totalnum; /* total number of sprites */
+ bool vanishifstill; /* Do we show this sprite if it's still? */
+
+ bool call_eachstep; /* Do we call the eachstep procedure? */
+ byte eachstep;
+
+ triptype *init(byte spritenum, bool do_check);
+ /* loads & sets up the sprite */
+ void original(); /* just sets Quick to false */
+ void andexor(); /* drops sprite onto screen */
+ void turn(byte whichway); /* turns him round */
+ void appear(int16 wx, int16 wy, byte wf); /* switches him on */
+ void bounce(); /* bounces off walls. */
+ void walk(); /* prepares for andexor, etc. */
+ void walkto(byte pednum); /* home in on a point */
+ void stophoming(); /* self-explanatory */
+ void homestep(); /* calculates ix & iy for one homing step */
+ void speed(int8 xx, int8 yy); /* sets ix & iy, non-homing, etc */
+ void stopwalk(); /* Stops the sprite from moving */
+ void chatter(); /* Sets up talk vars */
+ void set_up_saver(trip_saver_type &v);
+ void unload_saver(trip_saver_type v);
+
+ void savedata(/*untyped_file &f*/); /* Self-explanatory, */
+ void loaddata(/*untyped_file &f*/); /* really. */
+
+
+
+
+ void save_data_to_mem(uint16 &where);
+ void load_data_from_mem(uint16 &where);
+ triptype *done();
+
+ private:
+ bool collision_check();
+ };
+
+ class getsettype {
+ public:
+ Gyro::bytefield gs[maxgetset];
+ byte numleft;
+
+ getsettype *init();
+ void remember(Gyro::bytefield r);
+ void recall(Gyro::bytefield &r);
+ };
+
+
+ const int16 up = 0;
+ const int16 right = 1;
+ const int16 down = 2;
+ const int16 left = 3;
+ const int16 ur = 4;
+ const int16 dr = 5;
+ const int16 dl = 6;
+ const int16 ul = 7;
+ const int16 stopped = 8;
+
+ const int16 numtr = 5; /* current max no. of sprites */
+
+
+
+ const int16 procfollow_avvy_y = 1;
+
+ const int16 procback_and_forth = 2;
+
+ const int16 procface_avvy = 3;
+
+ const int16 procarrow_procs = 4;
+
+ const int16 procspludwick_procs = 5;
+
+ const int16 procgrab_avvy = 6;
+
+ const int16 procgeida_procs = 7;
+
+
+ void trippancy_link();
+
+ void get_back_loretta();
+
+ void loadtrip();
+
+ void call_special(uint16 which);
+
+ void open_the_door(byte whither, byte ped, byte magicnum); /* Handles slidey-open doors. */
+
+ void catamove(byte ped);
+
+ void stopwalking();
+
+ void tripkey(char dir);
+
+ void rwsp(byte t, byte r);
+
+ void apped(byte trn, byte np);
+
+ void getback();
+
+ void fliproom(byte room, byte ped);
+
+ bool infield(byte which); /* returns True if you're within field "which" */
+
+ bool neardoor(); /* returns True if you're near a door! */
+
+ void readstick();
+
+ void newspeed();
+
+ void new_game_for_trippancy();
+
+
+
+ triptype tr[numtr];
+ getsettype getset[2];
+ byte aa[1600];
+
+ bool mustexclaim;
+ uint16 saywhat;
+
+ } // End of namespace Trip.
+
+} // End of namespace Avalanche.
+
+#endif // TRIP6_H
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-31 00:07:13 +0000