---

ASys.cpp

Go to the documentation of this file.

/*
CS Senior Project 2003
Team : Leftfield
Project : ModernWarfare
Members :
- Russ Christensen              <rchriste@cs.utah.edu>
- Todd Smith                    <tcsmith@cs.utah.edu>
- Usit Duongsaa                 <duongsaa@cs.utah.edu>

Copyright 2003 Russ Christensen, Usit Duongsaa, and Todd Smith. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
THIS SOFTWARE IS PROVIDED BY RUSS CHRISTENSEN, USIT DUONGSAA, AND TODD SMITH ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RUSS, USIT, TODD OR OTHER CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


#include "AEngine.h"
#include "AState.h"
#include "AConstants.h"
#include "ADevice.h"
#include "ASharedFunc.h"
#include "float.h"

const int UPDATE_RATE                   =       60;                                     // update 60 times/sec
const int UPDATE_INTERVAL               =       1000/UPDATE_RATE;       // how many millisec between updates

//------------------------------------------------------------------------------------
void sys_init( HINSTANCE hInst, int width, int height, int colorDepth, bool fullScreen )
{       
        AS.hInst = hInst;
        AS.windowWidth  = width;
        AS.windowHeight = height;
        AS.colorDepth   = colorDepth;
        AS.isFullScreen = fullScreen;
        AS.initFunc   = NULL;
        AS.updateFunc = NULL;
        AS.renderFunc = NULL;
        AS.shutdownFunc = NULL;
        AS.pConsoleLogFile = NULL;
        AS.vshader_terrain = NULL;

        AS.camera_pos    = Vec3D( 3.0f, 0.0f, 3.0f );
        AS.camera_target = Vec3D( 0.0f, 0.0f, 0.0f );
        D3DXMatrixIdentity(& (AS.camera_world2projMatrix) );
        AS.skipRate = 0;

        //unsigned int newFlags = _RC_DOWN | _PC_64;
        //unsigned int mask             = _MCW_RC | _MCW_PC;
        //_controlfp(newFlags,mask);
}
//------------------------------------------------------------------------------------
void sys_setSkipRate( int rate )
{
        AS.skipRate = rate;
}
//------------------------------------------------------------------------------------
void sys_setInitFunc( AierraInitFunc f )
{
        AS.initFunc = f;
}
//------------------------------------------------------------------------------------
void sys_setUpdateFunc( AierraUpdateFunc f )
{
        AS.updateFunc = f;
}
//------------------------------------------------------------------------------------
void sys_setRenderFunc( AierraRenderFunc f )
{
        AS.renderFunc = f;
}
//------------------------------------------------------------------------------------
void sys_setShutdownFunc( AierraShutdownFunc f )
{
        AS.shutdownFunc = f;
}
//------------------------------------------------------------------------------------
// helper function for doGameLoop
void handleSystemMessages()
{
        MSG msg; 
        while(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))    
    {
                TranslateMessage( &msg );
        DispatchMessage( &msg );
        }
}
//------------------------------------------------------------------------------------
// helper for doGameLoop().  Latches input status from DirectInput
void updateInput()
{
        NDX_Input &N = AS.ndxInput;

        // update mouse
        DIMOUSESTATE mouseState;
        if( N.lpDIDMouse->GetDeviceState(sizeof(mouseState),&mouseState) != DI_OK )
                N.lpDIDMouse->Acquire();

        N.MouseX=mouseState.lX;
        N.MouseY=mouseState.lY;
        N.MouseXPos+=N.MouseX;
        N.MouseYPos+=N.MouseY;
        if(N.MouseXPos<N.MouseLimit.left)               N.MouseXPos=N.MouseLimit.left;
        if(N.MouseXPos>N.MouseLimit.right-1)    N.MouseXPos=N.MouseLimit.right-1;
        if(N.MouseYPos<N.MouseLimit.top)                N.MouseYPos=N.MouseLimit.top;
        if(N.MouseYPos>N.MouseLimit.bottom-1)   N.MouseYPos=N.MouseLimit.bottom-1;
        AS.input_mouseWheel += ((FLOAT)(mouseState.lZ)) / 1500.0f;
        if( AS.input_mouseWheel > 1.0f ) AS.input_mouseWheel = 1.0f;
        if( AS.input_mouseWheel < 0.0f ) AS.input_mouseWheel = 0.0f;

                N.MouseLBClick = !N.MouseLB && mouseState.rgbButtons[0];
                N.MouseRBClick = !N.MouseRB && mouseState.rgbButtons[1];
                N.MouseMBClick = !N.MouseMB && mouseState.rgbButtons[2];
        N.MouseLB = (mouseState.rgbButtons[0]) != 0;
        N.MouseRB = (mouseState.rgbButtons[1]) != 0;
        N.MouseMB = (mouseState.rgbButtons[2]) != 0;
        N.MouseLBDblClick = false;
        N.MouseMBDblClick = false;
        N.MouseRBDblClick = false;
        if(N.MouseLBClick)
        {
            if( (GetTickCount() - N.m_dwDoubleClickTimeLB) < N.m_dwDoubleClickDelay)         
                N.MouseLBDblClick = true;
            else
                N.m_dwDoubleClickTimeLB = GetTickCount();
        }

        if(N.MouseMBClick)
        {
            if( (GetTickCount() - N.m_dwDoubleClickTimeMB) < N.m_dwDoubleClickDelay)
                N.MouseMBDblClick = true;
            else
                N.m_dwDoubleClickTimeMB = GetTickCount();
        }

        if(N.MouseRBClick)
        {
            if( (GetTickCount() - N.m_dwDoubleClickTimeRB) < N.m_dwDoubleClickDelay)
                N.MouseRBDblClick = true;
            else
                N.m_dwDoubleClickTimeRB = GetTickCount();            
        }
        
        // update keyboard
        if( N.lpDIDKeys->GetDeviceState(256,&N.Keys) != DI_OK )
                N.lpDIDKeys->Acquire();
        for( int i=0; i<MAX_KEY; i++ )
        {
                AS.keyDownLastCycle[i] = AS.keyDownThisCycle[i];
                AS.keyDownThisCycle[i] = N.Keys[i] != 0;
        }

        // mouse idle
        Vec2D thisMouse( input_getMouseX(), input_getMouseY() );
        if( thisMouse != AS.input_lastTickMousePos )
        {
                AS.input_lastTickMousePos = thisMouse;
                AS.input_mouseIdleTickCount = 0;
        }
        else
        {
                AS.input_mouseIdleTickCount++;
        }
        
}
//------------------------------------------------------------------------------------
void beginRendering()
{
        if(AS.camera_screenSize==1.0f)
        {
                AS.pDevice->Clear( 0, NULL, AS.clearFlags, D3DCOLOR_XRGB(0,200,250), 1.0f, 0L );
                
                D3DVIEWPORT8 viewport;
                viewport.X = 0;
                viewport.Y = 0;
                viewport.Width  = AS.windowWidth;
                viewport.Height = AS.windowHeight;
                viewport.MinZ = 0.0f;
                viewport.MaxZ = 1.0f;
                AS.pDevice->SetViewport(&viewport);
        }
        else
        {
                D3DRECT rect;
                rect.x1 = (LONG) (AS.windowWidth /2 - AS.camera_screenSize*AS.windowWidth /2 );
                rect.x2 = (LONG) (AS.windowWidth /2 + AS.camera_screenSize*AS.windowWidth /2 );
                rect.y1 = (LONG) (AS.windowHeight/2 - AS.camera_screenSize*AS.windowHeight/2 );
                rect.y2 = (LONG) (AS.windowHeight/2 + AS.camera_screenSize*AS.windowHeight/2 );
                AS.pDevice->Clear( 1, &rect, AS.clearFlags, D3DCOLOR_XRGB(0,0,0), 1.0f, 0L );

                D3DVIEWPORT8 viewport;
                viewport.X = rect.x1;
                viewport.Y = rect.y1;
                viewport.Width  = rect.x2 - rect.x1;
                viewport.Height = rect.y2 - rect.y1;
                viewport.MinZ = 0.0f;
                viewport.MaxZ = 1.0f;
                AS.pDevice->SetViewport(&viewport);
        }

        AS.pDevice->BeginScene();
        device_flushSettings();
}
//------------------------------------------------------------------------------------
void endRendering()
{
        AS.pDevice->EndScene();
        AS.pDevice->Present(NULL,NULL,NULL,NULL);
}
//------------------------------------------------------------------------------------
// helper for doGameLoop
void drawConsole()
{
        istringstream in(AS.pConsoleStream->str());
        string line;
        
        while(in)                                       // read stuffs from console stream and store in line array
        {
                getline( in, line );
                if(line!="" || in)
                {
                        AS.consoleLineIndex = (AS.consoleLineIndex+1) % MAX_CONSOLE_LINES;
                        AS.consoleLines[ AS.consoleLineIndex ] = line;
                        if(AS.pConsoleLogFile) (*AS.pConsoleLogFile) << line << endl;
                }
        }

        delete AS.pConsoleStream;
        AS.pConsoleStream = new ostringstream;

        // draw blue background box and red border
        if(!AS.showConsole) return;
        overlay_rect( Vec2D(0.0f,0.0f), Vec2D(0.5f,1.0f), true, Colors::blue, BlendModes::MIX, 0.4f );
        overlay_rect( Vec2D(0.0f,0.0f), Vec2D(0.5f,0.999f), false, Colors::red );
                
        for( int i=0; i<MAX_CONSOLE_LINES; i++ )                // draw all lines
        {
                int lineIndex = (AS.consoleLineIndex+1+i) % MAX_CONSOLE_LINES;
                overlay_text() << AS.consoleLines[lineIndex];
                overlay_textOut( Vec2D(0.005f, i*0.033f) );             
        }
}
//------------------------------------------------------------------------------------
// helper for doGameLoop()
// draw update rate, frame rate & excess time rate
void drawFPS()
{
        if(!AS.showFPS) return;
        char s[256];
        sprintf( s, "update %6.2f\nrender %6.2f\n excess %8.2f\n", AS.updateRate, AS.renderRate, AS.excessRate );
        overlay_text() << s;
        overlay_textOut( Vec2D(0.82f,0.0f) );
}
//------------------------------------------------------------------------------------
// helper for doGameLoop()
// checks&processes system keys (commands directly to the engine)
void checkSysKeys()
{       
        // LShift+LCtrl+END ==> quit
        if( input_isKeyDown(KeyCodes::key_LCONTROL) && input_isKeyDown(KeyCodes::key_LSHIFT)
                && input_isKeyDown(KeyCodes::key_END) )
                throw TerminateNormally();

        // LShift+LCtrl+C ==> toggle console visibility
        if( input_isKeyDown(KeyCodes::key_LCONTROL) && input_isKeyDown(KeyCodes::key_LSHIFT)
                && input_isKeyPressed(KeyCodes::key_C) )        
                AS.showConsole = !AS.showConsole;       

        // LShift+LCtrl+F ==> toggle FPS visibility
        if( input_isKeyDown(KeyCodes::key_LCONTROL) && input_isKeyDown(KeyCodes::key_LSHIFT)
                && input_isKeyPressed(KeyCodes::key_F) )
                AS.showFPS = !AS.showFPS;
}
//------------------------------------------------------------------------------------
void flushRenderRequests()
{
        overlay_flush();
        mesh_flush();
        terrain_flush();
        sprite_flush();
}
//------------------------------------------------------------------------------------
void processRenderRequests()
{
        mesh_processRenderRequests();
        terrain_processRenderRequest();
        sprite_process();
        flare_process();
        
        drawConsole();
        drawFPS();
        overlay_render();
}
//------------------------------------------------------------------------------------
// helper function for sys_go.  this executes the gameloop forever (until an exception)
void doGameLoop()
{
        AS.idealMS = sys_getMilliSec();
        profiler_reset();
        updateInput();
        (AS.updateFunc)();

        while(true)
        {
                profiler_begin("sys_overhead");
                DWORD thisMS  = sys_getMilliSec();
                DWORD elapsed = thisMS - AS.idealMS;
                if( elapsed<1  ) elapsed = 1;
                if( elapsed>100) elapsed = 100;

                if( thisMS-AS.lastCountResetMS >= 1000 )                // calculate update/render/excess rate
                {
                        FLOAT deltaT = (FLOAT) (thisMS-AS.lastCountResetMS);
                        AS.updateRate = AS.updateCount*1000.0f / deltaT;
                        AS.renderRate = AS.renderCount*1000.0f / deltaT;
                        AS.excessRate = AS.excessCount*1000.0f / deltaT;
                        AS.lastCountResetMS = thisMS;
                        AS.updateCount = 0;
                        AS.renderCount = 0;
                        AS.excessCount = 0;                     
                }

                if( thisMS-AS.profiler_MSlastReset >= 20000 )   // profiler
                {
                        profiler_render();
                        profiler_reset();
                }
                profiler_end("sys_overhead");
                
                profiler_begin("sys_update");

                if( AS.fastForwardAmount>0 )
                {
                        for( int i=0; i<AS.fastForwardAmount; i++ )                             // fast forwarding
                        {
                                updateInput();
                                checkSysKeys();
                                (AS.updateFunc)();
                                AS.updateCount++;
                                handleSystemMessages();
                        }
                        elapsed = 0;
                        AS.idealMS = sys_getMilliSec();         // attempt to make the system think we're just right on time
                        AS.fastForwardAmount = 0;
                }

                while( elapsed >= 16 )                                          // keep updating until we catch up
                {
                        DWORD prevElapsed = elapsed;
                        updateInput();                  

                        checkSysKeys();
                        (AS.updateFunc)();
                        AS.updateCount++;
                        AS.idealMS += 16;
                        thisMS  = sys_getMilliSec();
                        elapsed = thisMS - AS.idealMS;
                        if(elapsed >= prevElapsed)
                        {
                                sys_console() << "WARNING Update is slower than 62.5Hz" << endl;
                                DWORD timeTaken = 16 + elapsed - prevElapsed;
                                if(timeTaken) sys_console() << "WARNING Update() is taking " << timeTaken << " ms" << endl;
                        }                       
                        
                        handleSystemMessages();
                }               
                profiler_end("sys_update");

                profiler_begin("sys_render");
                if( AS.renderNumber++ % (1+AS.skipRate) == 0 )
                {                                                                                       // rendering
                        AS.renderCount++;
                        flushRenderRequests();                  
                        (AS.renderFunc)();
                        beginRendering();
                        processRenderRequests();
                        endRendering();                 
                }
                profiler_end("sys_render");

                thisMS  = sys_getMilliSec();
                elapsed = thisMS - AS.idealMS;
                handleSystemMessages();

                profiler_begin("sys_sleep");
                if(elapsed<UPDATE_INTERVAL)                                     // block if we are going too fast
                {
                        AS.excessCount += 16-elapsed;
                        Sleep(16-elapsed);
                        while(elapsed<UPDATE_INTERVAL)
                        {
                                thisMS = sys_getMilliSec();
                                elapsed = thisMS - AS.idealMS;
                                if( elapsed<1  ) elapsed = 1;
                                if( elapsed>100) elapsed = 100;                                 
                        }                               
                }
                profiler_end("sys_sleep");

                handleSystemMessages();
        }
}
//------------------------------------------------------------------------------------
// window update function
LRESULT WINAPI AierraWindowProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    if( msg==WM_DESTROY ) throw TerminateNormally();
    return DefWindowProc( hWnd, msg, wParam, lParam );
}
//------------------------------------------------------------------------------------
void createWindow()
{
        // Register the window class
    WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, AierraWindowProc, 0L, 0L, GetModuleHandle(NULL),
                                          NULL, LoadCursor(NULL, IDC_ARROW), NULL, NULL, "Aierra Engine", NULL };
    RegisterClassEx( &wc );

    // Create the application's window  
    AS.hWnd = CreateWindow( "Aierra Engine", "Modern Warfare", WS_VISIBLE, 0,0, 
                                                        AS.windowWidth, AS.windowHeight,
                            GetDesktopWindow(), NULL, wc.hInstance, NULL );     
        if(AS.hWnd==NULL) throw Error("Can't Create New Window");
}
//------------------------------------------------------------------------------------
// find a display mode that the graphics card can support
void findCompatibleMode(D3DDISPLAYMODE &d3dDisplayMode)
{
        int modeCount = AS.pD3D->GetAdapterModeCount(D3DADAPTER_DEFAULT);
        bool foundGoodMode = false;
        for( int i=0; i<modeCount; i++ )
        {
                AS.pD3D->EnumAdapterModes( D3DADAPTER_DEFAULT, i, &d3dDisplayMode );
                D3DFORMAT format = d3dDisplayMode.Format;
                if( d3dDisplayMode.Width==AS.windowWidth && d3dDisplayMode.Height==AS.windowHeight
                                                                 && d3dDisplayMode.RefreshRate>=40 )
                        if( format==D3DFMT_A8R8G8B8 || format==D3DFMT_A4R4G4B4 || format==D3DFMT_R5G6B5 || format==D3DFMT_R8G8B8 )
                        {
                                foundGoodMode = true;
                                i = modeCount;                  // Break the loop
                        }                       
        }
        if(!foundGoodMode) throw Error("Cant't Find Compatible Display Mode");
}
//------------------------------------------------------------------------------------
void createRenderingDevice()
{
        AS.pD3D = Direct3DCreate8(D3D_SDK_VERSION);
        if( AS.pD3D==NULL) throw Error("Can't create Direct3D");

        int rc;         // return code
        D3DDISPLAYMODE                  d3dDisplayMode;
        D3DPRESENT_PARAMETERS   d3dParam;
        ZeroMemory( &d3dParam, sizeof(d3dParam) );
    d3dParam.Windowed = !AS.isFullScreen;
    d3dParam.SwapEffect = D3DSWAPEFFECT_DISCARD;

        if(AS.isFullScreen)
        {
                AS.clearFlags = D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL ;
                findCompatibleMode(d3dDisplayMode);
                // Confirm Mode Compatibility
                rc = AS.pD3D->CheckDeviceType( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, d3dDisplayMode.Format,                                                                               
                                                d3dDisplayMode.Format, false );
                if(FAILED(rc)) throw Error("Video Mode Not Compatible");                
                d3dParam.BackBufferWidth  = d3dDisplayMode.Width;
                d3dParam.BackBufferHeight = d3dDisplayMode.Height;
                d3dParam.BackBufferFormat = d3dDisplayMode.Format;      
                d3dParam.EnableAutoDepthStencil = TRUE;
                d3dParam.AutoDepthStencilFormat = D3DFMT_D24S8;
                d3dParam.FullScreen_RefreshRateInHz = d3dDisplayMode.RefreshRate;
                d3dParam.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
        }
        else
        {
                AS.clearFlags= D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER ;
                // choose same display mode as current desktop
                rc = AS.pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3dDisplayMode);
                if(FAILED(rc)) throw Error("Can't Find Existing Display Mode");
                d3dParam.BackBufferFormat = d3dDisplayMode.Format;
                d3dParam.EnableAutoDepthStencil = TRUE; 
                d3dParam.AutoDepthStencilFormat = D3DFMT_D16;
        }

        // create direct 3D rendering device
        rc = AS.pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, AS.hWnd,
                                                        D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dParam, &AS.pDevice );
        if( FAILED(rc) ) throw Error("Can't create Direct3D Device");
        
        ShowWindow(AS.hWnd, SW_SHOWDEFAULT);
    UpdateWindow(AS.hWnd);

        if(!AS.isFullScreen)            // get actual window size (minus the border,titlebar)
        {               
                RECT rect;
                GetClientRect(AS.hWnd,&rect);
                AS.windowWidth  = rect.right  - rect.left;
                AS.windowHeight = rect.bottom - rect.top;
        }
}
//------------------------------------------------------------------------------------
void sys_shutdown()
{
        static bool shutdownAlready = false;
        assert(!shutdownAlready);
        shutdownAlready = true;

        delete AS.pConsoleStream;
        
        for( UINT i=0; i<AS.res_fonts.size(); i++ )  delete AS.res_fonts[i];            // fonts

        delete AS.overlay_pTextStream;

        delete AS.pConsoleLogFile;

}
//------------------------------------------------------------------------------------
void displayLoadingScreen()
{
        overlay_flush();
        beginRendering();
        ATexture tex = load_texture("textures\\loading.tga");
        overlay_image( tex, Vec2D(0.5f,0.5f), Vec2D(1.0f,1.0f) );
        overlay_render();
        endRendering();
}
//------------------------------------------------------------------------------------
void sys_go()
{
        createWindow();
        createRenderingDevice();

        // init all major components
        input_init();
        overlay_init(); 

        // init all sub components
        // init console
        AS.showConsole = true;
        AS.showFPS     = false;
        AS.pConsoleStream = new ostringstream();
        AS.consoleLineIndex = 0;

        AS.camera_screenSize = 1.0f;
        AS.camera_vibratePos = 0.0f;
        AS.camera_vibrateSpeed = 0.0f;

        AS.input_mouseIdleTickCount = 0;
        AS.input_lastTickMousePos = Vec2D(0,0);

        // init game loop control counters
        AS.lastCountResetMS = 0;
        AS.updateCount = 0;
        AS.updateRate  = 0;
        AS.renderCount = 0;
        AS.renderRate  = 0;
        AS.excessCount = 0;
        AS.excessRate  = 0;
        AS.renderNumber = 0;
        AS.fastForwardAmount = 0;

        // specific to this game
        displayLoadingScreen();

        // networking
        AS.net_isInit = false;

        for(int i=0; i<MAX_LOCAL_RANDON_NUM; i++)                                       // local random number generator
                AS.res_localRandomNums.push_back( rand()%256 );
        for(int i=0; i<MAX_LOCAL_RANDON_FLOAT; i++ )
                AS.res_localRandomFloats.push_back( sys_randFloat() );
        AS.res_localRandomNumIndex = 0;
        AS.res_localRandomFloatIndex = 0;

        // user-defined initialization
        (AS.initFunc)();

        mesh_init();
        flare_init();
        sprite_init();

        // Let it all go
        try
        {
                doGameLoop();
        }
        catch(TerminateNormally e)
        {
                sys_shutdown();
                if(AS.shutdownFunc) (AS.shutdownFunc)();
                return;
        }
}
//------------------------------------------------------------------------------------
void sys_terminate()
{
        sys_flushConsole();
        throw TerminateNormally();
}
//------------------------------------------------------------------------------------
void sys_showFPS(bool show)
{
        AS.showFPS = show;
}
//------------------------------------------------------------------------------------
void sys_showConsole(bool show)
{
        AS.showConsole = show;  
}
//------------------------------------------------------------------------------------
void sys_enableConsoleLog(string filename)
{
        // make sure we wipe out all previous content in the file if it already exists
        AS.pConsoleLogFile = new ofstream(filename.c_str());
        (*AS.pConsoleLogFile) << "Clear Log" << endl;
        AS.pConsoleLogFile->close();
        delete AS.pConsoleLogFile;

        // open up the file for writting
        AS.pConsoleLogFile = new ofstream(filename.c_str());
}
//------------------------------------------------------------------------------------
ostream& sys_console()
{       
        assert(AS.pConsoleStream);
        return *(AS.pConsoleStream);
}
//------------------------------------------------------------------------------------
void sys_flushConsole()
{
        if(!AS.pConsoleLogFile) return;

        istringstream in(AS.pConsoleStream->str());
        string line;    
        while(in)
        {
                getline( in, line );
                if(line!="" || in)
                {
                        AS.consoleLineIndex = (AS.consoleLineIndex+1) % MAX_CONSOLE_LINES;
                        AS.consoleLines[ AS.consoleLineIndex ] = line;
                        (*AS.pConsoleLogFile) << line << endl;
                }
        }

        delete AS.pConsoleStream;
        AS.pConsoleStream = new ostringstream();
}
//------------------------------------------------------------------------------------
void sys_fastForwardUpdate( int times )
{
        assert(times>=0 && times<1000);
        AS.fastForwardAmount = times;   
}
//------------------------------------------------------------------------------------
DWORD sys_getMilliSec()
{
        LARGE_INTEGER                   tick;
        static LARGE_INTEGER    freq    = {0};  
        static bool                             inited  = false;
        if (!inited)
        {
                inited = true;
                QueryPerformanceFrequency( &freq );
        }
        QueryPerformanceCounter( &tick );
        return (DWORD)((tick.QuadPart * 1000) / freq.QuadPart);
}
//------------------------------------------------------------------------------------
// currently, these are just direct wrappers of the C library equivalents
// we will add log/profiling when we need to
void  sys_setRandSeed(int seed)
{
        srand( (unsigned int)seed );
        AS.res_localRandomNumIndex = seed % MAX_LOCAL_RANDON_NUM;
        AS.res_localRandomFloatIndex = seed % MAX_LOCAL_RANDON_FLOAT;
}
//------------------------------------------------------------------------------------
int   sys_randInt()
{
        return rand();
}
//------------------------------------------------------------------------------------
FLOAT sys_randFloat()
{
        return (rand()&0x0ff) / 128.0f - 1.0f;
}
//------------------------------------------------------------------------------------
int sys_localRandInt()
{
        AS.res_localRandomNumIndex = (AS.res_localRandomNumIndex + 1) % MAX_LOCAL_RANDON_NUM;
        return AS.res_localRandomNums[ AS.res_localRandomNumIndex ];
}
//------------------------------------------------------------------------------------
FLOAT sys_localRandFloat()
{
        AS.res_localRandomFloatIndex = (AS.res_localRandomFloatIndex + 1) % MAX_LOCAL_RANDON_FLOAT;
        return AS.res_localRandomFloats[ AS.res_localRandomFloatIndex ];
}
//------------------------------------------------------------------------------------
HWND sys_getWindowHandle()
{
        return AS.hWnd;
}
//------------------------------------------------------------------------------------

---