#include <unistd.h>

#include <GL/gl.h>

#include <libpng/png.h>

#include "system.h"

#include "species_sound.h"

#include "stratdef.h"

#include "bh_types.h"

#include "weapons.h"

#include "net.h"

#include "psndplat.h"

#include "hud.h"

#include "dynamics.h"

#include "pheromon.h"

#include "pfarlocs.h"

#include "generator.h"

#include "pvisible.h"

#include "lighting.h"

#include "npc_marine.h"

#include "userprofile.h"

#include "savegame.h"

#include "kshape.h"

#include "paintball.h"

#include "frustum.h"

#include "files.h"

extern int load_level(const char * fname, int);

extern void EmptyHierarchyLibrary();

extern void PurgeMSLShapeList();

extern void Deallocate_cplusplus();

extern void create_strategies_from_list();

extern void roll_credits();

extern void shutdown_network();

extern void DeallocateEnvImages();

extern void DeallocateModules();

extern void BuildMultiplayerLevelNameArray();

extern void PlayerDamagedOverlay(int intensity);

extern void Generate_Sphere();

extern void AddShapes();

extern int InitPlayer();

extern int InitTimer();

extern void PlayerBehaviour();

extern void shuffle_textures();

extern void assign_textures();

extern void mission_messages_add(const char *);

extern void InitGameDirectories(char *argv0);

extern int LoadCommonTextures();

extern void ThisFramesRenderingHasFinished();

extern void ThisFramesRenderingHasBegun();

extern void RenderStringCentred(char *stringPtr, int centreX, int y, int colour);

extern void ConstructOneOverSinTable();

extern int Destroy_CurrentEnvironment();

extern void FadeDownScreen(int brightness, int colour);

extern int InitNPCs();

extern void DeallocateAllImages();

extern void InitOpenGL();

extern void ResetOpenGL();

extern void RequestChangeOfWeaponNo(int weapon_nr);

extern void cleanup_strings();

SCREENDESCRIPTORBLOCK ScreenDescriptorBlock;

extern int CloakingPhase;

extern int numVisMods;

extern int numVisObjs;

extern int CheaterCounter;

extern int LevelHasStars;

extern int DrawingAReflection;

extern int current_decal_index;

extern int NumActiveDecals;

extern int PlanarGravity;

extern SCENEMODULE MainScene;

AVP_GAME_DESC AvP = { I_Marine, SinglePlayer, I_Medium, 0, 0,0,0,0,0,0,0,{'\0'} };

static SDL_Surface *surface = NULL;

static SDL_Rect **modes = NULL;

char * mission_messages = NULL;

const uint8_t Null_Name[8] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };

uint8_t* Keyboard;

int32_t lastTickCount;

struct shapeheader** mainshapelist;

int maxshapes = 2500;

int render_sky = 0;

int memoryInitialisationFailure = 0;

static int FrameRate;

int PrevNormalFrameTime;

int TimeScale = 65536;

int NormalFrameTime;

int RealFrameTime;

int GlobalFrameCounter;

int RouteFinder_CallsThisFrame;

unsigned int mission_messages_timer = 0;

int number_of_available_keys = 0;

int show_console = 0;

char current_key_pressed;

uint8_t GotAnyKey = 0;

static int max_videomodes;

static int current_video_mode_index = 0;

int SetVideoMode()

{

    int width = UserProfile.screen.width;

    int height = UserProfile.screen.height;

    if (NULL != (surface = SDL_SetVideoMode(width, height, 0, SDL_OPENGL | (UserProfile.fullscreen ? SDL_FULLSCREEN : 0)))) 

    {

        ScreenDescriptorBlock.SDB_Width     = width;

        ScreenDescriptorBlock.SDB_Height    = height;

        ScreenDescriptorBlock.SDB_CentreX   = width / 2;

        ScreenDescriptorBlock.SDB_CentreY   = height / 2;

        glViewport(0, 0, width, height);

        return 1;

    }

    fprintf(stderr, "(OpenGL) SDL SetVideoMode failed: %s\n", SDL_GetError());

return 0;

}

void toggle_mouse_grab()

{

    SDL_WM_GrabInput(((SDL_GRAB_OFF == SDL_WM_GrabInput(SDL_GRAB_QUERY)) ? SDL_GRAB_ON : SDL_GRAB_OFF));

}

static int InitSDL()

{

    if (!SDL_Init(SDL_INIT_VIDEO)) 

    {

        SDL_ShowCursor(0);

        SDL_EnableUNICODE(1);

        Keyboard = SDL_GetKeyState(&number_of_available_keys);

        int number_of_available_keys;

        atexit(SDL_Quit);

        if( (-1 != UserProfile.screen.height) && (-1 != UserProfile.screen.width)

        &&

        (!SDL_VideoModeOK(UserProfile.screen.height, UserProfile.screen.height, 0, SDL_OPENGL | (UserProfile.fullscreen ? SDL_FULLSCREEN : 0))))

        {

        }

        else

        {

            modes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);

            if (NULL != modes)

            {

                if(((SDL_Rect**)-1) == modes) 

                {

                    const SDL_VideoInfo *video_info = SDL_GetVideoInfo();

                    UserProfile.screen.width = video_info->current_w;

                    UserProfile.screen.height = video_info->current_h;

                }

                else

                {

                    for (max_videomodes=0; modes[max_videomodes]; max_videomodes++)

                    {

                        UserProfile.screen.width = modes[max_videomodes]->w;

                        UserProfile.screen.height = modes[max_videomodes]->h;

                    }

                }

            }

        }

        return SetVideoMode();

    }

    fprintf(stderr, "%s\n", SDL_GetError());

return 0;

}

void change_video_mode(int next)

{

    if (NULL == modes)

    {

        modes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);

        if ((NULL == modes) || ((SDL_Rect**)-1) == modes) 

            return;

        for (max_videomodes=0; modes[max_videomodes]; max_videomodes++)

        {}

    }

    if ((NULL != modes) && ((SDL_Rect**)-1) != modes) 

    {

        if(next)

        {

            if(current_video_mode_index >= max_videomodes -1)

                current_video_mode_index = 0;

            else

                current_video_mode_index++;

        }

        else

        {

            if(current_video_mode_index <= 0)

                current_video_mode_index = --max_videomodes;

            else

                current_video_mode_index--;

        }

        UserProfile.screen.width = modes[current_video_mode_index]->w;

        UserProfile.screen.height = modes[current_video_mode_index]->h;

        SetVideoMode();

    }

}

#define TimerFrame    1000

/*

    Timer functions are based on Windows timer

    giving number of millisecond ticks since Windows

    was last booted.  Note this will wrap round after

    Windows has been up continuously for  approximately

    49.7 days.  This is not considered to be too

    significant a limitation...

*/

static void ResetFrameCounter()

{

    InitTimer();

    lastTickCount = timeGetTime();

    /* KJL 15:03:33 12/16/96 - I'm setting NormalFrameTime too, rather than checking that it's

    non-zero everytime I have to divide by it, since it usually is zero on the first frame. */

    NormalFrameTime = 65536 >> 4;

    PrevNormalFrameTime = RealFrameTime = NormalFrameTime;

    FrameRate = 16;

    GlobalFrameCounter = 0;

    CloakingPhase = 0;

    RouteFinder_CallsThisFrame = 0;

}

void FrameCounterHandler()

{

    int newTickCount = timeGetTime();

    int fcnt = newTickCount - lastTickCount;

    lastTickCount = newTickCount;

    if (!fcnt)

        fcnt = 1; /* for safety */

    FrameRate = TimerFrame / fcnt;

    PrevNormalFrameTime = NormalFrameTime;

    RealFrameTime = NormalFrameTime = DIV_FIXED(fcnt, TimerFrame);

    if (TimeScale != ONE_FIXED)

        NormalFrameTime = MUL_FIXED(NormalFrameTime, TimeScale);

    /* cap NormalFrameTime if frame rate is really low */

    if (NormalFrameTime > 16384)

        NormalFrameTime = 16384;

    GlobalFrameCounter++;

    CloakingPhase += NormalFrameTime >> 5;

    RouteFinder_CallsThisFrame = 0;

}

static void show_mission_messages()

{

    static const int color =((255 << 24) + (95 << 16) + (179 << 8) + 39);

    int x = ScreenDescriptorBlock.SDB_CentreX;

    int y = ScreenDescriptorBlock.SDB_Width/8;

    int len = strlen(mission_messages);

    if (len < 71)

    {

        RenderStringCentred(mission_messages, x , y, color);

    }

    else

    {

        char *ptr = malloc(len + 1);

        if (ptr)

        {

            int i = 0;

            int height = 0;

            strcpy(ptr, mission_messages);

            char *ptr_mesg_org = ptr;

            for (; i < len; i++)

            {

                switch(ptr[i])

                {

                    case '\n':

                    {

                        height += 14;

                        ptr[i] = '\0';

                        RenderStringCentred(ptr, x , (y + height), color);

                        ptr += i + 1;

                        len -= i;

                        i = 0;

                    break;

                    }

                    default:

                    break;

                }

            }

            height += 14;

            RenderStringCentred(ptr, x , (y + height), color);

            free(ptr_mesg_org);

        }

    }

    if (mission_messages_timer < timeGetTime())

    {

        mission_messages_add(mission_messages);

        mission_messages = NULL;

        mission_messages_timer = 0;

    }

}

int got_any_key()

{

    static int GotAnyKeyDebounced = 0;

    if (GotAnyKey)

    {

        if (GotAnyKeyDebounced)

        {

            GotAnyKeyDebounced = 0;

            return 1;

        }

    }

    else

        GotAnyKeyDebounced = 1;

return 0;

}

static void ScreenShot()

{

    char Name[40]= {'\0'} ;

    int length = strlen("screen_shot");

    sprintf(Name, "screen_shot00.png");

    static int image_number = 0;

    for(; image_number < 100; image_number++)

    {

        Name[length] = image_number / 10 + '0';

        Name[length+1] = (image_number % 10) + '0';

        FILE* tempfp = OpenGameFile(Name, 1, FILETYPE_CONFIG);

        if(!tempfp)

            break;

        else

            fclose(tempfp);

    }

    if(100 == image_number)

        return;

    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

    if (png_ptr)

    {

        png_infop info_ptr = png_create_info_struct(png_ptr);

        if (info_ptr)

        {

            FILE *fp = OpenGameFile(Name, 0, FILETYPE_CONFIG);

            if (fp)

            {

                png_init_io(png_ptr, fp);

                png_set_IHDR(png_ptr, info_ptr, surface->w, surface->h, 16, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);

                png_write_info(png_ptr, info_ptr);

                unsigned short screenbuf[surface->h][surface->w * 3];

                glReadPixels(0, 0, surface->w, surface->h, GL_RGB, GL_UNSIGNED_SHORT, screenbuf);

        #if 0

            {

                int i = surface->h - 1;

                for (; i >= 0; i--)

                    png_write_row(png_ptr, screenbuf[i]);

            }

        #else

            {

                int i = 0;

                unsigned short *rows[surface->h];

                for (; i < surface->h; i++)

                    rows[i] = screenbuf[surface->h - i - 1];

                png_write_image(png_ptr, rows);

            }

        #endif

                //png_write_end(png_ptr, NULL);

                png_write_flush(png_ptr);

                png_destroy_write_struct(&png_ptr, &info_ptr);

                fclose(fp);

            }

            else

            printf("Error creating image file %s\n", Name);

        }

        else

        {

            png_destroy_write_struct(&png_ptr, NULL);

        }

    }

}

void read_user_input()

{

    SDL_Event sdl_event;

    current_key_pressed = '\0';

    Keyboard[SDL_BUTTON_WHEELUP] = Keyboard[SDL_BUTTON_WHEELDOWN] = GotAnyKey = 0;

    while (SDL_PollEvent(&sdl_event))

    {

        switch(sdl_event.type)

        {

            case SDL_MOUSEBUTTONDOWN:

                Keyboard[sdl_event.button.button] = GotAnyKey = 1;

            break;

            case SDL_MOUSEBUTTONUP:

                Keyboard[SDL_BUTTON_LEFT] = Keyboard[SDL_BUTTON_RIGHT] = Keyboard[SDL_BUTTON_MIDDLE] = 0;

            break;

            case SDL_KEYDOWN:

            {

                switch(sdl_event.key.keysym.sym)

                {

                    case  SDLK_F2:

                        show_console = !show_console;

                    break;

                    case SDLK_ESCAPE:

                    {

                        extern void TriggerInGameMenus();

                        if (AvP.MainLoopRunning)

                            TriggerInGameMenus();

                    }

                    break;

                    case SDLK_1:

                        if (!PaintBallMode.IsOn)

                            RequestChangeOfWeaponNo(0);

                        else

                            PaintBallMode_ChangeSubclass(+1);

                    break;

                    case SDLK_2:

                        if (!PaintBallMode.IsOn)

                            RequestChangeOfWeaponNo(1);

                        else

                            PaintBallMode_ChangeSubclass(-1);

                    break;

                    case SDLK_3:

                        if (!PaintBallMode.IsOn)

                            RequestChangeOfWeaponNo(2);

                        else

                            PaintBallMode.DecalIsInverted = ~PaintBallMode.DecalIsInverted;

                    break;

                    case SDLK_4:

                        if (!PaintBallMode.IsOn)

                            RequestChangeOfWeaponNo(3);

                        else

                            PaintBallMode_Randomise();

                    break;

                    case SDLK_5:

                            RequestChangeOfWeaponNo(4);

                    break;

                    case SDLK_6:

                            RequestChangeOfWeaponNo(5);

                    break;

                    case SDLK_7:

                            RequestChangeOfWeaponNo(6);

                    break;

                    case SDLK_8:

                            RequestChangeOfWeaponNo(7);

                    break;

                    case SDLK_9:

                            RequestChangeOfWeaponNo(8);

                    break;

                    case SDLK_0:

                            RequestChangeOfWeaponNo(9);

                    default:

                        break;

                }

                current_key_pressed = sdl_event.key.keysym.unicode;

                GotAnyKey = 1;

            }

            default:

            break;

        }

    }

}

static void DoLevelStatisticsScreen()

{

    if(AvP.LevelCompleted)

    {

        SDL_Event sdl_event;

        glClear(GL_COLOR_BUFFER_BIT);

        SDL_GL_SwapBuffers();

        if ((-1 == AvP.LevelCompleted) || CheaterCounter)

        {

            RenderStringCentred("Level Completed With Cheats", ScreenDescriptorBlock.SDB_CentreX, 20, 0xffff0000);

            if(CheaterCounter) // let user complete level if no other cheats is activated, bonus mode will not be unlocked if present.

            {

                RenderStringCentred("Press any key to restart game", ScreenDescriptorBlock.SDB_CentreX, ScreenDescriptorBlock.SDB_Height-20,
0xffffffff);

                AvP.LevelCompleted = 0;

            }

            else

            {

                RenderStringCentred("Press ESCAPE to restart level, or any other key to continue", ScreenDescriptorBlock.SDB_CentreX,
ScreenDescriptorBlock.SDB_Height-20, 0xffffffff);

            }

            //if (!deathFadeLevel) 

            //FadeDownScreen(deathFadeLevel, 0);

        }

        else

        {

            //FadeDownScreen(0, 0);

            DoStatisticsScreen();

            RenderStringCentred("Press ESCAPE to restart level, or any other key to continue", ScreenDescriptorBlock.SDB_CentreX,
ScreenDescriptorBlock.SDB_Height-20, 0xffffffff);

        }

        SDL_GL_SwapBuffers();

        while (SDL_WaitEvent(&sdl_event))

        {

            if(SDL_KEYDOWN == sdl_event.type)

            {

                AvP.RestartLevel = (Keyboard[SDLK_ESCAPE] || !AvP.LevelCompleted);

                glClear(GL_COLOR_BUFFER_BIT);

                show_console = 0;

                break;

            }

        }

    }

}

static void load_common_sounds()

{

    extern const char * common_sounds[];

    int soundIndex = 0;

    for (; soundIndex < SID_STARTOF_SCREAMSLOTS; soundIndex++)

    {

        if (LoadWavFile(soundIndex, "common", common_sounds[soundIndex]))

        {

            switch(soundIndex)

            {

                case SID_PRED_LAUNCHER:

                    GameSounds[soundIndex].pitch = -3;        

                break;

                case SID_PULSE_START:

                case SID_PULSE_LOOP:

                case SID_PULSE_END:

                case SID_ALIEN_KILL:

                case SID_ACID_SPRAY:

                case SID_DOORSTART:

                case SID_DOORMID:

                case SID_NOAMMO:

                    GameSounds[soundIndex].pitch = -2;        

                break;

                case SID_TELETEXT:

                case SID_PRED_VISION_ON:

                case SID_INCIN_START:

                case SID_INCIN_LOOP:

                case SID_INCIN_END:

                case SID_SHOTGUN:

                case SID_SMART1:

                case SID_SMART2:

                case SID_SMART3:

                case SID_EXPLOSION:

                    GameSounds[soundIndex].pitch = -4;        

                break;

                default:

                    continue;

            }

                /* pitch offset is in semitones: need to convert to 1/128ths */

                InitialiseBaseFrequency(soundIndex);

        }

    }

}

static void Game_Has_Loaded()

{

    do

    {

        glClear(GL_COLOR_BUFFER_BIT);

        ThisFramesRenderingHasBegun();

        RenderStringCentred("Press any key to continue", ScreenDescriptorBlock.SDB_CentreX, (ScreenDescriptorBlock.SDB_Height*23)/24-9, 0xffffffff);

        SDL_GL_SwapBuffers();

        FrameCounterHandler();

        /* If in a network game then we may as well check the network messages while waiting*/

        if(SinglePlayer != AvP.PlayMode)

        {

            //send messages , mainly  needed so that the host will send the game description

            //allowing people to join while the host is loading

            NetSendMessages();

        }

        read_user_input();

        /* after this call, no more graphics can be drawn until the next frame */

        ThisFramesRenderingHasFinished();

    } while(!got_any_key());

}

int main(int argc, char *argv[])

{

    InitGameDirectories(argv[0]);

    LoadUserProfile();

    if (!InitSDL())

    {

        fprintf(stderr, "Could not find a sutable resolution!\n");

        fprintf(stderr, "At least 640x480 is needed.  Does OpenGL work?\n");

        return 1;

    }

    mainshapelist = calloc(maxshapes, sizeof(struct shapeheader*));

    if(!mainshapelist)

    {

        exit(EXIT_FAILURE);

    }

    else

    {

        int i;

        for(i = 0; i < maxshapes; i++)

            mainshapelist[i] = NULL;

    }

    SetDefaultMultiplayerConfig();

    SetFastRandom();

        ConstructOneOverSinTable();

    BuildMultiplayerLevelNameArray();

    InitialiseDynamicsBlocks();

    InitialiseStrategyBlocks();

    InitialiseLightBlocks();

    init_sky();

    Generate_Sphere();

    if (PlatStartSoundSys())

    {

        load_common_sounds();

        LoadSpeciesSounds();

    }

    if(UserProfile.grabmouse)

        toggle_mouse_grab();

    if(LoadCommonTextures() && InitNPCs())

    {

        //PlayIntroSequence();

        int random_textures = (UserProfile.CheatMode[CHEATMODE_RANDOMTEXTURES] && (CHEATMODE_RANDOMTEXTURES == UserProfile.active_bonus));

        if (!random_textures)

            assign_textures(); //to npc and player

        InitOpenGL();

        while(AvP.RestartLevel || (LoadGameRequest != SAVELOAD_REQUEST_NONE ) || MainMenus())

        {

            CheaterCounter = 0;

            DrawingAReflection = 0;

            numVisMods = numVisObjs = 0;

            NumActiveLightElements = 0;

            NumActiveDecals = current_decal_index = 0;

            ResetFrameCounter();

            InitHive();

            InitSquad();

            CurrentGameStats_Initialise();

            InitialiseTxAnimBlocks(); 

            InitialiseObjectBlocks();

            InitialiseParticleSystem();

            InitialiseSfxBlocks();

            if(!AvP.RestartLevel)

            {

                //PrintHierarchyLibrary();

                MirroringActive = 0;

                if (!load_level(AvP.LevelName, UserProfile.GameOptions.MapPrelighting))

                    break;

                assign_textures(); // to level

                if (random_textures)

                    shuffle_textures();

            }

            else

            {

                //reset the displayblock for modules to 0

                int i=2;

                while(!MainScene.sm_module[i].end_module)

                    MainScene.sm_module[i++].m_dptr = NULL;

            }

            InitPlayer();

            create_strategies_from_list();

            AssignAllSBNames();

            ActivateHive();

            if(SinglePlayer != AvP.PlayMode)

            {

                /*Need to choose a starting position for the player , but first we must look

                through the network messages to find out which generator spots are currently clear*/

                netGameData.myGameState = NGS_Playing;

                TeleportNetPlayerToAStartingPosition(1);

            }

            else

            {

                FrameCounterHandler();

                if(LoadSavedGame()) // error occurred; restart level.

                {

                    DestroyAllStrategyBlocks();

                    LoadGameRequest = SAVELOAD_REQUEST_NONE;

                    AvP.RestartLevel = 1;

                    continue;

                }

            }

            PlanarGravity = 1;

            TimeScale = ONE_FIXED;

            switch(UserProfile.active_bonus)

            {

                case CHEATMODE_FREEFALL:

                    PlanarGravity = 0;

                break;

                case CHEATMODE_DISCOINFERNO:

                case CHEATMODE_TRIPTASTIC:

                    MakeLightElement(&PlayerStatus.DisplayBlock->ObWorld, LIGHTELEMENT_ROTATING);

                break;

                case CHEATMODE_WARPSPEED:

                    TimeScale = 2 * ONE_FIXED;

                break;

                case CHEATMODE_LANDOFTHEGIANTS:

                    TimeScale = ONE_FIXED / 2;

                break;

                case CHEATMODE_UNDERWATER:

                    TimeScale = (ONE_FIXED * 7) / 10;

                default:

                break;

            }

            switch(AvP.PlayMode)

            {

                case NetworkPeer:

                case NetworkHost:

                    AvP.Network = 1;

                break;

                default:

                    AvP.Network = 0;

            }

    {

    //UserProfile.active_bonus = CHEATMODE_DRAWFULLBRIGHT;

    GiveAllWeaponsCheat();

    //PlayerStatus.sbptr->DamageBlock.Indestructable = 1;

    }

            AvP.MainLoopRunning = 1;

            AvP.RestartLevel = 0;

            ChooseLightingModel();

            //Game_Has_Loaded();

            ResetOpeGL();

            while(AvP.MainLoopRunning)

            {

                FrameCounterHandler();

                ThisFramesRenderingHasBegun();

                read_user_input();

                PlayerBehaviour();

                TranslationSetup();

                PlayerPheromoneSystem();

                ModuleHandler();

    //PlayerStatus.sbptr->DamageBlock.Indestructable = 1;

//glDepthFunc(GL_ALWAYS);

                ExecuteBehaviour();

//glDepthFunc(GL_FALSE);

                if(render_sky)

                {

                    glClear(GL_COLOR_BUFFER_BIT);

                    LevelHasStars ? RenderStarfield() : RenderSky();

                }

                ObjectDynamics();

                UpdateRunTimeLights();

                AddShapes();

                HandleParticleSystem();

                if (PlayerStatus.RequestsToStandUp)

                    TestForValidPlayerStandUp(PlayerStatus.sbptr);

glClear(GL_DEPTH_BUFFER_BIT);

                if(PlayerStatus.FirstPersonView)

                    PlayerStatus.Hud();

                if (mission_messages_timer)

                    show_mission_messages();

                if (show_console)

                {

                    static char console_command[30] = {'\0'};

                    static int current_console_text_pos = 0;

                    if (Keyboard[SDLK_BACKSPACE])

                    { 

                        if (current_console_text_pos > 0)

                        console_command[--current_console_text_pos] = '\0';

                    }

                    else if (Keyboard[SDLK_RETURN])

                    {

                        extern int parse_and_exec_console_command();

                        if(parse_and_exec_console_command(console_command))

                        {

                            //memset(console_command, 0, 30);

                            //current_console_text_pos = 0;

                            Sound_Play(SID_MENUS_SELECT_ITEM, "r");

                        }

                    }

                    else if (Keyboard[SDLK_UP] || Keyboard[SDLK_TAB] || Keyboard[SDLK_RIGHT])

                    {

                        extern const char* next_console_command();

                        strncpy(console_command, next_console_command(), 29);

                        current_console_text_pos = strlen(console_command);

                    }

                    else if (Keyboard[SDLK_DOWN] || Keyboard[SDLK_LEFT])

                    {

                        extern const char * prev_console_command();

                        strncpy(console_command, prev_console_command(), 29);

                        current_console_text_pos = strlen(console_command);

                    }

                    else if (current_key_pressed)

                    {

                        if (current_console_text_pos < 30)

                            console_command[current_console_text_pos++] = current_key_pressed;

                    }

                    RenderStringCentred("Console", ScreenDescriptorBlock.SDB_CentreX, ScreenDescriptorBlock.SDB_CentreY  -HUD_FONT_HEIGHT *2 ,
0xffff0000);

                    RenderStringCentred(console_command, ScreenDescriptorBlock.SDB_CentreX, ScreenDescriptorBlock.SDB_CentreY, 0xffff0000);

                    memset(Keyboard, 0, number_of_available_keys);

                }

                if (PlayerStatus.sbptr->DamageBlock.IsOnFire)

                {

                    extern void PlayerOnFireOverlay();

                    extern int myNetworkKillerId;

                    extern int myIgniterId;

                    extern int AVPDPNetID;

                    DAMAGEBLOCK * player_damage = &PlayerStatus.sbptr->DamageBlock;

                    if(PlayerStatus.FirstPersonView)

                        PlayerOnFireOverlay();

                    myNetworkKillerId = myIgniterId;

                    CauseDamageToObject(PlayerStatus.sbptr, &damage_profiles[FIREDAMAGE], NormalFrameTime, NULL);

                    myNetworkKillerId = AVPDPNetID;

                    if (PlayerStatus.soundCracklingFire != SOUND_NOACTIVEINDEX) 

                        Sound_Update3d(PlayerStatus.soundCracklingFire, &PlayerStatus.sbptr->DynPtr->Position);

                    else

                        Sound_Play(SID_FIRE, "dle", &PlayerStatus.sbptr->DynPtr->Position, &PlayerStatus.soundCracklingFire);