/**Klasa opisujaca gre po stronie javy. Odpowiada jej CGame
* po stronie C++. Obiekt tej klasy tworzony jest automatycznie przez
* system gry po uruchomieniu programu. Jest to klasa bazowa dla konkretnej
* gry. Jaka gra zostanie utworzona, okreslone jest w skrypcie "game.ini". */
public class Game extends GameObject
{
static Game cSingleton = null;
Game()
{
cSingleton = this;
}
/**Okresla, czy jestesmy w trybie "debug", aby miala sens nalezy wszystkie testowe
* shity zamykac w warunek
* if (Game._bDbg)
* {
* ...
* }
*
* wtedy po zmianie jednej zmiennej wyrzucamy niepotrzebne, testowe rzeczy, niepozadane
* przy wypuszczaniu wersji release.
* Szczegolnie moze sie przydac do kontoli klawiatury, zastosowanie schematu:
*
* void OnInputKey(int nKeyCode, boolean bKeyState, char nKeyAscii)
* {
* if (Game.bDbg)
* OnInputKeyDebug(nKeyCode, bKeyState, nKeyAscii);
* ...
* }
*
* void OnInputKeyDebug(int nKeyCode, boolean bKeyState, char nKeyAscii)
* {
* ...
* }
*
* gwarantuje, ze nie wypusci sie wersji z dodatkowymi "ficzerami" na klawiaturze.
* */
static boolean _bDbg = false;
void SetDebug(boolean bSet)
{
_bDbg = bSet;
}
/** czy asercje wlaczone */
static boolean m_bAssertOn = false;
/** wlacza/ wylacza assercje */
static void SetAssertion(boolean bSet)
{
m_bAssertOn = bSet;
}
/** Zwraca true gdy gra jest odpalona z poziomu edytora
*/
static native public boolean IsGameInEditor();
//--------------------------- ustawianie parametrow gry -----------------------------------
/**[native] Ustawia parametry ekranu gry.
* @param nSizeX szerokosc okna gry w pikselach (int
)
* @param nSizeY wysokosc okna gry w pikselach (int
)
* @param nBPP ilosc bitow koloru na piksel (int
)
* @param nInWindow jesli 1 to okno, 0 to pelny ekran (int
)
* */
native void SetScreenParams(int nSizeX, int nSizeY, int nBPP, int nInWindow);
/**[native] Ustawia nazwe okna gry. Mozliwe ze nazwa ta zostanie uzyta
* przy tworzeniu kluczy w rejestrze.
* @param name nazwa okna z gra (String
)*/
native void SetGameName(String name);
/** [native] Wlaczenie gry w tryb serwera dedykowanego tzn. gra nic nie renderuje.
* Metoda moze byc jedynie zawolana w PreInitialize klasy Game
*/
native void GoDedicatedServer();
/**[native] Aktywowanie nagrywania AVIkow. Wlacza gre w trybie stalej ramki
* o czestotliwosci odswiezania takiej jaka jest zadana parametrem.
* Powoduje wyrzucenie okienka z wyborem codeca, wiec najbezpieczniej
* wolac ta metode w OnPreInitialize().
* @param sFileName nazwa AVIka do ktorego bedzie zgrane
* @param fFPH framerate z jakim filmik ma byc nagrany
*/
static native void EnableRecordingAVI(String sFileName, float fFPH);
/**[native] Aktywuje nagrywanie inputow po wczytaniu levelu.
* @param sFileName nazwa pliku do ktorego zostana zapisane dane z inputow
* @param fFPH czestotliwosc nagrywania inputow
*/
static native void EnableInputRecording(String sFileName, float fFPH);
/**[native] Aktywuje odgrywanie inputow z dysku po odczytaniu levelu
* @param sFileName nazwa pliku z ktorego zostana odczytane dane do inputow
* @param fFPH czestotliwosc odgrywania inputow
*/
static native void EnableInputPlaying(String sFileName, float fFPH);
/**[native] Ustawienie stalego ziarna dla gry
* @param fFPH czestotliwosc
*/
static native void EnableConstantGrain(float fFPH);
/**[native] Wylacza startowy warning o slabosci karty graficznej (ponizej gf 3 i radeona)
*/
public final native void DisableGF3Warning();
/**[native] Zatrzymuje liczniki czasu na levelach.
*/
public final native void TimersStop();
/**[native] Startuje liczniki czasu na levelach po zrobieniu TimersStop().
*/
public final native void TimersStart();
/**[native] Definiuje czy timery na tworzonych przez gre levelach
* beda domyslnie zatrzymane. Defaultowo ustawione na true.
* @param bFrozen jesli true to timery beda zatrzymane
*/
public final native void TimersDefaultFrozen(boolean bFrozen);
/**[native] Okresla ile ekranow (w poziomie i w pionie) ma przypadac
* na jeden screenshot np. 2 oznacza, ze przy rozdzielczosci ekranu
* 640x480 screenshot bedzie mial wymiary 1280x960
*/
public final native void SetScreenshotSlices(int iNum);
/**[native] Robi duzy screenshot do pliku screen.tga */
public native final void TakeScreenshot();
public native final void TakeScreenshot(String sFileName);
/**[native] Ustawia procentowy udzial wolania metod OnCreate w progresie
* wczytywania leveli.
* @param fPercent procent wyrazony ulamkiem (0..1)
*/
static public native void SetLoadingOnCreatePercentage(float fPercent);
/** Okresla czy ma byc wolany GarbaegCollector co ramke gry
*/
public boolean bGC = false;
/** Wlacza pokazywanie predkosci tworzenia wektorow
*/
public boolean bVectorSpeed = false;
//static int PROFILE_GarbageCollector = 0;
float fLastTime = 0.0f;
int nLastVectAll = 0;
int nLastVectAllC = 0;
int nLastVect1 = 0;
int nLastVect2 = 0;
int nLastVect3 = 0;
int nLastVect4 = 0;
boolean bDumpVectors = false;
public void OnFrame()
{
/*
if(PROFILE_GarbageCollector==0)
{
PROFILE_GarbageCollector = ProfileAdd("Java", "Garbage collecting");
}
if(bGC)
{
ProfileBegin(PROFILE_GarbageCollector);
System.gc();
ProfileEnd(PROFILE_GarbageCollector);
}
*/
if(bVectorSpeed)
{
Vector.dump = false;
if(bDumpVectors)
{
Vector.dump = true;
bDumpVectors = false;
}
Vector.count_all = true;
float fCurrTime = GetAbsoluteTime();
float fDeltaTime = fCurrTime - fLastTime;
fLastTime = fCurrTime;
float fSpeedAll = ((float)(Vector.num_vectors_all - nLastVectAll))/fDeltaTime;
nLastVectAll = Vector.num_vectors_all;
float fSpeedAllC = ((float)(Vector.num_vectors_c - nLastVectAllC))/fDeltaTime;
nLastVectAllC = Vector.num_vectors_c;
float fSpeed1 = ((float)(Vector.num_vectors - nLastVect1))/fDeltaTime;
nLastVect1 = Vector.num_vectors;
float fSpeed2 = ((float)(Vector.num_vectors2 - nLastVect2))/fDeltaTime;
nLastVect2 = Vector.num_vectors2;
float fSpeed3 = ((float)(Vector.num_vectors3 - nLastVect3))/fDeltaTime;
nLastVect3 = Vector.num_vectors3;
float fSpeed4 = ((float)(Vector.num_vectors4 - nLastVect4))/fDeltaTime;
nLastVect4 = Vector.num_vectors4;
LogR("Vector all="+fSpeedAll+" allC="+fSpeedAllC);
LogR(" v1="+fSpeed1);
LogR(" v2="+fSpeed2);
LogR(" v3="+fSpeed3);
LogR(" v4="+fSpeed4);
LogR("\n");
}
}
public void gc()
{
//ProfileBegin(PROFILE_GarbageCollector);
System.gc();
//ProfileBegin(PROFILE_GarbageCollector);
}
//--------------------------- obsluga handlerow gry -----------------------------------
/** Handler wolany przed stowrzeniem okna gry.*/
public void OnPreInitialize(String[] aParams)
{
// tu powinno byc ustawienie rozdzielczosci i parametrow okna
SetScreenParams(640,480, 16, 1);
SetGameName("Generic Techland game");
if (aParams != null)
ReadExecuteParams(aParams);
}
final static String SAFE_MODE = "safemode";
static boolean _bSafeMode = false;
/** odczyt parametrow wejsciowych gry */
public void ReadExecuteParams(String[] aParams)
{
String sAVIFile = "SSHOT.avi";
float fFPS = 25.0f;
if( aParams.length > 0)
{
for(int i=0; i <"+nSlices+">\n");
SetScreenshotSlices(nSlices);
}
//gra odpala sie z niskim odswiezaniem, przydatne przy starych monitorach,
//ktore windows zle rozpoznaje i pozwala na ustawienie za wysokiego odswiezania
if( aParams[i].compareTo(SAFE_MODE)==0 )
{
_bSafeMode = true;
SetLowestDisplayFreq(true);
ForceNoEAX();
SetSafeMode( true );
}
}
}
}
// ---------------- SCREENSHOT SUPPORT --------------------------
/* Aby uzywac screenshot support w grze nalezy:
* 0. wolac OnPreInitialize() w swojej implementacji
* ew. ReadExecuteParams(...) z Game.java
* 1. wolac super.OnInitialize() w swojej implementacji tej funkcji
* 2. wolac super.OnInputKey() jesli uzywamy OnInputKey
* 3. wywolac funkcje SetScreenshotView(cModule, iView) na rzecz gry
* z parametrami modulu i widoku z ktorego chcemy pobierac screenshoty
*
* W czasie gry:
* PAUSE - przelacza tryb screenshotowy
* F12 - wlacza/wylacza czas pozostawiajac kamere screenshotowa
* F11 - wlacza/wylacza nagrywanie AVI do pliku (jesli przy uruchomieniu
* uzyto parametru 'ssrec' i wywolano fcje ReadExecuteParams() w
* ` implementracji OnPreInitialize()
*/
private static boolean _bScreenshotMode = false;
private static FreeCamera _cScreenshotCamera = null;
private static Camera _cOriginalCamera = null;
static Module _cSShotModule = null;
private static MeshObject _cSShotCamTarget = null;
private static int _iScreenshotView = -1;
private static boolean _bStopTimeMode = true;
private static boolean _bAVIRecEnabled = false;
private static boolean _bAVIRecording = false;
private static boolean _bShowSprites = false;
boolean IsScreenShotMode() { return _bScreenshotMode; }
FreeCamera GetScreenShotCamera() { return _cScreenshotCamera; }
boolean IsAviRecording() {return _bAVIRecording;}
public void SetScreenshotView(Module cModule, int iView)
{
_cSShotModule = cModule;
_iScreenshotView = iView;
_bScreenshotMode = false;
_cSShotModule.AcquireObjectModule(_cScreenshotCamera);
}
public void ClearScreenshotView()
{
FreeCamera.GetObjectNameModule().AcquireObjectModule(_cScreenshotCamera);
}
public void SetScreenshotCamTarget( MeshObject cMesh )
{
_cSShotCamTarget = cMesh;
}
public FreeCamera GetScreenshotCamera ()
{
return _cScreenshotCamera;
}
static Module GetSShotModule()
{
return _cSShotModule;
}
boolean bCheats = false;
static boolean CheatsEnabled(){ return (cSingleton != null) && (cSingleton.bCheats); }
void OnInputKey(int nKeyCode, boolean bKeyState, char nKeyAscii)
{
if(!bCheats) return;
if ( (_cSShotModule == null) ||
(_cScreenshotCamera == null) )
return;
if (!bKeyState)
{
switch(nKeyCode)
{
//wstrzymanie czasu
case EKey._PAUSE :
{
if (!_bScreenshotMode)
{
TimersStop();
_bStopTimeMode = true;
_bShowSprites = false;
_cSShotModule.ShowSprites(false);
_cOriginalCamera = _cSShotModule.GetViewCamera(_iScreenshotView);
_cSShotModule.SetViewCamera(_iScreenshotView, _cScreenshotCamera);
//pobieramy aktualna pozycje kamery z gry, zeby ustawic ta screenshotowa
_cScreenshotCamera.SetPosition(_cOriginalCamera.GetPosition());
}
else
{
_cSShotModule.SetViewCamera(_iScreenshotView, _cOriginalCamera);
_bStopTimeMode = false;
_bShowSprites = true;
_cSShotModule.ShowSprites(true);
TimersStart();
if (_bAVIRecording)
StopAVIRecording();
}
_bScreenshotMode = !_bScreenshotMode;
CrashLog("Game: screenshot support "+_bScreenshotMode+"\n");
}
break;
//przelaczanie celowania kamery screenshotowej
case EKey._F8 :
{
if (_bScreenshotMode && _cScreenshotCamera != null)
{
if (_cScreenshotCamera.target == null)
_cScreenshotCamera.target = _cSShotCamTarget;
else
_cScreenshotCamera.target = null;
}
} break;
//wstrzymanie czasu z pozostawieniem kamery niescreenshotowej
case EKey._F9 :
{
if (!_bAVIRecording)
{
if(_bStopTimeMode)
TimersStart();
else
TimersStop();
_bStopTimeMode = !_bStopTimeMode;
}
}
break;
case EKey._F11 :
{
// PZ: usuniety warunek, zeby mozna bylo avi w czasie gry walic
if ( //_bScreenshotMode &&
_bAVIRecEnabled )
{
if (!_bAVIRecording)
{
StartAVIRecording();
if(_bStopTimeMode) TimersStart();
}
else
{
if(_bStopTimeMode) TimersStop();
StopAVIRecording();
}
_bAVIRecording = !_bAVIRecording;
}
}
break;
case EKey._F10 :
{
//if ( _bScreenshotMode )
if (_cSShotModule != null)
{
_bShowSprites = !_bShowSprites;
_cSShotModule.ShowSprites(_bShowSprites);
}
}
break;
}
}
}
// -------------------------------------------------------------
/** Handler wolany po zainicjalizowaniu engine'a gry.*/
public void OnInitialize()
{
//CrashLog("[Game::OnInitilize] Abstract game object initialized.\n");
if (_bDbg)
{
CrashLog("----------------------------------------------------\n");
CrashLog("This game supports screenshots. Usage:\n");
CrashLog("\tPAUSE - toggle screenshot mode (stops frame, changes camera)\n\tF12 - start/stop time (during screenshot mode!)\n");
if (_bAVIRecEnabled)
{
CrashLog("AVI recording for screenshots is enabled. Usage:\n\tF11 during stop frame to record.\n");
}
CrashLog("----------------------------------------------------\n");
}
_cScreenshotCamera = (FreeCamera)CreateObject("FreeCamera");
RegisterKeyRequest();
ResetRandom();
}
public void OnTakeScreenShot(String sFile)
{
LogR("ScreenShot " + sFile + " Taken\n");
}
// ---------------- SCREENSHOT SUPPORT END ------------------------
/**Ustala czy po wcisnieciu 'n' maja sie pokazywac spite'y z nazwami meshobjectow*/
static boolean bCanShowObjectNames = false;
void SetCanShowObjectNames(boolean bShow)
{
bCanShowObjectNames = bShow;
}
/* Handler wolany gdy okno gry jest (de)aktywowane */
void OnWindowActivate(boolean bActive)
{
if (bActive)
Log("Game window activated\n");
else
Log("Game window deactivated\n");
}
}