engines/saga/introproc_ite.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  *
  24  */
  25
  26 // Intro sequence scene procedures
  27
  28 #include "saga/saga.h"
  29 #include "saga/gfx.h"
  30
  31 #include "saga/animation.h"
  32 #include "saga/events.h"
  33 #include "saga/font.h"
  34 #include "saga/sndres.h"
  35 #include "saga/palanim.h"
  36 #include "saga/music.h"
  37
  38 #include "saga/scene.h"
  39 #include "saga/resource.h"
  40
  41 namespace Saga {
  42
  43 using Common::UNK_LANG;
  44 using Common::EN_ANY;
  45 using Common::DE_DEU;
  46 using Common::IT_ITA;
  47
  48 // Intro scenes
  49 #define RID_ITE_INTRO_ANIM_SCENE 1538
  50 #define RID_ITE_CAVE_SCENE_1 1542
  51 #define RID_ITE_CAVE_SCENE_2 1545
  52 #define RID_ITE_CAVE_SCENE_3 1548
  53 #define RID_ITE_CAVE_SCENE_4 1551
  54 #define RID_ITE_VALLEY_SCENE 1556
  55 #define RID_ITE_TREEHOUSE_SCENE 1560
  56 #define RID_ITE_FAIREPATH_SCENE 1564
  57 #define RID_ITE_FAIRETENT_SCENE 1567
  58
  59 // ITE intro music
  60 #define MUSIC_1 9
  61 #define MUSIC_2 10
  62
  63 LoadSceneParams ITE_IntroList[] = {
  64         {RID_ITE_INTRO_ANIM_SCENE, kLoadByResourceId, NULL, Scene::SC_ITEIntroAnimProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
  65         {RID_ITE_CAVE_SCENE_1, kLoadByResourceId, NULL, Scene::SC_ITEIntroCave1Proc, false, kTransitionFade, 0, NO_CHAPTER_CHANGE},
  66         {RID_ITE_CAVE_SCENE_2, kLoadByResourceId, NULL, Scene::SC_ITEIntroCave2Proc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
  67         {RID_ITE_CAVE_SCENE_3, kLoadByResourceId, NULL, Scene::SC_ITEIntroCave3Proc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
  68         {RID_ITE_CAVE_SCENE_4, kLoadByResourceId, NULL, Scene::SC_ITEIntroCave4Proc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
  69         {RID_ITE_VALLEY_SCENE, kLoadByResourceId, NULL, Scene::SC_ITEIntroValleyProc, false, kTransitionFade, 0, NO_CHAPTER_CHANGE},
  70         {RID_ITE_TREEHOUSE_SCENE, kLoadByResourceId, NULL, Scene::SC_ITEIntroTreeHouseProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
  71         {RID_ITE_FAIREPATH_SCENE, kLoadByResourceId, NULL, Scene::SC_ITEIntroFairePathProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
  72         {RID_ITE_FAIRETENT_SCENE, kLoadByResourceId, NULL, Scene::SC_ITEIntroFaireTentProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE}
  73 };
  74
  75 int Scene::ITEStartProc() {
  76         size_t scenesCount;
  77         size_t i;
  78
  79         LoadSceneParams firstScene;
  80         LoadSceneParams tempScene;
  81
  82         scenesCount = ARRAYSIZE(ITE_IntroList);
  83
  84         for (i = 0; i < scenesCount; i++) {
  85                 tempScene = ITE_IntroList[i];
  86                 tempScene.sceneDescriptor = _vm->_resource->convertResourceId(tempScene.sceneDescriptor);
  87                 _vm->_scene->queueScene(&tempScene);
  88         }
  89
  90
  91         firstScene.loadFlag = kLoadBySceneNumber;
  92         firstScene.sceneDescriptor = _vm->getStartSceneNumber();
  93         firstScene.sceneDescription = NULL;
  94         firstScene.sceneSkipTarget = true;
  95         firstScene.sceneProc = NULL;
  96         firstScene.transitionType = kTransitionFade;
  97         firstScene.actorsEntrance = 0;
  98         firstScene.chapter = -1;
  99
 100         _vm->_scene->queueScene(&firstScene);
 101
 102         return SUCCESS;
 103 }
 104
 105 Event *Scene::ITEQueueDialogue(Event *q_event, int n_dialogues, const IntroDialogue dialogue[]) {
 106         TextListEntry textEntry;
 107         TextListEntry *entry;
 108         Event event;
 109         int voice_len;
 110         int i;
 111
 112         // Queue narrator dialogue list
 113         textEntry.knownColor = kKnownColorSubtitleTextColor;
 114         textEntry.effectKnownColor = kKnownColorTransparent;
 115         textEntry.useRect = true;
 116         textEntry.rect.left = 0;
 117         textEntry.rect.right = _vm->getDisplayInfo().width;
 118         if (_vm->getLanguage() == Common::DE_DEU) {
 119                 textEntry.rect.top = INTRO_DE_CAPTION_Y;
 120         } else if (_vm->getLanguage() == Common::IT_ITA) {
 121                 textEntry.rect.top = INTRO_IT_CAPTION_Y;
 122         } else {
 123                 textEntry.rect.top = INTRO_CAPTION_Y;
 124         }
 125         textEntry.rect.bottom = _vm->getDisplayInfo().height;
 126         textEntry.font = kKnownFontMedium;
 127         textEntry.flags = (FontEffectFlags)(kFontOutline | kFontCentered);
 128
 129         for (i = 0; i < n_dialogues; i++) {
 130                 textEntry.text = dialogue[i].i_str;
 131                 entry = _vm->_scene->_textList.addEntry(textEntry);
 132
 133                 // Display text
 134                 event.type = kEvTOneshot;
 135                 event.code = kTextEvent;
 136                 event.op = kEventDisplay;
 137                 event.data = entry;
 138                 event.time = (i == 0) ? 0 : VOICE_PAD;
 139                 q_event = _vm->_events->chain(q_event, &event);
 140
 141                 // Play voice
 142                 event.type = kEvTOneshot;
 143                 event.code = kVoiceEvent;
 144                 event.op = kEventPlay;
 145                 event.param = dialogue[i].i_voice_rn;
 146                 event.time = 0;
 147                 q_event = _vm->_events->chain(q_event, &event);
 148
 149                 voice_len = _vm->_sndRes->getVoiceLength(dialogue[i].i_voice_rn);
 150                 if (voice_len < 0) {
 151                         voice_len = strlen(dialogue[i].i_str) * VOICE_LETTERLEN;
 152                 }
 153
 154                 // Remove text
 155                 event.type = kEvTOneshot;
 156                 event.code = kTextEvent;
 157                 event.op = kEventRemove;
 158                 event.data = entry;
 159                 event.time = voice_len;
 160                 q_event = _vm->_events->chain(q_event, &event);
 161         }
 162
 163         return q_event;
 164 }
 165
 166 enum {
 167         kCHeader,
 168         kCText
 169 };
 170
 171 enum {
 172         kITEPC           = (1 << 0),
 173         kITEPCCD         = (1 << 1),
 174         kITEMac          = (1 << 2),
 175         kITEWyrmKeep     = (1 << 3),
 176         kITEAny          = 0xffff,
 177         kITENotWyrmKeep  = kITEAny & ~kITEWyrmKeep
 178 };
 179
 180 // Queue a page of credits text. The original interpreter did word-wrapping
 181 // automatically. We currently don't.
 182
 183 Event *Scene::ITEQueueCredits(int delta_time, int duration, int n_credits, const IntroCredit credits[]) {
 184         int game;
 185         Common::Language lang;
 186
 187         // The assumption here is that all WyrmKeep versions have the same
 188         // credits, regardless of which operating system they're for.
 189
 190         lang = _vm->getLanguage();
 191
 192         if (_vm->getFeatures() & GF_WYRMKEEP) {
 193                 game = kITEWyrmKeep;
 194         } else if (_vm->getPlatform() == Common::kPlatformMacintosh) {
 195                 game = kITEMac;
 196         } else if (_vm->getFeatures() & GF_EXTRA_ITE_CREDITS) {
 197                 game = kITEPCCD;
 198         } else {
 199                 game = kITEPC;
 200         }
 201
 202         int line_spacing = 0;
 203         int paragraph_spacing;
 204         KnownFont font = kKnownFontSmall;
 205         int i;
 206
 207         int n_paragraphs = 0;
 208         int credits_height = 0;
 209
 210         for (i = 0; i < n_credits; i++) {
 211                 if (credits[i].lang != lang && credits[i].lang != UNK_LANG) {
 212                         continue;
 213                 }
 214
 215                 if (!(credits[i].game & game)) {
 216                         continue;
 217                 }
 218
 219                 switch (credits[i].type) {
 220                 case kCHeader:
 221                         font = kKnownFontSmall;
 222                         line_spacing = 4;
 223                         n_paragraphs++;
 224                         break;
 225                 case kCText:
 226                         font = kKnownFontMedium;
 227                         line_spacing = 2;
 228                         break;
 229                 default:
 230                         error("Unknown credit type");
 231                 }
 232
 233                 credits_height += (_vm->_font->getHeight(font) + line_spacing);
 234         }
 235
 236         paragraph_spacing = (200 - credits_height) / (n_paragraphs + 3);
 237         credits_height += (n_paragraphs * paragraph_spacing);
 238
 239         int y = paragraph_spacing;
 240
 241         TextListEntry textEntry;
 242         TextListEntry *entry;
 243         Event event;
 244         Event *q_event = NULL;
 245
 246         textEntry.knownColor = kKnownColorSubtitleTextColor;
 247         textEntry.effectKnownColor = kKnownColorTransparent;
 248         textEntry.flags = (FontEffectFlags)(kFontOutline | kFontCentered);
 249         textEntry.point.x = 160;
 250
 251         for (i = 0; i < n_credits; i++) {
 252                 if (credits[i].lang != lang && credits[i].lang != UNK_LANG) {
 253                         continue;
 254                 }
 255
 256                 if (!(credits[i].game & game)) {
 257                         continue;
 258                 }
 259
 260                 switch (credits[i].type) {
 261                 case kCHeader:
 262                         font = kKnownFontSmall;
 263                         line_spacing = 4;
 264                         y += paragraph_spacing;
 265                         break;
 266                 case kCText:
 267                         font = kKnownFontMedium;
 268                         line_spacing = 2;
 269                         break;
 270                 default:
 271                         break;
 272                 }
 273
 274                 textEntry.text = credits[i].string;
 275                 textEntry.font = font;
 276                 textEntry.point.y = y;
 277
 278                 entry = _vm->_scene->_textList.addEntry(textEntry);
 279
 280                 // Display text
 281                 event.type = kEvTOneshot;
 282                 event.code = kTextEvent;
 283                 event.op = kEventDisplay;
 284                 event.data = entry;
 285                 event.time = delta_time;
 286                 q_event = _vm->_events->queue(&event);
 287
 288                 // Remove text
 289                 event.type = kEvTOneshot;
 290                 event.code = kTextEvent;
 291                 event.op = kEventRemove;
 292                 event.data = entry;
 293                 event.time = duration;
 294                 q_event = _vm->_events->chain(q_event, &event);
 295
 296                 y += (_vm->_font->getHeight(font) + line_spacing);
 297         }
 298
 299         return q_event;
 300 }
 301
 302 int Scene::SC_ITEIntroAnimProc(int param, void *refCon) {
 303         return ((Scene *)refCon)->ITEIntroAnimProc(param);
 304 }
 305
 306 // Handles the introductory Dreamer's Guild / NWC logo animation scene.
 307 int Scene::ITEIntroAnimProc(int param) {
 308         Event event;
 309         Event *q_event;
 310
 311         switch (param) {
 312         case SCENE_BEGIN:{
 313                 // Background for intro scene is the first frame of the
 314                 // intro animation; display it and set the palette
 315                 event.type = kEvTOneshot;
 316                 event.code = kBgEvent;
 317                 event.op = kEventDisplay;
 318                 event.param = kEvPSetPalette;
 319                 event.time = 0;
 320                 q_event = _vm->_events->queue(&event);
 321
 322                 debug(3, "Intro animation procedure started.");
 323                 debug(3, "Linking animation resources...");
 324
 325                 _vm->_anim->setFrameTime(0, ITE_INTRO_FRAMETIME);
 326
 327                 // Link this scene's animation resources for continuous
 328                 // playback
 329                 int lastAnim;
 330
 331                 if (_vm->getFeatures() & GF_WYRMKEEP) {
 332                         if (_vm->getPlatform() == Common::kPlatformMacintosh) {
 333                                 lastAnim = 3;
 334                         } else {
 335                                 lastAnim = 2;
 336                         }
 337                 } else {
 338                         if (_vm->getPlatform() == Common::kPlatformMacintosh) {
 339                                 lastAnim = 4;
 340                         } else {
 341                                 lastAnim = 5;
 342                         }
 343                 }
 344
 345                 for (int i = 0; i < lastAnim; i++)
 346                         _vm->_anim->link(i, i+1);
 347
 348                 _vm->_anim->setFlag(lastAnim, ANIM_FLAG_ENDSCENE);
 349
 350                 debug(3, "Beginning animation playback.");
 351
 352                 // Begin the animation
 353                 event.type = kEvTOneshot;
 354                 event.code = kAnimEvent;
 355                 event.op = kEventPlay;
 356                 event.param = 0;
 357                 event.time = 0;
 358                 q_event = _vm->_events->chain(q_event, &event);
 359
 360                 // Queue intro music playback
 361                 event.type = kEvTOneshot;
 362                 event.code = kMusicEvent;
 363                 event.param = MUSIC_1;
 364                 event.param2 = MUSIC_LOOP;
 365                 event.op = kEventPlay;
 366                 event.time = 0;
 367                 q_event = _vm->_events->chain(q_event, &event);
 368                 }
 369                 break;
 370         case SCENE_END:
 371                 break;
 372         default:
 373                 warning("Illegal scene procedure parameter");
 374                 break;
 375         }
 376
 377         return 0;
 378 }
 379
 380 int Scene::SC_ITEIntroCave1Proc(int param, void *refCon) {
 381         return ((Scene *)refCon)->ITEIntroCave1Proc(param);
 382 }
 383
 384 // Handles first introductory cave painting scene
 385 int Scene::ITEIntroCave1Proc(int param) {
 386         Event event;
 387         Event *q_event;
 388         int lang = 0;
 389
 390         if (_vm->getLanguage() == Common::DE_DEU)
 391                 lang = 1;
 392         else if (_vm->getLanguage() == Common::IT_ITA)
 393                 lang = 2;
 394
 395         static const IntroDialogue dialogue[][4] = {
 396                 { { // English
 397                         0,              // cave voice 0
 398                         "We see the sky, we see the land, we see the water, "
 399                         "and we wonder: Are we the only ones?"
 400                 },
 401                 {
 402                         1,              // cave voice 1
 403                         "Long before we came to exist, the humans ruled the "
 404                         "Earth."
 405                 },
 406                 {
 407                         2,              // cave voice 2
 408                         "They made marvelous things, and moved whole "
 409                         "mountains."
 410                 },
 411                 {
 412                         3,              // cave voice 3
 413                         "They knew the Secret of Flight, the Secret of "
 414                         "Happiness, and other secrets beyond our imagining."
 415                 } },
 416                 // -----------------------------------------------------
 417                 { { // German
 418                         0,              // cave voice 0
 419                         "Um uns sind der Himmel, das Land und die Seen; und "
 420                         "wir fragen uns - sind wir die einzigen?"
 421                 },
 422                 {
 423                         1,              // cave voice 1
 424                         "Lange vor unserer Zeit herrschten die Menschen "
 425                         "\201ber die Erde."
 426                 },
 427                 {
 428                         2,              // cave voice 2
 429                         "Sie taten wundersame Dinge und versetzten ganze "
 430                         "Berge."
 431                 },
 432                 {
 433                         3,              // cave voice 3
 434                         "Sie kannten das Geheimnis des Fluges, das Geheimnis "
 435                         "der Fr\224hlichkeit und andere Geheimnisse, die "
 436                         "unsere Vorstellungskraft \201bersteigen."
 437                 } },
 438                 // -----------------------------------------------------
 439                 { { // Italian fan translation
 440                         0,              // cave voice 0
 441                         "Guardiamo il cielo, guardiamo la terra, guardiamo "
 442                         "l'acqua, e ci chiediamo: Siamo forse soli?"
 443                 },
 444                 {
 445                         1,              // cave voice 1
 446                         "Molto tempo prima che noi esistessimo, gli Umani "
 447                         "dominavano la terra."
 448                 },
 449                 {
 450                         2,              // cave voice 2
 451                         "Fecero cose meravigliose, e mossero intere "
 452                         "montagne."
 453                 },
 454                 {
 455                         3,              // cave voice 3
 456                         "Conoscevano il Segreto del Volo, il Segreto della "
 457                         "Felicit\205, ed altri segreti oltre ogni nostra "
 458                         "immaginazione."
 459                 } }
 460         };
 461
 462         int n_dialogues = ARRAYSIZE(dialogue[lang]);
 463
 464         switch (param) {
 465         case SCENE_BEGIN:
 466                 // Begin palette cycling animation for candles
 467                 event.type = kEvTOneshot;
 468                 event.code = kPalAnimEvent;
 469                 event.op = kEventCycleStart;
 470                 event.time = 0;
 471                 q_event = _vm->_events->queue(&event);
 472
 473                 // Queue narrator dialogue list
 474                 q_event = ITEQueueDialogue(q_event, n_dialogues, dialogue[lang]);
 475
 476                 // End scene after last dialogue over
 477                 event.type = kEvTOneshot;
 478                 event.code = kSceneEvent;
 479                 event.op = kEventEnd;
 480                 event.time = VOICE_PAD;
 481                 q_event = _vm->_events->chain(q_event, &event);
 482
 483                 break;
 484         case SCENE_END:
 485                 break;
 486
 487         default:
 488                 warning("Illegal scene procedure paramater");
 489                 break;
 490         }
 491
 492         return 0;
 493 }
 494
 495 int Scene::SC_ITEIntroCave2Proc(int param, void *refCon) {
 496         return ((Scene *)refCon)->ITEIntroCave2Proc(param);
 497 }
 498
 499 // Handles second introductory cave painting scene
 500 int Scene::ITEIntroCave2Proc(int param) {
 501         Event event;
 502         Event *q_event;
 503         int lang = 0;
 504
 505         if (_vm->getLanguage() == Common::DE_DEU)
 506                 lang = 1;
 507         else if (_vm->getLanguage() == Common::IT_ITA)
 508                 lang = 2;
 509
 510         static const IntroDialogue dialogue[][3] = {
 511                 { { // English
 512                         4,              // cave voice 4
 513                         "The humans also knew the Secret of Life, and they "
 514                         "used it to give us the Four Great Gifts:"
 515                 },
 516                 {
 517                         5,              // cave voice 5
 518                         "Thinking minds, feeling hearts, speaking mouths, and "
 519                         "reaching hands."
 520                 },
 521                 {
 522                         6,              // cave voice 6
 523                         "We are their children."
 524                 } },
 525                 // -----------------------------------------------------
 526                 { { // German
 527                         4,              // cave voice 4
 528                         "Au$erdem kannten die Menschen das Geheimnis des "
 529                         "Lebens. Und sie nutzten es, um uns die vier gro$en "
 530                         "Geschenke zu geben -"
 531                 },
 532                 {
 533                         5,              // cave voice 5
 534                         "den denkenden Geist, das f\201hlende Herz, den "
 535                         "sprechenden Mund und die greifende Hand."
 536                 },
 537                 {
 538                         6,              // cave voice 6
 539                         "Wir sind ihre Kinder."
 540                 } },
 541                 // -----------------------------------------------------
 542                 { { // Italian fan translation
 543                         4,              // cave voice 4
 544                         "Gli Umani conoscevano anche il Segreto della Vita, "
 545                         "e lo usarono per darci i Quattro Grandi Doni:"
 546
 547                 },
 548                 {
 549                         5,              // cave voice 5
 550                         "Il pensiero, le emozioni, la parola e la manualit\205."
 551
 552                 },
 553                 {
 554                         6,              // cave voice 6
 555                         "Siamo i loro figli."
 556                 } }
 557         };
 558
 559         int n_dialogues = ARRAYSIZE(dialogue[lang]);
 560
 561         switch (param) {
 562         case SCENE_BEGIN:
 563                 // Start 'dissolve' transition to new scene background
 564                 event.type = kEvTContinuous;
 565                 event.code = kTransitionEvent;
 566                 event.op = kEventDissolve;
 567                 event.time = 0;
 568                 event.duration = DISSOLVE_DURATION;
 569                 q_event = _vm->_events->queue(&event);
 570
 571                 // Begin palette cycling animation for candles
 572                 event.type = kEvTOneshot;
 573                 event.code = kPalAnimEvent;
 574                 event.op = kEventCycleStart;
 575                 event.time = 0;
 576                 q_event = _vm->_events->chain(q_event, &event);
 577
 578                 // Queue narrator dialogue list
 579                 q_event = ITEQueueDialogue(q_event, n_dialogues, dialogue[lang]);
 580
 581                 // End scene after last dialogue over
 582                 event.type = kEvTOneshot;
 583                 event.code = kSceneEvent;
 584                 event.op = kEventEnd;
 585                 event.time = VOICE_PAD;
 586                 q_event = _vm->_events->chain(q_event, &event);
 587
 588                 break;
 589         case SCENE_END:
 590                 break;
 591         default:
 592                 warning("Illegal scene procedure paramater");
 593                 break;
 594         }
 595
 596         return 0;
 597 }
 598
 599 int Scene::SC_ITEIntroCave3Proc(int param, void *refCon) {
 600         return ((Scene *)refCon)->ITEIntroCave3Proc(param);
 601 }
 602
 603 // Handles third introductory cave painting scene
 604 int Scene::ITEIntroCave3Proc(int param) {
 605         Event event;
 606         Event *q_event;
 607         int lang = 0;
 608
 609         if (_vm->getLanguage() == Common::DE_DEU)
 610                 lang = 1;
 611         else if (_vm->getLanguage() == Common::IT_ITA)
 612                 lang = 2;
 613
 614         static const IntroDialogue dialogue[][3] = {
 615                 { { // English
 616                         7,              // cave voice 7
 617                         "They taught us how to use our hands, and how to "
 618                         "speak."
 619                 },
 620                 {
 621                         8,              // cave voice 8
 622                         "They showed us the joy of using our minds."
 623                 },
 624                 {
 625                         9,              // cave voice 9
 626                         "They loved us, and when we were ready, they surely "
 627                         "would have given us the Secret of Happiness."
 628                 } },
 629                 // -----------------------------------------------------
 630                 { { // German
 631                         7,              // cave voice 7
 632                         "Sie lehrten uns zu sprechen und unsere H\204nde zu "
 633                         "benutzen."
 634                 },
 635                 {
 636                         8,              // cave voice 8
 637                         "Sie zeigten uns die Freude am Denken."
 638                 },
 639                 {
 640                         9,              // cave voice 9
 641                         "Sie liebten uns, und w\204ren wir bereit gewesen, "
 642                         "h\204tten sie uns sicherlich das Geheimnis der "
 643                         "Fr\224hlichkeit offenbart."
 644                 } },
 645                 // -----------------------------------------------------
 646                 { { // Italian fan translation
 647                         7,              // cave voice 7
 648                         "Ci insegnarono come usare le mani e come parlare. "
 649
 650                 },
 651                 {
 652                         8,              // cave voice 8
 653                         "Ci mostrarono le gioie che l'uso della mente "
 654                         "pu\225 dare. "
 655                 },
 656                 {
 657                         9,              // cave voice 9
 658                         "Ci amarono, ed una volta pronti, ci avrebbero "
 659                         "sicuramente svelato il Segreto della Felicit\205."
 660
 661                 } }
 662         };
 663
 664         int n_dialogues = ARRAYSIZE(dialogue[lang]);
 665
 666         switch (param) {
 667         case SCENE_BEGIN:
 668                 // Start 'dissolve' transition to new scene background
 669                 event.type = kEvTContinuous;
 670                 event.code = kTransitionEvent;
 671                 event.op = kEventDissolve;
 672                 event.time = 0;
 673                 event.duration = DISSOLVE_DURATION;
 674                 q_event = _vm->_events->queue(&event);
 675
 676                 // Begin palette cycling animation for candles
 677                 event.type = kEvTOneshot;
 678                 event.code = kPalAnimEvent;
 679                 event.op = kEventCycleStart;
 680                 event.time = 0;
 681                 q_event = _vm->_events->chain(q_event, &event);
 682
 683                 // Queue narrator dialogue list
 684                 q_event = ITEQueueDialogue(q_event, n_dialogues, dialogue[lang]);
 685
 686                 // End scene after last dialogue over
 687                 event.type = kEvTOneshot;
 688                 event.code = kSceneEvent;
 689                 event.op = kEventEnd;
 690                 event.time = VOICE_PAD;
 691                 q_event = _vm->_events->chain(q_event, &event);
 692
 693                 break;
 694         case SCENE_END:
 695                 break;
 696         default:
 697                 warning("Illegal scene procedure paramater");
 698                 break;
 699         }
 700
 701         return 0;
 702 }
 703
 704 int Scene::SC_ITEIntroCave4Proc(int param, void *refCon) {
 705         return ((Scene *)refCon)->ITEIntroCave4Proc(param);
 706 }
 707
 708 // Handles fourth introductory cave painting scene
 709 int Scene::ITEIntroCave4Proc(int param) {
 710         Event event;
 711         Event *q_event;
 712         int lang = 0;
 713
 714         if (_vm->getLanguage() == Common::DE_DEU)
 715                 lang = 1;
 716         else if (_vm->getLanguage() == Common::IT_ITA)
 717                 lang = 2;
 718
 719         static const IntroDialogue dialogue[][4] = {
 720                 { { // English
 721                         10,             // cave voice 10
 722                         "And now we see the sky, the land, and the water that "
 723                         "we are heirs to, and we wonder: why did they leave?"
 724                 },
 725                 {
 726                         11,             // cave voice 11
 727                         "Do they live still, in the stars? In the oceans "
 728                         "depths? In the wind?"
 729                 },
 730                 {
 731                         12,             // cave voice 12
 732                         "We wonder, was their fate good or evil?"
 733                 },
 734                 {
 735                         13,             // cave voice 13
 736                         "And will we also share the same fate one day?"
 737                 } },
 738                 // -----------------------------------------------------
 739                 { { // German
 740                         10,             // cave voice 10
 741                         "Und nun sehen wir den Himmel, das Land und die "
 742                         "Seen - unser Erbe. Und wir fragen uns - warum "
 743                         "verschwanden sie?"
 744                 },
 745                 {
 746                         11,             // cave voice 11
 747                         "Leben sie noch in den Sternen? In den Tiefen des "
 748                         "Ozeans? Im Wind?"
 749                 },
 750                 {
 751                         12,             // cave voice 12
 752                         "Wir fragen uns - war ihr Schicksal gut oder b\224se?"
 753                 },
 754                 {
 755                         13,             // cave voice 13
 756                         "Und wird uns eines Tages das gleiche Schicksal "
 757                         "ereilen?"
 758                 } },
 759                 // -----------------------------------------------------
 760                 { { // Italian fan translation
 761                         10,             // cave voice 10
 762                         "Ed ora che guardiamo il cielo, la terra e l'acqua "
 763                         "che abbiamo ereditato, pensiamo: Perch\202 partirono?"
 764
 765                 },
 766                 {
 767                         11,             // cave voice 11
 768                         "Vivono ancora, nelle stelle? Nelle profondit\205 "
 769                         "dell'oceano? Nel vento?"
 770                 },
 771                 {
 772                         12,             // cave voice 12
 773                         "Ci domandiamo, il loro destino fu felice o nefasto?"
 774                 },
 775                 {
 776                         13,             // cave voice 13
 777                         "E un giorno, condivideremo anche noi lo stesso "
 778                         "destino?"
 779                 } }
 780         };
 781
 782         int n_dialogues = ARRAYSIZE(dialogue[lang]);
 783
 784         switch (param) {
 785         case SCENE_BEGIN:
 786                 // Start 'dissolve' transition to new scene background
 787                 event.type = kEvTContinuous;
 788                 event.code = kTransitionEvent;
 789                 event.op = kEventDissolve;
 790                 event.time = 0;
 791                 event.duration = DISSOLVE_DURATION;
 792                 q_event = _vm->_events->queue(&event);
 793
 794                 // Begin palette cycling animation for candles
 795                 event.type = kEvTOneshot;
 796                 event.code = kPalAnimEvent;
 797                 event.op = kEventCycleStart;
 798                 event.time = 0;
 799                 q_event = _vm->_events->chain(q_event, &event);
 800
 801                 // Queue narrator dialogue list
 802                 q_event = ITEQueueDialogue(q_event, n_dialogues, dialogue[lang]);
 803
 804                 // End scene after last dialogue over
 805                 event.type = kEvTOneshot;
 806                 event.code = kSceneEvent;
 807                 event.op = kEventEnd;
 808                 event.time = VOICE_PAD;
 809                 q_event = _vm->_events->chain(q_event, &event);
 810
 811                 break;
 812         case SCENE_END:
 813                 break;
 814         default:
 815                 warning("Illegal scene procedure paramater");
 816                 break;
 817         }
 818
 819         return 0;
 820 }
 821
 822 int Scene::SC_ITEIntroValleyProc(int param, void *refCon) {
 823         return ((Scene *)refCon)->ITEIntroValleyProc(param);
 824 }
 825
 826 // Handles intro title scene (valley overlook)
 827 int Scene::ITEIntroValleyProc(int param) {
 828         Event event;
 829         Event *q_event;
 830
 831         static const IntroCredit credits[] = {
 832                 {EN_ANY, kITEAny, kCHeader, "Producer"},
 833                 {DE_DEU, kITEAny, kCHeader, "Produzent"},
 834                 {IT_ITA, kITEAny, kCHeader, "Produttore"},
 835                 {UNK_LANG, kITEAny, kCText, "Walter Hochbrueckner"},
 836                 {EN_ANY, kITEAny, kCHeader, "Executive Producer"},
 837                 {DE_DEU, kITEAny, kCHeader, "Ausf\201hrender Produzent"},
 838                 {IT_ITA, kITEAny, kCHeader, "Produttore Esecutivo"},
 839                 {UNK_LANG, kITEAny, kCText, "Robert McNally"},
 840                 {UNK_LANG, kITEWyrmKeep, kCHeader, "2nd Executive Producer"},
 841                 {EN_ANY, kITENotWyrmKeep, kCHeader, "Publisher"},
 842                 {DE_DEU, kITENotWyrmKeep, kCHeader, "Herausgeber"},
 843                 {IT_ITA, kITENotWyrmKeep, kCHeader, "Editore"},
 844                 {UNK_LANG, kITEAny, kCText, "Jon Van Caneghem"}
 845         };
 846
 847         int n_credits = ARRAYSIZE(credits);
 848
 849         switch (param) {
 850         case SCENE_BEGIN:
 851                 // Begin title screen background animation
 852                 _vm->_anim->setCycles(0, -1);
 853
 854                 event.type = kEvTOneshot;
 855                 event.code = kAnimEvent;
 856                 event.op = kEventPlay;
 857                 event.param = 0;
 858                 event.time = 0;
 859                 q_event = _vm->_events->queue(&event);
 860
 861                 // Begin ITE title theme music
 862                 _vm->_music->stop();
 863
 864                 event.type = kEvTOneshot;
 865                 event.code = kMusicEvent;
 866                 event.param = MUSIC_2;
 867                 event.param2 = MUSIC_NORMAL;
 868                 event.op = kEventPlay;
 869                 event.time = 0;
 870                 q_event = _vm->_events->chain(q_event, &event);
 871
 872                 // Pause animation before logo
 873                 event.type = kEvTOneshot;
 874                 event.code = kAnimEvent;
 875                 event.op = kEventStop;
 876                 event.param = 0;
 877                 event.time = 3000;
 878                 q_event = _vm->_events->chain(q_event, &event);
 879
 880                 // Display logo
 881                 event.type = kEvTContinuous;
 882                 event.code = kTransitionEvent;
 883                 event.op = kEventDissolveBGMask;
 884                 event.time = 0;
 885                 event.duration = LOGO_DISSOLVE_DURATION;
 886                 q_event = _vm->_events->chain(q_event, &event);
 887
 888                 // Remove logo
 889                 event.type = kEvTContinuous;
 890                 event.code = kTransitionEvent;
 891                 event.op = kEventDissolve;
 892                 event.time = 3000;
 893                 event.duration = LOGO_DISSOLVE_DURATION;
 894                 q_event = _vm->_events->chain(q_event, &event);
 895
 896                 // Unpause animation before logo
 897                 event.type = kEvTOneshot;
 898                 event.code = kAnimEvent;
 899                 event.op = kEventPlay;
 900                 event.time = 0;
 901                 event.param = 0;
 902                 q_event = _vm->_events->chain(q_event, &event);
 903
 904                 // Queue game credits list
 905                 q_event = ITEQueueCredits(9000, CREDIT_DURATION1, n_credits, credits);
 906
 907                 // End scene after credit display
 908                 event.type = kEvTOneshot;
 909                 event.code = kSceneEvent;
 910                 event.op = kEventEnd;
 911                 event.time = 1000;
 912                 q_event = _vm->_events->chain(q_event, &event);
 913
 914                 break;
 915         case SCENE_END:
 916                 break;
 917         default:
 918                 warning("Illegal scene procedure parameter");
 919                 break;
 920         }
 921
 922         return 0;
 923 }
 924
 925 int Scene::SC_ITEIntroTreeHouseProc(int param, void *refCon) {
 926         return ((Scene *)refCon)->ITEIntroTreeHouseProc(param);
 927 }
 928
 929 // Handles second intro credit screen (treehouse view)
 930 int Scene::ITEIntroTreeHouseProc(int param) {
 931         Event event;
 932         Event *q_event;
 933
 934         static const IntroCredit credits1[] = {
 935                 {EN_ANY, kITEAny, kCHeader, "Game Design"},
 936                 {DE_DEU, kITEAny, kCHeader, "Spielentwurf"},
 937                 {IT_ITA, kITEAny, kCHeader, "Progetto"},
 938                 {UNK_LANG, kITEAny, kCText, "Talin, Joe Pearce, Robert McNally"},
 939                 {EN_ANY, kITEAny, kCText, "and Carolly Hauksdottir"},
 940                 {DE_DEU, kITEAny, kCText, "und Carolly Hauksdottir"},
 941                 {IT_ITA, kITEAny, kCText, "e Carolly Hauksdottir"},
 942                 {EN_ANY, kITEAny, kCHeader, "Screenplay and Dialog"},
 943                 {EN_ANY, kITEAny, kCText, "Robert Leh, Len Wein, and Bill Rotsler"},
 944                 {DE_DEU, kITEAny, kCHeader, "Geschichte und Dialoge"},
 945                 {DE_DEU, kITEAny, kCText, "Robert Leh, Len Wein und Bill Rotsler"},
 946                 {IT_ITA, kITEAny, kCHeader, "Sceneggiatura e Dialoghi"},
 947                 {IT_ITA, kITEAny, kCText, "Robert Leh, Len Wein e Bill Rotsler"}
 948         };
 949
 950         int n_credits1 = ARRAYSIZE(credits1);
 951
 952         static const IntroCredit credits2[] = {
 953                 {UNK_LANG, kITEWyrmKeep, kCHeader, "Art Direction"},
 954                 {UNK_LANG, kITEWyrmKeep, kCText, "Allison Hershey"},
 955                 {EN_ANY, kITEAny, kCHeader, "Art"},
 956                 {DE_DEU, kITEAny, kCHeader, "Grafiken"},
 957                 {IT_ITA, kITEAny, kCHeader, "Grafica"},
 958                 {UNK_LANG, kITEWyrmKeep, kCText, "Ed Lacabanne, Glenn Price, April Lee,"},
 959                 {UNK_LANG, kITENotWyrmKeep, kCText, "Edward Lacabanne, Glenn Price, April Lee,"},
 960                 {UNK_LANG, kITEWyrmKeep, kCText, "Lisa Sample, Brian Dowrick, Reed Waller,"},
 961                 {EN_ANY, kITEWyrmKeep, kCText, "Allison Hershey and Talin"},
 962                 {DE_DEU, kITEWyrmKeep, kCText, "Allison Hershey und Talin"},
 963                 {IT_ITA, kITEWyrmKeep, kCText, "Allison Hershey e Talin"},
 964                 {EN_ANY, kITENotWyrmKeep, kCText, "Lisa Iennaco, Brian Dowrick, Reed"},
 965                 {EN_ANY, kITENotWyrmKeep, kCText, "Waller, Allison Hershey and Talin"},
 966                 {DE_DEU, kITEAny, kCText, "Waller, Allison Hershey und Talin"},
 967                 {IT_ITA, kITEAny, kCText, "Waller, Allison Hershey e Talin"},
 968                 {EN_ANY, kITENotWyrmKeep, kCHeader, "Art Direction"},
 969                 {DE_DEU, kITENotWyrmKeep, kCHeader, "Grafische Leitung"},
 970                 {IT_ITA, kITENotWyrmKeep, kCHeader, "Direzione Grafica"},
 971                 {UNK_LANG, kITENotWyrmKeep, kCText, "Allison Hershey"}
 972         };
 973
 974         int n_credits2 = ARRAYSIZE(credits2);
 975
 976         switch (param) {
 977         case SCENE_BEGIN:
 978                 // Start 'dissolve' transition to new scene background
 979                 event.type = kEvTContinuous;
 980                 event.code = kTransitionEvent;
 981                 event.op = kEventDissolve;
 982                 event.time = 0;
 983                 event.duration = DISSOLVE_DURATION;
 984                 q_event = _vm->_events->queue(&event);
 985
 986                 if (_vm->_anim->hasAnimation(0)) {
 987                         // Begin title screen background animation
 988                         _vm->_anim->setFrameTime(0, 100);
 989
 990                         event.type = kEvTOneshot;
 991                         event.code = kAnimEvent;
 992                         event.op = kEventPlay;
 993                         event.param = 0;
 994                         event.time = 0;
 995                         q_event = _vm->_events->chain(q_event, &event);
 996                 }
 997
 998                 // Queue game credits list
 999                 q_event = ITEQueueCredits(DISSOLVE_DURATION + 2000, CREDIT_DURATION1, n_credits1, credits1);
1000                 q_event = ITEQueueCredits(DISSOLVE_DURATION + 7000, CREDIT_DURATION1, n_credits2, credits2);
1001
1002                 // End scene after credit display
1003                 event.type = kEvTOneshot;
1004                 event.code = kSceneEvent;
1005                 event.op = kEventEnd;
1006                 event.time = 1000;
1007                 q_event = _vm->_events->chain(q_event, &event);
1008
1009                 break;
1010         case SCENE_END:
1011                 break;
1012         default:
1013                 warning("Illegal scene procedure parameter");
1014                 break;
1015         }
1016
1017         return 0;
1018 }
1019
1020 int Scene::SC_ITEIntroFairePathProc(int param, void *refCon) {
1021         return ((Scene *)refCon)->ITEIntroFairePathProc(param);
1022 }
1023
1024 // Handles third intro credit screen (path to puzzle tent)
1025 int Scene::ITEIntroFairePathProc(int param) {
1026         Event event;
1027         Event *q_event;
1028
1029         static const IntroCredit credits1[] = {
1030                 {EN_ANY, kITEAny, kCHeader, "Programming"},
1031                 {DE_DEU, kITEAny, kCHeader, "Programmiert von"},
1032                 {IT_ITA, kITEAny, kCHeader, "Programmazione"},
1033                 {UNK_LANG, kITEAny, kCText, "Talin, Walter Hochbrueckner,"},
1034                 {EN_ANY, kITEAny, kCText, "Joe Burks and Robert Wiggins"},
1035                 {DE_DEU, kITEAny, kCText, "Joe Burks und Robert Wiggins"},
1036                 {IT_ITA, kITEAny, kCText, "Joe Burks e Robert Wiggins"},
1037                 {EN_ANY, kITEPCCD | kITEWyrmKeep, kCHeader, "Additional Programming"},
1038                 {EN_ANY, kITEPCCD | kITEWyrmKeep, kCText, "John Bolton"},
1039                 {UNK_LANG, kITEMac, kCHeader, "Macintosh Version"},
1040                 {UNK_LANG, kITEMac, kCText, "Michael McNally and Robert McNally"},
1041                 {EN_ANY, kITEAny, kCHeader, "Music and Sound"},
1042                 {DE_DEU, kITEAny, kCHeader, "Musik und Sound"},
1043                 {IT_ITA, kITEAny, kCHeader, "Musica e Sonoro"},
1044                 {UNK_LANG, kITEAny, kCText, "Matt Nathan"}
1045         };
1046
1047         int n_credits1 = ARRAYSIZE(credits1);
1048
1049         static const IntroCredit credits2[] = {
1050                 {EN_ANY, kITEAny, kCHeader, "Directed by"},
1051                 {DE_DEU, kITEAny, kCHeader, "Regie"},
1052                 {IT_ITA, kITEAny, kCHeader, "Regia"},
1053                 {UNK_LANG, kITEAny, kCText, "Talin"}
1054         };
1055
1056         int n_credits2 = ARRAYSIZE(credits2);
1057
1058         switch (param) {
1059         case SCENE_BEGIN:
1060                 // Start 'dissolve' transition to new scene background
1061                 event.type = kEvTContinuous;
1062                 event.code = kTransitionEvent;
1063                 event.op = kEventDissolve;
1064                 event.time = 0;
1065                 event.duration = DISSOLVE_DURATION;
1066                 q_event = _vm->_events->queue(&event);
1067
1068                 // Begin title screen background animation
1069                 _vm->_anim->setCycles(0, -1);
1070
1071                 event.type = kEvTOneshot;
1072                 event.code = kAnimEvent;
1073                 event.op = kEventPlay;
1074                 event.param = 0;
1075                 event.time = 0;
1076                 q_event = _vm->_events->chain(q_event, &event);
1077
1078                 // Queue game credits list
1079                 q_event = ITEQueueCredits(DISSOLVE_DURATION + 2000, CREDIT_DURATION1, n_credits1, credits1);
1080                 q_event = ITEQueueCredits(DISSOLVE_DURATION + 7000, CREDIT_DURATION1, n_credits2, credits2);
1081
1082                 // End scene after credit display
1083                 event.type = kEvTOneshot;
1084                 event.code = kSceneEvent;
1085                 event.op = kEventEnd;
1086                 event.time = 1000;
1087                 q_event = _vm->_events->chain(q_event, &event);
1088
1089                 break;
1090         case SCENE_END:
1091                 break;
1092         default:
1093                 warning("Illegal scene procedure parameter");
1094                 break;
1095         }
1096
1097         return 0;
1098 }
1099
1100 int Scene::SC_ITEIntroFaireTentProc(int param, void *refCon) {
1101         return ((Scene *)refCon)->ITEIntroFaireTentProc(param);
1102 }
1103
1104 // Handles fourth intro credit screen (treehouse view)
1105 int Scene::ITEIntroFaireTentProc(int param) {
1106         Event event;
1107         Event *q_event;
1108         Event *q_event_start;
1109
1110         switch (param) {
1111         case SCENE_BEGIN:
1112
1113                 // Start 'dissolve' transition to new scene background
1114                 event.type = kEvTContinuous;
1115                 event.code = kTransitionEvent;
1116                 event.op = kEventDissolve;
1117                 event.time = 0;
1118                 event.duration = DISSOLVE_DURATION;
1119                 q_event_start = _vm->_events->queue(&event);
1120
1121                 // End scene after momentary pause
1122                 event.type = kEvTOneshot;
1123                 event.code = kSceneEvent;
1124                 event.op = kEventEnd;
1125                 event.time = 5000;
1126                 q_event = _vm->_events->chain(q_event_start, &event);
1127
1128                 break;
1129         case SCENE_END:
1130                 break;
1131         default:
1132                 warning("Illegal scene procedure parameter");
1133                 break;
1134         }
1135
1136         return 0;
1137 }
1138
1139 } // End of namespace Saga