tiberium/CnC_Remastered_Collection
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Source Code commit

Browse source 
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
This commit is contained in:
PG-SteveT 2020-05-27 12:16:20 -07:00
parent ea8ecc76fa
commit 03416d24e1
1038 changed files with 629779 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

986
REDALERT/EGOS.CPP Normal file
View file

@ -0,0 +1,986 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: /counterstrike/EGOS.CPP 2 3/10/97 3:19p Steve_tall $ */
/*************************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S **
*************************************************************************************
* *
* Project Name : Command & Conquer - Red Alert *
* *
* File Name : EGOS.CPP *
* *
* Programmer : Steve Tall *
* *
* Start Date : September 4th, 1996 *
* *
* Last Update : September 4th, 1996 [ST] *
* *
*-----------------------------------------------------------------------------------*
* Overview: *
* *
* Scrolling movie style credits. *
* *
*-----------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if(0)
//PG_TO_FIX
#include "function.h"
/*
** List of Ego Class instances
** There will be one instance for each line of text.
*/
DynamicVectorClass<EgoClass *> EgoList;
/*
** Number of slideshow pictures
*/
#define NUM_SLIDES 17
/*
** Length of time frame is displayed for
*/
#define FRAME_DELAY 150
/*
** Number of frames that palete fade occurs over
*/
#define FADE_DELAY 37
/*
** Names of slideshow pictures to play behind the text
*/
char SlideNames[NUM_SLIDES][13]={
"aftr_hi.pcx",
"aly1.pcx",
"apc_hi.pcx",
"aphi0049.pcx",
"bnhi0020.pcx",
"dchi0040.pcx",
"frhi0166.pcx",
"lab.pcx",
"landsbrg.pcx",
"mahi0107.pcx",
"mig_hi.pcx",
"mtfacthi.pcx",
"needle.pcx",
"sov2.pcx",
"spy.pcx",
"stalin.pcx",
"tent.pcx"
};
/*
** Names of low res slideshow pictures to play behind the text
*/
char LoresSlideNames[NUM_SLIDES][13]={
"malo0107.cps",
"mig_lo.cps",
"mtfactlo.cps",
"needl-lo.cps",
"sov2-lo.cps",
"spy-lo.cps",
"staln-lo.cps",
"tent-lo.cps",
"aftr_lo.cps",
"aly1-lo.cps",
"apc_lo.cps",
"aplo0049.cps",
"bnlo0020.cps",
"dclo0040.cps",
"frlo0166.cps",
"lab-lo.cps",
"lands-lo.cps"
};
/*
** Array of all the palettes required for the slides
*/
char SlidePals[NUM_SLIDES][256*3];
/*
** Array of graphic buffers containing the slides
*/
GraphicBufferClass *SlideBuffers[NUM_SLIDES];
/*
** Original copy of slide (pref in video mem) that we use to undraw the text
*/
GraphicBufferClass *BackgroundPage;
/*
** This palette contains both the font palette entries and the slide
** palette.
*/
PaletteClass ComboPalette;
/*
** Ptr to the combo palette.
*/
unsigned char *ComboPalPtr;
/*
** Lookup table. If an entry is non-zero then it should be faded in/out when the slide changes.
*/
char PaletteLUT[256];
/*
** Height of the strips that are blitted from the slides to the backgound and hid pages.
** We blit in several strips over several frames so as not to impact on the frame rate.
*/
#define CHUNK_HEIGHT RESFACTOR * 50
#ifndef WIN32
extern void Vsync(void);
#pragma aux Vsync modify [edx ebx eax] = \
"mov edx,03DAh" \
"mov ebx,[VertBlank]" \
"and bl,001h" \
"shl bl,3" \
"in_vbi:" \
"in al,dx" \
"and al,008h" \
"xor al,bl" \
"je in_vbi" \
"out_vbi:" \
"in al,dx" \
"and al,008h" \
"xor al,bl" \
"jne out_vbi"
#endif //WIN32
/***********************************************************************************************
* EC::EgoClass -- EgoClass constructor *
* *
* *
* *
* INPUT: x position of text *
* y position of text *
* ptr to text string *
* flags to print text with *
* *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/9/96 11:53PM ST : Created *
*=============================================================================================*/
EgoClass::EgoClass (int x, int y, char *text, TextPrintType flags)
{
XPos = x;
YPos = y;
Flags= flags;
Text = new char [strlen (text)+1];
strcpy (Text, text);
}
/***********************************************************************************************
* EC::~EgoClass -- EgoClass destructor *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/9/96 11:54PM ST : Created *
*=============================================================================================*/
EgoClass::~EgoClass(void)
{
delete [] Text;
}
/***********************************************************************************************
* EC::Scroll -- Apply the given distance to the y position of the text. *
* A positive distance scrolls up. *
* *
* *
* INPUT: distance in pixels to scroll up *
* *
* OUTPUT: true if text scrolled beyond the top of the screen *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/9/96 11:55PM ST : Created *
*=============================================================================================*/
bool EgoClass::Scroll(int distance)
{
YPos -= distance;
if (YPos < -20) {
return (true);
}else{
return (false);
}
}
/***********************************************************************************************
* EC::Render -- Draws the text to the logic page *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/9/96 11:57PM ST : Created *
*=============================================================================================*/
void EgoClass::Render (void)
{
if (YPos < LogicPage->Get_Height() && YPos > -16) {
Fancy_Text_Print(Text, XPos, YPos, GadgetClass::Get_Color_Scheme(), TBLACK, Flags);
}
}
/***********************************************************************************************
* EC::Wipe -- Wipes the previously rendered text by blitting a rectangle from the given *
* background screen. *
* *
* *
* INPUT: ptr to screen containing original background *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/9/96 11:58PM ST : Created *
*=============================================================================================*/
void EgoClass::Wipe (GraphicBufferClass *background)
{
int width = String_Pixel_Width (Text);
int x = XPos;
if (Flags & TPF_RIGHT) {
x -= width;
}else{
if (Flags & TPF_CENTER){
x -= width/2;
}
}
background->Blit(*LogicPage, x-1, YPos, x-1, YPos, width+2, 7 * RESFACTOR +1, false);
}
/***********************************************************************************************
* Set_Pal -- Low level palette set *
* *
* *
* *
* INPUT: ptr to palette *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/9/96 11:59PM ST : Created *
*=============================================================================================*/
void Set_Pal(char *palette)
{
//#ifndef WIN32
//Vsync();
//unsigned char *rgbptr = (unsigned char *) palette;
//outportb(0x03C8, 0); //Start from color 0
//for (int index = 0; index < 256; index++) {
// outrgb(rgbptr[index*3], rgbptr[index*3+1], rgbptr[index*3+2]);
//}
//#else //WIN32
Set_Palette((void*)palette);
//#endif
}
/***********************************************************************************************
* Slide_Show -- Handles the blitting and fading of the background pictures. *
* *
* The picture frame number is used to trigger blitting and fading events *
* *
* *
* INPUT: picture number *
* frame *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/10/96 0:16AM ST : Created *
*=============================================================================================*/
void Slide_Show (int slide, int frame)
{
/*
** Temprary storage to save CCPalette to
*/
char save_palette[256*3];
if (frame >= 1 && frame <=4){
/*
** Blit in a quarter of the new frame to the background page.
*/
SlideBuffers[slide]->Blit (*BackgroundPage, 0, (frame-1) * CHUNK_HEIGHT,
0, (frame-1) * CHUNK_HEIGHT,
SeenBuff.Get_Width(), CHUNK_HEIGHT, false);
return;
}
if (frame >= 5 && frame <=8 ){
/*
** Blit in a quarter of the new frame to the hid page.
*/
BackgroundPage->Blit (HidPage, 0, (frame-5) * CHUNK_HEIGHT,
0, (frame-5) * CHUNK_HEIGHT,
SeenBuff.Get_Width(), CHUNK_HEIGHT, false);
return;
}
if (frame ==9){
/*
** Create the combo palette from the font entries and the picture entries.
*/
for (int index = 0 ; index < 256 ; index++ ){
if (PaletteLUT[index]) {
ComboPalPtr[index*3] = SlidePals[slide][index*3];
ComboPalPtr[index*3+1] = SlidePals[slide][index*3+1];
ComboPalPtr[index*3+2] = SlidePals[slide][index*3+2];
}
}
return;
}
if (frame >10 && frame < FADE_DELAY+10){
/*
** Fade up the picture in the background. The text colors never fade.
*/
memcpy (save_palette, CCPalette, sizeof(save_palette));
//CCPalette.Partial_Adjust (MIN (6*(frame-5), 255), ComboPalette, PaletteLUT);
CCPalette.Partial_Adjust (MIN ((255/FADE_DELAY)*(frame-10), 255), ComboPalette, PaletteLUT);
Set_Pal ( (char *) &CCPalette);
if (frame != 9+FADE_DELAY){
memcpy (CCPalette, save_palette, sizeof(save_palette));
}else{
memcpy (CCPalette, CurrentPalette, sizeof (CCPalette));
}
return;
}
if (frame >FRAME_DELAY && frame < FRAME_DELAY+FADE_DELAY){
/*
** Fade down the picture in the background. The text colors never fade.
*/
memcpy (save_palette, CCPalette, sizeof(save_palette));
CCPalette.Partial_Adjust (MIN ((255/FADE_DELAY)*(frame-FRAME_DELAY), 255), PaletteLUT);
if (frame != FRAME_DELAY+FADE_DELAY-1){
Set_Pal ( (char *) &CCPalette);
memcpy (CCPalette, save_palette, sizeof(save_palette));
}else{
/*
** If this is the last fade down frame then zero the picture palette entries.
*/
unsigned char *ccpalptr = (unsigned char*)CCPalette;
for (int index = 0 ; index < 256 ; index++){
if (PaletteLUT[index]){
ccpalptr[index*3] = 0;
ccpalptr[index*3+1] = 0;
ccpalptr[index*3+2] = 0;
}
}
Set_Pal ( (char *) &CCPalette);
}
}
}
/***********************************************************************************************
* Show_Who_Was_Responsible -- Main function to print the credits. *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 9/10/96 0:20AM ST : Created *
*=============================================================================================*/
void Show_Who_Was_Responsible (void)
{
int i;
int key;
/*
** Deault speed of credits scolling. This is the frame delay between pixel scrolls.
*/
static int speed = 3;
/*
** In DOS we need to scroll slower so we have a bool that lets us do it every other time
*/
#ifndef WIN32
bool scroll_now = false;
#endif //WIN32
/*
** Read in the credits file to be displayed
**
** Lines of text in CREDITS.TXT are treated as follows....
**
** If the text starts and ends to the left of column 40 then text will be right justified.
** If the text starts before column 40 and ends after it then it will be centered.
** If the text starts after column 40 it will be right justified.
*/
CCFileClass creditsfile ("credits.txt");
if ( !creditsfile.Is_Available()) return;
char *credits = new char [creditsfile.Size()+1];
creditsfile.Read (credits, creditsfile.Size());
/*
** Initialise the text printing system.
*/
GadgetClass::Set_Color_Scheme(&ColorRemaps[PCOLOR_GREEN]);
Fancy_Text_Print(TXT_NONE, 0, 0, GadgetClass::Get_Color_Scheme(),
TBLACK, TPF_CENTER|TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_NOSHADOW);
/*
** Miscellaneous stuff for parsing the credits text file.
*/
int length = creditsfile.Size();
int line = 0;
int column = 0;
char *cptr = credits;
char ch, lastchar, oldchar;
char *strstart, *strparse;
bool gotendstr;
int startcolumn, endcolumn, x;
int y=SeenBuff.Get_Height()+2;
EgoClass *ego;
TextPrintType flags;
/*
** Search through the text file and extract the strings, using each string to create
** a new EgoClass
*/
do {
/*
** Search for text
*/
ch = *cptr++;
length --;
/*
** Look for a non whitespace character.
*/
switch ( ch ){
case 13:
/*
** Char was carriage return. Go on to the next line starting at column 0.
*/
line++;
column = 0;
break;
case 10:
/*
** Ignore line feed. CR does both.
*/
break;
/*
** Space character. Just advance the cursor and move on.
*/
case 32:
column++;
break;
/*
** Tab char. Advance to the next tab column. Tabs are every 8 columns.
*/
case 9:
column += 8;
column &= 0xfffffff8;
break;
default:
/*
** Found new string. Work out where it ends so we know how to treat it.
*/
lastchar = ch;
strstart = cptr-1;
strparse = cptr-1;
endcolumn = startcolumn = column;
gotendstr = false;
do {
ch = *strparse++;
switch ( ch ){
case 9:
case 10:
case 13:
gotendstr = true;
break;
case 32:
if (lastchar == 32) gotendstr = true;
endcolumn++;
break;
default:
endcolumn++;
}
if (strparse >= cptr+length) gotendstr = true;
lastchar = ch;
}while (!gotendstr);
if (strparse >= cptr+length) break;
/*
** Strip off any trailing space.
*/
if (*(strparse-2) == 32){
strparse--;
endcolumn -= 2;
}
/*
** If string straddles the center column then center it.
**
** If string is on the left hand side then right justify it.
**
** If string is on the right hand side then left justify it.
*/
flags = TPF_6PT_GRAD | TPF_USE_GRAD_PAL | TPF_DROPSHADOW; //TPF_NOSHADOW;
if (startcolumn <40 && endcolumn >40){
flags = flags | TPF_CENTER;
x = SeenBuff.Get_Width() / 2;
}else{
if (startcolumn <40){
flags = flags | TPF_RIGHT;
x = endcolumn *SeenBuff.Get_Width() /80;
}else{
x = startcolumn * SeenBuff.Get_Width() / 80;
}
}
/*
** Temporarily terminate the string.
*/
oldchar = *(strparse-1);
*(strparse-1) = 0;
/*
** Create the new class and add it to our list.
*/
ego = new EgoClass (x, y+ line *8 *RESFACTOR, strstart, flags);
EgoList.Add (ego);
/*
** Restore the character that was lost when we added the terminator.
*/
*(strparse-1) = oldchar;
/*
** Fix up our outer loop parsing variables.
*/
cptr = strparse;
column += strparse - strstart;
length -= strparse - strstart-1;
if (ch == 13) {
line++;
column = 0;
}else{
if (ch == 9){
column += 7;
column &= 0xfffffff8;
}
}
break;
}
} while ( length>0 );
/*
** Work out which palette entries the font needs so we dont fade those colors.
*/
memset (PaletteLUT, 1, sizeof (PaletteLUT));
int pcolor = PCOLOR_GREEN;
for (int index = 0; index < 6; index++) {
PaletteLUT[ColorRemaps[pcolor].FontRemap[10+index]] =0;
}
//PaletteLUT[ColorRemaps[pcolor].BrightColor] = 0;
PaletteLUT[ColorRemaps[pcolor].Color] = 0;
PaletteLUT[ColorRemaps[pcolor].Shadow] = 0;
PaletteLUT[ColorRemaps[pcolor].Background] = 0;
PaletteLUT[ColorRemaps[pcolor].Corners] = 0;
PaletteLUT[ColorRemaps[pcolor].Highlight] = 0;
PaletteLUT[ColorRemaps[pcolor].Bright] = 0;
PaletteLUT[ColorRemaps[pcolor].Underline] = 0;
PaletteLUT[ColorRemaps[pcolor].Bar] = 0;
PaletteLUT[ColorRemaps[pcolor].Box] = 0;
/*
** Stop the music.
*/
Theme.Stop();
/*
** Fade to black.
*/
BlackPalette.Set(TIMER_SECOND*2, Call_Back);
/*
** Load the reference palette for the font.
*/
//Load_Title_Page(true);
//#ifdef WIN32
// Load_Picture("EGOPAL.CPS", SysMemPage, SysMemPage, CCPalette, BM_DEFAULT);
//#else //WIN32
// Load_Picture("EGOPAL.CPS", HidPage, HidPage, CCPalette, BM_DEFAULT);
//#endif //WIN32
CCFileClass("EGOPAL.PAL").Read(&CCPalette, sizeof(CCPalette));
/*
** Copy the font palette entries into the combo palette.
*/
PaletteClass credit_palette;
ComboPalPtr = (unsigned char *) &ComboPalette;
unsigned char *creditpal_ptr = (unsigned char *) &credit_palette;
memcpy (ComboPalette, CCPalette, sizeof (ComboPalette));
for (index = 0 ; index < 256 ; index++ ){
if (PaletteLUT[index]) {
ComboPalPtr[index*3] = 0;
ComboPalPtr[index*3+1] = 0;
ComboPalPtr[index*3+2] = 0;
}
}
/*
** Clear the Seen Page since we will not be blitting to all of it.
*/
SeenBuff.Clear();
HidPage.Clear();
/*
** Set the font palette.
*/
memcpy ( CCPalette, ComboPalette, sizeof (ComboPalette) );
CCPalette.Set();
/*
** Loop through and load up all the slideshow pictures
*/
for (index = 0 ; index < NUM_SLIDES ; index++){
#ifdef WIN32
SlideBuffers[index] = new GraphicBufferClass;
SlideBuffers[index]->Init (SeenBuff.Get_Width(), SeenBuff.Get_Height(), NULL , 0 , (GBC_Enum)0);
Load_Title_Screen(&SlideNames[index][0], SlideBuffers[index], (unsigned char*) &SlidePals[index][0]);
#else //WIN32
SlideBuffers[index] = new GraphicBufferClass (SeenBuff.Get_Width(), SeenBuff.Get_Height(), (void*)NULL);
Load_Picture(&LoresSlideNames[index][0], *SlideBuffers[index], *SlideBuffers[index], (unsigned char *)&SlidePals[index][0], BM_DEFAULT);
#endif //WIN32
}
/*
** Create a new graphic buffer to restore the background from. Initialise it to black so
** we can start scrolling before the first slideshow picture is blitted.
*/
#ifdef WIN32
BackgroundPage = new GraphicBufferClass;
BackgroundPage->Init (SeenBuff.Get_Width(), SeenBuff.Get_Height(), NULL , 0 , (GBC_Enum)(GBC_VIDEOMEM));
#else //WIN32
BackgroundPage = new GraphicBufferClass (SeenBuff.Get_Width(), SeenBuff.Get_Height(), (void*)NULL );
#endif //WIN32
SeenBuff.Blit(*BackgroundPage);
/*
** Go away nasty keyboard.
*/
Keyboard->Clear();
Set_Logic_Page(HidPage);
/*
** Start any old song.
*/
fixed oldvolume = Options.ScoreVolume;
if (oldvolume == 0) {
Options.Set_Score_Volume(fixed(4, 10), false);
}
Theme.Queue_Song(THEME_CREDITS);
/*
** Init misc timing variables.
*/
int time = TickCount;
int frame = 0;
int picture_frame = 0;
int slide_number = 0;
Hide_Mouse();
/*
** Save the priority of this process so we can change it back later
*/
//DWORD process_priority = GetPriorityClass(GetCurrentProcess());
/*
** Main scrolling loop.
** Keeps going until all the EgoClass objects are deleted or esc is pressed.
*/
while ( EgoList.Count() ){
frame++;
/*
** Once we have been running for a few frames, and Windows has time to do its virtual
** memory stuff, increase our priority level.
*/
//if (frame == 30){
// SetPriorityClass (GetCurrentProcess() , HIGH_PRIORITY_CLASS);
//}
/*
** Update the slideshow frame and switch to the next picture if its time.
*/
picture_frame++;
if (picture_frame > FRAME_DELAY+50){
if (slide_number <NUM_SLIDES-1){
slide_number++;
picture_frame = 0;
}else{
slide_number = 0;
picture_frame = 0;
}
}
/*
** Do the slideshow background.
*/
Slide_Show (slide_number, picture_frame);
/*
** Scroll the text. If any text goes off the top then delete that object.
*/
#ifndef WIN32
scroll_now = !scroll_now;
if (scroll_now){
#endif //WIN32
for (i=EgoList.Count()-1 ; i>=0 ; i--){
EgoList[i]->Wipe(BackgroundPage);
if ( EgoList[i]->Scroll(1) ){
EgoList.Delete(i);
break;
}
}
#ifndef WIN32
}
#endif //WIN32
/*
** Render all the text strings in their new positions.
*/
if (LogicPage->Lock()){
for (i=EgoList.Count()-1 ; i>=0 ; i--){
EgoList[i]->Render();
}
LogicPage->Unlock();
}
if (frame > 1000 && !Theme.Still_Playing()){
Theme.Queue_Song(THEME_CREDITS); //NONE);
}
/*
** Stop calling Theme.AI after a while so a different song doesnt start playing
*/
Call_Back();
// if (frame <1000 ){
// Theme.AI();
// }else{
// Sound_Callback();
// }
/*
** Kill any spare time before blitting the hid page forward.
*/
while (TickCount - time < frame *speed && !Keyboard->Check()) {}
/*
** Blit all but the top and bottom of the hid page. This is beacuse the text print doesn't
** clip vertically and looks ugly when it suddenly appears and disappears.
*/
#ifndef WIN32
Wait_Vert_Blank(VertBlank);
//Vsync();
#endif //WIN32
HidPage.Blit(SeenBuff, 0, 8*RESFACTOR, 0, 8*RESFACTOR, SeenBuff.Get_Width(), SeenBuff.Get_Height() - 16*RESFACTOR, false);
/*
** Try and prevent Win95 from swapping out pictures we havnt used yet.
*/
#ifdef WIN32
if (frame && 3 == 3){
for (i=slide_number+1 ; i<NUM_SLIDES ; i++){
if ( !SlideBuffers[i]->Get_IsDirectDraw() ){
Force_VM_Page_In ((void*)SlideBuffers[i]->Get_Offset(), SeenBuff.Get_Width() * SeenBuff.Get_Height() );
}
}
}
#endif //WIN32
/*
** If user hits escape then break.
*/
key = KN_NONE;
if (Keyboard->Check()){
key = Keyboard->Get();
if (key == KN_ESC){
break;
}
#if (0)
if (key == KN_Z){
speed--;
if (speed <1 ) speed=1;
time = TickCount;
frame = 0;
}
if (key == KN_X){
speed++;
time = TickCount;
frame = 0;
}
#endif //(0)
}
}
if (key == KN_ESC){
Theme.Fade_Out();
BlackPalette.Set(TIMER_SECOND*2, Call_Back);
}else{
/*
** Wait for the picture to fade down
*/
while (picture_frame <= FADE_DELAY+FRAME_DELAY){
if (picture_frame < FRAME_DELAY && picture_frame > 10+FADE_DELAY){
picture_frame = FRAME_DELAY;
}
frame++;
picture_frame++;
Slide_Show (slide_number, picture_frame);
Call_Back();
// Sound_Callback(); //Theme.AI();
/*
** Kill any spare time
*/
while (TickCount - time < frame *speed && !Keyboard->Check()) {}
}
}
/*
** Tidy up.
*/
//SetPriorityClass (GetCurrentProcess() , process_priority);
SeenBuff.Clear();
Show_Mouse();
GadgetClass::Set_Color_Scheme(&ColorRemaps[PCOLOR_DIALOG_BLUE]);
Theme.Stop();
Options.Set_Score_Volume(oldvolume, false);
for (index = 0 ; index < NUM_SLIDES ; index++){
delete SlideBuffers[index];
}
delete BackgroundPage;
delete [] credits;
EgoList.Clear();
}
#endif