mirror of
https://github.com/ZDoom/Raze.git
synced 2024-11-28 06:53:29 +00:00
878 lines
22 KiB
Text
878 lines
22 KiB
Text
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2010-2019 EDuke32 developers and contributors
|
|
Copyright (C) 2019 sirlemonhead, Nuke.YKT
|
|
Copyright (C) 2020-2021 Christoph Oelckers
|
|
This file is part of Raze.
|
|
PCExhumed is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License version 2
|
|
as published by the Free Software Foundation.
|
|
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.
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
|
|
struct LMFDecoder native
|
|
{
|
|
static native bool Identify(String fn);
|
|
static native LMFDecoder Create(String fn);
|
|
native bool Frame(double clock);
|
|
native TextureID GetTexture();
|
|
native void Close();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
class LmfPlayer : SkippableScreenJob
|
|
{
|
|
LMFDecoder decoder;
|
|
double nextclock;
|
|
String fn;
|
|
|
|
ScreenJob Init(String filename)
|
|
{
|
|
fn = filename;
|
|
return self;
|
|
}
|
|
|
|
override void Start()
|
|
{
|
|
decoder = LMFDecoder.Create(fn);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
override void Draw(double smoothratio)
|
|
{
|
|
double clock = (ticks + smoothratio) * 1000000000. / GameTicRate;
|
|
if (clock >= nextclock)
|
|
{
|
|
if (decoder.Frame(clock))
|
|
{
|
|
jobstate = finished;
|
|
return;
|
|
}
|
|
}
|
|
|
|
double duration = clock * (120. / 8000000000.);
|
|
double z = 2048 * duration;
|
|
if (z > 65536) z = 65536;
|
|
|
|
double angle = 1536. + 16. * duration;
|
|
if (angle >= 2048.) angle = 0.;
|
|
|
|
Screen.DrawTexture(decoder.getTexture(), false, 160, 100, DTA_FullscreenScale, FSMode_Fit320x200,
|
|
DTA_CenterOffset, true, DTA_FlipY, true, DTA_ScaleX, z / 65536., DTA_ScaleY, z / 65536., DTA_Rotate, (-angle - 512) * (360. / 2048.));
|
|
}
|
|
|
|
override void OnDestroy()
|
|
{
|
|
decoder.Close();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
class LobotomyScreen : ImageScreen
|
|
{
|
|
ScreenJob Init(String texname, int fade)
|
|
{
|
|
Super.InitNamed(texname, fade);
|
|
return self;
|
|
}
|
|
|
|
override void OnSkip()
|
|
{
|
|
Exhumed.StopLocalSound();
|
|
}
|
|
|
|
override void Start()
|
|
{
|
|
Exhumed.PlayLocalSound(ExhumedSnd.kSoundJonLaugh2, 7000, false, CHANF_UI);
|
|
}
|
|
|
|
override void OnTick()
|
|
{
|
|
Super.OnTick();
|
|
if (jobstate == finished) Exhumed.StopLocalSound();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
class MainTitle : SkippableScreenJob
|
|
{
|
|
String a, b;
|
|
int mystate;
|
|
int duration;
|
|
int var_4;
|
|
int esi;
|
|
int nCount;
|
|
int starttime;
|
|
static const short skullDurations[] = { 6, 25, 43, 50, 68, 78, 101, 111, 134, 158, 173, 230, 600 };
|
|
|
|
ScreenJob Init()
|
|
{
|
|
Super.Init(fadein);
|
|
a = StringTable.Localize("$TXT_EX_COPYRIGHT1");
|
|
b = StringTable.Localize("$TXT_EX_COPYRIGHT2");
|
|
duration = skullDurations[0];
|
|
esi = 130;
|
|
return self;
|
|
}
|
|
|
|
override void Start()
|
|
{
|
|
Exhumed.PlayLocalSound(59, 0, true, CHANF_UI);
|
|
Exhumed.playCDtrack(19, true);
|
|
}
|
|
|
|
override void OnTick()
|
|
{
|
|
int ticker = ticks * 120 / GameTicRate;
|
|
if (ticks > 1 && mystate == 0 && !Exhumed.LocalSoundPlaying())
|
|
{
|
|
if (random(0, 15))
|
|
Exhumed.PlayLocalSound(ExhumedSnd.kSoundJonLaugh2, 0, false, CHANF_UI);
|
|
else
|
|
Exhumed.PlayLocalSound(61, 0, false, CHANF_UI);
|
|
mystate = 1;
|
|
starttime = ticker;
|
|
}
|
|
if (mystate == 1)
|
|
{
|
|
if (ticker > duration)
|
|
{
|
|
nCount++;
|
|
if (nCount > 12)
|
|
{
|
|
jobstate = finished;
|
|
return;
|
|
}
|
|
duration = starttime + skullDurations[nCount];
|
|
var_4 = var_4 == 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
override void Draw(double sr)
|
|
{
|
|
Exhumed.DrawPlasma();
|
|
Exhumed.DrawRel("SkullHead", 160, 100);
|
|
if (mystate == 0)
|
|
{
|
|
Exhumed.DrawRel("SkullJaw", 161, 130);
|
|
}
|
|
else
|
|
{
|
|
int nStringWidth = SmallFont.StringWidth(a);
|
|
Screen.DrawText(SmallFont, Font.CR_UNTRANSLATED, 160 - nStringWidth / 2, 200 - 24, a, DTA_FullscreenScale, FSMode_Fit320x200);
|
|
nStringWidth = SmallFont.StringWidth(b);
|
|
Screen.DrawText(SmallFont, Font.CR_UNTRANSLATED, 160 - nStringWidth / 2, 200 - 16, b, DTA_FullscreenScale, FSMode_Fit320x200);
|
|
|
|
|
|
String nTile = "SkullJaw";
|
|
|
|
if (var_4)
|
|
{
|
|
if (esi >= 135) nTile = "SkullJaw2";
|
|
else esi += 5;
|
|
}
|
|
else if (esi <= 130) esi = 130;
|
|
else esi -= 2;
|
|
|
|
int y;
|
|
|
|
if (nTile == "SkullJaw2")
|
|
{
|
|
y = 131;
|
|
}
|
|
else
|
|
{
|
|
y = esi;
|
|
if (y > 135) y = 135;
|
|
}
|
|
|
|
Exhumed.DrawRel(nTile, 161, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
class MapScreen : ScreenJob
|
|
{
|
|
static const int MapLevelOffsets[] = { 0, 50, 10, 20, 0, 45, -20, 20, 5, 0, -10, 10, 30, -20, 0, 20, 0, 0, 0, 0 };
|
|
static const int MapPlaqueX[] = { 100, 230, 180, 10, 210, 10, 10, 140, 30, 200, 145, 80, 15, 220, 190, 20, 220, 20, 200, 20 };
|
|
static const int MapPlaqueY[] = { 170, 10, 125, 95, 160, 110, 50, 0, 20, 150, 170, 80, 0, 35, 40, 130, 160, 10, 10, 10 };
|
|
static const int MapPlaqueTextX[] = { 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 18, 18, 18, 18, 18, 19, 18, 18, 18, 19 };
|
|
static const int MapPlaqueTextY[] = { 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 6, 5, 6, 6, 6, 6, 6, 5, 4 };
|
|
|
|
static const int FireTilesX[] = { 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1 };
|
|
static const int FireTilesY[] = { 3, 0, 3, 0, 0, 0, 1, 1, 2, 0, 2, 0 };
|
|
|
|
static const int MapLevelFires[] = {
|
|
3, 0, 107, 95 , 1, 58, 140 , 2, 28, 38 ,
|
|
3, 2, 240, 0 , 0, 237, 32 , 1, 200, 30 ,
|
|
2, 2, 250, 57 , 0, 250, 43 , 2, 200, 70 ,
|
|
2, 1, 82, 59 , 2, 84, 16 , 0, 10, 95 ,
|
|
2, 2, 237, 50 , 1, 215, 42 , 1, 210, 50 ,
|
|
3, 0, 40, 7 , 1, 75, 6 , 2, 100, 10 ,
|
|
3, 0, 58, 61 , 1, 85, 80 , 2, 111, 63 ,
|
|
3, 0, 260, 65 , 1, 228, 0 , 2, 259, 15 ,
|
|
2, 0, 81, 38 , 2, 58, 38 , 2, 30, 20 ,
|
|
3, 0, 259, 49 , 1, 248, 76 , 2, 290, 65 ,
|
|
3, 2, 227, 66 , 0, 224, 98 , 1, 277, 30 ,
|
|
2, 0, 100, 10 , 2, 48, 76 , 2, 80, 80 ,
|
|
3, 0, 17, 2 , 1, 29, 49 , 2, 53, 28 ,
|
|
3, 0, 266, 42 , 1, 283, 99 , 2, 243, 108 ,
|
|
2, 0, 238, 19 , 2, 240, 92 , 2, 190, 40 ,
|
|
2, 0, 27, 0 , 1, 70, 40 , 0, 20, 130 ,
|
|
3, 0, 275, 65 , 1, 235, 8 , 2, 274, 6 ,
|
|
3, 0, 75, 45 , 1, 152, 105 , 2, 24, 68 ,
|
|
3, 0, 290, 25 , 1, 225, 63 , 2, 260, 110 ,
|
|
0, 1, 20, 10 , 1, 20, 10 , 1, 20, 10
|
|
};
|
|
|
|
const FIRE_SIZE = 10;
|
|
const FIRE_TYPE = 1;
|
|
const FIRE_XOFS = 2;
|
|
const FIRE_YOFS = 3;
|
|
const FIRE_ELEMENT_SIZE = 3;
|
|
|
|
int x;
|
|
int delta;
|
|
int nIdleSeconds;
|
|
|
|
int curYPos, destYPos;
|
|
int nLevel, nLevelNew, nLevelBest;
|
|
|
|
native static void SetNextLevel(int num);
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
ScreenJob Init(int oldlevel, int newlevel, int maxlevel)
|
|
{
|
|
Super.Init(fadein|fadeout);
|
|
nLevel = oldlevel - 1;
|
|
nLevelNew = newlevel - 1;
|
|
nLevelBest = min(maxlevel, 19) - 1;
|
|
curYPos = MapLevelOffsets[nLevel] + (200 * (nLevel / 2));
|
|
destYPos = MapLevelOffsets[nLevelNew] + (200 * (nLevelNew / 2));
|
|
if (curYPos < destYPos) delta = 2;
|
|
else if (curYPos > destYPos) delta = -2;
|
|
// Trim smoke in widescreen
|
|
/*
|
|
vec2_t mapwinxy1 = windowxy1, mapwinxy2 = windowxy2;
|
|
int32_t width = mapwinxy2.x - mapwinxy1.x + 1, height = mapwinxy2.y - mapwinxy1.y + 1;
|
|
if (3 * width > 4 * height)
|
|
{
|
|
mapwinxy1.x += (width - 4 * height / 3) / 2;
|
|
mapwinxy2.x -= (width - 4 * height / 3) / 2;
|
|
}
|
|
*/
|
|
return self;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
override bool OnEvent(InputEvent ev)
|
|
{
|
|
if (ev.type == InputEvent.Type_KeyDown)
|
|
{
|
|
int key = ev.KeyScan;
|
|
let binding = Bindings.GetBinding(key);
|
|
if (key == InputEvent.KEY_UPARROW || key == InputEvent.KEY_PAD_DPAD_UP || key == InputEvent.Key_kpad_8 || binding ~== "+move_forward")
|
|
{
|
|
if (curYPos == destYPos && nLevelNew <= nLevelBest)
|
|
{
|
|
nLevelNew++;
|
|
SetNextLevel(nLevelNew + 1);
|
|
destYPos = MapLevelOffsets[nLevelNew] + (200 * (nLevelNew / 2));
|
|
|
|
if (curYPos <= destYPos) delta = 2;
|
|
else delta = -2;
|
|
nIdleSeconds = 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (key == InputEvent.KEY_DOWNARROW || key == InputEvent.KEY_PAD_DPAD_DOWN || key == InputEvent.Key_kpad_2 || binding ~== "+move_backward")
|
|
{
|
|
if (curYPos == destYPos && nLevelNew > 0)
|
|
{
|
|
nLevelNew--;
|
|
SetNextLevel(nLevelNew + 1);
|
|
destYPos = MapLevelOffsets[nLevelNew] + (200 * (nLevelNew / 2));
|
|
|
|
if (curYPos <= destYPos) delta = 2;
|
|
else delta = -2;
|
|
nIdleSeconds = 0;
|
|
}
|
|
return true;
|
|
}
|
|
if (!System.specialKeyEvent(ev)) jobstate = skipped;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
override void OnTick()
|
|
{
|
|
if (curYPos != destYPos)
|
|
{
|
|
// scroll the map every couple of ms
|
|
curYPos += delta;
|
|
|
|
if ((curYPos > destYPos && delta > 0) || (curYPos < destYPos && delta < 0))
|
|
curYPos = destYPos;
|
|
|
|
nIdleSeconds = 0;
|
|
}
|
|
else nIdleSeconds++;
|
|
if (nIdleSeconds > 300) jobstate = finished;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
override void Draw(double smoothratio)
|
|
{
|
|
int currentclock = int((ticks + smoothratio) * 120 / GameTicRate);
|
|
|
|
int tileY = curYPos;
|
|
|
|
// Draw the background screens
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
let tex = String.Format("MapBG%02d", i+1);
|
|
Exhumed.DrawAbs(tex, x, tileY);
|
|
tileY -= 200;
|
|
}
|
|
|
|
// for each level - drawing the 'level completed' on-fire smoke markers
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
int screenY = (i >> 1) * -200;
|
|
|
|
if (nLevelBest >= i) // check if the player has finished this level
|
|
{
|
|
for (int j = 0; j < MapLevelFires[i * FIRE_SIZE]; j++)
|
|
{
|
|
int nFireFrame = ((currentclock >> 4) & 3);
|
|
int elem = i * FIRE_SIZE + FIRE_ELEMENT_SIZE * j;
|
|
int nFireType = MapLevelFires[elem + FIRE_TYPE];
|
|
int x = MapLevelFires[elem + FIRE_XOFS];
|
|
int y = MapLevelFires[elem + FIRE_YOFS];
|
|
|
|
String nTile = String.Format("MAPFIRE_%d%d", nFireType+1, nFireFrame+1);
|
|
int smokeX = x + FireTilesX[nFireType*3 + nFireFrame];
|
|
int smokeY = y + FireTilesY[nFireType*3 + nFireFrame] + curYPos + screenY;
|
|
|
|
// Use rotatesprite to trim smoke in widescreen
|
|
Exhumed.DrawAbs(nTile, smokeX, smokeY);
|
|
// Todo: mask out the sides of the screen if the background is not widescreen.
|
|
}
|
|
}
|
|
|
|
int t = (((currentclock & 16) >> 4));
|
|
|
|
String nTile = String.Format("MapPlaque%d_%02d", t+1, i+1);
|
|
|
|
int nameX = mapPlaqueX[i];
|
|
int nameY = mapPlaqueY[i] + curYPos + screenY;
|
|
|
|
// Draw level name plaque
|
|
Exhumed.DrawAbs(nTile, nameX, nameY);
|
|
|
|
int shade = 96;
|
|
|
|
if (nLevelNew == i)
|
|
{
|
|
shade = (Raze.bsin(16 * currentclock) + 31) >> 8;
|
|
}
|
|
else if (nLevelBest >= i)
|
|
{
|
|
shade = 31;
|
|
}
|
|
|
|
int textY = nameY + MapPlaqueTextY[i];
|
|
int textX = nameX + MapPlaqueTextX[i];
|
|
nTile = String.Format("MapPlaqueText_%02d", i+1);
|
|
|
|
// draw the text, alternating between red and black
|
|
Exhumed.DrawAbs(nTile, textX, textY, shade);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// cinema (this has been stripped off all game logic that was still in here)
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
class Cinema : SkippableScreenJob
|
|
{
|
|
TextOverlay textov;
|
|
TextureID cinematile;
|
|
int currentCinemaPalette;
|
|
int cdtrack;
|
|
int palette;
|
|
bool done;
|
|
|
|
ScreenJob Init(String bgTexture, String text, int pal, int cdtrk)
|
|
{
|
|
Super.Init(fadein|fadeout);
|
|
cinematile = TexMan.CheckForTexture(bgTexture, TexMan.Type_Any);
|
|
textov = new("TextOverlay");
|
|
palette = Translation.MakeID(Translation_BasePalette, pal);
|
|
textov.Init(text, Font.CR_NATIVEPAL, palette);
|
|
cdtrack = cdtrk;
|
|
return self;
|
|
}
|
|
|
|
override void Start()
|
|
{
|
|
System.StopAllSounds();
|
|
if (cdtrack != -1)
|
|
{
|
|
Exhumed.playCDtrack(cdtrack+2, false);
|
|
}
|
|
}
|
|
|
|
override void OnTick()
|
|
{
|
|
if (done) jobstate = finished;
|
|
}
|
|
|
|
override void Draw(double smoothratio)
|
|
{
|
|
Screen.DrawTexture(cinematile, false, 0, 0, DTA_FullscreenEx, FSMode_ScaleToFit43, DTA_TranslationIndex, palette);
|
|
textov.DisplayText();
|
|
done = textov.ScrollText((ticks + smoothratio) * (120. / GameTicRate));
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
class LastLevelCinema : ScreenJob
|
|
{
|
|
int var_24;
|
|
int var_28;
|
|
|
|
int ebp;
|
|
int phase;
|
|
int nextclock;
|
|
uint nStringTypeOn, nCharTypeOn;
|
|
int screencnt;
|
|
bool skiprequest;
|
|
|
|
BrokenLines screentext;
|
|
Font printFont;
|
|
TextureID tex;
|
|
|
|
ScreenJob Init()
|
|
{
|
|
Super.Init(fadein | fadeout);
|
|
var_24 = 16;
|
|
var_28 = 12;
|
|
nextclock = 4;
|
|
let p = StringTable.Localize("REQUIRED_CHARACTERS", false);
|
|
if (p == "REQUIRED_CHARACTERS") printFont = SmallFont2;
|
|
else printFont = ConFont;
|
|
return self;
|
|
}
|
|
|
|
native static TextureID DoStatic(int a, int b);
|
|
native static TextureID UndoStatic();
|
|
|
|
void Phase1()
|
|
{
|
|
if (var_24 >= 116)
|
|
{
|
|
if (var_28 < 192)
|
|
var_28 += 20;
|
|
}
|
|
else
|
|
{
|
|
var_24 += 20;
|
|
}
|
|
|
|
tex = DoStatic(var_28, var_24);
|
|
}
|
|
|
|
bool InitPhase2()
|
|
{
|
|
let label = StringTable.Localize(String.Format("$TXT_EX_LASTLEVEL%d", screencnt + 1));
|
|
screentext = printFont.BreakLines(label, 320);
|
|
if (screentext.Count() == 0) return false;
|
|
|
|
nStringTypeOn = 0;
|
|
nCharTypeOn = 0;
|
|
|
|
ebp = screentext.Count() * 4; // half height of the entire text
|
|
ebp = 81 - ebp; // offset from the screen's center.
|
|
tex = UndoStatic();
|
|
return true;
|
|
}
|
|
|
|
bool Phase3()
|
|
{
|
|
tex = DoStatic(var_28, var_24);
|
|
|
|
if (var_28 > 20)
|
|
{
|
|
var_28 -= 20;
|
|
return true;
|
|
}
|
|
|
|
if (var_24 > 20)
|
|
{
|
|
var_24 -= 20;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void DisplayPhase2()
|
|
{
|
|
int yy = ebp;
|
|
|
|
// for international content, use the generic 8x8 font. The original one is too small for expansion.
|
|
if (printFont == ConFont)
|
|
{
|
|
yy *= 2;
|
|
for (int i = 0; i < nStringTypeOn; i++, yy += 10) Screen.DrawText(ConFont, Font.CR_GREEN, 140, yy, screentext.StringAt(i), DTA_FullscreenScale, FSMode_Fit640x400);
|
|
Screen.DrawText(ConFont, Font.CR_GREEN, 140, yy, screentext.StringAt(nStringTypeOn), DTA_FullscreenScale, FSMode_Fit640x400, DTA_TextLen, nCharTypeOn);
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < nStringTypeOn; i++, yy += 8) Screen.DrawText(SmallFont2, Font.CR_UNTRANSLATED, 70, yy, screentext.StringAt(i), DTA_FullscreenScale, FSMode_Fit320x200);
|
|
Screen.DrawText(SmallFont2, Font.CR_UNTRANSLATED, 70, yy, screentext.StringAt(nStringTypeOn), DTA_FullscreenScale, FSMode_Fit320x200, DTA_TextLen, nCharTypeOn);
|
|
}
|
|
}
|
|
|
|
override bool OnEvent(InputEvent ev)
|
|
{
|
|
if (ev.type == InputEvent.Type_KeyDown && !System.specialKeyEvent(ev)) skiprequest = true;
|
|
return true;
|
|
}
|
|
|
|
override void Start()
|
|
{
|
|
Exhumed.PlayLocalSound(ExhumedSnd.kSound75, 0, false, CHANF_UI);
|
|
phase = 1;
|
|
}
|
|
|
|
override void OnTick()
|
|
{
|
|
switch (phase)
|
|
{
|
|
case 1:
|
|
Phase1();
|
|
if (skiprequest || ticks >= nextclock)
|
|
{
|
|
InitPhase2();
|
|
phase = 2;
|
|
skiprequest = false;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
let text = screenText.StringAt(nStringTypeOn);
|
|
int chr;
|
|
[chr,nCharTypeOn] = text.GetNextCodePoint(nCharTypeOn);
|
|
|
|
if (chr == 0)
|
|
{
|
|
nCharTypeOn = 0;
|
|
nStringTypeOn++;
|
|
if (nStringTypeOn >= screentext.Count())
|
|
{
|
|
nextclock = (GameTicRate * (screentext.Count() + 2)) + ticks;
|
|
phase = 3;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
nCharTypeOn++;
|
|
if (chr != 32) Exhumed.PlayLocalSound(ExhumedSnd.kSound71, 0, false, CHANF_UI);
|
|
}
|
|
|
|
if (skiprequest)
|
|
{
|
|
nextclock = (GameTicRate * (screentext.Count() + 2)) + ticks;
|
|
phase = 4;
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
if (ticks >= nextclock || skiprequest)
|
|
{
|
|
Exhumed.PlayLocalSound(ExhumedSnd.kSound75, 0, false, CHANF_UI);
|
|
phase = 4;
|
|
nextclock = ticks + 60;
|
|
skiprequest = false;
|
|
}
|
|
|
|
case 4:
|
|
if (ticks >= nextclock)
|
|
{
|
|
skiprequest |= !Phase3();
|
|
}
|
|
if (skiprequest)
|
|
{
|
|
// Go to the next text page.
|
|
if (screencnt != 2)
|
|
{
|
|
screencnt++;
|
|
nextclock = ticks + 60;
|
|
skiprequest = 0;
|
|
phase = 1;
|
|
}
|
|
else jobstate = finished;
|
|
}
|
|
|
|
if (skiprequest)
|
|
{
|
|
jobstate = finished;
|
|
}
|
|
}
|
|
}
|
|
|
|
override void Draw(double sm)
|
|
{
|
|
Screen.DrawTexture(tex, false, 0, 0, DTA_FullscreenEx, FSMode_ScaleToFit43);
|
|
if (phase == 2 || phase == 3) DisplayPhase2();
|
|
}
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Credits roll
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
class ExCredits : ScreenJob
|
|
{
|
|
Array<String> credits;
|
|
Array<String> pagelines;
|
|
int page;
|
|
int pagetime;
|
|
bool skiprequest;
|
|
|
|
ScreenJob Init()
|
|
{
|
|
Super.Init();
|
|
String text;
|
|
int lump = Wads.CheckNumForFullName("credits.txt");
|
|
if (lump > -1) text = Wads.ReadLump(lump);
|
|
text.Substitute("\r", "");
|
|
text.Split(credits, "\n\n");
|
|
return self;
|
|
}
|
|
|
|
override bool OnEvent(InputEvent ev)
|
|
{
|
|
if (ev.type == InputEvent.Type_KeyDown && !System.specialKeyEvent(ev)) skiprequest = true;
|
|
return true;
|
|
}
|
|
|
|
override void Start()
|
|
{
|
|
if (credits.Size() == 0)
|
|
{
|
|
jobstate = finished;
|
|
return;
|
|
}
|
|
Exhumed.playCDtrack(19, false);
|
|
pagetime = 0;
|
|
page = -1;
|
|
}
|
|
|
|
override void OnTick()
|
|
{
|
|
if (ticks >= pagetime || skiprequest)
|
|
{
|
|
page++;
|
|
pagelines.Clear();
|
|
if (page < credits.Size())
|
|
credits[page].Split(pagelines, "\n");
|
|
else
|
|
{
|
|
if (skiprequest || !musplaying.handle)
|
|
{
|
|
jobstate = finished;
|
|
return;
|
|
}
|
|
}
|
|
pagetime = ticks + 90; //
|
|
}
|
|
}
|
|
|
|
override void Draw(double smoothratio)
|
|
{
|
|
int y = 100 - ((10 * (pagelines.Size() - 1)) / 2);
|
|
|
|
int ptime = clamp((pagetime - ticks - smoothratio) * 1000 / GameTicRate, 0, 2000); // in milliseconds
|
|
int light;
|
|
|
|
if (ptime < 255) light = ptime;
|
|
else if (ptime > 2000 - 255) light = 2000 - ptime;
|
|
else light = 255;
|
|
|
|
let colr = Color(255, light, light, light);
|
|
|
|
for (int i = 0; i < pagelines.Size(); i++)
|
|
{
|
|
int nStringWidth = SmallFont.StringWidth(pagelines[i]);
|
|
Screen.DrawText(SmallFont, Font.CR_UNTRANSLATED, 160 - nStringWidth / 2, y, pagelines[i], DTA_FullscreenScale, FSMode_Fit320x200, DTA_Color, colr);
|
|
y += 10;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ExhumedCutscenes
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
static void BuildIntro(ScreenJobRunner runner)
|
|
{
|
|
let logo = (gameinfo.gameType & GAMEFLAG_EXHUMED) ? "TileBMGLogo" : "TilePIELogo";
|
|
runner.Append(ImageScreen.CreateNamed(logo, ScreenJob.fadein | ScreenJob.fadeout));
|
|
runner.Append(new("LobotomyScreen").Init("LobotomyLogo", ScreenJob.fadein | ScreenJob.fadeout));
|
|
if (LMFDecoder.Identify("book.mov")) runner.Append(new("LMFPlayer").Init("book.mov"));
|
|
else runner.Append(MoviePlayerJob.Create("book.mov", 0));
|
|
runner.Append(new("MainTitle").Init());
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
static void BuildMap(ScreenJobRunner runner, MapRecord frommap, SummaryInfo info, MapRecord tomap)
|
|
{
|
|
// This is only defined for the regular levels.
|
|
int frommapnum = frommap == null? 1 : frommap.levelNumber;
|
|
if (fromMapnum < 1 || fromMapNum > 20 || tomap == null || tomap.levelNumber < 1 || tomap.levelNumber > 20) return;
|
|
|
|
// hijack the super secret info in the summary info to convey the max. map because we won't need that field for its real purpose.
|
|
runner.Append(new("MapScreen").Init(fromMapNum, toMap.levelNumber, info.supersecrets));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// This removes all the insanity the original setup had with these.
|
|
// Simplicity rules!
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
static void BuildCinemaBefore5(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("Cinema").Init("TileCinema5", "$TXT_EX_CINEMA2", 3, 2));
|
|
}
|
|
|
|
static void BuildCinemaAfter10(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("Cinema").Init("TileCinema10", "$TXT_EX_CINEMA4", 5, 3));
|
|
}
|
|
|
|
static void BuildCinemaBefore11(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("Cinema").Init("TileCinema11", "$TXT_EX_CINEMA3", 1, 4));
|
|
}
|
|
|
|
static void BuildCinemaAfter15(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("Cinema").Init("TileCinema15", "$TXT_EX_CINEMA6", 7, 6));
|
|
}
|
|
|
|
static void BuildCinemaBefore20(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("LastLevelCinema").Init());
|
|
}
|
|
|
|
static void BuildCinemaAfter20(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("Cinema").Init("TileCinema20", "$TXT_EX_CINEMA8", 6, 8));
|
|
runner.Append(new("ExCredits").Init());
|
|
}
|
|
|
|
static void BuildCinemaLose(ScreenJobRunner runner)
|
|
{
|
|
runner.Append(new("Cinema").Init("TileCinemaLose", "$TXT_EX_CINEMA7", 4, 7));
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// player died
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
static void BuildGameOverScene(ScreenJobRunner runner)
|
|
{
|
|
System.StopMusic();
|
|
Exhumed.PlayLocalSound(ExhumedSnd.kSoundJonLaugh2, 0, false, CHANF_UI);
|
|
runner.Append(ImageScreen.CreateNamed("Gameover", ScreenJob.fadein | ScreenJob.fadeout, 0x7fffffff, Translation.MakeID(Translation_BasePalette, 16)));
|
|
}
|
|
|
|
}
|