C4Game Class Reference

#include <C4Game.h>

Collaboration diagram for C4Game:

Public Types
enum	InitMode { IM_Normal = 0 , IM_Section = 1 , IM_ReInit = 2 }

Public Member Functions
	C4Game ()
	~C4Game ()
void	Clear ()
void	Abort (bool fApproved=false)
void	Evaluate ()
void	ShowGameOverDlg ()
bool	DoKeyboardInput (C4KeyCode vk_code, C4KeyEventType event_type, bool alt, bool ctrl, bool shift, bool repeated, class C4GUI::Dialog *for_dialog=nullptr, bool fPlrCtrlOnly=false, int32_t strength=-1)
bool	DoKeyboardInput (C4KeyCodeEx key, C4KeyEventType event_type, class C4GUI::Dialog *for_dialog=nullptr, bool fPlrCtrlOnly=false, int32_t strength=-1)
void	DrawCrewOverheadText (C4TargetFacet &cgo, int32_t player_nr)
void	FixRandom (uint64_t seed)
bool	Init ()
bool	PreInit ()
void	SetScenarioFilename (const char *)
bool	HasScenario ()
bool	Execute ()
C4Player *	JoinPlayer (const char *filename, int32_t at_client, const char *at_client_name, C4PlayerInfo *info)
void	OnPlayerJoinFinished ()
bool	DoGameOver ()
bool	CanQuickSave ()
bool	QuickSave (const char *filename, const char *title, bool force_save=false)
void	SetInitProgress (float to_progress)
void	OnResolutionChanged (unsigned int res_x, unsigned int res_y)
void	OnKeyboardLayoutChanged ()
void	InitFullscreenComponents (bool is_running)
bool	ToggleChat ()
bool	TogglePause ()
bool	Pause ()
bool	Unpause ()
bool	IsPaused ()
void	Synchronize (bool save_player_files)
void	SyncClearance ()
bool	DropFile (const char *filename, float x, float y)
bool	DropDef (C4ID id, float x, float y)
bool	ReloadFile (const char *filepath)
bool	ReloadDef (C4ID id)
bool	ReloadParticle (const char *name)
void	ClearPointers (C4Object *obj)
C4Object *	CreateObject (C4PropList *type, C4Object *creator, int32_t owner=NO_OWNER, int32_t x=50, int32_t y=50, int32_t r=0, bool grow_from_center=false, C4Real xdir=Fix0, C4Real ydir=Fix0, C4Real rdir=Fix0, int32_t controller=NO_OWNER)
C4Object *	CreateObject (C4ID type, C4Object *creator, int32_t owner=NO_OWNER, int32_t x=50, int32_t y=50, int32_t r=0, bool grow_from_center=false, C4Real xdir=Fix0, C4Real ydir=Fix0, C4Real rdir=Fix0, int32_t controller=NO_OWNER)
C4Object *	CreateObjectConstruction (C4PropList *type, C4Object *creator, int32_t owner, int32_t center_x=0, int32_t bottom_y=0, int32_t con=1, bool adjust_terrain=false)
C4Object *	CreateInfoObject (C4ObjectInfo *info, int32_t owner, int32_t x=50, int32_t y=50)
C4Object *	FindConstuctionSiteBlock (int32_t x, int32_t y, int32_t wdt, int32_t hgt)
C4Object *	FindObject (C4Def *def, int32_t x=0, int32_t y=0, int32_t wdt=0, int32_t hgt=0, DWORD ocf=OCF_All, C4Object *find_next=nullptr)
C4Object *	FindVisObject (float x, float y, int32_t player_nr, const C4Facet &viewport_game, const C4Facet &viewport_gui, float game_x, float game_y, DWORD category, float gui_x, float gui_y)
int32_t	ObjectCount (C4ID id)
void	CastObjects (C4ID id, C4Object *creator, int32_t num, int32_t level, int32_t x, int32_t y, int32_t owner=NO_OWNER, int32_t controller=NO_OWNER, C4ValueArray *out_objects=nullptr)
C4Object *	PlaceVegetation (C4PropList *def, int32_t x, int32_t y, int32_t wdt, int32_t hgt, int32_t growth, C4PropList *shape_proplist, C4PropList *out_pos_proplist)
C4Object *	PlaceAnimal (C4PropList *def)
C4Value	GRBroadcast (const char *function, C4AulParSet *pars=nullptr, bool pass_error=false, bool reject_test=false)
bool	LoadScenarioSection (const char *section_name, DWORD flags)
bool	CreateSectionFromTempFile (const char *section_name, const char *temp_filename)
bool	DrawTextSpecImage (C4Facet &target, const char *spec, class C4DrawTransform *transform, uint32_t color=0xff)
float	GetTextSpecImageAspect (const char *spec)
bool	DrawPropListSpecImage (C4Facet &target, C4PropList *spec)
bool	SpeedUp ()
bool	SlowDown ()
bool	InitKeyboard ()
void	UpdateLanguage ()
bool	InitPlayerControlSettings ()
bool	InitPlayerControlUserSettings ()
void	SetDefaultGamma ()
bool	LoadAdditionalSystemGroup (class C4Group &parent_group)
bool	SaveGameTitle (C4Group &hGroup)
void	CompileFunc (StdCompiler *compiler, CompileSettings settings, C4ValueNumbers *)
bool	SaveData (C4Group &group, bool save_section, bool save_exact, bool save_sync, C4ValueNumbers *)
bool	ToggleChart ()
void	SetGlobalSoundModifier (C4PropList *modifier_props)
C4String *	GetTranslatedString (const class C4Value &input_string, C4Value *selected_language, bool fail_silently) const
C4PropList *	AllocateTranslatedString ()

Public Attributes
C4GameParameters &	Parameters
class C4ScenarioParameters &	StartupScenarioParameters
C4ClientList &	Clients
C4TeamList &	Teams
C4PlayerInfoList &	PlayerInfos
C4PlayerInfoList &	RestorePlayerInfos
C4RoundResults &	RoundResults
C4Scenario	C4S
class C4ScenarioParameterDefs &	ScenarioParameterDefs
C4ComponentHost	Info
C4ComponentHost	Title
C4ComponentHost	Names
C4ComponentHost	GameText
C4LangStringTable	MainSysLangStringTable
C4LangStringTable	ScenarioLangStringTable
StdStrBuf	PlayerNames
C4Control &	Input
C4PathFinder	PathFinder
C4TransferZones	TransferZones
C4Group	ScenarioFile
C4GroupSet	GroupSet
C4Group *	pParentGroup
C4Extra	Extra
class C4ScenarioObjectsScriptHost *	pScenarioObjectsScript
C4ScenarioSection *	pScenarioSections
C4ScenarioSection *	pCurrentScenarioSection
C4PlayerControlDefs	PlayerControlDefs
C4PlayerControlAssignmentSets	PlayerControlUserAssignmentSets
C4PlayerControlAssignmentSets	PlayerControlDefaultAssignmentSets
C4Scoreboard	Scoreboard
std::unique_ptr< C4Network2Stats >	pNetworkStatistics
C4KeyboardInput &	KeyboardInput
std::unique_ptr< C4FileMonitor >	pFileMonitor
std::unique_ptr< C4GameSec1Timer >	pSec1Timer
C4Value &	GlobalSoundModifier
char	CurrentScenarioSection [C4MaxName+1]
char	ScenarioFilename [_MAX_PATH_LEN]
StdCopyStrBuf	ScenarioTitle
char	PlayerFilenames [20 *_MAX_PATH_LEN]
char	DefinitionFilenames [20 *_MAX_PATH_LEN]
char	DirectJoinAddress [_MAX_PATH_LEN]
char	DirectJoinTempFilename [_MAX_PATH_LEN]
std::unique_ptr< C4Network2Reference >	pJoinReference
int32_t	StartupPlayerCount
int32_t	StartupTeamCount
int32_t	FPS
int32_t	cFPS
int32_t	HaltCount
bool	InitialPlayersJoined
bool	GameOver
bool	EvaluateOnAbort
bool	Evaluated
bool	GameOverDlgShown
bool	fScriptCreatedObjects
bool	fLobby
int32_t	iLobbyTimeout
bool	fObserve
bool	fReferenceDefinitionOverride
bool	NetworkActive
bool	Record
StdStrBuf	RecordDumpFile
StdStrBuf	RecordStream
StdStrBuf	TempScenarioFile
bool	fPreinited {false}
int32_t	FrameCounter
int32_t	iTick2
int32_t	iTick3
int32_t	iTick5
int32_t	iTick10
int32_t	iTick35
int32_t	iTick255
int32_t	iTick1000
bool	TimeGo
int32_t	Time
int32_t	StartTime
int32_t	InitProgress
int32_t	LastInitProgress
int32_t	LastInitProgressShowTime
int32_t	RandomSeed
bool	GameGo
bool	FullSpeed
int32_t	FrameSkip
bool	DoSkipFrame
bool	fResortAnyObject
bool	IsRunning
bool	PointersDenumerated
size_t	StartupLogPos {0}
size_t	QuitLogPos {0}
bool	fQuitWithError {false}
bool	DebugMode
StdCopyStrBuf	NextMission
StdCopyStrBuf	NextMissionText
StdCopyStrBuf	NextMissionDesc
uint16_t	DebugPort
StdStrBuf	DebugPassword
StdStrBuf	DebugHost
int	DebugWait
std::unique_ptr< C4ScriptGuiWindow >	ScriptGuiRoot

Static Public Attributes
static constexpr const char *	DirectJoinFilePrefix = "file:"

Protected Member Functions
void	Default ()
void	InitInEarth ()
void	InitVegetation ()
void	InitAnimals ()
void	InitGoals ()
void	InitRules ()
void	InitValueOverloads ()
void	InitEnvironment ()
void	CloseScenario ()
void	DeleteObjects (bool delete_inactive)
void	ExecObjects ()
void	Ticks ()
bool	CheckObjectEnumeration ()
bool	LoadScenarioComponents ()
bool	InitGame (C4Group &group, InitMode init_mode, bool load_sky, C4ValueNumbers *)
bool	InitGameFinal (InitMode init_mode)
bool	InitNetworkFromAddress (const char *address)
bool	InitNetworkFromReferenceFile (const char *temp_filename)
bool	InitNetworkFromReference (const C4Network2Reference &Reference)
bool	InitNetworkHost ()
bool	InitControl ()
bool	InitScriptEngine ()
bool	LinkScriptEngine ()
bool	ReLinkScriptEngine ()
bool	InitPlayers (C4ValueNumbers *)
bool	OpenScenario ()
bool	InitDefs ()
bool	InitMaterialTexture ()
bool	GameOverCheck ()
bool	PlaceInEarth (C4ID id)
bool	CompileRuntimeData (C4Group &group, InitMode init_mode, bool exact, bool sync, C4ValueNumbers *)
C4Object *	NewObject (C4PropList *def, C4Object *creator, int32_t owner, C4ObjectInfo *info, int32_t x, int32_t y, int32_t r, C4Real xdir, C4Real ydir, C4Real rdir, int32_t con, int32_t controller, bool grow_from_center)
void	ClearObjectPtrs (C4Object *to_obj)
void	ObjectRemovalCheck ()
bool	ToggleDebugMode ()
bool	ActivateMenu (const char *command)

Detailed Description

Definition at line 32 of file C4Game.h.

Member Enumeration Documentation

InitMode

enum C4Game::InitMode

Enumerator
IM_Normal
IM_Section
IM_ReInit

Definition at line 36 of file C4Game.h.

    {
        IM_Normal = 0,
        IM_Section = 1,
        IM_ReInit = 2
    };

Constructor & Destructor Documentation

C4Game()

C4Game::C4Game

(

)

Definition at line 97 of file C4Game.cpp.

              :
        ScenarioParameterDefs(GameScenarioParameterDefs),
        Parameters(GameParameters),
        StartupScenarioParameters(GameStartupScenarioParameters),
        Clients(Parameters.Clients),
        Teams(Parameters.Teams),
        PlayerInfos(Parameters.PlayerInfos),
        RestorePlayerInfos(Parameters.RestorePlayerInfos),
        RoundResults(GameRoundResults),
        Input(Control.Input),
        KeyboardInput(C4KeyboardInput_Init()),
        pSec1Timer(new C4GameSec1Timer()),
        GlobalSoundModifier(GameGlobalSoundModifier)
{
    Default();
}

~C4Game()

C4Game::~C4Game

(

)

Definition at line 114 of file C4Game.cpp.

{
    // make sure no startup gfx remain loaded
    C4Startup::Unload();
}

References C4Startup::Unload().

Here is the call graph for this function:

Member Function Documentation

Abort()

void C4Game::Abort

(

bool

fApproved = false

)

Definition at line 4541 of file C4Game.cpp.

{
    // league needs approval
    if (Network.isEnabled() && Parameters.isLeague() && !approval_given)
    {
        if (Control.isCtrlHost() && !Game.GameOver)
        {
            Network.Vote(VT_Cancel);
            return;
        }
        if (!Control.isCtrlHost() && !Game.GameOver && ::Players.GetLocalByIndex(0))
        {
            Network.Vote(VT_Kick, true, Control.ClientID());
            return;
        }
    }
    if (EvaluateOnAbort)
    {
        // Scenario forces evaluation. This is intended for scenarios that
        // always save progress in the players, such as Tower of Despair.
        Evaluate();
    }
    // hard-abort: eval league and quit
    // manually evaluate league
    Players.RemoveLocal(true, true);
    Players.RemoveAtRemoteClient(true, true);
    // normal quit
    Application.QuitGame();
}

References Application, C4GameControl::ClientID(), Control, Evaluate(), EvaluateOnAbort, Game, GameOver, C4PlayerList::GetLocalByIndex(), C4GameControl::isCtrlHost(), C4Network2::isEnabled(), C4GameParameters::isLeague(), Network, Parameters, Players, C4Application::QuitGame(), C4PlayerList::RemoveAtRemoteClient(), C4PlayerList::RemoveLocal(), C4Network2::Vote(), VT_Cancel, and VT_Kick.

Referenced by C4AbortGameDialog::OnClosed().

Here is the call graph for this function:

Here is the caller graph for this function:

ActivateMenu()

bool C4Game::ActivateMenu ( const char *  command )

protected

Definition at line 4518 of file C4Game.cpp.

{
    // no new menu during round evaluation
    if (C4GameOverDlg::IsShown())
    {
        return false;
    }
    // forward to primary player
    C4Player *player = ::Players.GetLocalByIndex(0);
    if (!player)
    {
        return false;
    }
    player->Menu.ActivateCommand(player->Number, command);
    return true;
}

References C4PlayerList::GetLocalByIndex(), C4GameOverDlg::IsShown(), C4ScriptGuiWindowPropertyName::player, and Players.

Here is the call graph for this function:

AllocateTranslatedString()

C4PropList * C4Game::AllocateTranslatedString

(

)

Definition at line 4878 of file C4Game.cpp.

{
    C4PropListScript *value_proplist = new C4PropListScript();
    value_proplist->SetProperty(P_Function, C4VString(&::Strings.P[P_Translate]));
    return value_proplist;
}

References C4VString(), C4StringTable::P, P_Function, P_Translate, C4PropList::SetProperty(), and Strings.

Here is the call graph for this function:

CanQuickSave()

bool C4Game::CanQuickSave

(

)

Definition at line 2374 of file C4Game.cpp.

{
    // Network hosts only
    if (Network.isEnabled() && !Network.isHost())
    {
        Log(LoadResStr("IDS_GAME_NOCLIENTSAVE"));
        return false;
    }
 
    return true;
}

References C4Network2::isEnabled(), C4Network2::isHost(), LoadResStr(), Log(), and Network.

Referenced by C4MainMenu::ActivateSavegame(), and QuickSave().

Here is the call graph for this function:

Here is the caller graph for this function:

CastObjects()

void C4Game::CastObjects	(	C4ID	id,
		C4Object *	creator,
		int32_t	num,
		int32_t	level,
		int32_t	x,
		int32_t	y,
		int32_t	owner = NO_OWNER,
		int32_t	controller = NO_OWNER,
		C4ValueArray *	out_objects = nullptr
	)

Definition at line 1763 of file C4Game.cpp.

{
    int32_t out_obj_size = 0;
    if (out_objects)
    {
        out_obj_size = out_objects->GetSize();
        out_objects->SetSize(out_obj_size + amount);
    }
    for (int32_t count = 0; count < amount; count++)
    {
        // Must do these calculation steps separately, because the order of
        // invokations of Random() is not defined if they're used as parameters
        int32_t angle = Random(360);
        C4Real xdir = C4REAL10(Random(2*level+1)-level);
        C4Real ydir = C4REAL10(Random(2*level+1)-level);
        C4Real rdir = itofix(Random(3)+1);
        C4Object *obj = CreateObject(id, creator, owner,
                     x, y,angle,
                     false,
                     xdir,
                     ydir,
                     rdir, controller);
        if (obj && obj->Status && out_objects)
        {
            (*out_objects)[out_obj_size + count] = C4VObj(obj);
        }
    }
}

References C4REAL10(), C4VObj(), CreateObject(), C4ValueArray::GetSize(), itofix(), Random(), C4ValueArray::SetSize(), and C4PropList::Status.

Referenced by C4Landscape::P::BlastMaterial2Objects().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckObjectEnumeration()

bool C4Game::CheckObjectEnumeration ( )

protected

Definition at line 4075 of file C4Game.cpp.

{
 
    struct Check
    {
        int32_t maxNumber{0};
        Check() = default;
        // Check valid & maximum number & duplicate numbers
        bool that(C4Object* obj)
        {
            // Invalid number
            if (obj->Number < 1)
            {
                LogFatal(FormatString("Invalid object enumeration number (%d) of object %s (x=%d)", obj->Number, obj->id.ToString(), obj->GetX()).getData());
                return false;
            }
            // Max
            if (obj->Number > maxNumber)
            {
                maxNumber = obj->Number;
            }
            // Duplicate
            for (C4Object *other : Objects)
            {
                if (other != obj)
                {
                    if (obj->Number == other->Number)
                    {
                        LogFatal(FormatString("Duplicate object enumeration number %d (%s and %s)", other->Number, obj->GetName(), other->GetName()).getData());
                        return false;
                    }
                }
            }
            for (C4Object *inactive : Objects.InactiveObjects)
            {
                if (inactive != obj)
                {
                    if (obj->Number == inactive->Number)
                    {
                        LogFatal(FormatString("Duplicate object enumeration number %d (%s and %s(i))", inactive->Number, obj->GetName(), inactive->GetName()).getData());
                        return false;
                    }
                }
            }
            return true;
        }
    };
 
    Check check;
    for (C4Object *obj : Objects)
    {
        if (!check.that(obj))
        {
            return false;
        }
    }
 
    for (C4Object *obj : Objects.InactiveObjects)
    {
        if (!check.that(obj))
        {
            return false;
        }
    }
 
    // Adjust enumeration index
    C4PropListNumbered::SetEnumerationIndex(check.maxNumber);
    // Done
    return true;
}

References FormatString(), StdStrBuf::getData(), C4PropList::GetName(), C4Object::GetX(), C4Object::id, C4GameObjects::InactiveObjects, LogFatal(), C4PropListNumbered::Number, Objects, C4PropListNumbered::SetEnumerationIndex(), and C4ID::ToString().

Here is the call graph for this function:

Clear()

void C4Game::Clear

(

)

Definition at line 672 of file C4Game.cpp.

{
    pFileMonitor.reset();
 
    // fade out music
    Application.MusicSystem.FadeOut(2000);
 
    // game no longer running
    IsRunning = false;
    PointersDenumerated = false;
 
    C4ST_SHOWSTAT
    // C4ST_RESET
 
    // Evaluation
    if (GameOver)
    {
        if (!Evaluated)
        {
            Evaluate();
        }
    }
 
    // stop statistics
    pNetworkStatistics.reset();
    C4AulProfiler::Abort();
 
    // next mission (shoud have been transferred to C4Application now if next mission was desired)
    NextMission.Clear();
    NextMissionText.Clear();
    NextMissionDesc.Clear();
 
    // Clear control
    Network.Clear();
    Control.Clear();
    MouseControl.Clear();
    KeyboardInput.Clear();
    PlayerControlUserAssignmentSets.Clear();
    PlayerControlDefaultAssignmentSets.Clear();
    PlayerControlDefs.Clear();
 
    // Clear game info
    Scoreboard.Clear();
    Players.Clear();
    Parameters.Clear();
    RoundResults.Clear();
    C4S.Clear();
    ScenarioParameterDefs.Clear();
    StartupScenarioParameters.Clear();
    Info.Clear();
    Title.Clear();
    Names.Clear();
    GameText.Clear();
    RecordDumpFile.Clear();
    RecordStream.Clear();
 
#ifdef WITH_QT_EDITOR
    // clear console pointers held into script engine
    ::Console.EditCursor.Clear();
    ::Console.ClearGamePointers();
#endif
    // notify editor
    Console.CloseGame();
 
    // Clear the particles before cleaning up the objects.
    Particles.Clear();
    // Clear the script GUI before cleaning up the objects.
    // This prevents unnecessary ClearPointers callbacks when deleting the objects.
    ScriptGuiRoot.reset();
 
    DeleteObjects(true);
 
    // exit gui
    pGUI->Clear();
 
    // Clear landscape
    Weather.Clear();
    Landscape.Clear();
    PXS.Clear();
    ::MaterialMap.Clear();
    TextureMap.Clear(); // texture map *MUST* be cleared after the materials, because of the patterns!
    PathFinder.Clear();
    TransferZones.Clear();
 
    ::Messages.Clear();
    MessageInput.Clear();
    SetGlobalSoundModifier(nullptr); // must be called before script engine clear
    Application.SoundSystem.Modifiers.Clear(); // free some prop list pointers
 
    // Clear script engine
    ::MapScript.Clear();
    ::Definitions.Clear();
    ::GameScript.Clear();
    C4PropListNumbered::ClearShelve(); // may be nonempty if there was a fatal error during section load
    ScriptEngine.Clear();
    pScenarioObjectsScript = nullptr;
 
    // delete any remaining prop lists from circular chains
    C4PropListNumbered::ClearNumberedPropLists(); 
    C4PropListScript::ClearScriptPropLists();
 
    // Clear translation tables
    MainSysLangStringTable.Clear();
    ScenarioLangStringTable.Clear();
 
    // Cleanup remaining open scenario files
    CloseScenario();
    GroupSet.Clear();
    ::Application.MusicSystem.ClearGame();
    Application.SoundSystem.Clear(); // will be re-inited by application pre-init if running from startup system
 
    // Clear remaining graphics
#ifndef USE_CONSOLE
    ::FontLoader.Clear();
#endif
    ::MeshMaterialManager.Clear();
    GraphicsSystem.Clear();
 
    // global fullscreen class is not cleared, because it holds the carrier window
    // but the menu must be cleared (maybe move Fullscreen.Menu somewhere else?)
    FullScreen.CloseMenu();
 
    // Message
    // avoid double message by not printing it if no restbl is loaded
    // this would log an "[Undefined]" only, anyway
    // (could abort the whole clear-procedure here, btw?)
    if (::Languages.HasStringTable())
    {
        Log(LoadResStr("IDS_CNS_GAMECLOSED"));
    }
 
    // clear game starting parameters
    *DefinitionFilenames = *DirectJoinAddress = *ScenarioFilename = *PlayerFilenames = 0;
 
    // join reference
    pJoinReference.reset();
 
    // okay, game cleared now. Remember log section
    QuitLogPos = GetLogPos();
 
    fPreinited = false;
    C4PropListNumbered::ResetEnumerationIndex();
 
    // FIXME: remove this
    Default();
}

References C4AulProfiler::Abort(), Application, C4S, C4ST_SHOWSTAT, C4ComponentHost::Clear(), C4GroupSet::Clear(), C4GameControl::Clear(), C4GameParameters::Clear(), C4PlayerControlDefs::Clear(), C4PlayerControlAssignmentSets::Clear(), C4RoundResults::Clear(), C4EditCursor::Clear(), C4GraphicsSystem::Clear(), C4FontLoader::Clear(), C4GameMessageList::Clear(), C4GUI::Screen::Clear(), C4KeyboardInput::Clear(), C4MessageInput::Clear(), C4MouseControl::Clear(), C4Scoreboard::Clear(), C4MapScriptHost::Clear(), C4MaterialMap::Clear(), C4ParticleSystem::Clear(), C4PathFinder::Clear(), C4PXSSystem::Clear(), C4Scenario::Clear(), C4TextureMap::Clear(), C4TransferZones::Clear(), C4Weather::Clear(), StdStrBuf::Clear(), StdMeshMatManager::Clear(), C4Network2::Clear(), C4DefList::Clear(), C4SoundModifierList::Clear(), C4SoundSystem::Clear(), C4PlayerList::Clear(), C4ScenarioParameterDefs::Clear(), C4ScenarioParameters::Clear(), C4AulScriptEngine::Clear(), C4GameScriptHost::Clear(), C4Landscape::Clear(), C4MusicSystem::ClearGame(), C4PropListNumbered::ClearNumberedPropLists(), C4PropListScript::ClearScriptPropLists(), C4PropListNumbered::ClearShelve(), C4Console::CloseGame(), C4FullScreen::CloseMenu(), CloseScenario(), Console, Control, Default(), DefinitionFilenames, Definitions, DeleteObjects(), DirectJoinAddress, C4Console::EditCursor, Evaluate(), Evaluated, C4MusicSystem::FadeOut(), FontLoader, fPreinited, FullScreen, GameOver, GameScript, GameText, GetLogPos(), GraphicsSystem, GroupSet, C4Language::HasStringTable(), Info, IsRunning, KeyboardInput, Landscape, Languages, LoadResStr(), Log(), MainSysLangStringTable, MapScript, MaterialMap, MeshMaterialManager, MessageInput, Messages, C4SoundSystem::Modifiers, MouseControl, C4Application::MusicSystem, Names, Network, NextMission, NextMissionDesc, NextMissionText, Parameters, Particles, PathFinder, pFileMonitor, pGUI, pJoinReference, PlayerControlDefaultAssignmentSets, PlayerControlDefs, PlayerControlUserAssignmentSets, PlayerFilenames, Players, pNetworkStatistics, PointersDenumerated, pScenarioObjectsScript, PXS, QuitLogPos, RecordDumpFile, RecordStream, C4PropListNumbered::ResetEnumerationIndex(), RoundResults, ScenarioFilename, ScenarioLangStringTable, ScenarioParameterDefs, Scoreboard, ScriptEngine, ScriptGuiRoot, SetGlobalSoundModifier(), C4Application::SoundSystem, StartupScenarioParameters, TextureMap, Title, TransferZones, and Weather.

Referenced by C4Application::Clear(), and C4Application::GameTick().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearObjectPtrs()

void C4Game::ClearObjectPtrs ( C4Object *  to_obj )

protected

Definition at line 1109 of file C4Game.cpp.

{
    // May not call Objects.ClearPointers() because that would
    // remove pObj from primary list and pObj is to be kept
    // until CheckObjectRemoval().
    for (C4Object *obj : Objects)
    {
        obj->ClearPointers(to_obj);
    }
    // check in inactive objects as well
    for (C4Object *obj : Objects.InactiveObjects)
    {
        obj->ClearPointers(to_obj);
    }
}

References C4Object::ClearPointers(), C4GameObjects::InactiveObjects, and Objects.

Referenced by ClearPointers().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearPointers()

void C4Game::ClearPointers

(

C4Object *

obj

)

Definition at line 1125 of file C4Game.cpp.

{
    ::AulExec.ClearPointers(obj);
    ::Objects.ForeObjects.ClearPointers(obj);
    ::Messages.ClearPointers(obj);
    ClearObjectPtrs(obj);
    Application.SoundSystem.ClearPointers(obj);
    ::Players.ClearPointers(obj);
    ::Viewports.ClearPointers(obj);
    ::MessageInput.ClearPointers(obj);
    ::Console.ClearPointers(obj);
    ::MouseControl.ClearPointers(obj);
    if (ScriptGuiRoot)
    {
        ScriptGuiRoot->ClearPointers(obj);
    }
    TransferZones.ClearPointers(obj);
    if (::ScriptEngine.pGlobalEffects)
    {
        ::ScriptEngine.pGlobalEffects->ClearPointers(obj);
    }
    if (::GameScript.pScenarioEffects)
    {
        ::GameScript.pScenarioEffects->ClearPointers(obj);
    }
    ::Landscape.ClearPointers(obj);
}

References Application, AulExec, ClearObjectPtrs(), C4AulExec::ClearPointers(), C4ViewportList::ClearPointers(), C4ObjectList::ClearPointers(), C4Console::ClearPointers(), C4GameMessageList::ClearPointers(), C4MessageInput::ClearPointers(), C4MouseControl::ClearPointers(), C4Landscape::ClearPointers(), C4TransferZones::ClearPointers(), C4SoundSystem::ClearPointers(), C4PlayerList::ClearPointers(), C4Effect::ClearPointers(), Console, C4GameObjects::ForeObjects, GameScript, Landscape, MessageInput, Messages, MouseControl, Objects, C4AulScriptEngine::pGlobalEffects, Players, C4GameScriptHost::pScenarioEffects, ScriptEngine, ScriptGuiRoot, C4Application::SoundSystem, TransferZones, and Viewports.

Referenced by C4Object::AssignRemoval(), C4ObjectList::DeleteObjects(), LoadScenarioSection(), C4GameObjects::ResortUnsorted(), and C4Object::StatusDeactivate().

Here is the call graph for this function:

Here is the caller graph for this function:

CloseScenario()

void C4Game::CloseScenario ( )

protected

Definition at line 310 of file C4Game.cpp.

{
    // close scenario
    ScenarioFile.Close();
    GroupSet.CloseFolders();
    pParentGroup = nullptr;
    // remove if temporary
    if (TempScenarioFile)
    {
        EraseItem(TempScenarioFile.getData());
        TempScenarioFile.Clear();
    }
    // clear scenario section
    // this removes any temp files, which may yet need to be used by any future features
    // so better don't do this too early (like, in C4Game::Clear)
    if (pScenarioSections)
    {
        delete pScenarioSections;
        pScenarioSections = pCurrentScenarioSection = nullptr;
    }
}

References StdStrBuf::Clear(), C4Group::Close(), C4GroupSet::CloseFolders(), EraseItem(), StdStrBuf::getData(), GroupSet, pCurrentScenarioSection, pParentGroup, pScenarioSections, ScenarioFile, and TempScenarioFile.

Referenced by Clear().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileFunc()

void C4Game::CompileFunc	(	StdCompiler *	compiler,
		CompileSettings	settings,
		C4ValueNumbers *	numbers
	)

Definition at line 2055 of file C4Game.cpp.

{
    if (settings.init_mode == IM_Normal && settings.fExact)
    {
        compiler->Name("Game");
        compiler->Value(mkNamingAdapt(Time,                  "Time",                  0));
        compiler->Value(mkNamingAdapt(FrameCounter,          "Frame",                 0));
        if (settings.fSync)
        {
            compiler->Value(mkNamingAdapt(Control.ControlTick,   "ControlTick",           0));
            compiler->Value(mkNamingAdapt(Control.SyncRate,      "SyncRate",              C4SyncCheckRate));
        }
        compiler->Value(mkNamingAdapt(iTick2,                "Tick2",                 0));
        compiler->Value(mkNamingAdapt(iTick3,                "Tick3",                 0));
        compiler->Value(mkNamingAdapt(iTick5,                "Tick5",                 0));
        compiler->Value(mkNamingAdapt(iTick10,               "Tick10",                0));
        compiler->Value(mkNamingAdapt(iTick35,               "Tick35",                0));
        compiler->Value(mkNamingAdapt(iTick255,              "Tick255",               0));
        compiler->Value(mkNamingAdapt(iTick1000,             "Tick1000",              0));
        compiler->Value(mkNamingAdapt(InitialPlayersJoined,  "InitialPlayersJoined", false));
        compiler->Value(mkNamingAdapt(StartupPlayerCount,    "StartupPlayerCount",    0));
        compiler->Value(mkNamingAdapt(StartupTeamCount,      "StartupTeamCount",      0));
        compiler->Value(mkNamingAdapt(C4PropListNumbered::EnumerationIndex,"ObjectEnumerationIndex",0));
        compiler->Value(mkNamingAdapt(mkStringAdaptMA(CurrentScenarioSection),        "CurrentScenarioSection", ""));
        compiler->Value(mkNamingAdapt(fResortAnyObject,      "ResortAnyObj",          false));
        compiler->Value(mkNamingAdapt(mkParAdapt(GlobalSoundModifier, numbers),   "GlobalSoundModifier", C4Value()));
        compiler->Value(mkNamingAdapt(NextMission,           "NextMission",           StdCopyStrBuf()));
        compiler->Value(mkNamingAdapt(NextMissionText,       "NextMissionText",       StdCopyStrBuf()));
        compiler->Value(mkNamingAdapt(NextMissionDesc,       "NextMissionDesc",       StdCopyStrBuf()));
        compiler->NameEnd();
 
        // Music settings
        compiler->Value(mkNamingAdapt(::Application.MusicSystem, "Music"));
 
        // scoreboard compiles into main level [Scoreboard]
        compiler->Value(mkNamingAdapt(Scoreboard, "Scoreboard"));
        // Keyboard status of global keys synchronized for exact (runtime join) only; not for savegames,
        // as keys might be released between a savegame save and its resume
    }
 
    if (settings.fExact)
    {
        compiler->Value(mkNamingAdapt(Weather, "Weather"));
        compiler->Value(mkNamingAdapt(Landscape, "Landscape"));
        compiler->Value(mkNamingAdapt(Landscape.GetSky(), "Sky"));
 
        // save custom GUIs only if a real savegame and not for editor-scenario-saves or section changes
        if (settings.init_mode == IM_Normal)
        {
            compiler->Name("GUI");
            if (compiler->isDeserializer())
            {
                C4Value val;
                compiler->Value(mkNamingAdapt(mkParAdapt(val, numbers), "ScriptGUIs", C4VNull));
                // if loading, assume
                assert(ScriptGuiRoot->GetID() == 0); // ID of 0 means "had no subwindows ever" aka "is fresh" for root
                // we will need to denumerate and create the actual GUI post-loading
                // for now, just remember our enumerated ID
                if (val.GetType() == C4V_Enum)
                {
                    int enumID = val._getInt();
                    ScriptGuiRoot->SetEnumeratedID(enumID);
                }
            }
            else
            {
                C4Value *val = new C4Value(ScriptGuiRoot->ToC4Value());
                compiler->Value(mkNamingAdapt(mkParAdapt(*val, numbers), "ScriptGUIs", C4VNull));
            }
            compiler->NameEnd();
        }
    }
 
    if (settings.fPlayers)
    {
        assert(compiler->isSerializer());
        // player parsing: Parse all players
        // This doesn't create any players, but just parses existing by their ID
        // Primary player ininitialization (also setting ID) is done by player info list
        // Won't work this way for binary mode!
        for (C4Player *pPlr = Players.First; pPlr; pPlr = pPlr->Next)
        {
            compiler->Value(mkNamingAdapt(mkParAdapt(*pPlr, numbers), FormatString("Player%d", pPlr->ID).getData()));
        }
    }
 
    // Section load: Clear existing prop list numbering to make room for the new objects
    // Numbers will be re-acquired in C4GameObjects::PostLoad
    if (settings.init_mode == IM_Section)
    {
        C4PropListNumbered::ShelveNumberedPropLists();
    }
 
    compiler->Value(mkParAdapt(Objects, !settings.fExact, numbers));
 
    compiler->Value(mkNamingAdapt(mkParAdapt(ScriptEngine, settings.init_mode == IM_Section, numbers), "Script"));
}

References C4Value::_getInt(), Application, C4SyncCheckRate, C4V_Enum, C4VNull, Control, C4GameControl::ControlTick, CurrentScenarioSection, C4PropListNumbered::EnumerationIndex, C4PlayerList::First, FormatString(), FrameCounter, fResortAnyObject, StdStrBuf::getData(), C4Landscape::GetSky(), C4Value::GetType(), GlobalSoundModifier, IM_Normal, IM_Section, InitialPlayersJoined, StdCompiler::isDeserializer(), StdCompiler::isSerializer(), iTick10, iTick1000, iTick2, iTick255, iTick3, iTick35, iTick5, Landscape, mkNamingAdapt(), mkParAdapt(), mkStringAdaptMA(), C4Application::MusicSystem, StdCompiler::Name(), StdCompiler::NameEnd(), C4Player::Next, NextMission, NextMissionDesc, NextMissionText, Objects, Players, Scoreboard, ScriptEngine, ScriptGuiRoot, C4PropListNumbered::ShelveNumberedPropLists(), StartupPlayerCount, StartupTeamCount, C4GameControl::SyncRate, Time, StdCompiler::Value(), and Weather.

Here is the call graph for this function:

CompileRuntimeData()

bool C4Game::CompileRuntimeData ( C4Group &  group, InitMode  init_mode, bool  exact, bool  sync, C4ValueNumbers *  numbers  )

protected

Definition at line 2153 of file C4Game.cpp.

{
    ::Objects.Clear(init_mode != IM_Section);
    GameText.Load(group, C4CFN_Game);
    CompileSettings Settings(init_mode, false, exact, sync);
    // C4Game is not defaulted on compilation.
    // Loading of runtime data overrides only certain values.
    // Doesn't compile players; those will be done later
    if (GameText.GetData())
    {
        if (!CompileFromBuf_LogWarn<StdCompilerINIRead>(
            mkParAdapt(*this, Settings, numbers),
            GameText.GetDataBuf(), C4CFN_Game))
        {
            return false;
        }
        // Objects
        int32_t object_count = Objects.ObjectCount();
        if (object_count)
        {
            LogF(LoadResStr("IDS_PRC_OBJECTSLOADED"), object_count);
        }
    }
    // Success
    return true;
}

References C4CFN_Game, C4GameObjects::Clear(), GameText, C4ComponentHost::GetData(), C4ComponentHost::GetDataBuf(), IM_Section, C4ComponentHost::Load(), LoadResStr(), LogF(), mkParAdapt(), C4ObjectList::ObjectCount(), and Objects.

Here is the call graph for this function:

CreateInfoObject()

C4Object * C4Game::CreateInfoObject	(	C4ObjectInfo *	info,
		int32_t	owner,
		int32_t	x = 50,
		int32_t	y = 50
	)

Definition at line 1351 of file C4Game.cpp.

{
    C4Def *def;
    // Valid check
    if (!info)
    {
        return nullptr;
    }
    // Get def
    if (!(def = C4Id2Def(info->id)))
    {
        return nullptr;
    }
    // Create object
    return NewObject( def, nullptr,
                      owner, info,
                      x, y, 0,
                      Fix0, Fix0, Fix0,
                      FullCon, NO_OWNER, false);
}

References C4Id2Def(), Fix0, FullCon, C4ObjectInfoCore::id, NewObject(), and NO_OWNER.

Referenced by C4Player::PlaceReadyCrew().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateObject() [1/2]

C4Object * C4Game::CreateObject	(	C4ID	type,
		C4Object *	creator,
		int32_t	owner = NO_OWNER,
		int32_t	x = 50,
		int32_t	y = 50,
		int32_t	r = 0,
		bool	grow_from_center = false,
		C4Real	xdir = Fix0,
		C4Real	ydir = Fix0,
		C4Real	rdir = Fix0,
		int32_t	controller = NO_OWNER
	)

Definition at line 1315 of file C4Game.cpp.

{
 
    // Get pDef
    C4Def *def;
    if (!(def = C4Id2Def(id)))
    {
        return nullptr;
    }
    // Create object
    return NewObject(def, creator,
                     owner, nullptr,
                     x, y, r,
                     xdir, ydir, rdir,
                     FullCon, controller, grow_from_center);
}

References C4Id2Def(), FullCon, and NewObject().

Here is the call graph for this function:

CreateObject() [2/2]

C4Object * C4Game::CreateObject	(	C4PropList *	type,
		C4Object *	creator,
		int32_t	owner = NO_OWNER,
		int32_t	x = 50,
		int32_t	y = 50,
		int32_t	r = 0,
		bool	grow_from_center = false,
		C4Real	xdir = Fix0,
		C4Real	ydir = Fix0,
		C4Real	rdir = Fix0,
		int32_t	controller = NO_OWNER
	)

Definition at line 1334 of file C4Game.cpp.

{
    // check Definition
    if (!proplist || !proplist->GetDef())
    {
        return nullptr;
    }
    // Create object
    return NewObject(proplist, creator,
                     owner, nullptr,
                     x, y,r,
                     xdir, ydir, rdir,
                     FullCon, controller, grow_from_center);
}

References FullCon, C4PropList::GetDef(), and NewObject().

Referenced by CastObjects(), C4Object::CreateContents(), C4Landscape::P::DigMaterial2Objects(), InitEnvironment(), InitGoals(), InitRules(), C4EditCursor::PerformDuplicationLegacy(), PlaceAnimal(), PlaceInEarth(), C4Player::PlaceReadyMaterial(), and C4Player::PlaceReadyVehic().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateObjectConstruction()

C4Object * C4Game::CreateObjectConstruction	(	C4PropList *	type,
		C4Object *	creator,
		int32_t	owner,
		int32_t	center_x = 0,
		int32_t	bottom_y = 0,
		int32_t	con = 1,
		bool	adjust_terrain = false
	)

Definition at line 1373 of file C4Game.cpp.

{
    // Get def
    if (!proplist)
    {
        return nullptr;
    }
    C4Def *def;
    if (!(def = proplist->GetDef()))
    {
        return nullptr;
    }
 
    int32_t wdt = def->Shape.Wdt;
    int32_t hgt = def->Shape.Hgt;
    int32_t x = center_x - wdt/2;
    int32_t y = bottom_y - hgt;
 
    // Terrain
    if (adjust_terrain)
    {
        // Clear site background (ignored for ultra-large structures)
        if (wdt * hgt < 12000)
        {
            Landscape.DigFreeRect(x, y, wdt, hgt);
        }
        // Raise Terrain
        Landscape.RaiseTerrain(x, y + hgt, wdt);
    }
 
    // Create object
    C4Object *obj;
    if (!(obj = NewObject(proplist, creator,
                         owner, nullptr,
                         center_x, bottom_y, 0,
                         Fix0, Fix0, Fix0,
                         con, creator ? creator->Controller : NO_OWNER, false)))
    {
        return nullptr;
    }
 
    return obj;
}

References C4Object::Controller, C4Landscape::DigFreeRect(), Fix0, C4PropList::GetDef(), C4Rect::Hgt, Landscape, NewObject(), NO_OWNER, C4Landscape::RaiseTerrain(), C4Def::Shape, and C4Rect::Wdt.

Referenced by C4Player::PlaceReadyBase().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSectionFromTempFile()

bool C4Game::CreateSectionFromTempFile	(	const char *	section_name,
		const char *	temp_filename
	)

Definition at line 4244 of file C4Game.cpp.

{
    // Remove existing (temp) section of same name
    C4ScenarioSection *existing_section = pScenarioSections;
    C4ScenarioSection *prev = nullptr;
    while (existing_section)
    {
        if (SEqualNoCase(existing_section->name.getData(), section_name))
        {
            break;
        }
        else
        {
            existing_section = (prev = existing_section)->pNext;
        }
    }
    bool deleted_current_section = false;
    if (existing_section)
    {
        deleted_current_section = (existing_section == pCurrentScenarioSection);
        if (deleted_current_section)
        {
            pCurrentScenarioSection = nullptr;
            pScenarioObjectsScript = nullptr;
        }
        if (existing_section->pObjectScripts)
        {
            delete existing_section->pObjectScripts;
        }
        if (prev)
        {
            prev->pNext = existing_section->pNext;
        }
        else
        {
            pScenarioSections = existing_section->pNext;
        }
        existing_section->pNext = nullptr;
        delete existing_section;
    }
    // Create new (temp) section
    C4ScenarioSection *new_section = new C4ScenarioSection(section_name);
    if (!new_section->ScenarioLoad(temp_filename, true))
    {
        pScenarioSections = new_section->pNext;
        new_section->pNext = nullptr;
        delete new_section;
        return false;
    }
    // Re-Link current section into newly created section
    if (deleted_current_section)
    {
        pCurrentScenarioSection = new_section;
        pScenarioObjectsScript = new_section->pObjectScripts;
    }
    // Link new Objects.c (or re-link because old Objects.c was removed)
    ReLinkScriptEngine();
    return !!new_section;
}

References StdStrBuf::getData(), C4ScenarioSection::name, pCurrentScenarioSection, C4ScenarioSection::pNext, C4ScenarioSection::pObjectScripts, pScenarioObjectsScript, pScenarioSections, ReLinkScriptEngine(), C4ScenarioSection::ScenarioLoad(), and SEqualNoCase().

Here is the call graph for this function:

Default()

void C4Game::Default ( )

protected

Definition at line 1804 of file C4Game.cpp.

{
    PointersDenumerated = false;
    IsRunning = false;
    FrameCounter = 0;
    GameOver = GameOverDlgShown = InitialPlayersJoined = false;
    ScenarioFilename[0] = 0;
    PlayerFilenames[0] = 0;
    DefinitionFilenames[0] = 0;
    DirectJoinAddress[0] = 0;
    pJoinReference = nullptr;
    StartupPlayerCount = 0;
    StartupTeamCount = 0;
    ScenarioTitle.Ref("");
    HaltCount = 0;
    fReferenceDefinitionOverride = false;
    Evaluated = false;
    EvaluateOnAbort = false;
    TimeGo = false;
    Time = 0;
    StartTime = 0;
    InitProgress = 0; LastInitProgress = 0;
    FPS = cFPS = 0;
    fScriptCreatedObjects = false;
    fLobby = fObserve = false;
    iLobbyTimeout = 0;
    iTick2 = iTick3 = iTick5 = iTick10 = iTick35 = iTick255 = iTick1000 = 0;
    FullSpeed = false;
    FrameSkip = 1; DoSkipFrame = false;
    ::Definitions.Default();
    ::MaterialMap.Default();
    Objects.Default();
    Players.Default();
    Weather.Default();
    Landscape.Default();
    ::DefaultRanks.Default();
    MassMover.Default();
    PXS.Default();
    GraphicsSystem.Default();
    C4S.Default();
    ::Messages.Default();
    MessageInput.Default();
    MouseControl.Default();
    PathFinder.Default();
    TransferZones.Default();
    GroupSet.Default();
    pParentGroup = nullptr;
    pScenarioSections = pCurrentScenarioSection = nullptr;
    *CurrentScenarioSection = 0;
    fResortAnyObject = false;
    pNetworkStatistics.reset();
    ::Application.MusicSystem.ClearGame();
    DebugPort = 0;
    DebugPassword.Clear();
    DebugHost.Clear();
    DebugWait = false;
    assert(!ScriptGuiRoot);
    ScriptGuiRoot.reset();
}

References Application, C4S, cFPS, StdStrBuf::Clear(), C4MusicSystem::ClearGame(), CurrentScenarioSection, DebugHost, DebugPassword, DebugPort, DebugWait, C4GroupSet::Default(), C4GraphicsSystem::Default(), C4GameMessageList::Default(), C4MessageInput::Default(), C4MouseControl::Default(), C4Landscape::Default(), C4MassMoverSet::Default(), C4MaterialMap::Default(), C4PathFinder::Default(), C4PXSSystem::Default(), C4Scenario::Default(), C4TransferZones::Default(), C4Weather::Default(), C4DefList::Default(), C4PlayerList::Default(), C4RankSystem::Default(), C4GameObjects::Default(), DefaultRanks, DefinitionFilenames, Definitions, DirectJoinAddress, DoSkipFrame, Evaluated, EvaluateOnAbort, fLobby, fObserve, FPS, FrameCounter, FrameSkip, fReferenceDefinitionOverride, fResortAnyObject, fScriptCreatedObjects, FullSpeed, GameOver, GameOverDlgShown, GraphicsSystem, GroupSet, HaltCount, iLobbyTimeout, InitialPlayersJoined, InitProgress, IsRunning, iTick10, iTick1000, iTick2, iTick255, iTick3, iTick35, iTick5, Landscape, LastInitProgress, MassMover, MaterialMap, MessageInput, Messages, MouseControl, C4Application::MusicSystem, Objects, PathFinder, pCurrentScenarioSection, pJoinReference, PlayerFilenames, Players, pNetworkStatistics, PointersDenumerated, pParentGroup, pScenarioSections, PXS, StdStrBuf::Ref(), ScenarioFilename, ScenarioTitle, ScriptGuiRoot, StartTime, StartupPlayerCount, StartupTeamCount, Time, TimeGo, TransferZones, and Weather.

Referenced by Clear().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteObjects()

void C4Game::DeleteObjects ( bool  delete_inactive )

protected

Definition at line 1307 of file C4Game.cpp.

{
    // del any objects
    ::Objects.DeleteObjects(delete_inactive);
    // reset resort flag
    fResortAnyObject = false;
}

References C4GameObjects::DeleteObjects(), fResortAnyObject, and Objects.

Referenced by Clear(), and LoadScenarioSection().

Here is the call graph for this function:

Here is the caller graph for this function:

DoGameOver()

bool C4Game::DoGameOver

(

)

Definition at line 3806 of file C4Game.cpp.

{
    // Duplication safety
    if (GameOver)
    {
        return false;
    }
    // Flag, log, call
    GameOver = true;
    Log(LoadResStr("IDS_PRC_GAMEOVER"));
    GRBroadcast(PSF_OnGameOver);
    // Flag all surviving players as winners
    for (C4Player *pPlayer = Players.First; pPlayer; pPlayer = pPlayer->Next)
    {
        if (!pPlayer->Eliminated)
        {
            pPlayer->EvaluateLeague(false, true);
        }
    }
    // Immediately save config so mission access gained by this round is stored if the game crashes during shutdown
    // or in a following round
    Config.Save();
    return true;
}

References Config, C4PlayerList::First, GameOver, GRBroadcast(), LoadResStr(), Log(), C4Player::Next, Players, PSF_OnGameOver, and C4Config::Save().

Referenced by GameOverCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

DoKeyboardInput() [1/2]

bool C4Game::DoKeyboardInput	(	C4KeyCode	vk_code,
		C4KeyEventType	event_type,
		bool	alt,
		bool	ctrl,
		bool	shift,
		bool	repeated,
		class C4GUI::Dialog *	for_dialog = nullptr,
		bool	fPlrCtrlOnly = false,
		int32_t	strength = -1
	)

Definition at line 2288 of file C4Game.cpp.

{
    // compose key
    C4KeyCodeEx Key(vk_code, C4KeyShiftState(alt*KEYS_Alt + ctrl*KEYS_Control + shift*KEYS_Shift), repeated);
    return DoKeyboardInput(Key, event_type, for_dialog, fPlrCtrlOnly, strength);
}

References KEYS_Alt, KEYS_Control, and KEYS_Shift.

Referenced by ConsoleHandleWin32KeyboardMessage(), C4StartupMainDlg::KeyEnterDown(), and C4StartupMainDlg::KeyEnterUp().

Here is the caller graph for this function:

DoKeyboardInput() [2/2]

bool C4Game::DoKeyboardInput	(	C4KeyCodeEx	key,
		C4KeyEventType	event_type,
		class C4GUI::Dialog *	for_dialog = nullptr,
		bool	fPlrCtrlOnly = false,
		int32_t	strength = -1
	)

Definition at line 2296 of file C4Game.cpp.

{
    key.FixShiftKeys();
    // compose keyboard scope
    DWORD InScope = 0;
    if (fPlrCtrlOnly)
    {
        InScope = KEYSCOPE_Control;
    }
    else
    {
        if (IsRunning)
        {
            InScope = KEYSCOPE_Generic;
        }
        // if GUI has keyfocus, this overrides regular controls
        if (pGUI->HasKeyboardFocus() || for_dialog)
        {
            InScope |= KEYSCOPE_Gui;
            // control to console mode dialog: Make current keyboard target the active dlg,
            //  so it can process input
            if (for_dialog)
            {
                pGUI->ActivateDialog(for_dialog);
            }
            // any keystroke in GUI resets tooltip times
            pGUI->KeyAny();
        }
        else
        {
            if (!Application.isEditor)
            {
                if (FullScreen.MainMenu && FullScreen.MainMenu->IsActive()) // fullscreen menu
                {
                    InScope |= KEYSCOPE_FullSMenu;
                }
                else if (Game.C4S.Head.Replay && C4S.Head.Film) // film view only
                {
                    InScope |= KEYSCOPE_FilmView;
                }
                else if (::Viewports.GetViewport(NO_OWNER)) // NO_OWNER-viewport-controls
                {
                    InScope |= KEYSCOPE_FreeView;
                }
                else
                {
                    // regular player viewport controls
                    InScope |= KEYSCOPE_FullSView;
                    // player controls disabled during round over dlg
                    if (!C4GameOverDlg::IsShown())
                    {
                        InScope |= KEYSCOPE_Control;
                    }
                }
            }
            else
            {
                // regular player viewport controls
                InScope |= KEYSCOPE_Control;
            }
        }
        // fullscreen/console (in running game)
        if (IsRunning)
        {
            if (FullScreen.Active) InScope |= KEYSCOPE_Fullscreen;
            if (Console.Active)    InScope |= KEYSCOPE_Console;
        }
    }
    // okay; do input
    if (KeyboardInput.DoInput(key, event_type, InScope, strength))
    {
        return true;
    }
 
    // unprocessed key
    return false;
}

References C4GUI::Screen::ActivateDialog(), C4Window::Active, Application, C4S, Console, C4KeyboardInput::DoInput(), C4SHead::Film, C4KeyCodeEx::FixShiftKeys(), FullScreen, Game, C4ViewportList::GetViewport(), C4GUI::Screen::HasKeyboardFocus(), C4Scenario::Head, C4Menu::IsActive(), C4Application::isEditor, IsRunning, C4GameOverDlg::IsShown(), C4GUI::Screen::KeyAny(), KeyboardInput, KEYSCOPE_Console, KEYSCOPE_Control, KEYSCOPE_FilmView, KEYSCOPE_FreeView, KEYSCOPE_Fullscreen, KEYSCOPE_FullSMenu, KEYSCOPE_FullSView, KEYSCOPE_Generic, KEYSCOPE_Gui, C4FullScreen::MainMenu, NO_OWNER, pGUI, C4SHead::Replay, and Viewports.

Here is the call graph for this function:

DrawCrewOverheadText()

void C4Game::DrawCrewOverheadText	(	C4TargetFacet &	cgo,
		int32_t	player_nr
	)

Definition at line 1897 of file C4Game.cpp.

{
    // All drawing in this function must not be affected by zoom; but remember zoom and reset later.
    ZoomData r;
    pDraw->GetZoom(&r);
    const float zoom = r.Zoom;
    r.Zoom = 1.0;
    pDraw->SetZoom(r);
 
    // Offset for all text/objects
    const float fixedOffsetX = -cgo.X * cgo.Zoom + cgo.X;
    const float fixedOffsetY = (-cgo.Y - 10.0f) * cgo.Zoom + cgo.Y;
 
    // Draw cursor mark arrow & cursor object name
    C4Facet &fctCursor = GraphicsResource.fctMouseCursor;
    for (C4Player *player = Players.First; player; player = player->Next)
    {
        // Draw a small selector & name above the cursor? F.e. after switching crew.
        const bool drawCursorInfo = (player->Number == player_nr || player_nr == NO_OWNER) // only for the viewport's player..
                                 && (player->CursorFlash && player->Cursor); // ..and if the player wants to show their cursor.
        // Otherwise, for allied players we might want to draw player & crew names.
        // Note that these two conditions are generally mutually-exclusive.
        const bool drawPlayerAndCursorNames = (player->Number != player_nr) // Never for own player..
                                           && (Config.Graphics.ShowCrewNames || Config.Graphics.ShowCrewCNames) // ..and if the settings allow it..
                                           && !Hostile(player_nr, player->Number) && !player->IsInvisible(); // ..and of course only if applicable.
        
        if (!drawPlayerAndCursorNames && !drawCursorInfo)
        {
            continue;
        }
 
        // Lambda to calculate correct drawing position of object, (re-)adjusted by zoom.
        float drawX, drawY, drawZoom;
        auto calculateObjectTextPosition = [&](C4Object *obj)
        {
            obj->GetDrawPosition(cgo, fixtof(obj->fix_x), fixtof(obj->fix_y), 1.0, drawX, drawY, drawZoom);
            drawX = drawX * cgo.Zoom + fixedOffsetX;
            drawY = drawY * cgo.Zoom - static_cast<float>(obj->Def->Shape.Hgt) / 2.0 + fixedOffsetY;
        };
 
        // Actual text output!
        if (drawPlayerAndCursorNames)
        {
            // We need to show crew names for that player, we do so for every crew-member.
            for (C4Object * const & crew : player->Crew)
            {
                if (!crew->Status || !crew->Def) continue;
                if (crew->Contained) continue;
                if ((crew->OCF & OCF_CrewMember) == 0) continue;
                if (!crew->IsVisible(player_nr, false)) continue;
 
                calculateObjectTextPosition(crew);
                drawY -= 5.0f; // aesthetical offset
 
                // compose string
                char text[C4GM_MaxText + 1];
                if (Config.Graphics.ShowCrewNames)
                if (Config.Graphics.ShowCrewCNames)
                {
                    sprintf(text, "%s (%s)", crew->GetName(), player->GetName());
                }
                else
                {
                    SCopy(player->GetName(), text);
                }
                else
                {
                    SCopy(crew->GetName(), text);
                }
 
                // Word wrap to cgo width
                int32_t char_width, dummy;
                ::GraphicsResource.FontRegular.GetTextExtent("m", char_width, dummy, false);
                int32_t iMaxLine = std::max<int32_t>(cgo.Wdt / std::max<int32_t>(1, char_width), 20);
                SWordWrap(text, ' ', '|', iMaxLine);
 
                // Center text vertically, too
                int textWidth, textHeight;
                ::GraphicsResource.FontRegular.GetTextExtent(text, textWidth, textHeight, true);
 
                // Draw
                pDraw->TextOut(text, ::GraphicsResource.FontRegular, 1.0, cgo.Surface, drawX, drawY - static_cast<float>(textHeight) / 2.0, player->ColorDw | 0x7f000000, ACenter);
            }
        }
        else if (drawCursorInfo)
        {
            C4Object * const cursor = player->Cursor;
            calculateObjectTextPosition(cursor);
 
            // Draw a down-arrow above the Clonk's head
            drawY += -fctCursor.Hgt;
            fctCursor.Draw(cgo.Surface, drawX - static_cast<float>(fctCursor.Wdt) / 2.0, drawY, 4);
            // And possibly draw some info text, too
            if (cursor->Info)
            {
                int32_t texthgt = ::GraphicsResource.FontRegular.GetLineHeight();
                StdStrBuf str;
                if (cursor->Info->Rank > 0)
                {
                    str.Format("%s|%s", cursor->Info->sRankName.getData(), cursor->GetName());
                    texthgt += texthgt;
                }
                else
                {
                    str = cursor->GetName();
                }
 
                pDraw->TextOut(str.getData(), ::GraphicsResource.FontRegular, 1.0, cgo.Surface,
                    drawX,
                    drawY - static_cast<float>(texthgt) / 2.0,
                    0xffff0000, ACenter);
            }
        }
    }
 
    // Reset zoom
    r.Zoom = zoom;
    pDraw->SetZoom(r);
}

References ACenter, C4GM_MaxText, Config, C4Object::Contained, C4Object::Def, C4GraphicsResource::fctMouseCursor, C4PlayerList::First, fixtof(), C4GraphicsResource::FontRegular, StdStrBuf::Format(), StdStrBuf::getData(), CStdFont::GetLineHeight(), C4PropList::GetName(), CStdFont::GetTextExtent(), C4Draw::GetZoom(), C4Config::Graphics, GraphicsResource, Hostile(), C4Object::Info, C4Object::IsVisible(), NO_OWNER, C4Object::OCF, OCF_CrewMember, pDraw, C4ScriptGuiWindowPropertyName::player, Players, C4ObjectInfoCore::Rank, SCopy(), C4Draw::SetZoom(), C4ConfigGraphics::ShowCrewCNames, C4ConfigGraphics::ShowCrewNames, sprintf, C4ObjectInfoCore::sRankName, C4PropList::Status, C4Facet::Surface, SWordWrap(), C4ScriptGuiWindowPropertyName::text, C4Draw::TextOut(), C4Facet::Wdt, C4Facet::X, C4Facet::Y, ZoomData::Zoom, and C4TargetFacet::Zoom.

Referenced by C4Viewport::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawPropListSpecImage()

bool C4Game::DrawPropListSpecImage	(	C4Facet &	target,
		C4PropList *	spec
	)

Definition at line 4687 of file C4Game.cpp.

{
    // safety
    assert(spec);
    if (!spec)
    {
        return false;
    }
 
    // get source definition
    C4PropList *source_def_proplist = spec->GetPropertyPropList(P_Source);
    if (!source_def_proplist)
    {
        return false;
    }
    C4Def *source_def = source_def_proplist->GetDef();
    if (!source_def)
    {
        return false;
    }
 
    // get custom color
    uint32_t color = (uint32_t)spec->GetPropertyInt(P_Color);
 
    C4String *source_name = spec->GetPropertyStr(P_Name);
    if (!source_name)
    {
        // Base graphics
        source_def->Draw(target, false, color);
    }
    else
    {
        // Alternative named graphics
        C4DefGraphics *source_graphics = source_def->Graphics.Get(source_name->GetCStr());
        if (!source_graphics)
        {
            return false;
        }
        source_graphics->Draw(target, color, nullptr, 0, 0, nullptr);
    }
    return true;
}

References C4Def::Draw(), C4DefGraphics::Draw(), C4DefGraphics::Get(), C4String::GetCStr(), C4PropList::GetDef(), C4PropList::GetPropertyInt(), C4PropList::GetPropertyPropList(), C4PropList::GetPropertyStr(), C4Def::Graphics, P_Color, P_Name, and P_Source.

Referenced by C4GameMessage::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawTextSpecImage()

bool C4Game::DrawTextSpecImage	(	C4Facet &	target,
		const char *	spec,
		class C4DrawTransform *	transform,
		uint32_t	color = 0xff
	)

Definition at line 4621 of file C4Game.cpp.

{
    // safety
    assert(spec && *spec);
    if (!spec)
    {
        return false;
    }
 
    C4Facet source;
    if (GetTextSpecFacet(spec, source))
    {
        source.DrawXT(target.Surface, target.X, target.Y, target.Wdt, target.Hgt, 0, 0, transform);
        return true;
    }
    else
    {
        C4Def *def = C4Id2Def(C4ID(spec));
        if (!def)
        {
            return false;
        }
 
        def->Draw(target, false, color, nullptr, 0, 0, transform);
        return true;
    }
}

References C4Id2Def(), C4Def::Draw(), C4Facet::DrawXT(), GetTextSpecFacet(), C4Facet::Hgt, C4Facet::Surface, C4Facet::Wdt, C4Facet::X, and C4Facet::Y.

Referenced by C4MainMenu::DoRefillInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

DropDef()

bool C4Game::DropDef	(	C4ID	id,
		float	x,
		float	y
	)

Definition at line 1746 of file C4Game.cpp.

{
    // Get def
    C4Def *def;
    if ((def = C4Id2Def(id)))
    {
        ::Control.DoInput(CID_EMMoveObj, C4ControlEMMoveObject::CreateObject(id, ftofix(x), ftofix(y), nullptr), CDT_Decide);
        return true;
    }
    else
    {
        // Failure
        Console.Out(FormatString(LoadResStr("IDS_CNS_DROPNODEF"),id.ToString()).getData());
    }
    return false;
}

References C4Id2Def(), CDT_Decide, CID_EMMoveObj, Console, Control, C4ControlEMMoveObject::CreateObject(), C4GameControl::DoInput(), FormatString(), ftofix(), LoadResStr(), and C4ConsoleGUI::Out().

Referenced by DropFile().

Here is the call graph for this function:

Here is the caller graph for this function:

DropFile()

bool C4Game::DropFile	(	const char *	filename,
		float	x,
		float	y
	)

Definition at line 1722 of file C4Game.cpp.

{
    C4ID id;
    C4Def *def;
    // Drop def to create object
    if (SEqualNoCase(GetExtension(filename), "ocd"))
    {
        // Get id from file
        if ((id = DefFileGetID(filename)))
        {
            // Get loaded def or try to load def from file
            if ((def = C4Id2Def(id))
             || (::Definitions.Load(filename, C4D_Load_RX, Config.General.LanguageEx,&Application.SoundSystem) && (def = C4Id2Def(id))) )
            {
                return DropDef(id, x, y);
            }
        }
        // Failure
        Console.Out(FormatString(LoadResStr("IDS_CNS_DROPNODEF"),GetFilename(filename)).getData());
        return false;
    }
    return false;
}

References Application, C4D_Load_RX, C4Id2Def(), Config, Console, DefFileGetID(), Definitions, DropDef(), FormatString(), C4Config::General, GetExtension(), GetFilename(), C4ConfigGeneral::LanguageEx, C4DefList::Load(), LoadResStr(), C4ConsoleGUI::Out(), SEqualNoCase(), and C4Application::SoundSystem.

Referenced by C4Viewport::DropFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Evaluate()

void C4Game::Evaluate

(

)

Definition at line 1864 of file C4Game.cpp.

{
 
    // League game?
    bool is_league = Network.isEnabled() && Network.isHost() && Parameters.isLeague();
 
    // Stop record
    StdStrBuf RecordName;
    BYTE RecordSHA[SHA_DIGEST_LENGTH];
    if (Control.isRecord())
    {
        Control.StopRecord(&RecordName, is_league ? RecordSHA : nullptr);
    }
 
    // Send league result
    if (is_league)
    {
        Network.LeagueGameEvaluate(RecordName.getData(), RecordSHA);
    }
 
    // Players
    // saving local players only, because remote players will probably not rejoin after evaluation anyway)
    Players.Evaluate();
    Players.Save(true);
 
    // Round results
    RoundResults.EvaluateGame();
 
    // Set game flag
    Log(LoadResStr("IDS_PRC_EVALUATED"));
    Evaluated = true;
}

References Control, C4PlayerList::Evaluate(), Evaluated, C4RoundResults::EvaluateGame(), StdStrBuf::getData(), C4Network2::isEnabled(), C4Network2::isHost(), C4GameParameters::isLeague(), C4GameControl::isRecord(), C4Network2::LeagueGameEvaluate(), LoadResStr(), Log(), Network, Parameters, Players, RoundResults, C4PlayerList::Save(), SHA_DIGEST_LENGTH, and C4GameControl::StopRecord().

Referenced by Abort(), Clear(), and Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

ExecObjects()

void C4Game::ExecObjects ( )

protected

Definition at line 1648 of file C4Game.cpp.

{
    if (Config.General.DebugRec)
    {
        AddDbgRec(RCT_Block, "ObjEx", 6);
    }
 
    // Execute objects - reverse order to ensure
    for (C4Object *obj : Objects.reverse())
    {
        if (obj)
        {
            if (obj->Status)
            {
                // Execute object
                obj->Execute();
            }
            // Status reset: process removal delay
            else if (obj->RemovalDelay > 0)
            {
                obj->RemovalDelay--;
            }
        }
    }
 
    if (Config.General.DebugRec)
    {
        AddDbgRec(RCT_Block, "ObjCC", 6);
    }
 
    // Cross check objects
    Objects.CrossCheck();
 
    if (Config.General.DebugRec)
    {
        AddDbgRec(RCT_Block, "ObjRs", 6);
    }
 
    // Resort
    if (fResortAnyObject)
    {
        fResortAnyObject = false;
        Objects.ResortUnsorted();
    }
 
    if (Config.General.DebugRec)
    {
        AddDbgRec(RCT_Block, "ObjRm", 6);
    }
 
    // Removal
    if (!::Game.iTick255)
    {
        ObjectRemovalCheck();
    }
}

References AddDbgRec(), Config, C4GameObjects::CrossCheck(), C4ConfigGeneral::DebugRec, fResortAnyObject, Game, C4Config::General, iTick255, ObjectRemovalCheck(), Objects, RCT_Block, C4GameObjects::ResortUnsorted(), and C4ObjectList::reverse().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

bool C4Game::Execute

(

)

Definition at line 868 of file C4Game.cpp.

{
    // Let's go
    GameGo = true;
 
    // Network
    Network.Execute();
 
    // Prepare control
    bool control_prepared;
    EXEC_S(     control_prepared = Control.Prepare();     , ControlStat )
    if (!control_prepared)
    {
        return false; // not ready yet: wait
    }
 
    // Halt
    if (HaltCount)
    {
        return false;
    }
 
    if (Config.General.DebugRec)
    {
        Landscape.DoRelights();
    }
 
    // Execute the control
    Control.Execute();
    if (!IsRunning)
    {
        return false;
    }
 
    // Ticks
    EXEC_DR(    Ticks();                                                , "Ticks")
 
    if (Config.General.DebugRec)
    {
        // debugrec
        AddDbgRec(RCT_DbgFrame, &FrameCounter, sizeof(int32_t));
    }
 
    // allow the particle system to execute the next frame BEFORE the other game stuff is calculated since it will run in parallel to the main thread
    Particles.CalculateNextStep();
 
    // Game
 
    EXEC_S(     ExecObjects();                    , ExecObjectsStat )
    EXEC_S_DR(  C4Effect::Execute(&ScriptEngine.pGlobalEffects);
                C4Effect::Execute(&GameScript.pScenarioEffects);
                                                  , GEStats             , "GEEx\0");
    EXEC_S_DR(  PXS.Execute();                    , PXSStat             , "PXSEx")
    EXEC_S_DR(  MassMover.Execute();              , MassMoverStat       , "MMvEx")
    EXEC_S_DR(  Weather.Execute();                , WeatherStat         , "WtrEx")
    EXEC_S_DR(  Landscape.Execute();              , LandscapeStat       , "LdsEx")
    EXEC_S_DR(  Players.Execute();                , PlayersStat         , "PlrEx")
    EXEC_S_DR(  ::Messages.Execute();             , MessagesStat        , "MsgEx")
 
    EXEC_DR(    MouseControl.Execute();                                 , "Input")
 
    EXEC_DR(    GameOverCheck();                                        , "Misc\0")
 
    Control.DoSyncCheck();
 
    // Evaluation; Game over dlg
    if (GameOver)
    {
        if (!Evaluated)
        {
            Evaluate();
        }
        if (!GameOverDlgShown)
        {
            ShowGameOverDlg();
        }
    }
 
    // show stat each 1000 ticks
    if (!(FrameCounter % 1000))
    {
        C4ST_SHOWPARTSTAT(FrameCounter)
        C4ST_RESETPART
    }
 
    if (Config.General.DebugRec)
    {
        AddDbgRec(RCT_Block, "eGame", 6);
        Landscape.DoRelights();
    }
 
    return true;
}

References AddDbgRec(), C4ST_RESETPART, C4ST_SHOWPARTSTAT, C4ParticleSystem::CalculateNextStep(), Config, Control, C4ConfigGeneral::DebugRec, C4Landscape::DoRelights(), C4GameControl::DoSyncCheck(), Evaluate(), Evaluated, EXEC_DR, EXEC_S, EXEC_S_DR, ExecObjects(), C4GameControl::Execute(), C4GameMessageList::Execute(), C4MouseControl::Execute(), C4Landscape::Execute(), C4MassMoverSet::Execute(), C4PXSSystem::Execute(), C4Weather::Execute(), C4Network2::Execute(), C4PlayerList::Execute(), C4Effect::Execute(), FrameCounter, GameGo, GameOver, GameOverCheck(), GameOverDlgShown, GameScript, C4Config::General, HaltCount, IsRunning, Landscape, MassMover, Messages, MouseControl, Network, Particles, C4AulScriptEngine::pGlobalEffects, Players, C4GameControl::Prepare(), C4GameScriptHost::pScenarioEffects, PXS, RCT_Block, RCT_DbgFrame, ScriptEngine, ShowGameOverDlg(), Ticks(), and Weather.

Referenced by C4Application::GameTick().

Here is the call graph for this function:

Here is the caller graph for this function:

FindConstuctionSiteBlock()

C4Object * C4Game::FindConstuctionSiteBlock	(	int32_t	x,
		int32_t	y,
		int32_t	wdt,
		int32_t	hgt
	)

Definition at line 1423 of file C4Game.cpp.

{
    C4Rect search_area;
    search_area.x = x;
    search_area.y = y;
    search_area.Wdt = wdt;
    search_area.Hgt = hgt;
 
    C4LArea Area(&::Objects.Sectors, x, y, wdt, hgt);
    C4LSector *sector;
 
    for (C4ObjectList *objects = Area.FirstObjectShapes(&sector); sector; objects = Area.NextObjectShapes(objects, &sector))
    {
        for (C4Object *obj : *objects)
        {
            if (obj->Status && !obj->Contained)
            {
                if (obj->OCF & OCF_Exclusive)
                {
                    C4Rect blocking_area = obj->Shape;
                    blocking_area.x += obj->GetX();
                    blocking_area.y += obj->GetY();
                    if (search_area.Overlap(blocking_area))
                    {
                        return obj;
                    }
                }
            }
        }
    }
    return nullptr;
}

References C4LArea::FirstObjectShapes(), C4Rect::Hgt, C4LArea::NextObjectShapes(), Objects, OCF_Exclusive, C4Rect::Overlap(), C4GameObjects::Sectors, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by ConstructionCheck(), and FindConSiteSpot().

Here is the call graph for this function:

Here is the caller graph for this function:

FindObject()

C4Object * C4Game::FindObject	(	C4Def *	def,
		int32_t	x = 0,
		int32_t	y = 0,
		int32_t	wdt = 0,
		int32_t	hgt = 0,
		DWORD	ocf = OCF_All,
		C4Object *	find_next = nullptr
	)

Definition at line 1456 of file C4Game.cpp.

{
 
    C4Object *closest_obj = nullptr;
    int32_t closest_distance = 0;
    int32_t min_distance = -1;
    C4Object *find_next_copy = find_next;
 
    // check the easy case first: no instances at all?
    if (def && !def->Count)
    {
        return nullptr;
    }
 
    // Finding next closest: find closest but further away than last closest
    if (find_next && (wdt == -1) && (hgt == -1))
    {
        int32_t dx = find_next->GetX() - x;
        int32_t dy = find_next->GetY() - y;
        min_distance = dx * dx + dy * dy;
        find_next = nullptr;
    }
 
    // Scan all objects
    for (C4Object *obj : Objects)
    {
        // Not skipping to find next
        if (!find_next)
            // Status
            if (obj->Status)
                // ID
                if (!def || (obj->Def == def))
                    // OCF (match any specified)
                    if (obj->OCF & ocf)
                        // Area
                        {
                            // Point
                            if ((wdt == 0) && (hgt == 0))
                            {
                                if (Inside<int32_t>(x-(obj->GetX()+obj->Shape.x), 0, obj->Shape.Wdt-1))
                                    if (Inside<int32_t>(y-(obj->GetY()+obj->Shape.y), 0, obj->Shape.Hgt-1))
                                        return obj;
                                continue;
                            }
                            // Closest
                            if ((wdt == -1) && (hgt == -1))
                            {
                                int32_t dx = obj->GetX() - x;
                                int32_t dy = obj->GetY() - y;
                                int32_t distance = dx * dy + dy * dy;
                                // same distance?
                                if ((distance == min_distance) && !find_next_copy)
                                    return obj;
                                // nearer than/first closest?
                                if (!closest_obj || (distance < closest_distance))
                                    if (distance > min_distance)
                                    {
                                        closest_obj = obj;
                                        closest_distance = distance;
                                    }
                            }
                            // Range
                            else if (Inside<int32_t>(obj->GetX()-x, 0, wdt-1) && Inside<int32_t>(obj->GetY()-y, 0, hgt-1))
                                return obj;
                        }
 
        // Find next mark reached
        if (obj == find_next_copy)
        {
            find_next = find_next_copy = nullptr;
        }
    }
 
    return closest_obj;
 
}

References C4Def::Count, C4Object::GetX(), C4Object::GetY(), and Objects.

Referenced by C4Command::Acquire(), and C4EditCursor::Move().

Here is the call graph for this function:

Here is the caller graph for this function:

FindVisObject()

C4Object * C4Game::FindVisObject	(	float	x,
		float	y,
		int32_t	player_nr,
		const C4Facet &	viewport_game,
		const C4Facet &	viewport_gui,
		float	game_x,
		float	game_y,
		DWORD	category,
		float	gui_x,
		float	gui_y
	)

Definition at line 1536 of file C4Game.cpp.

{
    // FIXME: Use C4FindObject here for optimization
    // -- can't really do that, since sectors ignore parallaxity, etc.
    // determine layer to search in
    C4Object *layer_object = nullptr;
    C4Player *player = ::Players.Get(player_nr);
    if (player && player->Cursor)
    {
        layer_object = player->Cursor->Layer;
    }
    // scan all object lists separately
    C4ObjectList *obj_list = &::Objects.ForeObjects;
    while (obj_list)
    {
        // Scan all objects in list
        for (C4Object *obj : *obj_list)
        {
            // Status
            if (obj->Status == C4OS_NORMAL)
                // exclude fore-objects from main list
                if ((obj_list != &Objects) || (~obj->Category & C4D_Foreground))
                    // exclude MouseIgnore-objects
                    if (~obj->Category & C4D_MouseIgnore)
                        // Category (match any specified)
                        if (obj->Category & category)
                            // Container
                            if (!obj->Contained)
                                // Visibility
                                if (obj->IsVisible(player_nr, false))
                                    // Layer check: Layered objects are invisible to players whose cursor is in another layer
                                    // except for GUI: GUI always visible
                                {
                                    if (obj->Layer != layer_object)
                                        if (obj_list != &::Objects.ForeObjects)
                                            continue;
                                    // Area
                                    // get object position
                                    float obj_x, obj_y, check_x, check_y;
                                    if (obj_list == &::Objects.ForeObjects)
                                    {
                                        // object position for HUD object
                                        check_x = gui_x; check_y = gui_y;
                                        obj->GetViewPos(obj_x, obj_y, -viewport_gui.X, -viewport_gui.Y, viewport_gui);
                                    }
                                    else
                                    {
                                        // object position for game object
                                        check_x = game_x; check_y = game_y;
                                        obj->GetViewPos(obj_x, obj_y, x, y, viewport_game);
                                    }
                                    // Point search
                                    if (Inside<float>(check_x-(obj_x+obj->Shape.x),0, float(obj->Shape.Wdt)-1))
                                        if (Inside<float>(check_y-(obj_y+obj->Shape.y-obj->addtop()),0, float(obj->Shape.Hgt+obj->addtop()-1)))
                                            return obj;
                                }
        }
        // next list
        if (obj_list == &::Objects.ForeObjects)
        {
            obj_list = &Objects;
        }
        else
        {
            obj_list = nullptr;
        }
    }
 
    // none found
    return nullptr;
}

References C4D_Foreground, C4D_MouseIgnore, C4OS_NORMAL, C4GameObjects::ForeObjects, C4PlayerList::Get(), Objects, C4ScriptGuiWindowPropertyName::player, Players, C4Facet::X, and C4Facet::Y.

Referenced by C4MouseControl::GetTargetObject().

Here is the call graph for this function:

Here is the caller graph for this function:

FixRandom()

void C4Game::FixRandom

(

uint64_t

seed

)

Definition at line 3801 of file C4Game.cpp.

{
    FixedRandom(seed);
}

References FixedRandom().

Referenced by C4Landscape::Init(), InitControl(), LoadScenarioSection(), PreInit(), and Synchronize().

Here is the call graph for this function:

Here is the caller graph for this function:

GameOverCheck()

bool C4Game::GameOverCheck ( )

protected

Definition at line 819 of file C4Game.cpp.

{
    // Only every 35 ticks
    if (::Game.iTick35)
    {
        return false;
    }
 
    // do not GameOver in replay
    if (Control.isReplay())
    {
        return false;
    }
 
    // All players eliminated: game over
    bool all_players_eliminated = false;
    if (!Players.GetCountNotEliminated())
    {
        all_players_eliminated = true;
    }
 
    // Message
    if (all_players_eliminated)
    {
        DoGameOver();
    }
 
    return GameOver;
}

References Control, DoGameOver(), Game, GameOver, C4PlayerList::GetCountNotEliminated(), C4GameControl::isReplay(), iTick35, and Players.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTextSpecImageAspect()

float C4Game::GetTextSpecImageAspect

(

const char *

spec

)

Definition at line 4649 of file C4Game.cpp.

{
    // safety
    assert(spec && *spec);
    if (!spec)
    {
        return -1.0f;
    }
 
    C4Facet source;
    if (GetTextSpecFacet(spec, source))
    {
        return static_cast<float>(source.Wdt) / static_cast<float>(source.Hgt);
    }
    else
    {
        C4Def *def = C4Id2Def(C4ID(spec));
        if (!def)
        {
            return -1.0f;
        }
 
        C4DefGraphics* gfx = &def->Graphics;
        if (gfx->Type == C4DefGraphics::TYPE_Bitmap)
        {
            return static_cast<float>(def->PictureRect.Wdt) / static_cast<float>(def->PictureRect.Hgt);
        }
        else if (gfx->Type == C4DefGraphics::TYPE_Mesh)
        {
            const StdMesh& mesh = *gfx->Mesh;
            const StdMeshBox& box = mesh.GetBoundingBox();
            return (box.x2 - box.x1) / (box.y2 - box.y1);
        }
 
        return -1.0f;
    }
}

References C4Id2Def(), StdMesh::GetBoundingBox(), GetTextSpecFacet(), C4Def::Graphics, C4Facet::Hgt, C4Rect::Hgt, C4Def::PictureRect, C4DefGraphics::Type, C4DefGraphics::TYPE_Bitmap, C4DefGraphics::TYPE_Mesh, C4Facet::Wdt, C4Rect::Wdt, StdMeshBox::x1, StdMeshBox::x2, StdMeshBox::y1, and StdMeshBox::y2.

Here is the call graph for this function:

GetTranslatedString()

C4String * C4Game::GetTranslatedString	(	const class C4Value &	input_string,
		C4Value *	selected_language,
		bool	fail_silently
	)		const

Definition at line 4805 of file C4Game.cpp.

{
    // Resolve a localized string
    // If a string is passed, just return it
    // If a proplist like { DE="Hallo, Welt!", US="Hello, world!" } is passed, return the string matching the selected language
    // Nothing?
    if (input_string.GetType() == C4V_Nil)
    {
        return nullptr;
    }
    // Non-localized string?
    if (input_string.GetType() == C4V_String)
    {
        return input_string._getStr();
    }
    // Invalid type for this function?
    C4PropList *proplist = input_string._getPropList();
    if (!proplist || proplist->GetPropertyStr(P_Function) != &::Strings.P[P_Translate])
    {
        if (fail_silently)
        {
            return nullptr;
        }
        else
        {
            throw C4AulExecError(FormatString("Invalid value for translation: %s", input_string.GetDataString().getData()).getData());
        }
    }
    // This is a proplist. Resolve the language as the key.
    char lang_code[3] = "";
    for (int32_t lang_index = 0; SCopySegment(Config.General.LanguageEx, lang_index, lang_code, ',', 2); ++lang_index)
    {
        C4String *lang_string = ::Strings.FindString(lang_code);
        if (lang_string) // If the string is not found, it cannot be the key in a prop list
        {
            C4Value localized_string_val;
            if (proplist->GetPropertyByS(lang_string, &localized_string_val))
            {
                C4String *localized_string = localized_string_val.getStr();
                if (localized_string)
                {
                    // Found it!
                    if (selected_language)
                    {
                        selected_language->SetString(lang_string);
                    }
                    return localized_string;
                }
            }
        }
    }
    // No language matched. Just use any property and assume it's a language key.
    for (C4String *lang_string : proplist->GetSortedLocalProperties(false))
    {
        C4Value localized_string_val;
        if (proplist->GetPropertyByS(lang_string, &localized_string_val))
        {
            C4String *localized_string = localized_string_val.getStr();
            if (localized_string)
            {
                // Found it!
                if (selected_language)
                {
                    selected_language->SetString(lang_string);
                }
                return localized_string;
            }
        }
    }
    // No string properties. There's no localized information to be found.
    return nullptr;
}

References C4Value::_getPropList(), C4Value::_getStr(), C4V_Nil, C4V_String, Config, C4StringTable::FindString(), FormatString(), C4Config::General, StdStrBuf::getData(), C4Value::GetDataString(), C4PropList::GetPropertyByS(), C4PropList::GetPropertyStr(), C4PropList::GetSortedLocalProperties(), C4Value::getStr(), C4Value::GetType(), C4ConfigGeneral::LanguageEx, C4StringTable::P, P_Function, P_Translate, SCopySegment(), C4Value::SetString(), and Strings.

Here is the call graph for this function:

GRBroadcast()

C4Value C4Game::GRBroadcast	(	const char *	function,
		C4AulParSet *	pars = nullptr,
		bool	pass_error = false,
		bool	reject_test = false
	)

Definition at line 4756 of file C4Game.cpp.

{
    std::string func{ function };
    if (func[0] != '~')
    {
        func.insert(0, 1, '~');
    }
 
    // call objects first - scenario script might overwrite hostility, etc...
    C4Value result = ::Objects.GRBroadcast(func.c_str(), pars, pass_error, reject_test);
    // rejection tests abort on first nonzero result
    if (reject_test && !!result)
    {
        return result;
    }
    // scenario script call
    return ::GameScript.Call(func.c_str(), pars, pass_error);
}

References C4GameScriptHost::Call(), GameScript, C4GameObjects::GRBroadcast(), and Objects.

Referenced by C4Object::AssignDeath(), DoGameOver(), C4Player::Init(), LoadScenarioSection(), OnPlayerJoinFinished(), C4PlayerList::Remove(), C4Player::ScenarioInit(), and C4Player::SetWealth().

Here is the call graph for this function:

Here is the caller graph for this function:

HasScenario()

bool C4Game::HasScenario ( )

inline

Definition at line 163 of file C4Game.h.

{ return *DirectJoinAddress || *ScenarioFilename || RecordStream.getSize(); }

References DirectJoinAddress, StdStrBuf::getSize(), RecordStream, and ScenarioFilename.

Referenced by C4Application::ParseCommandLine(), and C4Application::PreInit().

Here is the call graph for this function:

Here is the caller graph for this function:

Init()

bool C4Game::Init

(

)

Definition at line 397 of file C4Game.cpp.

{
    C4ValueNumbers numbers;
    IsRunning = false;
 
    InitProgress = 0;
    LastInitProgress = 0;
    SetInitProgress(0);
 
    // reinit keyboard to reflect any config changes that might have been done
    // this is a good time to do it, because no GUI dialogs are opened
    if (!InitKeyboard())
    {
        LogFatal(LoadResStr("IDS_ERR_NOKEYBOARD"));
    }
 
    // start log pos (used by startup)
    StartupLogPos = GetLogPos();
    fQuitWithError = false;
    C4GameLobby::UserAbort = false;
 
    // Store a start time that identifies this game on this host
    StartTime = time(nullptr);
 
    // Get PlayerFilenames from Config, if ParseCommandLine did not fill some in
    // Must be done here, because InitGame calls PlayerInfos.InitLocal
    if (!*PlayerFilenames)
    {
        SCopy(Config.General.Participants, PlayerFilenames, std::min(sizeof(PlayerFilenames), sizeof(Config.General.Participants)) - 1);
    }
 
    // Join a game?
    if (pJoinReference || *DirectJoinAddress)
    {
 
        if (!GraphicsSystem.pLoaderScreen)
        {
            // init extra; needed for loader screen
            Log(LoadResStr("IDS_PRC_INITEXTRA"));
            if (!Extra.Init())
            {
                LogFatal(LoadResStr("IDS_PRC_ERREXTRA"));
                return false;
            }
 
            // init loader
            if (!Application.isEditor && !GraphicsSystem.InitLoaderScreen(C4S.Head.Loader.c_str()))
            {
                LogFatal(LoadResStr("IDS_PRC_ERRLOADER"));
                return false;
            }
        }
 
        SetInitProgress(5);
 
        // Initialize network
        if (pJoinReference)
        {
            // By reference
            bool success = InitNetworkFromReference(*pJoinReference);
            pJoinReference.reset();
            if (!success)
            {
                return false;
            }
        }
        else if (SEqual2(DirectJoinAddress, DirectJoinFilePrefix))
        {
            // By reference serialized to temp file
            if (!InitNetworkFromReferenceFile(DirectJoinAddress + strlen(DirectJoinFilePrefix)))
            {
                return false;
            }
        }
        else
        {
            // By address
            if (!InitNetworkFromAddress(DirectJoinAddress))
            {
                return false;
            }
        }
 
        // check wether console mode is allowed
        if (Application.isEditor && !Parameters.AllowDebug)
        {
            LogFatal(LoadResStr("IDS_TEXT_JOININCONSOLEMODENOTALLOW"));
            return false;
        }
 
        // do lobby (if desired)
        if (Network.isLobbyActive())
        {
            if (!Network.DoLobby())
            {
                return false;
            }
        }
 
        // get scenario
        char scenario_filename[_MAX_PATH_LEN];
        SetInitProgress(6);
        if (!Network.RetrieveScenario(scenario_filename))
        {
            return false;
        }
 
        // open new scenario
        SCopy(scenario_filename, ScenarioFilename, _MAX_PATH);
        if (!OpenScenario())
        {
            return false;
        }
        TempScenarioFile.Copy(ScenarioFilename);
 
        // get everything else
        if (!Parameters.GameRes.RetrieveFiles())
        {
            return false;
        }
 
        // Check network game data scenario type (safety)
        if (!C4S.Head.NetworkGame)
        {
            LogFatal(LoadResStr("IDS_NET_NONETGAME"));
            return false;
        }
 
        SetInitProgress(7);
 
    }
    // Local game or host?
    else
    {
        // Open scenario
        if (!OpenScenario())
        {
            LogFatal(LoadResStr("IDS_PRC_FAIL"));
            return false;
        }
 
        // init extra; needed for loader screen
        Log(LoadResStr("IDS_PRC_INITEXTRA"));
        if (!Extra.Init())
        {
            LogFatal(LoadResStr("IDS_PRC_ERREXTRA"));
            return false;
        }
 
        // init loader
        if (!Application.isEditor && !GraphicsSystem.InitLoaderScreen(C4S.Head.Loader.c_str()))
        {
            LogFatal(LoadResStr("IDS_PRC_ERRLOADER"));
            return false;
        }
 
        // Init network
        if (!InitNetworkHost())
        {
            return false;
        }
        SetInitProgress(7);
    }
 
    // now free all startup gfx to make room for game gfx
    C4Startup::Unload();
 
    // Init debugmode
    DebugMode = !!Application.isEditor;
    if (Config.General.AlwaysDebug)
    {
        DebugMode = true;
    }
    if (!Parameters.AllowDebug)
    {
        DebugMode = false;
    }
 
    // Init game
    if (!InitGame(ScenarioFile, IM_Normal, true, &numbers))
    {
        return false;
    }
 
    // Network final init
    if (Network.isEnabled())
    {
        if (!Network.FinalInit())
        {
            return false;
        }
    }
    // non-net may have to synchronize now to keep in sync with replays
    // also needs to synchronize to update transfer zones
    else
    {
        // - would kill DebugRec-sync for runtime debugrec starts
        C4DebugRecOff DBGRECOFF(!!C4S.Head.SaveGame);
        SyncClearance();
        Synchronize(false);
    }
 
    // Init players
    if (!InitPlayers(&numbers))
    {
        return false;
    }
    SetInitProgress(98);
 
    // Final init
    if (!InitGameFinal(IM_Normal))
    {
        return false;
    }
    SetInitProgress(99);
 
    // Sound modifier from savegames
    if (GlobalSoundModifier)
    {
        SetGlobalSoundModifier(GlobalSoundModifier._getPropList());
    }
 
    // Message board and upper board
    if (!Application.isEditor)
    {
        InitFullscreenComponents(true);
    }
 
    // Default fullscreen menu, in case any old surfaces are left (extra safety)
    FullScreen.CloseMenu();
 
    // start statistics (always for now. Make this a config?)
    pNetworkStatistics = std::make_unique<C4Network2Stats>();
 
    // clear loader screen
    if (GraphicsSystem.pLoaderScreen)
    {
        delete GraphicsSystem.pLoaderScreen;
        GraphicsSystem.pLoaderScreen = nullptr;
    }
 
    // game running now!
    IsRunning = true;
 
    // Start message
    Log(LoadResStr(C4S.Head.NetworkGame ? "IDS_PRC_JOIN" : C4S.Head.SaveGame ? "IDS_PRC_RESUME" : "IDS_PRC_START"));
 
    // set non-exclusive GUI
    pGUI->SetExclusive(false);
 
    // after GUI is made non-exclusive, recheck the scoreboard
    Scoreboard.DoDlgShow(0, false);
    SetInitProgress(100);
 
    // and redraw background
    GraphicsSystem.InvalidateBg();
 
    // Notify editor
    Console.InitGame();
 
    return true;
}

References C4Value::_getPropList(), _MAX_PATH, _MAX_PATH_LEN, C4GameParameters::AllowDebug, C4ConfigGeneral::AlwaysDebug, Application, C4S, C4FullScreen::CloseMenu(), Config, Console, StdStrBuf::Copy(), DebugMode, DirectJoinAddress, DirectJoinFilePrefix, C4Scoreboard::DoDlgShow(), C4Network2::DoLobby(), Extra, C4Network2::FinalInit(), fQuitWithError, FullScreen, C4GameParameters::GameRes, C4Config::General, GetLogPos(), GlobalSoundModifier, GraphicsSystem, C4Scenario::Head, IM_Normal, C4Extra::Init(), InitFullscreenComponents(), C4Console::InitGame(), InitGame(), InitGameFinal(), InitKeyboard(), C4GraphicsSystem::InitLoaderScreen(), InitNetworkFromAddress(), InitNetworkFromReference(), InitNetworkFromReferenceFile(), InitNetworkHost(), InitPlayers(), InitProgress, C4GraphicsSystem::InvalidateBg(), C4Application::isEditor, C4Network2::isEnabled(), C4Network2::isLobbyActive(), IsRunning, LastInitProgress, C4SHead::Loader, LoadResStr(), Log(), LogFatal(), Network, C4SHead::NetworkGame, OpenScenario(), Parameters, C4ConfigGeneral::Participants, pGUI, pJoinReference, PlayerFilenames, C4GraphicsSystem::pLoaderScreen, pNetworkStatistics, C4GameResList::RetrieveFiles(), C4Network2::RetrieveScenario(), C4SHead::SaveGame, ScenarioFile, ScenarioFilename, SCopy(), Scoreboard, SEqual2(), C4GUI::Screen::SetExclusive(), SetGlobalSoundModifier(), SetInitProgress(), StartTime, StartupLogPos, SyncClearance(), Synchronize(), TempScenarioFile, C4Startup::Unload(), and C4GameLobby::UserAbort.

Referenced by C4Application::GameTick().

Here is the call graph for this function:

Here is the caller graph for this function:

InitAnimals()

void C4Game::InitAnimals ( )

protected

Definition at line 3516 of file C4Game.cpp.

{
    int32_t cnt, cnt2;
    C4ID idAnimal; int32_t iCount;
    // Place animals
    for (cnt = 0; (idAnimal = C4S.Animals.FreeLife.GetID(cnt,&iCount)); cnt++)
    {
        for (cnt2 = 0; cnt2 < iCount; cnt2++)
        {
            PlaceAnimal(C4Id2Def(idAnimal));
        }
    }
    // Place nests
    for (cnt = 0; (idAnimal = C4S.Animals.EarthNest.GetID(cnt,&iCount)); cnt++)
    {
        for (cnt2 = 0; cnt2 < iCount; cnt2++)
        {
            PlaceInEarth(idAnimal);
        }
    }
}

References C4Scenario::Animals, C4Id2Def(), C4S, C4SAnimals::EarthNest, C4SAnimals::FreeLife, C4IDList::GetID(), PlaceAnimal(), and PlaceInEarth().

Here is the call graph for this function:

InitControl()

bool C4Game::InitControl ( )

protected

Definition at line 3183 of file C4Game.cpp.

{
    // update random seed
    if (C4S.Head.NetworkGame || C4S.Head.Replay)
    {
        RandomSeed = C4S.Head.RandomSeed;
    }
    // Randomize
    FixRandom(RandomSeed);
 
    // Replay?
    if (C4S.Head.Replay)
    {
        // no joins
        PlayerFilenames[0]=0;
        // start playback
        if (!Control.InitReplay(ScenarioFile))
        {
            return false;
        }
        // no record!
        Record = false;
    }
    else if (Network.isEnabled())
    {
        // initialize
        if (!Control.InitNetwork(Clients.getLocal()))
        {
            return false;
        }
        // league? always record
        if (Parameters.isLeague())
        {
            Record = true;
        }
    }
    // Otherwise: local game
    else
    {
        // init
        if (!Control.InitLocal(Clients.getLocal()))
        {
            return false;
        }
    }
 
    // record?
    if (Record)
    {
        if (!Control.StartRecord(true, Parameters.doStreaming()))
        {
            // Special: If this happens for a league host, the game must not start.
            if (Network.isEnabled() && Network.isHost() && Parameters.isLeague())
            {
                LogFatal(LoadResStr("IDS_ERR_NORECORD"));
                return false;
            }
            else
            {
                Log(LoadResStr("IDS_ERR_NORECORD"));
            }
        }
    }
 
    return true;
}

References C4S, Clients, Control, C4GameParameters::doStreaming(), FixRandom(), C4ClientList::getLocal(), C4Scenario::Head, C4GameControl::InitLocal(), C4GameControl::InitNetwork(), C4GameControl::InitReplay(), C4Network2::isEnabled(), C4Network2::isHost(), C4GameParameters::isLeague(), LoadResStr(), Log(), LogFatal(), Network, C4SHead::NetworkGame, Parameters, PlayerFilenames, RandomSeed, C4SHead::RandomSeed, Record, C4SHead::Replay, ScenarioFile, and C4GameControl::StartRecord().

Here is the call graph for this function:

InitDefs()

bool C4Game::InitDefs ( )

protected

Definition at line 120 of file C4Game.cpp.

{
    int32_t def_count = 0;
    Log(LoadResStr("IDS_PRC_INITDEFS"));
    int def_res_count = 0;
    C4GameRes *def;
    for (def = Parameters.GameRes.iterRes(nullptr, NRT_Definitions); def; def = Parameters.GameRes.iterRes(def, NRT_Definitions))
    {
        ++def_res_count;
    }
    int i = 0;
    // Load specified defs
    for (def = Parameters.GameRes.iterRes(nullptr, NRT_Definitions); def; def = Parameters.GameRes.iterRes(def, NRT_Definitions))
    {
        int min_progress = 25 + (25 * i) / def_res_count;
        int max_progress = 25 + (25 * (i + 1)) / def_res_count;
        ++i;
        def_count += ::Definitions.Load(def->getFile(),C4D_Load_RX, Config.General.LanguageEx,&Application.SoundSystem, true, min_progress, max_progress);
 
        // Def load failure
        if (::Definitions.LoadFailure)
        {
            return false;
        }
    }
 
    // Load for scenario file - ignore sys group here, because it has been loaded already
    def_count += ::Definitions.Load(ScenarioFile, C4D_Load_RX, Config.General.LanguageEx,&Application.SoundSystem, true, true, 35, 40, false);
 
    // Absolutely no defs: we don't like that
    if (!def_count)
    {
        LogFatal(LoadResStr("IDS_PRC_NODEFS"));
        return false;
    }
 
    // Check def engine version (should be done immediately on def load)
    def_count = ::Definitions.CheckEngineVersion(C4XVER1, C4XVER2);
    if (def_count > 0)
    {
        LogF(LoadResStr("IDS_PRC_DEFSINVC4X"),def_count);
    }
 
    // Check for unmet requirements
    ::Definitions.CheckRequireDef();
 
    // build quick access table
    ::Definitions.BuildTable();
 
    // handle skeleton appends and includes
    ::Definitions.AppendAndIncludeSkeletons();
 
    // Done
    return true;
}

References C4DefList::AppendAndIncludeSkeletons(), Application, C4DefList::BuildTable(), C4D_Load_RX, C4DefList::CheckEngineVersion(), C4DefList::CheckRequireDef(), Config, Definitions, C4GameParameters::GameRes, C4Config::General, C4GameRes::getFile(), C4GameResList::iterRes(), C4ConfigGeneral::LanguageEx, C4DefList::Load(), C4DefList::LoadFailure, LoadResStr(), Log(), LogF(), LogFatal(), NRT_Definitions, Parameters, ScenarioFile, and C4Application::SoundSystem.

Here is the call graph for this function:

InitEnvironment()

void C4Game::InitEnvironment ( )

protected

Definition at line 4160 of file C4Game.cpp.

{
    // Place environment objects
    C4ID id;
    int32_t amount;
    for (int32_t index = 0; (id = C4S.Environment.Objects.GetID(index, &amount)); index++)
    {
        for (int32_t placed = 0; placed < amount; placed++)
        {
            CreateObject(id, nullptr);
        }
    }
}

References C4S, CreateObject(), C4Scenario::Environment, C4IDList::GetID(), and C4SEnvironment::Objects.

Here is the call graph for this function:

InitFullscreenComponents()

void C4Game::InitFullscreenComponents

(

bool

is_running

)

Definition at line 962 of file C4Game.cpp.

{
    // It can happen that this is called before graphics are loaded due to
    // an early OnResolutionChanged() call. Ignore it, the message board,
    // upper board and viewports will be initialized within the regular
    // startup sequence then.
    if (!GraphicsResource.IsInitialized())
    {
        return;
    }
 
    // fullscreen message board
    C4Facet cgo;
    cgo.Set(FullScreen.pSurface, 0, 0, C4GUI::GetScreenWdt(), C4GUI::GetScreenHgt());
    GraphicsSystem.MessageBoard->Init(cgo, !is_running);
    if (is_running)
    {
        // running game: Message board upper board and viewports
        C4Facet cgo2;
        cgo2.Set(FullScreen.pSurface, 0, 0, C4GUI::GetScreenWdt(), C4UpperBoardHeight);
        GraphicsSystem.UpperBoard.Init(cgo2);
        ::Viewports.RecalculateViewports();
    }
}

References C4UpperBoardHeight, FullScreen, C4GUI::GetScreenHgt(), C4GUI::GetScreenWdt(), GraphicsResource, GraphicsSystem, C4UpperBoard::Init(), C4GraphicsResource::IsInitialized(), C4GraphicsSystem::MessageBoard, C4Window::pSurface, C4ViewportList::RecalculateViewports(), C4Facet::Set(), C4GraphicsSystem::UpperBoard, and Viewports.

Referenced by Init(), and OnResolutionChanged().

Here is the call graph for this function:

Here is the caller graph for this function:

InitGame()

bool C4Game::InitGame ( C4Group &  group, InitMode  init_mode, bool  load_sky, C4ValueNumbers *  numbers  )

protected

Definition at line 2599 of file C4Game.cpp.

{
    // Activate debugger if requested
    // needs to happen before any scripts are compiled to bytecode so AB_DEBUG chunks will be inserted
    if (DebugPort)
    {
        if (Parameters.isLeague())
        {
            Log("Debugger disabled. Not allowed in league.");
        }
        else if (!::C4AulDebug::InitDebug(DebugPassword.getData(), DebugHost.getData()))
        {
            return false;
        }
    }
 
    if (init_mode == IM_Normal)
    {
 
        // file monitor
        if (Config.Developer.AutoFileReload && Application.isEditor && !pFileMonitor)
        {
            pFileMonitor = std::make_unique<C4FileMonitor>(FileMonitorCallback);
        }
 
        // system scripts
        if (!InitScriptEngine())
        {
            LogFatal(LoadResStr("IDS_PRC_FAIL"));
            return false;
        }
        SetInitProgress(8);
 
        // Scenario components
        if (!LoadScenarioComponents())
        {
            LogFatal(LoadResStr("IDS_PRC_FAIL"));
            return false;
        }
        SetInitProgress(9);
 
        // join local players for regular games
        // should be done before record/replay is initialized, so the players are stored in PlayerInfos.txt
        // for local savegame resumes, players are joined into PlayerInfos and later associated in InitPlayers
        if (!::Network.isEnabled())
        {
            if (!PlayerInfos.InitLocal())
            {
                LogFatal(LoadResStr("IDS_PRC_FAIL"));
                return false;
            }
        }
 
        // for replays, make sure teams are assigned correctly
        if (C4S.Head.Replay)
        {
            PlayerInfos.RecheckAutoGeneratedTeams(); // checks that all teams used in playerinfos exist
            Teams.RecheckPlayers();                  // syncs player list of teams with teams set in PlayerInfos
        }
 
        // set up control (inits Record/Replay)
        if (!InitControl())
        {
            return false;
        }
 
        // Graphics and fonts (may reinit main font, too)
        // redundant call in NETWORK2; but it may do scenario local overloads
        Log(LoadResStr("IDS_PRC_GFXRES"));
        if (!GraphicsResource.Init())
        {
            LogFatal(LoadResStr("IDS_PRC_FAIL"));
            return false;
        }
        SetInitProgress(25);
 
        // Definitions
        if (!InitDefs())
        {
            return false;
        }
        SetInitProgress(55);
 
        // Scenario scripts (and local system.ocg)
        ::GameScript.Load(ScenarioFile, C4CFN_Script, Config.General.LanguageEx, &ScenarioLangStringTable);
        // Map scripts
        ::MapScript.Load(ScenarioFile, C4CFN_MapScript, Config.General.LanguageEx, &ScenarioLangStringTable);
        // Scenario objects
        pScenarioObjectsScript->Load(ScenarioFile, C4CFN_ScenarioObjectsScript, Config.General.LanguageEx, &ScenarioLangStringTable);
        // After defs to get overloading priority
        if (!LoadAdditionalSystemGroup(ScenarioFile))
        {
            LogFatal(LoadResStr("IDS_PRC_FAIL"));
            return false;
        }
        SetInitProgress(57);
 
        // Final init for loaded player commands. Before linking scripts, so CON_* constants are registered
        PlayerControlDefs.FinalInit();
 
        // Register constants for scenario options
        ScenarioParameterDefs.RegisterScriptConstants(Parameters.ScenarioParameters);
 
        // Now that all controls and assignments are known, resolve user overloads on control assignments
        if (!InitPlayerControlUserSettings())
        {
            return false;
        }
        // Sort assignments by priority. Should be done last, because the user should not see this order in the control config dialog
        PlayerControlUserAssignmentSets.SortAssignments();
        // (Theoretically, PlayerControlDefaultAssignmentSets could be cleared now. However, the amount of memory used is negligible)
 
        // Link scripts
        if (!LinkScriptEngine())
        {
            return false;
        }
        SetInitProgress(58);
 
        // Materials
        if (!InitMaterialTexture())
        {
            LogFatal(LoadResStr("IDS_PRC_MATERROR"));
            return false;
        }
        SetInitProgress(60);
 
        // prepare script menus
        assert(!ScriptGuiRoot);
        ScriptGuiRoot = std::make_unique<C4ScriptGuiWindow>();
    }
    else if (load_sky)
    {
        // Sky needs graphics loaded, for shaders
        if (!GraphicsResource.Init())
        {
            LogFatal(LoadResStr("IDS_PRC_FAIL"));
            return false;
        }
    }
 
    // Load section sounds
    Application.SoundSystem.LoadEffects(group, nullptr, true);
 
    // determine startup player and team count, which may be used for initial map generation
    if (!FrameCounter)
    {
        StartupPlayerCount = PlayerInfos.GetStartupCount();
        StartupTeamCount = Teams.GetStartupTeamCount(StartupPlayerCount);
    }
 
    // The Landscape is the last long chunk of loading time, so it's a good place to start the music fadeout
    if (init_mode == IM_Normal)
    {
        Application.MusicSystem.FadeOut(2000);
    }
    // Landscape
    Log(LoadResStr("IDS_PRC_LANDSCAPE"));
    bool landscape_loaded = false;
    if (!Landscape.Init(group, init_mode != IM_Normal, load_sky, landscape_loaded, !!C4S.Head.SaveGame))
    {
        LogFatal(LoadResStr("IDS_ERR_GBACK"));
        return false;
    }
    SetInitProgress(88);
    // the savegame flag is set if runtime data is present, in which case this is to be used
    // except for scenario sections
    if (landscape_loaded && (!C4S.Head.SaveGame || init_mode == IM_Section))
    {
        Landscape.ScenarioInit();
    }
    // clear old landscape data
    if (init_mode != IM_Normal && landscape_loaded)
    {
        PXS.Clear();
        MassMover.Clear();
    }
    SetInitProgress(89);
    // Init main object list
    Objects.Init(Landscape.GetWidth(), Landscape.GetHeight());
 
    // Pathfinder
    if (init_mode == IM_Normal)
    {
        PathFinder.Init( &LandscapeFree, &TransferZones );
    }
    SetInitProgress(90);
 
    // PXS
    if (group.FindEntry(C4CFN_PXS))
    {
        if (!PXS.Load(group))
        {
            LogFatal(LoadResStr("IDS_ERR_PXS"));
            return false;
        }
    }
    SetInitProgress(91);
 
    // MassMover
    if (group.FindEntry(C4CFN_MassMover))
    {
        if (!MassMover.Load(group))
        {
            LogFatal(LoadResStr("IDS_ERR_MOVER"));
            return false;
        }
    }
    SetInitProgress(92);
 
    // definition value overloads
    // TODO: Remove this function? We could move value to script and allow it through regular overloads
    if (init_mode == IM_Normal)
    {
        InitValueOverloads();
    }
 
    // runtime data
    if (!CompileRuntimeData(group, init_mode, C4S.Head.SaveGame, C4S.Head.NetworkGame, numbers))
    {
        LogFatal(LoadResStr("IDS_PRC_FAIL"));
        return false;
    }
 
    SetInitProgress(93);
 
    // Load round results
    if (init_mode == IM_Normal)
    {
        if (group.FindEntry(C4CFN_RoundResults))
        {
            if (!RoundResults.Load(group, C4CFN_RoundResults))
            {
                LogFatal(LoadResStr("IDS_ERR_ERRORLOADINGROUNDRESULTS"));
                return false;
            }
        }
        else
        {
            RoundResults.Init();
        }
        // Per-scenario flag, ignored in sections.
        EvaluateOnAbort = C4S.Game.EvaluateOnAbort;
    }
 
    // Denumerate game data pointers
    if (init_mode == IM_Normal) ScriptEngine.Denumerate(numbers);
    if (init_mode == IM_Normal) GlobalSoundModifier.Denumerate(numbers);
 
    numbers->Denumerate();
    if (init_mode == IM_Normal)
    {
        ScriptGuiRoot->Denumerate(numbers);
    }
 
    // Object.PostLoad must happen after number->Denumerate(), becuase UpdateFace() will access Action proplist,
    // which might have a non-denumerated prototype otherwise
    Objects.PostLoad(init_mode == IM_Section, numbers);
 
    // Check object enumeration
    if (!CheckObjectEnumeration())
    {
        return false;
    }
 
    // Okay; everything in denumerated state from now on
    PointersDenumerated = true;
 
    // scenario objects script
    if (!GameText.GetData() && pScenarioObjectsScript && pScenarioObjectsScript->GetPropList())
    {
        pScenarioObjectsScript->GetPropList()->Call(PSF_InitializeObjects);
    }
 
    // Environment
    if (!C4S.Head.NoInitialize && landscape_loaded)
    {
        Log(LoadResStr("IDS_PRC_ENVIRONMENT"));
        InitVegetation();
        InitInEarth();
        InitAnimals();
        InitEnvironment();
        InitRules();
        InitGoals();
        Landscape.PostInitMap();
    }
    SetInitProgress(94);
 
    // Weather
    if (landscape_loaded)
    {
        Weather.Init(!C4S.Head.SaveGame);
    }
    SetInitProgress(96);
 
    // close any gfx groups, because they are no longer needed (after sky is initialized)
    GraphicsResource.CloseFiles();
 
    if (init_mode == IM_Normal) // reload doesn't affect the music (takes too long)
    {
        // Music
        ::Application.MusicSystem.InitForScenario(ScenarioFile);
        ::Application.MusicSystem.UpdateVolume();
        if (::Config.Sound.RXMusic)
        {
            // Play something that is not Frontend.mid
            ::Application.MusicSystem.Play();
        }
        else
        {
            ::Application.MusicSystem.Stop();
        }
        SetInitProgress(97);
    }
 
    return true;
}

References Application, C4ConfigDeveloper::AutoFileReload, Config, DebugHost, DebugPassword, DebugPort, C4Config::Developer, StdStrBuf::getData(), IM_Normal, C4AulDebug::InitDebug(), C4Application::isEditor, C4GameParameters::isLeague(), Log(), Parameters, and pFileMonitor.

Referenced by Init(), and LoadScenarioSection().

Here is the call graph for this function:

Here is the caller graph for this function:

InitGameFinal()

bool C4Game::InitGameFinal ( InitMode  init_mode )

protected

Definition at line 2917 of file C4Game.cpp.

{
    // Validate object owners & assign loaded info objects
    Objects.ValidateOwners();
    Objects.AssignInfo();
    Objects.AssignLightRange(); // update FoW-repellers
 
    // Ambience init (before scenario construction, so the scenario can easily modify ambience in Initialize)
    if (!C4S.Head.SaveGame)
    {
        ::GameScript.Call(PSF_InitializeAmbience);
    }
 
    // Script constructor call
    int32_t object_count = Objects.ObjectCount();
    if (!C4S.Head.SaveGame)
    {
        ::GameScript.Call(PSF_Initialize);
    }
    if (Objects.ObjectCount() != object_count)
    {
        fScriptCreatedObjects = true;
    }
 
    // Player final init
    C4Player *player;
    for (player = Players.First; player; player = player->Next)
    {
        if (init_mode == IM_ReInit)
        {
            player->ScenarioInit();
        }
        player->FinalInit(!C4S.Head.SaveGame);
    }
 
    // Create viewports
    if (init_mode == IM_Normal)
    {
        for (player = Players.First; player; player = player->Next)
        {
            if (player->LocalControl)
            {
                ::Viewports.CreateViewport(player->Number);
            }
        }
        // Check fullscreen viewports
        FullScreen.ViewportCheck();
        // update halt state
        Console.UpdateHaltCtrls(!!HaltCount);
 
        // Host: players without connected clients: remove via control queue
        if (Network.isEnabled() && Network.isHost())
        {
            for (int32_t cnt = 0; cnt < Players.GetCount(); cnt++)
            {
                if (Players.GetByIndex(cnt)->AtClient < 0)
                {
                    Players.Remove(Players.GetByIndex(cnt), true, false);
                }
            }
        }
 
        // It should be safe now to reload stuff
        if (pFileMonitor)
        {
            pFileMonitor->StartMonitoring();
        }
    }
    return true;
}

References C4GameObjects::AssignInfo(), C4GameObjects::AssignLightRange(), C4Player::AtClient, C4S, C4GameScriptHost::Call(), Console, C4ViewportList::CreateViewport(), C4PlayerList::First, fScriptCreatedObjects, FullScreen, GameScript, C4PlayerList::GetByIndex(), C4PlayerList::GetCount(), HaltCount, C4Scenario::Head, IM_Normal, IM_ReInit, C4Network2::isEnabled(), C4Network2::isHost(), Network, C4ObjectList::ObjectCount(), Objects, pFileMonitor, C4ScriptGuiWindowPropertyName::player, Players, PSF_Initialize, PSF_InitializeAmbience, C4PlayerList::Remove(), C4SHead::SaveGame, C4ConsoleGUI::UpdateHaltCtrls(), C4GameObjects::ValidateOwners(), C4FullScreen::ViewportCheck(), and Viewports.

Referenced by Init(), and LoadScenarioSection().

Here is the call graph for this function:

Here is the caller graph for this function:

InitGoals()

void C4Game::InitGoals ( )

protected

Definition at line 4188 of file C4Game.cpp.

{
    // Place goal objects
    C4ID id;
    int32_t amount;
    for (int32_t index = 0; (id = Parameters.Goals.GetID(index, &amount)); index++)
    {
        for (int32_t placed = 0; placed < amount; placed++)
        {
            CreateObject(id, nullptr);
        }
    }
}

References CreateObject(), C4IDList::GetID(), C4GameParameters::Goals, and Parameters.

Here is the call graph for this function:

InitInEarth()

void C4Game::InitInEarth ( )

protected

Definition at line 3481 of file C4Game.cpp.

{
    const int32_t maxvid = 100;
    int32_t cnt, vidnum;
    C4ID vidlist[maxvid];
    // Amount
    int32_t amt=(::Landscape.GetWidth()*::Landscape.GetHeight()/5000)*C4S.Landscape.InEarthLevel.Evaluate()/100;
    // List all valid IDs from C4S
    vidnum = ListExpandValids(C4S.Landscape.InEarth, vidlist, maxvid);
    // Place
    if (vidnum > 0)
        for (cnt = 0; cnt < amt; cnt++)
            PlaceInEarth(vidlist[Random(vidnum)]);
 
}

References C4S, C4SVal::Evaluate(), C4Landscape::GetHeight(), C4Landscape::GetWidth(), C4SLandscape::InEarth, C4SLandscape::InEarthLevel, Landscape, C4Scenario::Landscape, ListExpandValids(), PlaceInEarth(), and Random().

Here is the call graph for this function:

InitKeyboard()

bool C4Game::InitKeyboard

(

)

Definition at line 3625 of file C4Game.cpp.

{
    C4CustomKey::CodeList Keys;
 
    // clear previous
    KeyboardInput.Clear();
 
    // globals
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F3                ), "MusicToggle",            C4KeyScope(KEYSCOPE_Generic | KEYSCOPE_Gui),    new C4KeyCB  <C4MusicSystem>   (Application.MusicSystem, &C4MusicSystem::ToggleOnOff)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F9                ), "Screenshot",             C4KeyScope(KEYSCOPE_Fullscreen | KEYSCOPE_Gui), new C4KeyCBEx<C4GraphicsSystem, bool>(GraphicsSystem, false, &C4GraphicsSystem::SaveScreenshotKey)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F9,   KEYS_Control), "ScreenshotEx",           KEYSCOPE_Fullscreen, new C4KeyCBEx<C4GraphicsSystem, bool>(GraphicsSystem, true, &C4GraphicsSystem::SaveScreenshotKey)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_C,      KEYS_Alt), "ToggleChat",             C4KeyScope(KEYSCOPE_Generic | KEYSCOPE_Gui),    new C4KeyCB  <C4Game>   (*this, &C4Game::ToggleChat)));
 
    // main ingame
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F1                ), "ToggleShowHelp",         KEYSCOPE_Generic,    new C4KeyCB  <C4GraphicsSystem>(GraphicsSystem, &C4GraphicsSystem::ToggleShowHelp)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F4                ), "NetClientListDlgToggle", KEYSCOPE_Generic,    new C4KeyCB  <C4Network2>      (Network, &C4Network2::ToggleClientListDlg)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F5                ), "ZoomIn",                 KEYSCOPE_Generic,    new C4KeyCB  <C4ViewportList>  (::Viewports, &C4ViewportList::ViewportZoomIn)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F6                ), "ZoomOut",                KEYSCOPE_Generic,    new C4KeyCB  <C4ViewportList>  (::Viewports, &C4ViewportList::ViewportZoomOut)));
 
    // debug mode & debug displays
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F5,   KEYS_Control), "DbgModeToggle",          KEYSCOPE_Generic,    new C4KeyCB  <C4Game>          (*this, &C4Game::ToggleDebugMode)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F6,   KEYS_Control), "DbgShowVtxToggle",       KEYSCOPE_Generic,    new C4KeyCB  <C4GraphicsSystem>(GraphicsSystem, &C4GraphicsSystem::ToggleShowVertices)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F7,   KEYS_Control), "DbgShowActionToggle",    KEYSCOPE_Generic,    new C4KeyCB  <C4GraphicsSystem>(GraphicsSystem, &C4GraphicsSystem::ToggleShowAction)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_F8,   KEYS_Control), "DbgShow8BitSurface", KEYSCOPE_Generic,    new C4KeyCB  <C4GraphicsSystem>(GraphicsSystem, &C4GraphicsSystem::ToggleShow8BitSurface)));
 
    // playback speed - improve...
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_ADD,      KEYS_Shift), "GameSpeedUp",          KEYSCOPE_Generic,    new C4KeyCB  <C4Game>          (*this, &C4Game::SpeedUp)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_SUBTRACT, KEYS_Shift), "GameSlowDown",         KEYSCOPE_Generic,    new C4KeyCB  <C4Game>          (*this, &C4Game::SlowDown)));
 
    // fullscreen menu
    Keys.clear(); Keys.emplace_back(K_LEFT);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Left(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuLeft",     KEYSCOPE_FullSMenu,  new C4KeyCBEx<C4FullScreen, BYTE>   (FullScreen, COM_MenuLeft, &C4FullScreen::MenuKeyControl)));
    Keys.clear(); Keys.emplace_back(K_RIGHT);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Right(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuRight",    KEYSCOPE_FullSMenu,  new C4KeyCBEx<C4FullScreen, BYTE>   (FullScreen, COM_MenuRight, &C4FullScreen::MenuKeyControl)));
    Keys.clear(); Keys.emplace_back(K_UP);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Up(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuUp",       KEYSCOPE_FullSMenu,  new C4KeyCBEx<C4FullScreen, BYTE>   (FullScreen, COM_MenuUp, &C4FullScreen::MenuKeyControl)));
    Keys.clear(); Keys.emplace_back(K_DOWN);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Down(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuDown",     KEYSCOPE_FullSMenu,  new C4KeyCBEx<C4FullScreen, BYTE>   (FullScreen, COM_MenuDown, &C4FullScreen::MenuKeyControl)));
    Keys.clear(); Keys.emplace_back(K_SPACE); Keys.emplace_back(K_RETURN);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Ok(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuOK",       KEYSCOPE_FullSMenu,  new C4KeyCBEx<C4FullScreen, BYTE>   (FullScreen, COM_MenuEnter, &C4FullScreen::MenuKeyControl))); // name used by PlrControlKeyName
    Keys.clear(); Keys.emplace_back(K_ESCAPE);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Cancel(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuCancel",   KEYSCOPE_FullSMenu,  new C4KeyCBEx<C4FullScreen, BYTE>   (FullScreen, COM_MenuClose, &C4FullScreen::MenuKeyControl))); // name used by PlrControlKeyName
    Keys.clear(); Keys.emplace_back(K_SPACE);
    if (Config.Controls.GamepadGuiControl) ControllerKeys::Any(Keys);
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "FullscreenMenuOpen",     KEYSCOPE_FreeView,   new C4KeyCB  <C4FullScreen>   (FullScreen, &C4FullScreen::ActivateMenuMain))); // name used by C4MainMenu!
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_RIGHT             ), "FilmNextPlayer",         KEYSCOPE_FilmView,   new C4KeyCB  <C4ViewportList>(::Viewports, &C4ViewportList::ViewportNextPlayer)));
 
    // chat
    Keys.clear();
    Keys.emplace_back(K_RETURN);
    Keys.emplace_back(K_F2); // alternate chat key, if RETURN is blocked by player control
    KeyboardInput.RegisterKey(new C4CustomKey(Keys,                              "ChatOpen",               KEYSCOPE_Generic,    new C4KeyCBEx<C4MessageInput, bool>(MessageInput, false, &C4MessageInput::KeyStartTypeIn)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_RETURN, KEYS_Shift), "ChatOpen2Allies",        KEYSCOPE_Generic,    new C4KeyCBEx<C4MessageInput, bool>(MessageInput, true, &C4MessageInput::KeyStartTypeIn)));
 
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_LEFT              ), "FreeViewScrollLeft",     KEYSCOPE_FreeView,   new C4KeyCBEx<C4ViewportList, C4Vec2D>(::Viewports, C4Vec2D(-5, 0), &C4ViewportList::FreeScroll)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_RIGHT             ), "FreeViewScrollRight",    KEYSCOPE_FreeView,   new C4KeyCBEx<C4ViewportList, C4Vec2D>(::Viewports, C4Vec2D(+5, 0), &C4ViewportList::FreeScroll)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_UP                ), "FreeViewScrollUp",       KEYSCOPE_FreeView,   new C4KeyCBEx<C4ViewportList, C4Vec2D>(::Viewports, C4Vec2D(0, -5), &C4ViewportList::FreeScroll)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_DOWN              ), "FreeViewScrollDown",     KEYSCOPE_FreeView,   new C4KeyCBEx<C4ViewportList, C4Vec2D>(::Viewports, C4Vec2D(0, +5), &C4ViewportList::FreeScroll)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_TAB               ), "ScoreboardToggle",       KEYSCOPE_Generic,    new C4KeyCB  <C4Scoreboard>(Scoreboard, &C4Scoreboard::KeyUserShow)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_ESCAPE            ), "GameAbort",              KEYSCOPE_Fullscreen, new C4KeyCB  <C4FullScreen>(FullScreen, &C4FullScreen::ShowAbortDlg)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_PAUSE             ), "FullscreenPauseToggle",  KEYSCOPE_Fullscreen, new C4KeyCB  <C4Game>(Game, &C4Game::TogglePause)));
 
    // console keys
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_PAUSE             ), "ConsolePauseToggle",     KEYSCOPE_Console,    new C4KeyCB  <C4Console>(Console, &C4Console::TogglePause)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_ADD               ), "ToolsDlgGradeUp",        KEYSCOPE_Console,    new C4KeyCBEx<C4ToolsDlg, int32_t>(Console.ToolsDlg, +5, &C4ToolsDlg::ChangeGrade)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_SUBTRACT          ), "ToolsDlgGradeDown",      KEYSCOPE_Console,    new C4KeyCBEx<C4ToolsDlg, int32_t>(Console.ToolsDlg, -5, &C4ToolsDlg::ChangeGrade)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_M,  KEYS_Control), "ToolsDlgPopMaterial",    KEYSCOPE_Console,    new C4KeyCB  <C4ToolsDlg>(Console.ToolsDlg, &C4ToolsDlg::PopMaterial)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_T,  KEYS_Control), "ToolsDlgPopTextures",    KEYSCOPE_Console,    new C4KeyCB  <C4ToolsDlg>(Console.ToolsDlg, &C4ToolsDlg::PopTextures)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_I,  KEYS_Control), "ToolsDlgIFTToggle",      KEYSCOPE_Console,    new C4KeyCB  <C4ToolsDlg>(Console.ToolsDlg, &C4ToolsDlg::ToggleIFT)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_W,  KEYS_Control), "ToolsDlgToolToggle",     KEYSCOPE_Console,    new C4KeyCB  <C4ToolsDlg>(Console.ToolsDlg, &C4ToolsDlg::ToggleTool)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(K_DELETE            ), "EditCursorDelete",       KEYSCOPE_Console,    new C4KeyCB  <C4EditCursor>(Console.EditCursor, &C4EditCursor::Delete)));
 
    // no default keys assigned
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "EditCursorModeToggle",   KEYSCOPE_Console,    new C4KeyCB  <C4EditCursor>(Console.EditCursor, &C4EditCursor::ToggleMode)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "ChartToggle",            C4KeyScope(KEYSCOPE_Generic | KEYSCOPE_Gui),    new C4KeyCB  <C4Game>          (*this, &C4Game::ToggleChart)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "NetObsNextPlayer",       KEYSCOPE_FreeView,   new C4KeyCB  <C4ViewportList>(::Viewports, &C4ViewportList::ViewportNextPlayer)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "CtrlRateDown",           KEYSCOPE_Generic,    new C4KeyCBEx<C4GameControl, int32_t>(Control, -1, &C4GameControl::KeyAdjustControlRate)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "CtrlRateUp",             KEYSCOPE_Generic,    new C4KeyCBEx<C4GameControl, int32_t>(Control, +1, &C4GameControl::KeyAdjustControlRate)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "NetAllowJoinToggle",     KEYSCOPE_Generic,    new C4KeyCB  <C4Network2>      (Network, &C4Network2::ToggleAllowJoin)));
    KeyboardInput.RegisterKey(new C4CustomKey(C4KeyCodeEx(KEY_Default         ), "NetStatsToggle",         KEYSCOPE_Generic,    new C4KeyCB  <C4GraphicsSystem>(GraphicsSystem, &C4GraphicsSystem::ToggleShowNetStatus)));
 
    // load any custom keysboard overloads
    KeyboardInput.LoadCustomConfig();
 
    // done, success
    return true;
}

References C4FullScreen::ActivateMenuMain(), ControllerKeys::Any(), Application, ControllerKeys::Cancel(), C4ToolsDlg::ChangeGrade(), C4KeyboardInput::Clear(), COM_MenuClose, COM_MenuDown, COM_MenuEnter, COM_MenuLeft, COM_MenuRight, COM_MenuUp, Config, Console, Control, C4Config::Controls, C4EditCursor::Delete(), ControllerKeys::Down(), C4Console::EditCursor, C4ViewportList::FreeScroll(), FullScreen, Game, C4ConfigControls::GamepadGuiControl, GraphicsSystem, KEY_Default, C4GameControl::KeyAdjustControlRate(), KeyboardInput, KEYS_Alt, KEYS_Control, KEYS_Shift, KEYSCOPE_Console, KEYSCOPE_FilmView, KEYSCOPE_FreeView, KEYSCOPE_Fullscreen, KEYSCOPE_FullSMenu, KEYSCOPE_Generic, KEYSCOPE_Gui, C4MessageInput::KeyStartTypeIn(), C4Scoreboard::KeyUserShow(), ControllerKeys::Left(), C4KeyboardInput::LoadCustomConfig(), C4FullScreen::MenuKeyControl(), MessageInput, C4Application::MusicSystem, Network, ControllerKeys::Ok(), C4ToolsDlg::PopMaterial(), C4ToolsDlg::PopTextures(), C4KeyboardInput::RegisterKey(), ControllerKeys::Right(), C4GraphicsSystem::SaveScreenshotKey(), Scoreboard, C4FullScreen::ShowAbortDlg(), SlowDown(), SpeedUp(), C4Network2::ToggleAllowJoin(), ToggleChart(), ToggleChat(), C4Network2::ToggleClientListDlg(), ToggleDebugMode(), C4ToolsDlg::ToggleIFT(), C4EditCursor::ToggleMode(), C4MusicSystem::ToggleOnOff(), C4Console::TogglePause(), TogglePause(), C4GraphicsSystem::ToggleShow8BitSurface(), C4GraphicsSystem::ToggleShowAction(), C4GraphicsSystem::ToggleShowHelp(), C4GraphicsSystem::ToggleShowNetStatus(), C4GraphicsSystem::ToggleShowVertices(), C4ToolsDlg::ToggleTool(), C4Console::ToolsDlg, ControllerKeys::Up(), C4ViewportList::ViewportNextPlayer(), Viewports, C4ViewportList::ViewportZoomIn(), and C4ViewportList::ViewportZoomOut().

Referenced by Init(), and PreInit().

Here is the call graph for this function:

Here is the caller graph for this function:

InitMaterialTexture()

bool C4Game::InitMaterialTexture ( )

protected

Definition at line 987 of file C4Game.cpp.

{
    // Clear old data
    TextureMap.Clear();
    ::MaterialMap.Clear();
 
    // Check for scenario local materials
    bool has_local_materials = Game.ScenarioFile.FindEntry(C4CFN_Material);
 
    // Load all materials
    C4GameRes *material_resource = nullptr;
    bool first = true;
    bool overload_materials = true;
    bool overload_textures = true;
    long tex_count = 0;
    long mat_count = 0;
    while (overload_materials || overload_textures)
    {
 
        // Are there any scenario local materials that need to be looked at firs?
        C4Group materials;
        if (has_local_materials)
        {
            if (!materials.OpenAsChild(&Game.ScenarioFile, C4CFN_Material))
            {
                return false;
            }
            // Once only
            has_local_materials = false;
        }
        else
        {
            // Find next external material source
            material_resource = Game.Parameters.GameRes.iterRes(material_resource, NRT_Material);
            if (!material_resource)
            {
                break;
            }
            if (!Reloc.Open(materials, material_resource->getFile()))
            {
                return false;
            }
        }
 
        // Texture loader will access out of order. Pre-cache the small text-files to prevent rewind.
        materials.PreCacheEntries(C4CFN_TexMap);
        materials.PreCacheEntries(C4CFN_MaterialFiles, true);
 
        // First material file? Load texture map.
        bool continue_overload_materials = false;
        bool continue_overload_textures = false;
        if (first)
        {
            long tme_count = TextureMap.LoadMap(materials, C4CFN_TexMap, &continue_overload_materials, &continue_overload_textures);
            LogF(LoadResStr("IDS_PRC_TEXMAPENTRIES"), tme_count);
            // Only once
            first = false;
        }
        else
        {
            // Check overload-flags only
            if (!C4TextureMap::LoadFlags(materials, C4CFN_TexMap, &continue_overload_materials, &continue_overload_textures))
            {
                overload_materials = overload_textures = false;
            }
        }
 
        // Load textures
        if (overload_textures)
        {
            int local_text_count = TextureMap.LoadTextures(materials);
            // Automatically continue search if no texture was found
            if (!local_text_count)
            {
                continue_overload_textures = true;
            }
            tex_count += local_text_count;
        }
 
        // Load materials
        if (overload_materials)
        {
            int local_mat_count = ::MaterialMap.Load(materials);
            // Automatically continue search if no material was found
            if (!local_mat_count)
            {
                continue_overload_materials = true;
            }
            mat_count += local_mat_count;
        }
 
        // Set flags
        overload_textures = continue_overload_textures;
        overload_materials = continue_overload_materials;
    }
 
    // Logs
    LogF(LoadResStr("IDS_PRC_TEXTURES"), tex_count);
    LogF(LoadResStr("IDS_PRC_MATERIALS"), mat_count);
 
    // Load material enumeration
    if (!::MaterialMap.LoadEnumeration(ScenarioFile))
    {
        LogFatal(LoadResStr("IDS_PRC_NOMATENUM"));
        return false;
    }
 
    // Initialize texture map
    TextureMap.Init();
 
    // Cross map mats (after texture init, because Material-Texture-combinations are used)
    if (!::MaterialMap.CrossMapMaterials(C4S.Landscape.Material.c_str()))
    {
        return false;
    }
 
    // get material script funcs
    ::MaterialMap.UpdateScriptPointers();
 
    return true;
}

References C4CFN_Material, C4CFN_MaterialFiles, C4CFN_TexMap, C4S, C4MaterialMap::Clear(), C4TextureMap::Clear(), C4MaterialMap::CrossMapMaterials(), C4Group::FindEntry(), Game, C4GameParameters::GameRes, C4GameRes::getFile(), C4TextureMap::Init(), C4GameResList::iterRes(), C4Scenario::Landscape, C4MaterialMap::Load(), C4MaterialMap::LoadEnumeration(), C4TextureMap::LoadFlags(), C4TextureMap::LoadMap(), LoadResStr(), C4TextureMap::LoadTextures(), LogF(), LogFatal(), C4SLandscape::Material, MaterialMap, NRT_Material, C4Reloc::Open(), C4Group::OpenAsChild(), Parameters, C4Group::PreCacheEntries(), Reloc, ScenarioFile, TextureMap, and C4MaterialMap::UpdateScriptPointers().

Here is the call graph for this function:

InitNetworkFromAddress()

bool C4Game::InitNetworkFromAddress ( const char *  address )

protected

Definition at line 3889 of file C4Game.cpp.

{
    StdCopyStrBuf strRefQueryFailed(LoadResStr("IDS_NET_REFQUERY_FAILED"));
    // Query reference
    C4Network2RefClient RefClient;
    if (!RefClient.Init() ||
        !RefClient.SetServer(address) ||
        !RefClient.QueryReferences())
    {
        LogFatal(FormatString(strRefQueryFailed.getData(), RefClient.GetError()).getData());
        return false;
    }
 
    // We have to wait for the answer
    StdStrBuf message = FormatString(LoadResStr("IDS_NET_REFQUERY_QUERYMSG"), address);
    Log(message.getData());
 
    // Set up wait dialog
    C4GUI::MessageDialog *dialog = nullptr;
    if (!Application.isEditor)
    {
        // create & show
        dialog = new C4GUI::MessageDialog(message.getData(), LoadResStr("IDS_NET_REFQUERY_QUERYTITLE"),
                                        C4GUI::MessageDialog::btnAbort, C4GUI::Ico_NetWait, C4GUI::MessageDialog::dsMedium);
        if (!dialog || !dialog->Show(::pGUI, true))
        {
            return false;
        }
    }
    // Wait for response
    while (RefClient.isBusy())
    {
        // Execute GUI
        if (!Application.ScheduleProcs(100)
         || (dialog && dialog->IsAborted()))
        {
            delete dialog;
            return false;
        }
    }
    // Close dialog
    delete dialog;
 
    // Error?
    if (!RefClient.isSuccess())
    {
        LogFatal(FormatString(strRefQueryFailed.getData(), RefClient.GetError()).getData());
        return false;
    }
    // Get references
    C4Network2Reference **refs = nullptr;
    int32_t ref_count;
    if (!RefClient.GetReferences(refs, ref_count) || ref_count <= 0)
    {
        LogFatal(FormatString(strRefQueryFailed.getData(), LoadResStr("IDS_NET_REFQUERY_NOREF")).getData());
        return false;
    }
    // Connect to first reference
    bool connected = InitNetworkFromReference(*refs[0]);
    // Remove references
    for (int i = 0; i < ref_count; i++)
    {
        delete refs[i];
    }
    delete[] refs;
    return connected;
}

References Application, C4GUI::MessageDialog::btnAbort, C4GUI::MessageDialog::dsMedium, FormatString(), StdStrBuf::getData(), C4HTTPClient::GetError(), C4Network2RefClient::GetReferences(), C4GUI::Ico_NetWait, C4HTTPClient::Init(), InitNetworkFromReference(), C4GUI::Dialog::IsAborted(), C4HTTPClient::isBusy(), C4Application::isEditor, C4HTTPClient::isSuccess(), LoadResStr(), Log(), LogFatal(), pGUI, C4Network2RefClient::QueryReferences(), StdScheduler::ScheduleProcs(), C4HTTPClient::SetServer(), and C4GUI::Dialog::Show().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

InitNetworkFromReference()

bool C4Game::InitNetworkFromReference ( const C4Network2Reference &  Reference )

protected

Definition at line 3978 of file C4Game.cpp.

{
    // Find host data
    C4Client *host_data = reference.Parameters.Clients.getClientByID(C4ClientIDHost);
    if (!host_data)
    {
        LogFatal(LoadResStr("IDS_NET_INVALIDREF"));
        return false;
    }
    // Save scenario title
    ScenarioTitle = reference.getTitle();
    // Log
    LogF(LoadResStr("IDS_NET_JOINGAMEBY"), host_data->getName());
    // Init clients
    if (!Clients.Init())
    {
        return false;
    }
    // Connect
    if (Network.InitClient(reference, false) != C4Network2::IR_Success)
    {
        LogFatal(FormatString(LoadResStr("IDS_NET_NOHOSTCON"), host_data->getName()).getData());
        return false;
    }
    // init control
    if (!Control.InitNetwork(Clients.getLocal()))
    {
        return false;
    }
    // init local player info list
    Network.Players.Init();
    return true;
}

References C4ClientIDHost, C4GameParameters::Clients, Clients, Control, FormatString(), C4ClientList::getClientByID(), StdStrBuf::getData(), C4ClientList::getLocal(), C4Client::getName(), C4Network2Reference::getTitle(), C4Network2Players::Init(), C4ClientList::Init(), C4Network2::InitClient(), C4GameControl::InitNetwork(), C4Network2::IR_Success, LoadResStr(), LogF(), LogFatal(), Network, C4Network2Reference::Parameters, C4Network2::Players, and ScenarioTitle.

Referenced by Init(), InitNetworkFromAddress(), and InitNetworkFromReferenceFile().

Here is the call graph for this function:

Here is the caller graph for this function:

InitNetworkFromReferenceFile()

bool C4Game::InitNetworkFromReferenceFile ( const char *  temp_filename )

protected

Definition at line 3957 of file C4Game.cpp.

{
    // We need winsock for address parsing
    WinSockHolder winsock;
    // Load reference from temp file + delete the temp file
    bool success = false;
    C4Network2Reference ref;
    StdStrBuf join_data;
    if (join_data.LoadFromFile(temp_filename))
    {
        CompileFromBuf<StdCompilerINIRead>(mkNamingAdapt(ref, "Reference"), join_data);
        success = true;
    }
    EraseFile(temp_filename);
    if (!success)
    {
        return false;
    }
    return InitNetworkFromReference(ref);
}

References EraseFile(), InitNetworkFromReference(), StdStrBuf::LoadFromFile(), and mkNamingAdapt().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

InitNetworkHost()

bool C4Game::InitNetworkHost ( )

protected

Definition at line 4012 of file C4Game.cpp.

{
    // Network not active?
    if (!NetworkActive)
    {
        // Clear client list
        if (!C4S.Head.Replay)
        {
            Clients.Init();
        }
        return true;
    }
    // network not active?
    if (C4S.Head.NetworkGame)
    {
        LogFatal(LoadResStr("IDS_NET_NODIRECTSTART"));
        return Clients.Init();
    }
    // replay?
    if (C4S.Head.Replay)
    {
        LogFatal(LoadResStr("IDS_PRC_NONETREPLAY"));
        return true;
    }
    // clear client list
    if (!Clients.Init())
    {
        return false;
    }
    // init network as host
    if (!Network.InitHost(fLobby))
    {
        return false;
    }
    // init control
    if (!Control.InitNetwork(Clients.getLocal()))
    {
        return false;
    }
    // init local player info list
    Network.Players.Init();
    // allow connect
    Network.AllowJoin(true);
    // do lobby (if desired)
    if (fLobby)
    {
        if (!Network.DoLobby())
        {
            return false;
        }
    }
    else
    {
        // otherwise: start manually
        if (!Network.Start())
        {
            return false;
        }
    }
    // ok
    return true;
}

References C4Network2::AllowJoin(), C4S, Clients, Control, C4Network2::DoLobby(), fLobby, C4ClientList::getLocal(), C4Scenario::Head, C4Network2Players::Init(), C4ClientList::Init(), C4Network2::InitHost(), C4GameControl::InitNetwork(), LoadResStr(), LogFatal(), Network, NetworkActive, C4SHead::NetworkGame, C4Network2::Players, C4SHead::Replay, and C4Network2::Start().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

InitPlayerControlSettings()

bool C4Game::InitPlayerControlSettings

(

)

Definition at line 3725 of file C4Game.cpp.

{
    // Load controls and default control sets
    C4PlayerControlFile PlayerControlFile;
    if (!PlayerControlFile.Load(Application.SystemGroup, C4CFN_PlayerControls, &MainSysLangStringTable))
    {
        LogFatal("[!]Error loading player controls");
        return false;
    }
    PlayerControlDefs = PlayerControlFile.GetControlDefs();
    PlayerControlDefaultAssignmentSets.Clear();
    PlayerControlDefaultAssignmentSets.MergeFrom(PlayerControlFile.GetAssignmentSets(), C4PlayerControlAssignmentSet::MM_Normal);
    PlayerControlDefaultAssignmentSets.ResolveRefs(&PlayerControlDefs);
    // Merge w/ config settings into user control sets
    // User settings will be cleared and re-merged again later after scenario/definition control overloads, but initialization
    //  is needed already for config dialogs
    if (!InitPlayerControlUserSettings())
    {
        return false;
    }
    return true;
}

References Application, C4CFN_PlayerControls, C4PlayerControlAssignmentSets::Clear(), C4PlayerControlFile::GetAssignmentSets(), C4PlayerControlFile::GetControlDefs(), InitPlayerControlUserSettings(), C4PlayerControlFile::Load(), LogFatal(), MainSysLangStringTable, C4PlayerControlAssignmentSets::MergeFrom(), C4PlayerControlAssignmentSet::MM_Normal, PlayerControlDefaultAssignmentSets, PlayerControlDefs, C4PlayerControlAssignmentSets::ResolveRefs(), and C4Application::SystemGroup.

Referenced by PreInit().

Here is the call graph for this function:

Here is the caller graph for this function:

InitPlayerControlUserSettings()

bool C4Game::InitPlayerControlUserSettings

(

)

Definition at line 3748 of file C4Game.cpp.

{
    // Merge config control settings with user settings
    PlayerControlUserAssignmentSets.Clear();
    PlayerControlUserAssignmentSets.MergeFrom(PlayerControlDefaultAssignmentSets, C4PlayerControlAssignmentSet::MM_Inherit);
    PlayerControlUserAssignmentSets.MergeFrom(Config.Controls.UserSets, C4PlayerControlAssignmentSet::MM_ConfigOverload);
    PlayerControlUserAssignmentSets.ResolveRefs(&PlayerControlDefs);
    return true;
}

References C4PlayerControlAssignmentSets::Clear(), Config, C4Config::Controls, C4PlayerControlAssignmentSets::MergeFrom(), C4PlayerControlAssignmentSet::MM_ConfigOverload, C4PlayerControlAssignmentSet::MM_Inherit, PlayerControlDefaultAssignmentSets, PlayerControlDefs, PlayerControlUserAssignmentSets, C4PlayerControlAssignmentSets::ResolveRefs(), and C4ConfigControls::UserSets.

Referenced by InitPlayerControlSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

InitPlayers()

bool C4Game::InitPlayers ( C4ValueNumbers *  numbers )

protected

Definition at line 3073 of file C4Game.cpp.

{
    int32_t player_count = 0;
 
    if (C4S.Head.NetworkRuntimeJoin)
    {
        // Load players to restore from scenario
        C4PlayerInfoList LocalRestorePlayerInfos;
        LocalRestorePlayerInfos.Load(ScenarioFile, C4CFN_SavePlayerInfos, &ScenarioLangStringTable);
        // -- runtime join player restore
        // all restore functions will be executed on RestorePlayerInfos, because the main playerinfos may be more up-to-date
        // extract all players to temp store and update filenames to point there
        if (!LocalRestorePlayerInfos.RecreatePlayerFiles())
        {
            LogFatal(LoadResStr("IDS_ERR_NOPLRFILERECR"));
            return false;
        }
        // recreate the files
        if (!LocalRestorePlayerInfos.RecreatePlayers(numbers))
        {
            LogFatal(LoadResStr("IDS_ERR_NOPLRNETRECR"));
            return false;
        }
    }
    else if (RestorePlayerInfos.GetActivePlayerCount(true))
    {
        // -- savegame player restore
        // for savegames or regular scenarios with restore infos, the player info list should have been loaded from the savegame
        // or got restored from game text in OpenScenario()
        // merge restore player info into main player info list now
        // -for single-host games, this will move all infos
        // -for network games, it will merge according to savegame association done in the lobby
        // for all savegames, script players get restored by adding one new script player for earch savegame script player to the host
        if (!PlayerInfos.RestoreSavegameInfos(RestorePlayerInfos))
        {
            LogFatal(LoadResStr("IDS_ERR_NOPLRSAVEINFORECR"));
            return false;
        }
        RestorePlayerInfos.Clear();
        // try to associate local filenames (non-net+replay) or resources (net) with all player infos
        if (!PlayerInfos.RecreatePlayerFiles())
        {
            LogFatal(LoadResStr("IDS_ERR_NOPLRFILERECR"));
            return false;
        }
        // recreate players by joining all players whose joined-flag is already set
        if (!PlayerInfos.RecreatePlayers(numbers))
        {
            LogFatal(LoadResStr("IDS_ERR_NOPLRSAVERECR"));
            return false;
        }
    }
 
    // any regular non-net non-replay game: Do the normal control queue join
    // this includes additional player joins in savegames
    if (!Network.isEnabled() && !Control.NoInput())
    {
        if (!PlayerInfos.LocalJoinUnjoinedPlayersInQueue())
        {
            // error joining local players - either join was done earlier somehow,
            // or the player count check will soon end this round
        }
    }
 
    // non-replay player joins will be done by player info list when go tick is reached
    // this is handled by C4Network2Players and needs no further treatment here
    // set iPlrCnt for player count check in host/single games
    player_count = PlayerInfos.GetJoinIssuedPlayerCount();
 
    // Check valid participating player numbers (host/single only)
    if (!Network.isEnabled() || (Network.isHost() && !fLobby))
    {
#ifndef USE_CONSOLE
        // No players in fullscreen
        if (player_count == 0)
        {
            if (!Application.isEditor && !Control.NoInput())
            {
                LogFatal(LoadResStr("IDS_CNS_NOFULLSCREENPLRS")); return false;
            }
        }
#endif
        // Too many players
        if (player_count > Game.Parameters.MaxPlayers)
        {
            if (!Application.isEditor)
            {
                LogFatal(FormatString(LoadResStr("IDS_PRC_TOOMANYPLRS"),Game.Parameters.MaxPlayers).getData());
                return false;
            }
            else
            {
                Console.Message(FormatString(LoadResStr("IDS_PRC_TOOMANYPLRS"),Game.Parameters.MaxPlayers).getData());
            }
        }
    }
    // Console and no real players: halt
    if (Console.Active)
    {
        if (!fLobby)
        {
            if (!(PlayerInfos.GetActivePlayerCount(false) - PlayerInfos.GetActiveScriptPlayerCount(true, false)))
            {
                ++HaltCount;
            }
        }
    }
    return true;
}

References C4Window::Active, Application, C4CFN_SavePlayerInfos, C4S, C4PlayerInfoList::Clear(), Console, Control, fLobby, FormatString(), Game, C4PlayerInfoList::GetActivePlayerCount(), C4PlayerInfoList::GetActiveScriptPlayerCount(), StdStrBuf::getData(), C4PlayerInfoList::GetJoinIssuedPlayerCount(), HaltCount, C4Scenario::Head, C4Application::isEditor, C4Network2::isEnabled(), C4Network2::isHost(), C4PlayerInfoList::Load(), LoadResStr(), C4PlayerInfoList::LocalJoinUnjoinedPlayersInQueue(), LogFatal(), C4GameParameters::MaxPlayers, C4Console::Message(), Network, C4SHead::NetworkRuntimeJoin, C4GameControl::NoInput(), Parameters, PlayerInfos, C4PlayerInfoList::RecreatePlayerFiles(), C4PlayerInfoList::RecreatePlayers(), RestorePlayerInfos, C4PlayerInfoList::RestoreSavegameInfos(), ScenarioFile, and ScenarioLangStringTable.

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

InitRules()

void C4Game::InitRules ( )

protected

Definition at line 4174 of file C4Game.cpp.

{
    // Place rule objects
    C4ID id;
    int32_t amount;
    for (int32_t index = 0; (id = Parameters.Rules.GetID(index, &amount)); index++)
    {
        for (int32_t placed = 0; placed < std::max<int32_t>(amount, 1); placed++)
        {
            CreateObject(id, nullptr);
        }
    }
}

References CreateObject(), C4IDList::GetID(), Parameters, and C4GameParameters::Rules.

Here is the call graph for this function:

InitScriptEngine()

bool C4Game::InitScriptEngine ( )

protected

Definition at line 2988 of file C4Game.cpp.

{
    // engine functions
    InitCoreFunctionMap(&ScriptEngine);
    InitObjectFunctionMap(&ScriptEngine);
    InitGameFunctionMap(&ScriptEngine);
    ::MapScript.InitFunctionMap(&ScriptEngine);
 
    // system functions: check if system group is open
    if (!Application.OpenSystemGroup())
    {
        LogFatal(LoadResStr("IDS_ERR_INVALIDSYSGRP"));
        return false;
    }
    C4Group &File = Application.SystemGroup;
 
    // get scripts
    char filename[_MAX_FNAME_LEN] = { 0 };
    File.ResetSearch();
    while (File.FindNextEntry(C4CFN_ScriptFiles, filename, nullptr, !!filename[0]))
    {
        // host will be destroyed by script engine, so drop the references
        C4ScriptHost *script_host = new C4ExtraScriptHost();
        script_host->Reg2List(&ScriptEngine);
        script_host->Load(File, filename, Config.General.LanguageEx, &MainSysLangStringTable);
    }
 
    // if it's a physical group: watch out for changes
    if (!File.IsPacked() && Game.pFileMonitor)
    {
        Game.pFileMonitor->AddDirectory(File.GetFullName().getData());
    }
 
    // Prepare host for Objects.c script
    pScenarioObjectsScript = new C4ScenarioObjectsScriptHost();
    pScenarioObjectsScript->Reg2List(&::ScriptEngine);
 
    C4Value scen_obj_script_val;
    scen_obj_script_val.SetPropList(pScenarioObjectsScript->GetPropList());
    ::ScriptEngine.RegisterGlobalConstant("ScenarioObjects", scen_obj_script_val);
 
    // load standard clonk names
    Names.Load(File, C4CFN_Names);
 
    return true;
}

References _MAX_FNAME_LEN, Application, C4CFN_Names, C4CFN_ScriptFiles, Config, C4Group::FindNextEntry(), Game, C4Config::General, StdStrBuf::getData(), C4Group::GetFullName(), C4ExtraScriptHost::GetPropList(), InitCoreFunctionMap(), C4MapScriptHost::InitFunctionMap(), InitGameFunctionMap(), InitObjectFunctionMap(), C4Group::IsPacked(), C4ConfigGeneral::LanguageEx, C4ScriptHost::Load(), C4ComponentHost::Load(), LoadResStr(), LogFatal(), MainSysLangStringTable, MapScript, Names, C4Application::OpenSystemGroup(), pFileMonitor, pScenarioObjectsScript, C4ScriptHost::Reg2List(), C4AulScriptEngine::RegisterGlobalConstant(), C4Group::ResetSearch(), ScriptEngine, C4Value::SetPropList(), and C4Application::SystemGroup.

Here is the call graph for this function:

InitValueOverloads()

void C4Game::InitValueOverloads ( )

protected

Definition at line 4146 of file C4Game.cpp.

{
    C4ID overload_id;
    C4Def *def;
    // set new values
    for (int32_t i = 0; (overload_id = C4S.Game.Realism.ValueOverloads.GetID(i)); i++)
    {
        if ((def = ::Definitions.ID2Def(overload_id)))
        {
            def->Value = C4S.Game.Realism.ValueOverloads.GetIDCount(overload_id);
        }
    }
}

References C4S, Definitions, C4Scenario::Game, C4IDList::GetID(), C4IDList::GetIDCount(), C4DefList::ID2Def(), C4SGame::Realism, C4Def::Value, and C4SRealism::ValueOverloads.

Here is the call graph for this function:

InitVegetation()

void C4Game::InitVegetation ( )

protected

Definition at line 3497 of file C4Game.cpp.

{
    const int32_t maxvid = 100;
    int32_t cnt, vidnum;
    C4ID vidlist[maxvid];
    // Amount
    int32_t amt=(::Landscape.GetWidth()/50)*C4S.Landscape.VegLevel.Evaluate()/100;
    // Get percentage vidlist from C4S
    vidnum = ListExpandValids(C4S.Landscape.Vegetation, vidlist, maxvid);
    // Place vegetation
    if (vidnum > 0)
    {
        for (cnt = 0; cnt < amt; cnt++)
        {
            PlaceVegetation(C4Id2Def(vidlist[Random(vidnum)]),0, 0,::Landscape.GetWidth(),::Landscape.GetHeight(),-1, nullptr, nullptr);
        }
    }
}

References C4Id2Def(), C4S, C4SVal::Evaluate(), C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, C4Scenario::Landscape, ListExpandValids(), PlaceVegetation(), Random(), C4SLandscape::Vegetation, and C4SLandscape::VegLevel.

Here is the call graph for this function:

IsPaused()

bool C4Game::IsPaused

(

)

Definition at line 1235 of file C4Game.cpp.

{
    // pause state defined either by network or by game halt count
    if (::Network.isEnabled())
    {
        return !::Network.isRunning();
    }
    return !!HaltCount;
}

References HaltCount, C4Network2::isEnabled(), C4Network2::isRunning(), and Network.

Referenced by C4MusicSystem::Execute(), Pause(), TogglePause(), and Unpause().

Here is the call graph for this function:

Here is the caller graph for this function:

JoinPlayer()

C4Player * C4Game::JoinPlayer	(	const char *	filename,
		int32_t	at_client,
		const char *	at_client_name,
		C4PlayerInfo *	info
	)

Definition at line 3758 of file C4Game.cpp.

{
    assert(info);
    C4Player *player;
    // Join
    if (!( player = Players.Join(filename, true, at_client, at_client_name, info, nullptr) ))
    {
        return nullptr;
    }
    // Player final init
    player->FinalInit(true);
    // Create player viewport
    if (player->LocalControl)
    {
        ::Viewports.CreateViewport(player->Number);
    }
    // Check fullscreen viewports
    FullScreen.ViewportCheck();
    // Update menus
    Console.UpdateMenus();
    // Append player name to list of session player names (no duplicates)
    if (!SIsModule(PlayerNames.getData(), player->GetName()))
    {
        if (PlayerNames)
        {
            PlayerNames += ";";
        }
        PlayerNames += player->GetName();
    }
    // Success
    return player;
}

References Console, C4ViewportList::CreateViewport(), FullScreen, StdStrBuf::getData(), C4PlayerList::Join(), C4ScriptGuiWindowPropertyName::player, PlayerNames, Players, SIsModule(), C4Console::UpdateMenus(), C4FullScreen::ViewportCheck(), and Viewports.

Here is the call graph for this function:

LinkScriptEngine()

bool C4Game::LinkScriptEngine ( )

protected

Definition at line 3035 of file C4Game.cpp.

{
    // Link script engine (resolve includes/appends, generate code)
    ScriptEngine.Link(&::Definitions);
 
    // display errors
    LogF("C4AulScriptEngine linked - %d line%s, %d warning%s, %d error%s",
        ScriptEngine.lineCnt, (ScriptEngine.lineCnt != 1 ? "s" : ""),
        ScriptEngine.warnCnt, (ScriptEngine.warnCnt != 1 ? "s" : ""),
        ScriptEngine.errCnt, (ScriptEngine.errCnt != 1 ? "s" : ""));
 
    // update material pointers
    ::MaterialMap.UpdateScriptPointers();
    
    if (C4AulDebug *pDebug = C4AulDebug::GetDebugger())
    {
        if (!pDebug->Listen(DebugPort, !!DebugWait))
        {
            return false;
        }
    }
 
    return true;
}

References DebugPort, DebugWait, Definitions, C4AulScriptEngine::errCnt, C4AulDebug::GetDebugger(), C4AulScriptEngine::lineCnt, C4AulScriptEngine::Link(), LogF(), MaterialMap, ScriptEngine, C4MaterialMap::UpdateScriptPointers(), and C4AulScriptEngine::warnCnt.

Here is the call graph for this function:

LoadAdditionalSystemGroup()

bool C4Game::LoadAdditionalSystemGroup

(

class C4Group &

parent_group

)

Definition at line 3577 of file C4Game.cpp.

{
    // called for scenario local and definition local System.ocg groups
    C4Group SysGroup;
    char filename[_MAX_FNAME_LEN] = { 0 };
    if (SysGroup.OpenAsChild(&parent_group, C4CFN_System))
    {
        C4LangStringTable *local_strings = new C4LangStringTable();
        C4Language::LoadComponentHost(local_strings, SysGroup, C4CFN_ScriptStringTbl, Config.General.LanguageEx);
        // load custom scenario control definitions
        if (SysGroup.FindEntry(C4CFN_PlayerControls))
        {
            Log(LoadResStr("IDS_PRC_LOADSCEPLRCTRL"));
            C4PlayerControlFile PlayerControlFile;
            if (!PlayerControlFile.Load(SysGroup, C4CFN_PlayerControls, local_strings))
            {
                // non-fatal error here
                Log(LoadResStr("IDS_PRC_LOADSCEPLRCTRLFAIL"));
            }
            else
            {
                // local definitions loaded successfully - merge into global definitions
                PlayerControlDefs.MergeFrom(PlayerControlFile.GetControlDefs());
                PlayerControlDefaultAssignmentSets.MergeFrom(PlayerControlFile.GetAssignmentSets(), C4PlayerControlAssignmentSet::MM_LowPrio);
                PlayerControlDefaultAssignmentSets.ResolveRefs(&PlayerControlDefs);
            }
        }
        // load all scripts in there
        SysGroup.ResetSearch();
        while (SysGroup.FindNextEntry(C4CFN_ScriptFiles, filename, nullptr, !!filename[0]))
        {
            // host will be destroyed by script engine, so drop the references
            C4ScriptHost *script_host = new C4ExtraScriptHost();
            script_host->Reg2List(&ScriptEngine);
            script_host->Load(SysGroup, filename, Config.General.LanguageEx, local_strings);
        }
        // if it's a physical group: watch out for changes
        if (!SysGroup.IsPacked() && Game.pFileMonitor)
        {
            Game.pFileMonitor->AddDirectory(SysGroup.GetFullName().getData());
        }
        SysGroup.Close();
        // release string table if no longer used
        local_strings->DelRef();
    }
    return true;
}

References _MAX_FNAME_LEN, C4CFN_PlayerControls, C4CFN_ScriptFiles, C4CFN_ScriptStringTbl, C4CFN_System, C4Group::Close(), Config, C4LangStringTable::DelRef(), C4Group::FindEntry(), C4Group::FindNextEntry(), Game, C4Config::General, C4PlayerControlFile::GetAssignmentSets(), C4PlayerControlFile::GetControlDefs(), StdStrBuf::getData(), C4Group::GetFullName(), C4Group::IsPacked(), C4ConfigGeneral::LanguageEx, C4PlayerControlFile::Load(), C4ScriptHost::Load(), C4Language::LoadComponentHost(), LoadResStr(), Log(), C4PlayerControlAssignmentSets::MergeFrom(), C4PlayerControlDefs::MergeFrom(), C4PlayerControlAssignmentSet::MM_LowPrio, C4Group::OpenAsChild(), pFileMonitor, PlayerControlDefaultAssignmentSets, PlayerControlDefs, C4ScriptHost::Reg2List(), C4Group::ResetSearch(), C4PlayerControlAssignmentSets::ResolveRefs(), and ScriptEngine.

Referenced by C4DefList::Load().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadScenarioComponents()

bool C4Game::LoadScenarioComponents ( )

protected

Definition at line 3539 of file C4Game.cpp.

{
    // Info
    Info.Load(ScenarioFile, C4CFN_Info);
    // Overload clonk names from scenario file
    if (ScenarioFile.EntryCount(C4CFN_Names))
    {
        Names.Load(ScenarioFile, C4CFN_Names);
    }
    // scenario sections
    char filename[_MAX_FNAME_LEN] = { 0 };
    ScenarioFile.ResetSearch();
    *filename = 0;
    while (ScenarioFile.FindNextEntry(C4CFN_ScenarioSections, filename, nullptr, !!*filename))
    {
        // get section name
        char section_name[_MAX_FNAME_LEN];
        int32_t wildcard_pos = SCharPos('*', C4CFN_ScenarioSections);
        SCopy(filename + wildcard_pos, section_name, _MAX_FNAME);
        RemoveExtension(section_name);
        if (std::strlen(section_name)>C4MaxName || !*section_name)
        {
            DebugLog("invalid section name");
            LogFatal(FormatString(LoadResStr("IDS_ERR_SCENSECTION"), filename).getData());
            return false;
        }
        // load this section into temp store
        C4ScenarioSection *pSection = new C4ScenarioSection(section_name);
        if (!pSection->ScenarioLoad(filename, false))
        {
            LogFatal(FormatString(LoadResStr("IDS_ERR_SCENSECTION"), filename).getData());
            return false;
        }
    }
    // Success
    return true;
}

References _MAX_FNAME, _MAX_FNAME_LEN, C4CFN_Info, C4CFN_Names, C4CFN_ScenarioSections, C4MaxName, DebugLog(), C4Group::EntryCount(), C4Group::FindNextEntry(), FormatString(), Info, C4ComponentHost::Load(), LoadResStr(), LogFatal(), Names, RemoveExtension(), C4Group::ResetSearch(), ScenarioFile, C4ScenarioSection::ScenarioLoad(), SCharPos(), and SCopy().

Here is the call graph for this function:

LoadScenarioSection()

bool C4Game::LoadScenarioSection	(	const char *	section_name,
		DWORD	flags
	)

Definition at line 4304 of file C4Game.cpp.

{
    // note on scenario section saving:
    // if a scenario section overwrites a value that had used the default values in the main scenario section,
    // returning to the main section with an unsaved landscape (and thus an unsaved scenario core),
    // would leave those values in the altered state of the previous section
    // scenario designers should regard this and always define any values, that are defined in subsections as well
    C4Group group;
    C4Group *section_group;
    // if current section was the loaded section (maybe main, but need not for resumed savegames)
    if (!pCurrentScenarioSection)
    {
        if (!*CurrentScenarioSection)
        {
            SCopy(C4ScenSect_Main, CurrentScenarioSection, C4MaxName);
        }
        pCurrentScenarioSection = new C4ScenarioSection(CurrentScenarioSection);
        pCurrentScenarioSection->pObjectScripts = Game.pScenarioObjectsScript;
    }
    // find section to load
    C4ScenarioSection *section_to_load = pScenarioSections;
    while (section_to_load)
    {
        if (SEqualNoCase(section_to_load->name.getData(), section_name))
        {
            break;
        }
        else
        {
            section_to_load = section_to_load->pNext;
        }
    }
    if (!section_to_load)
    {
        DebugLogF("LoadScenarioSection: scenario section %s not found!", section_name);
        return false;
    }
    // save current section state
    if (section_to_load != pCurrentScenarioSection && (flags & (C4S_SAVE_LANDSCAPE | C4S_SAVE_OBJECTS)))
    {
        // ensure that the section file does point to temp store
        if (!pCurrentScenarioSection->EnsureTempStore(!(flags & C4S_SAVE_LANDSCAPE), !(flags & C4S_SAVE_OBJECTS)))
        {
            DebugLogF("LoadScenarioSection(%s): could not extract section files of current section %s", section_name, pCurrentScenarioSection->name.getData());
            return false;
        }
        // open current group
        if (!(section_group = pCurrentScenarioSection->GetGroupfile(group)))
        {
            DebugLog("LoadScenarioSection: error opening current group file");
            return false;
        }
        // store landscape, if desired (w/o material enumeration - that's assumed to stay consistent during the game)
        if (flags & C4S_SAVE_LANDSCAPE)
        {
            // storing the landscape implies storing the scenario core
            // otherwise, the ExactLandscape-flag would be lost
            // maybe imply exact landscapes by the existance of Landscape.png-files?
            C4Scenario scenario = C4S;
            scenario.SetExactLandscape();
            if (!scenario.Save(*section_group, true))
            {
                DebugLog("LoadScenarioSection: Error saving C4S");
                return false;
            }
            // landscape
            {
                C4DebugRecOff DBGRECOFF;
                if (!Landscape.Save(*section_group))
                {
                    DebugLog("LoadScenarioSection: Error saving Landscape");
                    return false;
                }
            }
            // PXS
            if (!PXS.Save(*section_group))
            {
                DebugLog("LoadScenarioSection: Error saving PXS");
                return false;
            }
            // MassMover (create copy, may not modify running data)
            C4MassMoverSet MassMoverSet;
            MassMoverSet.Copy(MassMover);
            if (!MassMoverSet.Save(*section_group))
            {
                DebugLog("LoadScenarioSection: Error saving MassMover");
                return false;
            }
        }
        // store objects
        if (flags & C4S_SAVE_OBJECTS)
        {
            C4ValueNumbers numbers;
            // objects: do not save info objects or inactive objects
            if (!SaveData(*section_group, true, false, false, &numbers))
            {
                DebugLog("LoadScenarioSection: Error saving objects");
                return false;
            }
        }
        // close current group
        if (group.IsOpen())
        {
            group.Close();
        }
        // mark modified
        pCurrentScenarioSection->fModified = true;
    }
    // open section group
    if (!(section_group = section_to_load->GetGroupfile(group)))
    {
        DebugLog("LoadScenarioSection: error opening group file");
        return false;
    }
    // remove all objects
    // do correct removal calls, because this will stop fire sounds, etc.
    for (C4Object *obj : Objects)
    {
        obj->AssignRemoval();
    }
    for (C4Object *obj : Objects)
    {
        if (obj->Status)
        {
            DebugLogF("LoadScenarioSection: WARNING: Object %d created in destruction process!", (int) obj->Number);
            ClearPointers(obj);
        }
    }
    // Final removal in case objects got recreated
    // Also kill inactive objects if scenario is reinitialized
    DeleteObjects(!!(flags & C4S_REINIT_SCENARIO));
    // remove global effects
    if (::ScriptEngine.pGlobalEffects && !(flags & C4S_KEEP_EFFECTS))
    {
        ::ScriptEngine.pGlobalEffects->ClearAll(C4FxCall_RemoveClear);
        // scenario section call might have been done from a global effect
        // rely on dead effect removal for actually removing the effects; do not clear the array here!
    }
    if (::GameScript.pScenarioEffects && !(flags & C4S_KEEP_EFFECTS))
    {
        ::GameScript.pScenarioEffects->ClearAll(C4FxCall_RemoveClear);
    }
    // del particles as well
    Particles.ClearAllParticles();
    // clear transfer zones
    TransferZones.Clear();
    // backup old sky
    std::string old_sky;
    old_sky = C4S.Landscape.SkyDef;
    // do not warn on ignored values in main section
    // they are caused because not all parts of scenario core are compiled on section change
    bool is_main_section = SEqualNoCase(section_to_load->name.getData(), C4ScenSect_Main);
    // overload scenario values (fails if no scenario core is present; that's OK)
    C4S.Load(*section_group, true, is_main_section);
    // determine whether a new sky has to be loaded
    bool should_load_new_sky = !SEqualNoCase(old_sky.c_str(), C4S.Landscape.SkyDef.c_str()) || section_group->FindEntry(C4CFN_Sky ".*");
    // set new Objects.c source
    Game.pScenarioObjectsScript = section_to_load->pObjectScripts;
    // remove reference to FoW from viewports, so that we can safely
    // reload the landscape and its FoW.
    Viewports.DisableFoW();
    // landscape initialization resets the RNG
    // set a new seed here to get new dynamic landscapes
    // TODO: add an option to disable this?
    RandomSeed = Random(2147483647);
    FixRandom(RandomSeed);
    // re-init game in new section
    C4ValueNumbers numbers;
    if (!InitGame(*section_group, (flags & C4S_REINIT_SCENARIO) ? IM_ReInit : IM_Section, should_load_new_sky, &numbers))
    {
        DebugLog("LoadScenarioSection: Error reiniting game");
        ::Viewports.EnableFoW();
        return false;
    }
    // restore shelved proplists in case loading failed
    C4PropListNumbered::UnshelveNumberedPropLists();
    // set new current section
    pCurrentScenarioSection = section_to_load;
    SCopy(pCurrentScenarioSection->name.getData(), CurrentScenarioSection);
    // Final init on game re-init (doing mostly player initialization)
    if (flags & C4S_REINIT_SCENARIO)
    {
        InitGameFinal(IM_ReInit);
        // Extra InitializePlayers callback on the already-joined players to start intros, etc.
        // (unless the call is still pending - can happen if section is loaded during player join)
        if (::Game.InitialPlayersJoined && ::Players.GetCount())
        {
            ::Game.GRBroadcast(PSF_InitializePlayers);
        }
    }
    // resize viewports, and enable lighting again
    ::Viewports.RecalculateViewports();
    ::Viewports.EnableFoW();
    // done, success
    return true;
}

References C4CFN_Sky, C4FxCall_RemoveClear, C4MaxName, C4S, C4S_KEEP_EFFECTS, C4S_REINIT_SCENARIO, C4S_SAVE_LANDSCAPE, C4S_SAVE_OBJECTS, C4ScenSect_Main, C4TransferZones::Clear(), C4Effect::ClearAll(), C4ParticleSystem::ClearAllParticles(), ClearPointers(), C4Group::Close(), C4MassMoverSet::Copy(), CurrentScenarioSection, DebugLog(), DebugLogF(), DeleteObjects(), C4ViewportList::DisableFoW(), C4ViewportList::EnableFoW(), C4ScenarioSection::EnsureTempStore(), C4Group::FindEntry(), FixRandom(), C4ScenarioSection::fModified, Game, GameScript, C4PlayerList::GetCount(), StdStrBuf::getData(), C4ScenarioSection::GetGroupfile(), GRBroadcast(), IM_ReInit, IM_Section, InitGame(), InitGameFinal(), InitialPlayersJoined, C4Group::IsOpen(), Landscape, C4Scenario::Landscape, C4Scenario::Load(), MassMover, C4ScenarioSection::name, Objects, Particles, pCurrentScenarioSection, C4AulScriptEngine::pGlobalEffects, Players, C4ScenarioSection::pNext, C4ScenarioSection::pObjectScripts, C4GameScriptHost::pScenarioEffects, pScenarioObjectsScript, pScenarioSections, PSF_InitializePlayers, PXS, Random(), RandomSeed, C4ViewportList::RecalculateViewports(), C4MassMoverSet::Save(), C4PXSSystem::Save(), C4Landscape::Save(), C4Scenario::Save(), SaveData(), SCopy(), ScriptEngine, SEqualNoCase(), C4Scenario::SetExactLandscape(), C4SLandscape::SkyDef, TransferZones, C4PropListNumbered::UnshelveNumberedPropLists(), and Viewports.

Here is the call graph for this function:

NewObject()

C4Object * C4Game::NewObject ( C4PropList *  def, C4Object *  creator, int32_t  owner, C4ObjectInfo *  info, int32_t  x, int32_t  y, int32_t  r, C4Real  xdir, C4Real  ydir, C4Real  rdir, int32_t  con, int32_t  controller, bool  grow_from_center  )

protected

Definition at line 1246 of file C4Game.cpp.

{
    // Safety
    if (!def)
    {
        return nullptr;
    }
    if (Config.General.DebugRec)
    {
        C4RCCreateObj rect;
        memset(&rect, '\0', sizeof(rect));
        strncpy(rect.id, def->GetName(), 32+1);
        rect.oei = C4PropListNumbered::GetEnumerationIndex() + 1;
        rect.x = x;
        rect.y = y;
        rect.ownr = owner;
        AddDbgRec(RCT_CrObj, &rect, sizeof(rect));
    }
 
    // Create object
    C4Object *obj;
    if (!(obj = new C4Object))
    {
        return nullptr;
    }
 
    // Initialize object
    obj->Init( def, creator, owner, info, x, y, r, xdir, ydir, rdir, controller );
 
    // Add to object list
    if (!Objects.Add(obj))
    {
        delete obj;
        return nullptr;
    }
 
    // ---- From now on, object is ready to be used in scripts!
    // Construction callback
    C4AulParSet pars(creator);
    obj->Call(PSF_Construction, &pars);
 
    // AssignRemoval called? (Con 0)
    if (!obj->Status)
    {
        return nullptr;
    }
    // Do initial con (grow)
    obj->DoCon(con, grow_from_center);
    // AssignRemoval called? (Con 0)
    if (!obj->Status)
    {
        return nullptr;
    }
    // Success
    return obj;
}

References C4GameObjects::Add(), AddDbgRec(), C4PropList::Call(), Config, C4ConfigGeneral::DebugRec, C4Object::DoCon(), C4Config::General, C4PropListNumbered::GetEnumerationIndex(), C4PropList::GetName(), C4RCCreateObj::id, C4Object::Init(), Objects, C4RCCreateObj::oei, C4RCCreateObj::ownr, PSF_Construction, RCT_CrObj, C4PropList::Status, C4RCCreateObj::x, and C4RCCreateObj::y.

Referenced by CreateInfoObject(), CreateObject(), and CreateObjectConstruction().

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectCount()

int32_t C4Game::ObjectCount

(

C4ID

id

)

Definition at line 1609 of file C4Game.cpp.

{
    C4Def *def;
    // check the easy cases first
    if (id != C4ID::None)
    {
        if (!(def = C4Id2Def(id)))
        {
            return 0; // no valid def
        }
        return def->Count;
    }
    int32_t count = 0;
    for (C4Object *obj : Objects)
    {
        // Status
        if (obj->Status)
        {
            ++count;
        }
    }
    return count;
}

References C4Id2Def(), C4Def::Count, C4ID::None, and Objects.

Here is the call graph for this function:

ObjectRemovalCheck()

void C4Game::ObjectRemovalCheck ( )

protected

Definition at line 1636 of file C4Game.cpp.

{
    for (C4Object *obj : Objects)
    {
        if (!obj->Status && (obj->RemovalDelay == 0))
        {
            Objects.Remove(obj);
            delete obj;
        }
    }
}

References Objects, and C4GameObjects::Remove().

Referenced by ExecObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

OnKeyboardLayoutChanged()

void C4Game::OnKeyboardLayoutChanged

(

)

Definition at line 4237 of file C4Game.cpp.

{
    // Layout changed: Re-resolve keys
    PlayerControlDefaultAssignmentSets.ResolveRefs(&PlayerControlDefs);
    PlayerControlUserAssignmentSets.ResolveRefs(&PlayerControlDefs);
}

References PlayerControlDefaultAssignmentSets, PlayerControlDefs, PlayerControlUserAssignmentSets, and C4PlayerControlAssignmentSets::ResolveRefs().

Referenced by C4Application::OnKeyboardLayoutChanged().

Here is the call graph for this function:

Here is the caller graph for this function:

OnPlayerJoinFinished()

void C4Game::OnPlayerJoinFinished

(

)

Definition at line 3791 of file C4Game.cpp.

{
    // Do the InitializePlayers callback once all player joins have finished with at least one human player
    if (!InitialPlayersJoined && !PlayerInfos.GetJoinPendingPlayerCount() && !::Players.HasPlayerInTeamSelection() && (::Players.GetCount(C4PT_User) > 0))
    {
        InitialPlayersJoined = true;
        GRBroadcast(PSF_InitializePlayers);
    }
}

References C4PT_User, C4PlayerList::GetCount(), C4PlayerInfoList::GetJoinPendingPlayerCount(), GRBroadcast(), C4PlayerList::HasPlayerInTeamSelection(), InitialPlayersJoined, PlayerInfos, Players, and PSF_InitializePlayers.

Referenced by C4Player::ScenarioAndTeamInit().

Here is the call graph for this function:

Here is the caller graph for this function:

OnResolutionChanged()

void C4Game::OnResolutionChanged	(	unsigned int	res_x,
		unsigned int	res_y
	)

Definition at line 4223 of file C4Game.cpp.

{
    // update anything that's dependant on screen resolution
    pGUI->SetBounds(C4Rect(0, 0, res_x, res_y));
    if (FullScreen.Active)
    {
        InitFullscreenComponents(!!IsRunning);
    }
    // note that this may fail if the gfx groups are closed already (runtime resolution change)
    // doesn't matter; old gfx are kept in this case
    GraphicsResource.ReloadResolutionDependantFiles();
    ::Viewports.RecalculateViewports();
}

References C4Window::Active, FullScreen, GraphicsResource, InitFullscreenComponents(), IsRunning, pGUI, C4ViewportList::RecalculateViewports(), C4GraphicsResource::ReloadResolutionDependantFiles(), C4GUI::Element::SetBounds(), and Viewports.

Referenced by C4Application::OnResolutionChanged().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenScenario()

bool C4Game::OpenScenario ( )

protected

Definition at line 177 of file C4Game.cpp.

{
 
    // Scenario from record stream
    if (RecordStream.getSize())
    {
        StdStrBuf RecordFile;
        if (!C4Playback::StreamToRecord(RecordStream.getData(), &RecordFile))
        {
            LogFatal("[!] Could not process record stream data!");
            return false;
        }
        SCopy(RecordFile.getData(), ScenarioFilename, _MAX_PATH);
    }
 
    // Scenario filename check & log
    if (!ScenarioFilename[0])
    {
        LogFatal(LoadResStr("IDS_PRC_NOC4S"));
        return false;
    }
    LogF(LoadResStr("IDS_PRC_LOADC4S"),ScenarioFilename);
 
    // get parent folder, if it's ocf
    pParentGroup = GroupSet.RegisterParentFolders(ScenarioFilename);
 
    // open scenario
    if (pParentGroup)
    {
        // open from parent group
        if (!ScenarioFile.OpenAsChild(pParentGroup, GetFilename(ScenarioFilename)))
        {
            LogF("%s: %s", LoadResStr("IDS_PRC_FILENOTFOUND"), (const char *)ScenarioFilename);
            return false;
        }
    }
    else
    {
        // open directly
        if (!Reloc.Open(ScenarioFile, ScenarioFilename))
        {
            LogF("%s: %s", LoadResStr("IDS_PRC_FILENOTFOUND"), (const char *)ScenarioFilename);
            return false;
        }
    }
 
    // Remember full (absolute) path
    SCopy(ScenarioFile.GetFullName().getData(), ScenarioFilename, _MAX_PATH);
 
    // add scenario to group
    GroupSet.RegisterGroup(ScenarioFile, false, C4GSPrio_Scenario, C4GSCnt_Scenario);
 
    // Read scenario core
    if (!C4S.Load(ScenarioFile))
    {
        LogFatal(LoadResStr("IDS_PRC_FILEINVALID"));
        return false;
    }
 
    // Check minimum engine version
    if (CompareVersion(C4S.Head.C4XVer[0],C4S.Head.C4XVer[1]) > 0)
    {
        LogFatal(FormatString(LoadResStr("IDS_PRC_NOREQC4X"), C4S.Head.C4XVer[0],C4S.Head.C4XVer[1]).getData());
        return false;
    }
 
    // Add scenario origin to group set
    if (C4S.Head.Origin.getLength() && !ItemIdentical(C4S.Head.Origin.getData(), ScenarioFilename))
    {
        GroupSet.RegisterParentFolders(C4S.Head.Origin.getData());
    }
 
    // Scenario definition preset
    StdStrBuf sDefinitionFilenames;
    if (!C4S.Definitions.AllowUserChange && C4S.Definitions.GetModules(&sDefinitionFilenames))
    {
        SCopy(sDefinitionFilenames.getData(), DefinitionFilenames, (sizeof DefinitionFilenames)-1);
        if (DefinitionFilenames[0])
        {
            Log(LoadResStr("IDS_PRC_SCEOWNDEFS"));
        }
        else
        {
            Log(LoadResStr("IDS_PRC_LOCALONLY"));
        }
    }
 
    // Check mission access
#ifndef USE_CONSOLE
#ifndef _DEBUG
    if (C4S.Head.MissionAccess[0]
     && !Application.isEditor
     && !SIsModule(Config.General.MissionAccess, C4S.Head.MissionAccess.c_str()))
    {
        LogFatal(LoadResStr("IDS_PRC_NOMISSIONACCESS"));
        return false;
    }
#endif
#endif
 
    // Title
    C4Language::LoadComponentHost(&Title, ScenarioFile, C4CFN_Title, Config.General.LanguageEx);
    if (!Title.GetLanguageString(Config.General.LanguageEx, ScenarioTitle))
    {
        ScenarioTitle = C4S.Head.Title;
    }
 
    // String tables
    C4Language::LoadComponentHost(&ScenarioLangStringTable, ScenarioFile, C4CFN_ScriptStringTbl, Config.General.LanguageEx);
 
    // Custom scenario parameter definitions. Load even as network client to get localized option names
    ScenarioParameterDefs.Load(ScenarioFile, &ScenarioLangStringTable);
 
    // Load parameters (not as network client, because then team info has already been sent by host)
    if (!Network.isEnabled() || Network.isHost())
    {
        if (!Parameters.Load(ScenarioFile, &C4S, GameText.GetData(), &ScenarioLangStringTable, DefinitionFilenames, &StartupScenarioParameters))
        {
            return false;
        }
    }
 
    SetInitProgress(4);
 
    // If scenario is a directory: Watch for changes
    if (!ScenarioFile.IsPacked() && pFileMonitor)
    {
        Game.pFileMonitor->AddDirectory(ScenarioFile.GetFullName().getData());
    }
 
    return true;
}

References _MAX_PATH, C4SDefinitions::AllowUserChange, Application, C4CFN_ScriptStringTbl, C4CFN_Title, C4GSCnt_Scenario, C4GSPrio_Scenario, C4S, C4SHead::C4XVer, CompareVersion(), Config, DefinitionFilenames, C4Scenario::Definitions, FormatString(), Game, GameText, C4Config::General, C4ComponentHost::GetData(), StdStrBuf::getData(), GetFilename(), C4Group::GetFullName(), C4ComponentHost::GetLanguageString(), StdStrBuf::getLength(), C4SDefinitions::GetModules(), StdStrBuf::getSize(), GroupSet, C4Scenario::Head, C4Application::isEditor, C4Network2::isEnabled(), C4Network2::isHost(), C4Group::IsPacked(), ItemIdentical(), C4ConfigGeneral::LanguageEx, C4Scenario::Load(), C4GameParameters::Load(), C4ScenarioParameterDefs::Load(), C4Language::LoadComponentHost(), LoadResStr(), Log(), LogF(), LogFatal(), C4ConfigGeneral::MissionAccess, C4SHead::MissionAccess, Network, C4Reloc::Open(), C4Group::OpenAsChild(), C4SHead::Origin, Parameters, pFileMonitor, pParentGroup, RecordStream, C4GroupSet::RegisterGroup(), C4GroupSet::RegisterParentFolders(), Reloc, ScenarioFile, ScenarioFilename, ScenarioLangStringTable, ScenarioParameterDefs, ScenarioTitle, SCopy(), SetInitProgress(), SIsModule(), StartupScenarioParameters, C4Playback::StreamToRecord(), Title, and C4SHead::Title.

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

Pause()

bool C4Game::Pause

(

)

Definition at line 1171 of file C4Game.cpp.

{
    // already paused?
    if (IsPaused())
    {
        return false;
    }
    // pause by net?
    if (::Network.isEnabled())
    {
        // league? Vote...
        if (Parameters.isLeague() && !Game.Evaluated)
        {
            ::Network.Vote(VT_Pause, true, true);
            return false;
        }
        // host only
        if (!::Network.isHost())
        {
            return true;
        }
        ::Network.Pause();
    }
    else
    {
        // pause game directly
        Game.HaltCount = true;
    }
    Console.UpdateHaltCtrls(IsPaused());
    return true;
}

References Console, Evaluated, Game, HaltCount, C4Network2::isEnabled(), C4Network2::isHost(), C4GameParameters::isLeague(), IsPaused(), Network, Parameters, C4Network2::Pause(), C4ConsoleGUI::UpdateHaltCtrls(), C4Network2::Vote(), and VT_Pause.

Referenced by C4Console::DoHalt(), C4Player::Execute(), C4Player::InitControl(), C4GameOverDlg::OnShown(), and TogglePause().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaceAnimal()

C4Object * C4Game::PlaceAnimal

(

C4PropList *

def

)

Definition at line 3446 of file C4Game.cpp.

{
    C4Def * pDef;
    if (!PropList || !(pDef = PropList->GetDef())) return nullptr;
    int32_t iX, iY;
    // Placement
    switch (PropList->GetPropertyInt(P_Placement))
    {
        // Running free
    case C4D_Place_Surface:
        iX = Random(::Landscape.GetWidth()); iY = Random(::Landscape.GetHeight());
        if (!FindSolidGround(iX, iY, pDef->Shape.Wdt)) return nullptr;
        break;
        // In liquid
    case C4D_Place_Liquid:
        iX = Random(::Landscape.GetWidth()); iY = Random(::Landscape.GetHeight());
        if (!FindSurfaceLiquid(iX, iY, pDef->Shape.Wdt, pDef->Shape.Hgt))
            if (!FindLiquid(iX, iY, pDef->Shape.Wdt, pDef->Shape.Hgt))
                return nullptr;
        iY += pDef->Shape.Hgt/2;
        break;
        // Floating in air
    case C4D_Place_Air:
        iX = Random(::Landscape.GetWidth());
        for (iY = 0; (iY<::Landscape.GetHeight()) && !GBackSemiSolid(iX, iY); iY++) {}
        if (iY <= 0) return nullptr;
        iY = Random(iY);
        break;
    default:
        return nullptr;
    }
    // Create object
    return CreateObject(PropList, nullptr, NO_OWNER, iX, iY);
}

References C4D_Place_Air, C4D_Place_Liquid, C4D_Place_Surface, CreateObject(), FindLiquid(), FindSolidGround(), FindSurfaceLiquid(), GBackSemiSolid(), C4PropList::GetDef(), C4Landscape::GetHeight(), C4PropList::GetPropertyInt(), C4Landscape::GetWidth(), C4Rect::Hgt, Landscape, NO_OWNER, P_Placement, Random(), C4Def::Shape, and C4Rect::Wdt.

Referenced by FnPlaceAnimal(), and InitAnimals().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaceInEarth()

bool C4Game::PlaceInEarth ( C4ID  id )

protected

Definition at line 3271 of file C4Game.cpp.

{
    int32_t cnt, tx, ty;
    for (cnt = 0; cnt < 35; cnt++) // cheap trys
    {
        tx = Random(::Landscape.GetWidth());
        ty = Random(::Landscape.GetHeight());
        if (GBackMat(tx, ty) == MEarth)
        {
            if (CreateObject(id, nullptr, NO_OWNER, tx, ty, Random(360)))
            {
                return true;
            }
        }
    }
    return false;
}

References CreateObject(), GBackMat(), C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, MEarth, NO_OWNER, and Random().

Referenced by InitAnimals(), and InitInEarth().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaceVegetation()

C4Object * C4Game::PlaceVegetation	(	C4PropList *	def,
		int32_t	x,
		int32_t	y,
		int32_t	wdt,
		int32_t	hgt,
		int32_t	growth,
		C4PropList *	shape_proplist,
		C4PropList *	out_pos_proplist
	)

Definition at line 3323 of file C4Game.cpp.

{
    int32_t cnt, iTx, iTy, iMaterial;
 
    // Get definition
    C4Def* pDef;
    if (!PropList || !(pDef = PropList->GetDef())) return nullptr;
 
    // No growth specified: full growth
    if (growth <= 0)
    {
        growth = FullCon;
    }
 
    // Place by placement type
    switch (PropList->GetPropertyInt(P_Placement))
    {
 
        // Surface soil
    case C4D_Place_Surface:
        for (cnt = 0; cnt < 20; cnt++)
        {
            // Random hit within target area
            if (!PlaceVegetation_GetRandomPoint(x, y, wdt, hgt, shape_proplist, out_pos_proplist, &iTx, &iTy)) break;
            // Above tunnel
            while ((iTy > 0) && Landscape.GetBackPix(iTx, iTy) == 0) iTy--;
            // Above semi solid
            if (!AboveSemiSolid(iTx, iTy) || !Inside<int32_t>(iTy, 50,::Landscape.GetHeight()-50))
                continue;
            // Still inside bounds?
            if (!PlaceVegetation_IsPosInBounds(iTx, iTy, x, y, wdt, hgt, shape_proplist)) continue;
            // Free above
            if (GBackSemiSolid(iTx, iTy-pDef->Shape.Hgt) || GBackSemiSolid(iTx, iTy-pDef->Shape.Hgt/2))
                continue;
            // Free upleft and upright
            if (GBackSemiSolid(iTx-pDef->Shape.Wdt/2, iTy-pDef->Shape.Hgt*2/3) || GBackSemiSolid(iTx+pDef->Shape.Wdt/2, iTy-pDef->Shape.Hgt*2/3))
                continue;
            // Soil check
            iTy += 3; // two pix into ground
            iMaterial = GBackMat(iTx, iTy);
            if (iMaterial!=MNone) if (::MaterialMap.Map[iMaterial].Soil)
                {
                    iTy += 5;
                    return CreateObjectConstruction(PropList, nullptr, NO_OWNER, iTx, iTy, growth);
                }
        }
        break;
 
        // Underwater
    case C4D_Place_Liquid:
        // Random range
        if (!PlaceVegetation_GetRandomPoint(x, y, wdt, hgt, shape_proplist, out_pos_proplist, &iTx, &iTy)) return nullptr;
        // Find liquid
        if (!FindSurfaceLiquid(iTx, iTy, pDef->Shape.Wdt, pDef->Shape.Hgt))
            if (!FindLiquid(iTx, iTy, pDef->Shape.Wdt, pDef->Shape.Hgt))
                return nullptr;
        // Liquid bottom
        if (!SemiAboveSolid(iTx, iTy)) return nullptr;
        iTy += 3;
        // Still inside bounds?
        if (!PlaceVegetation_IsPosInBounds(iTx, iTy, x, y, wdt, hgt, shape_proplist)) return nullptr;
        // Create object
        return CreateObjectConstruction(PropList, nullptr, NO_OWNER, iTx, iTy, growth);
        break;
 
        // Underground/Tunnel
    case C4D_Place_Subsurface:
        for (cnt = 0; cnt < 5; cnt++)
        {
            // Random range
            if (!PlaceVegetation_GetRandomPoint(x, y, wdt, hgt, shape_proplist, out_pos_proplist, &iTx, &iTy)) break;
            // Find tunnel
            if (!FindTunnel(iTx, iTy, pDef->Shape.Wdt, pDef->Shape.Hgt))
                continue;
            // Tunnel bottom
            if (!AboveSemiSolid(iTx, iTy)) continue;
            // Still inside bounds?
            if (!PlaceVegetation_IsPosInBounds(iTx, iTy, x, y, wdt, hgt, shape_proplist)) continue;
            // Soil check
            iTy += 3; // two pix into ground
            iMaterial = GBackMat(iTx, iTy);
            if (iMaterial!=MNone) if (::MaterialMap.Map[iMaterial].Soil)
                {
                    // Create object
                    iTy += 5;
                    return CreateObjectConstruction(PropList, nullptr, NO_OWNER, iTx, iTy, growth);
                }
        }
 
        // Under- or aboveground
    case C4D_Place_BothSurface:
        for (cnt = 0; cnt < 20; cnt++)
        {
            // Random hit within target area
            if (!PlaceVegetation_GetRandomPoint(x, y, wdt, hgt, shape_proplist, out_pos_proplist, &iTx, &iTy)) break;
            // Above semi solid
            if (!AboveSemiSolid(iTx, iTy) || !Inside<int32_t>(iTy, 50,::Landscape.GetHeight()-50))
                continue;
            // Free above
            if (GBackSemiSolid(iTx, iTy-pDef->Shape.Hgt) || GBackSemiSolid(iTx, iTy-pDef->Shape.Hgt/2))
                continue;
            // Still inside bounds?
            if (!PlaceVegetation_IsPosInBounds(iTx, iTy, x, y, wdt, hgt, shape_proplist))
                continue;
            // Free upleft and upright
            if (GBackSemiSolid(iTx-pDef->Shape.Wdt/2, iTy-pDef->Shape.Hgt*2/3) || GBackSemiSolid(iTx+pDef->Shape.Wdt/2, iTy-pDef->Shape.Hgt*2/3))
                continue;
            // Soil check
            iTy += 3; // two pix into ground
            iMaterial = GBackMat(iTx, iTy);
            if (iMaterial!=MNone) if (::MaterialMap.Map[iMaterial].Soil)
                {
                    iTy += 5;
                    return CreateObjectConstruction(PropList, nullptr, NO_OWNER, iTx, iTy, growth);
                }
        }
 
    }
 
    // Undefined placement type
    return nullptr;
}

References C4D_Place_Surface, FullCon, C4PropList::GetDef(), C4PropList::GetPropertyInt(), and P_Placement.

Referenced by FnPlaceVegetation(), and InitVegetation().

Here is the call graph for this function:

Here is the caller graph for this function:

PreInit()

bool C4Game::PreInit

(

)

Definition at line 333 of file C4Game.cpp.

{
    // init extra root group
    // this loads font definitions in this group as well
    // the function may return false, if no extra group is present - that is OK
    Extra.InitGroup();
 
    // Randomize
    RandomSeed = time(nullptr);
    FixRandom(RandomSeed);
 
    // Timer flags
    GameGo = false;
 
    // init message input (default commands)
    MessageInput.Init();
    Game.SetInitProgress(31.0f);
 
    // init keyboard input (default keys, plus overloads)
    if (!InitKeyboard())
    {
        LogFatal(LoadResStr("IDS_ERR_NOKEYBOARD"));
        return false;
    }
 
    // Load string table
    UpdateLanguage();
 
    // Player keyboard input: Key definitions and default sets
    if (!InitPlayerControlSettings())
    {
        return false;
    }
    Game.SetInitProgress(32.0f);
 
    // Rank system
    ::DefaultRanks.Init(Config.GetSubkeyPath("ClonkRanks"), LoadResStr("IDS_GAME_DEFRANKS"), 1000);
    Game.SetInitProgress(33.0f);
 
    // Graphics system (required for GUI)
    if (!GraphicsSystem.Init())
    {
        LogFatal(LoadResStr("IDS_ERR_NOGFXSYS"));
        return false;
    }
 
    // load GUI
#ifndef USE_CONSOLE
    C4Rect r;
    if (Application.isEditor)
    {
        Console.GetSize(&r);
    }
    else
    {
        FullScreen.GetSize(&r);
    }
    pGUI->Init(0, 0, r.Wdt, r.Hgt);
#endif
 
    fPreinited = true;
    return true;
}

References Application, Config, Console, DefaultRanks, Extra, FixRandom(), fPreinited, FullScreen, Game, GameGo, C4Window::GetSize(), C4Config::GetSubkeyPath(), GraphicsSystem, C4Rect::Hgt, C4GraphicsSystem::Init(), C4MessageInput::Init(), C4RankSystem::Init(), C4GUI::Screen::Init(), C4Extra::InitGroup(), InitKeyboard(), InitPlayerControlSettings(), C4Application::isEditor, LoadResStr(), LogFatal(), MessageInput, pGUI, RandomSeed, SetInitProgress(), UpdateLanguage(), and C4Rect::Wdt.

Referenced by C4Application::PreInit().

Here is the call graph for this function:

Here is the caller graph for this function:

QuickSave()

bool C4Game::QuickSave	(	const char *	filename,
		const char *	title,
		bool	force_save = false
	)

Definition at line 2386 of file C4Game.cpp.

{
    // Check
    if (!force_save)
    {
        if (!CanQuickSave())
        {
            return false;
        }
    }
 
    // Create savegame folder
    if (!Config.General.CreateSaveFolder(Config.AtUserDataPath(C4CFN_Savegames), LoadResStr("IDS_GAME_SAVEGAMESTITLE")))
    {
        Log(LoadResStr("IDS_GAME_FAILSAVEGAME"));
        return false;
    }
 
    // Create savegame subfolder(s)
    char save_folder[_MAX_PATH_LEN];
    for (uint32_t i = 0; i < SCharCount(DirectorySeparator, filename); i++)
    {
        SCopy(Config.AtUserDataPath(C4CFN_Savegames), save_folder);
        AppendBackslash(save_folder);
        SCopyUntil(filename, save_folder + SLen(save_folder), DirectorySeparator, _MAX_PATH, i);
        if (!Config.General.CreateSaveFolder(save_folder, title))
        {
            Log(LoadResStr("IDS_GAME_FAILSAVEGAME"));
            return false;
        }
    }
 
    // Compose savegame filename
    StdStrBuf save_path;
    save_path.Format("%s%c%s", Config.AtUserDataPath(C4CFN_Savegames), DirectorySeparator, filename);
 
    // Must not be the scenario file that is currently open
    if (ItemIdentical(ScenarioFilename, save_path.getData()))
    {
        StartSoundEffect("UI::Error");
        ::GraphicsSystem.FlashMessage(LoadResStr("IDS_GAME_NOSAVEONCURR"));
        Log(LoadResStr("IDS_GAME_FAILSAVEGAME"));
        return false;
    }
 
    // Wait message
    Log(LoadResStr("IDS_HOLD_SAVINGGAME"));
    GraphicsSystem.MessageBoard->EnsureLastMessage();
 
    // Save to target scenario file
    C4GameSave *game_save;
    game_save = new C4GameSaveSavegame();
    if (!game_save->Save(save_path.getData()))
    {
        Log(LoadResStr("IDS_GAME_FAILSAVEGAME"));
        delete game_save;
        return false;
    }
    delete game_save;
 
    // Success
    Log(LoadResStr("IDS_CNS_GAMESAVED"));
    return true;
}

References _MAX_PATH, _MAX_PATH_LEN, AppendBackslash(), C4Config::AtUserDataPath(), C4CFN_Savegames, CanQuickSave(), Config, C4ConfigGeneral::CreateSaveFolder(), DirectorySeparator, C4GraphicsSystem::FlashMessage(), StdStrBuf::Format(), C4Config::General, StdStrBuf::getData(), GraphicsSystem, ItemIdentical(), LoadResStr(), Log(), C4GraphicsSystem::MessageBoard, C4GameSave::Save(), ScenarioFilename, SCharCount(), SCopy(), SCopyUntil(), SLen(), and StartSoundEffect().

Referenced by C4MainMenu::MenuCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

ReLinkScriptEngine()

bool C4Game::ReLinkScriptEngine ( )

protected

Definition at line 3060 of file C4Game.cpp.

{
    ::ScriptEngine.ReLink(&::Definitions);
 
    // update effect pointers
    ::Objects.UpdateScriptPointers();
 
    // update material pointers
    ::MaterialMap.UpdateScriptPointers();
 
    return true;
}

References Definitions, MaterialMap, Objects, C4AulScriptEngine::ReLink(), ScriptEngine, C4MaterialMap::UpdateScriptPointers(), and C4GameObjects::UpdateScriptPointers().

Referenced by CreateSectionFromTempFile(), ReloadDef(), and ReloadFile().

Here is the call graph for this function:

Here is the caller graph for this function:

ReloadDef()

bool C4Game::ReloadDef

(

C4ID

id

)

Definition at line 2488 of file C4Game.cpp.

{
    // not in network
    if (::Network.isEnabled())
    {
        return false;
    }
 
    // syncronize (close menus with dead surfaces, etc.)
    // no need to sync back player files, though
    Synchronize(false);
 
    // SolidMasks might be updated
    C4SolidMask::RemoveSolidMasks();
 
    // reload def
    C4Def *def = ::Definitions.ID2Def(id);
    if (!def)
    {
        return false;
    }
 
    // Open Graphics.ocg -- we might need to fetch some shader (slices)
    // from there when reloading mesh materials.
    if (!::GraphicsResource.RegisterGlobalGraphics()) return false;
    if (!::GraphicsResource.RegisterMainGroups()) return false;
 
    // Message
    LogF("Reloading %s from %s", def->id.ToString(), GetFilename(def->Filename));
 
    // Reload def
    bool reload_succeeded;
    if (::Definitions.Reload(def, C4D_Load_RX, Config.General.LanguageEx, &Application.SoundSystem))
    {
        // update script engine - this will also do include callbacks and Freeze() def
        ReLinkScriptEngine();
        // Success, update all concerned object faces
        // may have been done by graphics-update already - but not for objects using graphics of another def
        // better update everything :)
        for (C4Object *obj : Objects)
        {
            if (obj->id == id)
            {
                obj->UpdateFace(true);
            }
        }
        reload_succeeded = true;
    }
    else
    {
        // Failure, remove all objects of this type
        for (C4Object *obj : Objects)
        {
            if (obj->id == id)
            {
                obj->AssignRemoval();
            }
        }
        // safety: If a removed def is being profiled, profiling must stop
        C4AulProfiler::Abort();
        // Kill def
        ::Definitions.Remove(def);
        // Log
        Log("Reloading failure. All objects of this type removed.");
        reload_succeeded = false;
    }
 
    // close Graphics.ocg again
    ::GraphicsResource.CloseFiles();
    // update game messages
    ::Messages.UpdateDef(id);
    // re-put removed SolidMasks
    C4SolidMask::PutSolidMasks();
    // done
    return reload_succeeded;
}

References C4AulProfiler::Abort(), Application, C4D_Load_RX, C4GraphicsResource::CloseFiles(), Config, Definitions, C4Def::Filename, C4Config::General, GetFilename(), GraphicsResource, C4Def::id, C4DefList::ID2Def(), C4Network2::isEnabled(), C4ConfigGeneral::LanguageEx, Log(), LogF(), Messages, Network, Objects, C4SolidMask::PutSolidMasks(), C4GraphicsResource::RegisterGlobalGraphics(), C4GraphicsResource::RegisterMainGroups(), ReLinkScriptEngine(), C4DefList::Reload(), C4DefList::Remove(), C4SolidMask::RemoveSolidMasks(), C4Application::SoundSystem, Synchronize(), C4ID::ToString(), and C4GameMessageList::UpdateDef().

Referenced by PropertyDlgProc(), and ReloadFile().

Here is the call graph for this function:

Here is the caller graph for this function:

ReloadFile()

bool C4Game::ReloadFile

(

const char *

filepath

)

Definition at line 2465 of file C4Game.cpp.

{
    // not in network
    if (::Network.isEnabled())
    {
        return false;
    }
    const char *relative_path = Config.AtRelativePath(filepath);
 
    // a definition? or part of a definition?
    C4Def *def;
    if ((def = ::Definitions.GetByPath(relative_path)))
    {
        return ReloadDef(def->id);
    }
    // script?
    if (ScriptEngine.ReloadScript(relative_path, Config.General.LanguageEx))
    {
        ReLinkScriptEngine();
    }
    return true;
}

References C4Config::AtRelativePath(), Config, Definitions, C4Config::General, C4DefList::GetByPath(), C4Def::id, C4Network2::isEnabled(), C4ConfigGeneral::LanguageEx, Network, ReLinkScriptEngine(), ReloadDef(), C4AulScriptEngine::ReloadScript(), and ScriptEngine.

Referenced by ConsoleDlgProc().

Here is the call graph for this function:

Here is the caller graph for this function:

ReloadParticle()

bool C4Game::ReloadParticle

(

const char *

name

)

Definition at line 2565 of file C4Game.cpp.

{
    // not in network
    if (::Network.isEnabled())
    {
        return false;
    }
    // safety
    if (!name)
    {
        return false;
    }
    // get particle def
    C4ParticleDef *def = Particles.definitions.GetDef(name);
    if (!def)
    {
        return false;
    }
    // verbose
    LogF("Reloading particle %s from %s", def->Name.getData(), GetFilename(def->Filename.getData()));
    // reload it
    if (!def->Reload())
    {
        // safer: remove all particles
        ::Particles.ClearAllParticles();
        delete def;
        LogF("Reloading failure. All particles removed.");
        // failure
        return false;
    }
    // success
    return true;
}

References C4ParticleSystem::ClearAllParticles(), C4ParticleSystem::definitions, C4ParticleDef::Filename, StdStrBuf::getData(), C4ParticleSystemDefinitionList::GetDef(), GetFilename(), C4Network2::isEnabled(), LogF(), C4ParticleDefCore::Name, Network, Particles, and C4ParticleDef::Reload().

Here is the call graph for this function:

SaveData()

bool C4Game::SaveData	(	C4Group &	group,
		bool	save_section,
		bool	save_exact,
		bool	save_sync,
		C4ValueNumbers *	numbers
	)

Definition at line 2180 of file C4Game.cpp.

{
    if (save_exact)
    {
        StdStrBuf Buf;
        // Decompile (without players for scenario sections)
        DecompileToBuf_Log<StdCompilerINIWrite>(mkParAdapt(*this, CompileSettings(save_section ? IM_Section : IM_Normal, !save_section && save_exact, save_exact, save_sync), numbers), &Buf, "Game");
 
        // Empty? All default save a Game.txt anyway because it is used to signal the engine to not load Objects.c
        if (!Buf.getLength())
        {
            Buf.Copy(" ");
        }
 
        // Save
        return group.Add(C4CFN_Game, Buf, false, true);
    }
    else
    {
        // Clear any exact game data in case scenario is saved from savegame resume
        group.Delete(C4CFN_Game);
 
        // Save objects to file using system scripts
        int32_t objects_file_handle = ::ScriptEngine.CreateUserFile();
        C4AulParSet pars(objects_file_handle);
        C4Value result_c4v(::ScriptEngine.GetPropList()->Call(PSF_SaveScenarioObjects, &pars));
        bool result = !!result_c4v;
        if (result_c4v.GetType() == C4V_Nil)
        {
            // Function returned nil: This usually means there was a script error during object writing.
            // It could also mean the scripter overloaded global func SaveScenarioObjects and returned nil.
            // In either case, objects will not match landscape any more, so better fail and don't save at all.
            LogF("ERROR: No valid result from global func " PSF_SaveScenarioObjects ". Saving objects failed.");
        }
        else
        {
            // Function completed successfully (returning true or false)
            C4AulUserFile *file = ::ScriptEngine.GetUserFile(objects_file_handle);
            if (!result || !file || !file->GetFileLength())
            {
                // Nothing written? Then we don't have objects.
                group.Delete(C4CFN_ScenarioObjectsScript);
                // That's OK; not an error.
                result = true;
            }
            else
            {
                // Write objects script to file!
                StdStrBuf data = file->GrabFileContents();
                result = group.Add(C4CFN_ScenarioObjectsScript, data, false, true);
            }
        }
        ::ScriptEngine.CloseUserFile(objects_file_handle);
        return result;
    }
}

References C4Group::Add(), C4CFN_Game, C4CFN_ScenarioObjectsScript, C4V_Nil, C4PropList::Call(), C4AulScriptEngine::CloseUserFile(), StdStrBuf::Copy(), C4AulScriptEngine::CreateUserFile(), C4Group::Delete(), C4AulUserFile::GetFileLength(), StdStrBuf::getLength(), C4AulScriptEngine::GetPropList(), C4Value::GetType(), C4AulScriptEngine::GetUserFile(), C4AulUserFile::GrabFileContents(), IM_Normal, IM_Section, LogF(), mkParAdapt(), PSF_SaveScenarioObjects, and ScriptEngine.

Referenced by LoadScenarioSection().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveGameTitle()

bool C4Game::SaveGameTitle

(

C4Group &

hGroup

)

Definition at line 2237 of file C4Game.cpp.

{
    // Game not running
    if (!FrameCounter)
    {
        char* bytes;
        size_t size;
        StdStrBuf real_filename;
 
        if (ScenarioFile.FindEntry(FormatString("%s.*",C4CFN_ScenarioTitle).getData(), &real_filename, &size))
        {
            if (ScenarioFile.LoadEntry(real_filename.getData(), &bytes, &size))
            {
                group.Add(real_filename.getData(), bytes, size, false, true);
            }
        }
    }
    // Fullscreen screenshot
    else if (!Application.isEditor && Application.Active)
    {
        C4Surface * sfcPic;
        int32_t iSfcWdt = 200;
        int32_t iSfcHgt = 150;
        if (!(sfcPic = new C4Surface(iSfcWdt, iSfcHgt, 0)))
        {
            return false;
        }
 
        // Fullscreen
        pDraw->Blit(FullScreen.pSurface,
                                0.0f, 0.0f, float(C4GUI::GetScreenWdt()),float(C4GUI::GetScreenHgt()-::GraphicsResource.FontRegular.GetLineHeight()),
                                sfcPic, 0,0, iSfcWdt, iSfcHgt);
 
        bool fOkay = true;
        fOkay = sfcPic->SavePNG(Config.AtTempPath(C4CFN_TempTitle), false, false, false);
 
        StdStrBuf destFilename = FormatString("%s.png",C4CFN_ScenarioTitle);
        delete sfcPic;
        if (!fOkay)
        {
            return false;
        }
        if (!group.Move(Config.AtTempPath(C4CFN_TempTitle),destFilename.getData()))
        {
            return false;
        }
    }
 
    return true;
}

References C4AbstractApp::Active, C4Group::Add(), Application, C4Config::AtTempPath(), C4Draw::Blit(), C4CFN_ScenarioTitle, C4CFN_TempTitle, Config, C4Group::FindEntry(), C4GraphicsResource::FontRegular, FormatString(), FrameCounter, FullScreen, StdStrBuf::getData(), CStdFont::GetLineHeight(), C4GUI::GetScreenHgt(), C4GUI::GetScreenWdt(), GraphicsResource, C4Application::isEditor, C4Group::LoadEntry(), C4Group::Move(), pDraw, C4Window::pSurface, C4Surface::SavePNG(), and ScenarioFile.

Referenced by C4GameSaveSavegame::SaveComponents().

Here is the call graph for this function:

Here is the caller graph for this function:

SetDefaultGamma()

void C4Game::SetDefaultGamma

(

)

Definition at line 4775 of file C4Game.cpp.

{
    // Skip this if graphics haven't been initialized yet (happens when
    // we bail during initialization)
    if (!pDraw) return;
    // Default gamma
    pDraw->ResetGamma();
    pDraw->SetGamma(float(Config.Graphics.Gamma) / 100.0,
                    float(Config.Graphics.Gamma) / 100.0,
                    float(Config.Graphics.Gamma) / 100.0,
                    C4MaxGammaUserRamps);
}

References C4MaxGammaUserRamps, Config, C4ConfigGraphics::Gamma, C4Config::Graphics, pDraw, C4Draw::ResetGamma(), and C4Draw::SetGamma().

Here is the call graph for this function:

SetGlobalSoundModifier()

void C4Game::SetGlobalSoundModifier

(

C4PropList *

modifier_props

)

Definition at line 4788 of file C4Game.cpp.

{
    // set in prop list (for savegames) and in sound system::
    C4SoundModifier *mod;
    if (new_modifier)
    {
        GlobalSoundModifier.SetPropList(new_modifier);
        mod = ::Application.SoundSystem.Modifiers.Get(new_modifier, true);
    }
    else
    {
        GlobalSoundModifier.Set0();
        mod = nullptr;
    }
    ::Application.SoundSystem.Modifiers.SetGlobalModifier(mod, NO_OWNER);
}

References Application, C4SoundModifierList::Get(), GlobalSoundModifier, C4SoundSystem::Modifiers, NO_OWNER, C4Value::Set0(), C4SoundModifierList::SetGlobalModifier(), C4Value::SetPropList(), and C4Application::SoundSystem.

Referenced by Clear(), and Init().

Here is the call graph for this function:

Here is the caller graph for this function:

SetInitProgress()

void C4Game::SetInitProgress

(

float

to_progress

)

Definition at line 4202 of file C4Game.cpp.

{
    // set new progress
    InitProgress = int32_t(to_progress);
    // if progress is more than one percent, display it
    if (InitProgress > LastInitProgress)
    {
        LastInitProgress = InitProgress;
        GraphicsSystem.MessageBoard->LogNotify();
    }
    // Cheap hack to get the Console window updated while loading
    // (unless game is running, i.e. section change - section change would be quick and timer execution can mess with things unpredictably)
    if (!IsRunning)
    {
        Application.FlushMessages();
#ifdef WITH_QT_EDITOR
        Application.ProcessQtEvents();
#endif
    }
}

References Application, C4AbstractApp::FlushMessages(), GraphicsSystem, InitProgress, IsRunning, LastInitProgress, and C4GraphicsSystem::MessageBoard.

Referenced by C4Startup::EnsureLoaded(), Init(), C4GraphicsResource::Init(), C4StartupGraphics::Init(), C4Landscape::Init(), C4GraphicsResource::InitFonts(), C4StartupGraphics::InitFonts(), C4DefList::Load(), OpenScenario(), C4Application::PreInit(), and PreInit().

Here is the call graph for this function:

Here is the caller graph for this function:

SetScenarioFilename()

void C4Game::SetScenarioFilename

(

const char *

scenario_filename

)

Definition at line 660 of file C4Game.cpp.

{
    SCopy(scenario_filename, ScenarioFilename, _MAX_PATH);
    if (SEqualNoCase(GetFilename(scenario_filename), "scenario.txt"))
    {
        if (GetFilename(ScenarioFilename) != ScenarioFilename)
        {
            *(GetFilename(ScenarioFilename) - 1) = 0;
        }
    }
}

References _MAX_PATH, GetFilename(), ScenarioFilename, SCopy(), and SEqualNoCase().

Referenced by C4Application::GameTick(), C4Application::OnCommand(), C4Application::OpenGame(), and C4Application::ParseCommandLine().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowGameOverDlg()

void C4Game::ShowGameOverDlg

(

)

Definition at line 3831 of file C4Game.cpp.

{
    // safety
    if (GameOverDlgShown)
    {
        return;
    }
    // flag, show
    GameOverDlgShown = true;
#ifndef USE_CONSOLE
    if (!Application.isEditor)
    {
        C4GameOverDlg *dialog = new C4GameOverDlg();
        dialog->SetDelOnClose();
        if (!dialog->Show(pGUI, true))
        {
            delete dialog;
            Application.QuitGame();
        }
    }
#endif
}

References Application, GameOverDlgShown, C4Application::isEditor, pGUI, C4Application::QuitGame(), C4GUI::Dialog::SetDelOnClose(), and C4GUI::Dialog::Show().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

SlowDown()

bool C4Game::SlowDown

(

)

Definition at line 4740 of file C4Game.cpp.

{
    FrameSkip = Clamp<int32_t>(FrameSkip - 1, 1, 50);
    if (FrameSkip == 1)
    {
        FullSpeed = false;
    }
    GraphicsSystem.FlashMessage(FormatString(LoadResStr("IDS_MSG_SPEED"), FrameSkip).getData());
    return true;
}

References C4GraphicsSystem::FlashMessage(), FormatString(), FrameSkip, FullSpeed, GraphicsSystem, and LoadResStr().

Referenced by InitKeyboard().

Here is the call graph for this function:

Here is the caller graph for this function:

SpeedUp()

bool C4Game::SpeedUp

(

)

Definition at line 4730 of file C4Game.cpp.

{
    // As these functions work stepwise, there's the old maximum speed of 50.
    // Use /fast to set to even higher speeds.
    FrameSkip = Clamp<int32_t>(FrameSkip + 1, 1, 50);
    FullSpeed = true;
    GraphicsSystem.FlashMessage(FormatString(LoadResStr("IDS_MSG_SPEED"), FrameSkip).getData());
    return true;
}

References C4GraphicsSystem::FlashMessage(), FormatString(), FrameSkip, FullSpeed, GraphicsSystem, and LoadResStr().

Referenced by InitKeyboard().

Here is the call graph for this function:

Here is the caller graph for this function:

SyncClearance()

void C4Game::SyncClearance

(

)

Definition at line 3854 of file C4Game.cpp.

{
    Objects.SyncClearance();
}

References Objects, and C4GameObjects::SyncClearance().

Referenced by C4Network2::FinalInit(), and Init().

Here is the call graph for this function:

Here is the caller graph for this function:

Synchronize()

void C4Game::Synchronize

(

bool

save_player_files

)

Definition at line 3859 of file C4Game.cpp.

{
    // Log
    LogSilentF("Network: Synchronization (Frame %i) [PlrSave: %d]",FrameCounter, save_player_files);
    // callback to control (to start record)
    Control.OnGameSynchronizing();
    // Fix random
    FixRandom(RandomSeed);
    // Synchronize members
    ::Definitions.Synchronize();
    Landscape.Synchronize();
    MassMover.Synchronize();
    Objects.Synchronize();
    // synchronize local player files if desired
    // this will reset any InActionTimes!
    // (not in replay mode)
    if (save_player_files && !Control.isReplay())
    {
        Players.SynchronizeLocalFiles();
    }
    // callback to network
    if (Network.isEnabled())
    {
        Network.OnGameSynchronized();
    }
    // TransferZone synchronization: Must do this after dynamic creation to avoid synchronization loss
    // if OnSynchronized-callbacks do sync-relevant changes
    TransferZones.Synchronize();
}

References Control, Definitions, FixRandom(), FrameCounter, C4Network2::isEnabled(), C4GameControl::isReplay(), Landscape, LogSilentF(), MassMover, Network, Objects, C4Network2::OnGameSynchronized(), C4GameControl::OnGameSynchronizing(), Players, RandomSeed, C4Landscape::Synchronize(), C4MassMoverSet::Synchronize(), C4TransferZones::Synchronize(), C4DefList::Synchronize(), C4GameObjects::Synchronize(), C4PlayerList::SynchronizeLocalFiles(), and TransferZones.

Referenced by C4Network2::FinalInit(), Init(), and ReloadDef().

Here is the call graph for this function:

Here is the caller graph for this function:

Ticks()

void C4Game::Ticks ( )

protected

Definition at line 2017 of file C4Game.cpp.

{
    // Frames
    FrameCounter++; GameGo = FullSpeed;
    // Ticks
    if (++iTick2 == 2)       iTick2 = 0;
    if (++iTick3 == 3)       iTick3 = 0;
    if (++iTick5 == 5)       iTick5 = 0;
    if (++iTick10 == 10)     iTick10 = 0;
    if (++iTick35 == 35)     iTick35 = 0;
    if (++iTick255 == 255)   iTick255 = 0;
    if (++iTick1000 == 1000) iTick1000 = 0;
 
    // FPS / time
    cFPS++;
    TimeGo = true;
 
    // Frame skip
    if (FrameCounter % FrameSkip)
    {
        DoSkipFrame = true;
    }
 
    // Control
    Control.Ticks();
 
    // Full speed
    if (GameGo)
    {
        Application.NextTick(); // short-circuit the timer
    }
    // statistics
    if (pNetworkStatistics)
    {
        pNetworkStatistics->ExecuteFrame();
    }
}

References Application, cFPS, Control, DoSkipFrame, FrameCounter, FrameSkip, FullSpeed, GameGo, iTick10, iTick1000, iTick2, iTick255, iTick3, iTick35, iTick5, C4Application::NextTick(), pNetworkStatistics, C4GameControl::Ticks(), and TimeGo.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

ToggleChart()

bool C4Game::ToggleChart

(

)

Definition at line 4535 of file C4Game.cpp.

{
    C4ChartDialog::Toggle();
    return true;
}

References C4ChartDialog::Toggle().

Referenced by InitKeyboard(), and C4MessageInput::ProcessCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

ToggleChat()

bool C4Game::ToggleChat

(

)

Definition at line 4751 of file C4Game.cpp.

{
    return C4ChatDlg::ToggleChat();
}

References C4ChatDlg::ToggleChat().

Referenced by InitKeyboard().

Here is the call graph for this function:

Here is the caller graph for this function:

ToggleDebugMode()

bool C4Game::ToggleDebugMode ( )

protected

Definition at line 4501 of file C4Game.cpp.

{
    // debug mode not allowed
    if (!Parameters.AllowDebug && !DebugMode)
    {
        GraphicsSystem.FlashMessage(LoadResStr("IDS_MSG_DEBUGMODENOTALLOWED"));
        return false;
    }
    DebugMode = !DebugMode;
    if (!DebugMode)
    {
        GraphicsSystem.DeactivateDebugOutput();
    }
    GraphicsSystem.FlashMessageOnOff(LoadResStr("IDS_CTL_DEBUGMODE"), DebugMode);
    return true;
}

References C4GameParameters::AllowDebug, C4GraphicsSystem::DeactivateDebugOutput(), DebugMode, C4GraphicsSystem::FlashMessage(), C4GraphicsSystem::FlashMessageOnOff(), GraphicsSystem, LoadResStr(), and Parameters.

Referenced by InitKeyboard().

Here is the call graph for this function:

Here is the caller graph for this function:

TogglePause()

bool C4Game::TogglePause

(

)

Definition at line 1153 of file C4Game.cpp.

{
    // pause toggling disabled during round evaluation
    if (C4GameOverDlg::IsShown())
    {
        return false;
    }
    // otherwise, toggle
    if (IsPaused())
    {
        return Unpause();
    }
    else
    {
        return Pause();
    }
}

References IsPaused(), C4GameOverDlg::IsShown(), Pause(), and Unpause().

Referenced by InitKeyboard(), and C4Console::TogglePause().

Here is the call graph for this function:

Here is the caller graph for this function:

Unpause()

bool C4Game::Unpause

(

)

Definition at line 1203 of file C4Game.cpp.

{
    // already paused?
    if (!IsPaused())
    {
        return false;
    }
    // pause by net?
    if (::Network.isEnabled())
    {
        // league? Vote...
        if (Parameters.isLeague() && !Game.Evaluated)
        {
            ::Network.Vote(VT_Pause, true, false);
            return false;
        }
        // host only
        if (!::Network.isHost())
        {
            return true;
        }
        ::Network.Start();
    }
    else
    {
        // unpause game directly
        Game.HaltCount = false;
    }
    Console.UpdateHaltCtrls(IsPaused());
    return true;
}

References Console, Evaluated, Game, HaltCount, C4Network2::isEnabled(), C4Network2::isHost(), C4GameParameters::isLeague(), IsPaused(), Network, Parameters, C4Network2::Start(), C4ConsoleGUI::UpdateHaltCtrls(), C4Network2::Vote(), and VT_Pause.

Referenced by C4Console::DoPlay(), C4GameOverDlg::OnClosed(), and TogglePause().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateLanguage()

void C4Game::UpdateLanguage

(

)

Definition at line 3719 of file C4Game.cpp.

{
    // Reload System.ocg string table
    C4Language::LoadComponentHost(&MainSysLangStringTable, Application.SystemGroup, C4CFN_ScriptStringTbl, Config.General.LanguageEx);
}

References Application, C4CFN_ScriptStringTbl, Config, C4Config::General, C4ConfigGeneral::LanguageEx, C4Language::LoadComponentHost(), MainSysLangStringTable, and C4Application::SystemGroup.

Referenced by PreInit().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

C4S

C4Scenario C4Game::C4S

Definition at line 74 of file C4Game.h.

Referenced by C4MainMenu::ActivateNewPlayer(), C4GameOverDlg::C4GameOverDlg(), C4Landscape::P::ChunkOZoom(), Clear(), C4PlayerInfo::CompileFunc(), C4RoundResults::CompileFunc(), C4Landscape::P::CreateMap(), C4Landscape::P::CreateMapS2(), Default(), DoKeyboardInput(), C4Viewport::Draw(), C4LandscapeRenderGL::Draw(), C4Landscape::DrawChunks(), C4Landscape::DrawMap(), C4Viewport::DrawOverlay(), C4Object::DrawSelectMark(), C4Player::Evaluate(), C4Viewport::Execute(), C4Weather::Execute(), C4Player::Execute(), C4ViewportList::FreeScroll(), C4Player::GainScenarioAchievement(), C4Language::GetPackGroups(), C4RoundResults::Init(), Init(), C4Network2Players::Init(), C4Sky::Init(), C4Weather::Init(), C4Landscape::Init(), C4Player::Init(), InitAnimals(), C4Landscape::P::InitBorderPix(), InitControl(), InitEnvironment(), C4GraphicsResource::InitFonts(), InitGameFinal(), InitInEarth(), C4Network2::InitLeague(), C4PlayerInfoList::InitLocal(), InitMaterialTexture(), InitNetworkHost(), InitPlayers(), InitValueOverloads(), InitVegetation(), C4Landscape::InsertDeadMaterial(), C4Landscape::InsertMaterial(), C4Network2Players::JoinLocalPlayer(), C4PlayerInfo::LoadFromLocalFile(), C4PlayerInfo::LoadResource(), LoadScenarioSection(), C4MainMenu::MenuCommand(), C4Viewport::NextPlayer(), C4GameLobby::Countdown::OnSec1Timer(), OpenScenario(), C4Player::PlaceReadyBase(), C4Player::PlaceReadyCrew(), C4Player::PlaceReadyMaterial(), C4Player::PlaceReadyVehic(), C4Landscape::PostInitMap(), C4MessageInput::ProcessInput(), C4PlayerInfoList::RecreatePlayerFiles(), C4PlayerInfoList::RecreatePlayers(), C4PlayerInfoList::RestoreSavegameInfos(), C4PlayerList::Save(), C4Landscape::ScenarioInit(), C4Player::ScenarioInit(), C4ToolsDlg::SetLandscapeMode(), C4GameLobby::MainDlg::Start(), C4FullScreen::ViewportCheck(), and C4ViewportList::ViewportNextPlayer().

cFPS

int32_t C4Game::cFPS

Definition at line 111 of file C4Game.h.

Referenced by Default(), C4GameSec1Timer::OnSec1Timer(), and Ticks().

Clients

C4ClientList& C4Game::Clients

Definition at line 69 of file C4Game.h.

Referenced by C4MainMenu::ActivateMain(), C4GameControl::ChangeToLocal(), ConsoleDlgProc(), C4GameControlNetwork::DecideControlDelivery(), C4Network2::EndVote(), C4GameControlNetwork::ExecQueuedSyncCtrl(), C4PlayerList::FileInUse(), C4Network2Players::GetClientChatColor(), C4ControlVote::getDesc(), C4Network2Players::GetLocalPlayerInfoPacket(), C4Network2::HandleJoinData(), C4Network2Players::HandlePlayerInfo(), C4Network2::HostConnect(), InitControl(), C4Network2::InitHost(), C4Network2::InitNetIO(), InitNetworkFromReference(), InitNetworkHost(), C4Network2Players::JoinLocalPlayer(), C4MainMenu::MenuCommand(), C4GameLobby::MainDlg::OnClientAddPlayer(), C4Network2::OnClientDisconnect(), C4Network2::OnGameSynchronized(), C4GameLobby::MainDlg::OnMessage(), C4GameLobby::MainDlg::OnReadyCheck(), C4Network2Players::OnStatusGoReached(), C4Network2::OpenVoteDialog(), C4ControlJoinPlayer::PreExecute(), C4GameControl::Prepare(), C4MessageInput::ProcessCommand(), C4PlayerInfoList::RecreatePlayers(), C4Network2::RequestActivate(), C4Network2::RetrieveScenario(), C4PlayerInfoList::SetAsRestoreInfos(), C4GameControlNetwork::SetRunning(), C4Network2ClientListBox::Update(), C4Console::UpdateNetMenu(), C4Network2ClientDlg::UpdateText(), and C4Network2::Vote().

CurrentScenarioSection

char C4Game::CurrentScenarioSection[C4MaxName+1]

Definition at line 101 of file C4Game.h.

Referenced by CompileFunc(), Default(), and LoadScenarioSection().

DebugHost

StdStrBuf C4Game::DebugHost

Definition at line 149 of file C4Game.h.

Referenced by Default(), InitGame(), and C4Application::ParseCommandLine().

DebugMode

bool C4Game::DebugMode

Definition at line 145 of file C4Game.h.

Referenced by DebugLog(), C4Viewport::Execute(), Init(), C4MessageInput::ProcessCommand(), ToggleDebugMode(), C4GraphicsSystem::ToggleShow8BitSurface(), C4GraphicsSystem::ToggleShowAction(), and C4GraphicsSystem::ToggleShowVertices().

DebugPassword

StdStrBuf C4Game::DebugPassword

Definition at line 149 of file C4Game.h.

Referenced by Default(), InitGame(), and C4Application::ParseCommandLine().

DebugPort

uint16_t C4Game::DebugPort

Definition at line 149 of file C4Game.h.

Referenced by Default(), InitGame(), LinkScriptEngine(), and C4Application::ParseCommandLine().

DebugWait

int C4Game::DebugWait

Definition at line 149 of file C4Game.h.

Referenced by Default(), LinkScriptEngine(), and C4Application::ParseCommandLine().

DefinitionFilenames

char C4Game::DefinitionFilenames[20 *_MAX_PATH_LEN]

Definition at line 105 of file C4Game.h.

Referenced by Clear(), Default(), C4StartupNetDlg::DoOK(), C4Extra::Init(), C4StartupMainDlg::OnNetJoin(), OpenScenario(), C4Application::ParseCommandLine(), C4StartupScenSelDlg::StartScenario(), and C4GameSave::WriteDescDefinitions().

DirectJoinAddress

char C4Game::DirectJoinAddress[_MAX_PATH_LEN]

Definition at line 106 of file C4Game.h.

Referenced by Clear(), Default(), C4StartupNetDlg::DoOK(), HasScenario(), Init(), C4StartupMainDlg::OnNetJoin(), and C4Application::ParseCommandLine().

DirectJoinFilePrefix

constexpr const char* C4Game::DirectJoinFilePrefix = "file:"

staticconstexpr

Definition at line 296 of file C4Game.h.

Referenced by C4StartupNetDlg::DoOK(), and Init().

DirectJoinTempFilename

char C4Game::DirectJoinTempFilename[_MAX_PATH_LEN]

Definition at line 107 of file C4Game.h.

DoSkipFrame

bool C4Game::DoSkipFrame

Definition at line 138 of file C4Game.h.

Referenced by Default(), C4ApplicationGameTimer::Execute(), C4GameControl::Ticks(), and Ticks().

Evaluated

bool C4Game::Evaluated

Definition at line 116 of file C4Game.h.

Referenced by Clear(), Default(), Evaluate(), Execute(), Pause(), and Unpause().

EvaluateOnAbort

bool C4Game::EvaluateOnAbort

Definition at line 115 of file C4Game.h.

Referenced by Abort(), and Default().

Extra

C4Extra C4Game::Extra

Definition at line 89 of file C4Game.h.

Referenced by Init(), and PreInit().

fLobby

bool C4Game::fLobby

Definition at line 119 of file C4Game.h.

Referenced by Default(), C4Console::FileNew(), C4Console::FileOpen(), C4Application::GameTick(), InitNetworkHost(), InitPlayers(), C4StartupMainDlg::OnNetJoin(), C4Application::ParseCommandLine(), C4TeamList::RecheckPlayerInfoTeams(), and C4StartupScenSelDlg::StartScenario().

fObserve

bool C4Game::fObserve

Definition at line 121 of file C4Game.h.

Referenced by Default(), C4StartupNetDlg::DoOK(), C4Application::GameTick(), C4StartupMainDlg::OnNetJoin(), C4Application::ParseCommandLine(), and C4StartupScenSelDlg::StartScenario().

fPreinited

bool C4Game::fPreinited {false}

Definition at line 128 of file C4Game.h.

Referenced by Clear(), and PreInit().

FPS

int32_t C4Game::FPS

Definition at line 111 of file C4Game.h.

Referenced by Default(), C4UpperBoard::Draw(), C4Network2Stats::ExecuteSecond(), C4Network2::HandleActivateReq(), C4GameSec1Timer::OnSec1Timer(), and C4Console::UpdateStatusBars().

fQuitWithError

bool C4Game::fQuitWithError {false}

Definition at line 143 of file C4Game.h.

Referenced by C4Startup::DoStartup(), C4Application::GameTick(), and Init().

FrameCounter

int32_t C4Game::FrameCounter

Definition at line 129 of file C4Game.h.

Referenced by C4Viewport::CalculateZoom(), C4Playback::Check(), CompileFunc(), C4ValueProviderLinear::CompileFunc(), C4GameControl::CtrlTickReached(), C4GameControl::DbgRec(), C4Network2::DeactivateInactiveClients(), Default(), C4GameControl::DoSyncCheck(), C4LandscapeRenderGL::Draw(), C4GameControl::ExecControl(), C4GameControl::ExecControlPacket(), C4GameControl::Execute(), C4PlayerControl::Execute(), Execute(), C4GameControlNetwork::Execute(), C4ValueProviderLinear::Execute(), C4ViewportList::FreeScroll(), C4GameControl::getCtrlTick(), C4GameControl::getNextControlTick(), C4Network2::HandleActivateReq(), C4Viewport::Init(), C4GameControl::Prepare(), C4SolidMask::Put(), C4GameControl::RemoveOldSyncChecks(), C4Network2::RequestActivate(), SaveGameTitle(), C4ControlSyncCheck::Set(), C4Client::SetActivated(), C4Player::SetHostility(), C4PlayerInfo::SetJoined(), C4PlayerInfo::SetRemoved(), C4Record::Start(), C4GameControl::StartRecord(), Synchronize(), C4GameControl::Ticks(), Ticks(), C4Network2ClientList::UpdateClientActivity(), and C4Console::UpdateStatusBars().

FrameSkip

int32_t C4Game::FrameSkip

Definition at line 138 of file C4Game.h.

Referenced by Default(), C4MessageInput::ProcessCommand(), SlowDown(), SpeedUp(), and Ticks().

fReferenceDefinitionOverride

bool C4Game::fReferenceDefinitionOverride

Definition at line 122 of file C4Game.h.

Referenced by Default().

fResortAnyObject

bool C4Game::fResortAnyObject

Definition at line 139 of file C4Game.h.

Referenced by CompileFunc(), C4Object::CompileFunc(), Default(), DeleteObjects(), ExecObjects(), and C4Object::Resort().

fScriptCreatedObjects

bool C4Game::fScriptCreatedObjects

Definition at line 118 of file C4Game.h.

Referenced by Default(), InitGameFinal(), and C4Console::SaveScenario().

FullSpeed

bool C4Game::FullSpeed

Definition at line 137 of file C4Game.h.

Referenced by Default(), C4MessageInput::ProcessCommand(), SlowDown(), SpeedUp(), and Ticks().

GameGo

bool C4Game::GameGo

Definition at line 136 of file C4Game.h.

Referenced by C4GameControlNetwork::CheckCompleteCtrl(), Execute(), C4ApplicationGameTimer::Execute(), PreInit(), C4GameControl::Ticks(), and Ticks().

GameOver

bool C4Game::GameOver

Definition at line 114 of file C4Game.h.

Referenced by Abort(), Clear(), Default(), DoGameOver(), C4Player::Evaluate(), Execute(), GameOverCheck(), and C4Network2::LeagueNotifyDisconnect().

GameOverDlgShown

bool C4Game::GameOverDlgShown

Definition at line 117 of file C4Game.h.

Referenced by Default(), Execute(), and ShowGameOverDlg().

GameText

C4ComponentHost C4Game::GameText

Definition at line 79 of file C4Game.h.

Referenced by Clear(), CompileRuntimeData(), C4Player::LoadRuntimeData(), and OpenScenario().

GlobalSoundModifier

C4Value& C4Game::GlobalSoundModifier

Definition at line 99 of file C4Game.h.

Referenced by CompileFunc(), Init(), and SetGlobalSoundModifier().

GroupSet

C4GroupSet C4Game::GroupSet

Definition at line 87 of file C4Game.h.

Referenced by Clear(), CloseScenario(), Default(), C4LoaderScreen::Init(), C4MusicSystem::InitForScenario(), C4GameResList::Load(), C4Extra::LoadDef(), C4GameResList::LoadFoldersWithLocalDefs(), OpenScenario(), and C4GraphicsResource::RegisterMainGroups().

HaltCount

int32_t C4Game::HaltCount

Definition at line 112 of file C4Game.h.

Referenced by C4GameControl::ChangeToLocal(), C4Network2::CheckStatusReached(), C4AulDebug::DebugStep(), Default(), C4EditCursor::Execute(), Execute(), InitGameFinal(), InitPlayers(), IsPaused(), C4EditCursor::LeftButtonDown(), C4AbortGameDialog::OnClosed(), C4AbortGameDialog::OnShown(), C4Network2::OnStatusAck(), C4Network2::OnStatusReached(), Pause(), and Unpause().

iLobbyTimeout

int32_t C4Game::iLobbyTimeout

Definition at line 120 of file C4Game.h.

Referenced by Default(), C4Network2::DoLobby(), and C4Application::ParseCommandLine().

Info

C4ComponentHost C4Game::Info

Definition at line 76 of file C4Game.h.

Referenced by Clear(), and LoadScenarioComponents().

InitialPlayersJoined

bool C4Game::InitialPlayersJoined

Definition at line 113 of file C4Game.h.

Referenced by CompileFunc(), Default(), LoadScenarioSection(), and OnPlayerJoinFinished().

InitProgress

int32_t C4Game::InitProgress

Definition at line 134 of file C4Game.h.

Referenced by Default(), C4MessageBoard::Draw(), Init(), and SetInitProgress().

Input

C4Control& C4Game::Input

Definition at line 82 of file C4Game.h.

Referenced by C4MouseControl::ButtonUpDragScript(), C4PlayerList::CtrlRemove(), C4ScriptGuiWindowAction::Execute(), C4MouseControl::LeftUpDragNone(), C4PlayerInfoList::LocalJoinUnjoinedPlayersInQueue(), C4GameSaveSavegame::OnSaving(), C4ObjectMenu::OnUserClose(), C4ObjectMenu::OnUserEnter(), C4ObjectMenu::OnUserSelectItem(), C4PlayerControl::PrepareInput(), C4MouseControl::RightUpDragNone(), and C4MouseControl::UpdateCursorTarget().

IsRunning

bool C4Game::IsRunning

Definition at line 140 of file C4Game.h.

Referenced by C4Network2::AllowJoin(), C4TeamList::CanLocalSeeTeam(), C4Network2::CheckStatusReached(), Clear(), C4FullScreen::Close(), Default(), DoKeyboardInput(), C4PlayerInfoList::DoLocalNonNetworkPlayerInfoUpdate(), C4GUI::Dialog::DoModal(), Execute(), C4GraphicsSystem::Execute(), C4MusicSystem::Execute(), C4Console::FileRecord(), C4Application::FullScreenMode(), C4Application::GameTick(), C4GameParameters::GetGameGoalString(), Init(), C4Network2Players::Init(), C4Network2::LeagueNotifyDisconnect(), C4Network2::OnClientDisconnect(), OnResolutionChanged(), C4GameSaveSavegame::OnSaving(), C4MusicSystem::Play(), C4MessageInput::ProcessCommand(), C4MessageInput::ProcessInput(), SetInitProgress(), and C4MusicSystem::ToggleOnOff().

iTick10

int32_t C4Game::iTick10

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4Object::ExecLife(), C4Object::ExecMovement(), C4Weather::Execute(), and Ticks().

iTick1000

int32_t C4Game::iTick1000

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4Weather::Execute(), and Ticks().

iTick2

int32_t C4Game::iTick2

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4Command::MoveTo(), and Ticks().

iTick255

int32_t C4Game::iTick255

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4Object::ExecLife(), ExecObjects(), Ticks(), and C4FoWLightSection::Update().

iTick3

int32_t C4Game::iTick3

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), C4GameObjects::CrossCheck(), Default(), and Ticks().

iTick35

int32_t C4Game::iTick35

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4EditCursor::Execute(), C4Menu::Execute(), C4Landscape::Execute(), C4Weather::Execute(), C4Player::Execute(), C4MusicSystem::Execute(), GameOverCheck(), C4Command::MoveTo(), C4Object::Push(), and Ticks().

iTick5

int32_t C4Game::iTick5

Definition at line 130 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4Object::ExecLife(), C4MouseControl::Execute(), Ticks(), and C4Command::Transfer().

KeyboardInput

C4KeyboardInput& C4Game::KeyboardInput

Definition at line 96 of file C4Game.h.

Referenced by Clear(), DoKeyboardInput(), C4PlayerControl::DoMouseInput(), GetKeyboardInputName(), InitKeyboard(), C4FullScreen::ViewportCheck(), and C4KeyBinding::~C4KeyBinding().

LastInitProgress

int32_t C4Game::LastInitProgress

Definition at line 134 of file C4Game.h.

Referenced by Default(), Init(), and SetInitProgress().

LastInitProgressShowTime

int32_t C4Game::LastInitProgressShowTime

Definition at line 134 of file C4Game.h.

MainSysLangStringTable

C4LangStringTable C4Game::MainSysLangStringTable

Definition at line 80 of file C4Game.h.

Referenced by Clear(), InitPlayerControlSettings(), InitScriptEngine(), and UpdateLanguage().

Names

C4ComponentHost C4Game::Names

Definition at line 78 of file C4Game.h.

Referenced by Clear(), InitScriptEngine(), LoadScenarioComponents(), and C4ObjectInfoList::New().

NetworkActive

bool C4Game::NetworkActive

Definition at line 123 of file C4Game.h.

Referenced by C4StartupNetDlg::DoOK(), C4Console::FileNew(), C4Console::FileOpen(), C4Application::GameTick(), InitNetworkHost(), C4GameParameters::Load(), C4StartupMainDlg::OnNetJoin(), C4StartupScenSelDlg::OnShown(), C4Application::ParseCommandLine(), C4Application::PreInit(), and C4StartupScenSelDlg::StartScenario().

NextMission

StdCopyStrBuf C4Game::NextMission

Definition at line 147 of file C4Game.h.

Referenced by C4GameOverDlg::C4GameOverDlg(), Clear(), and CompileFunc().

NextMissionDesc

StdCopyStrBuf C4Game::NextMissionDesc

Definition at line 147 of file C4Game.h.

Referenced by C4GameOverDlg::C4GameOverDlg(), Clear(), and CompileFunc().

NextMissionText

StdCopyStrBuf C4Game::NextMissionText

Definition at line 147 of file C4Game.h.

Referenced by C4GameOverDlg::C4GameOverDlg(), Clear(), and CompileFunc().

Parameters

C4GameParameters& C4Game::Parameters

Definition at line 67 of file C4Game.h.

Referenced by Abort(), C4MainMenu::ActivateMain(), C4MainMenu::ActivateNewPlayer(), C4PlayerInfoList::AssignPlayerIDs(), C4GameOptionButtons::C4GameOptionButtons(), C4GameOptionsList::C4GameOptionsList(), C4GameOverDlg::C4GameOverDlg(), Clear(), C4Network2::DeinitLeague(), Evaluate(), C4Player::Evaluate(), C4ApplicationGameTimer::Execute(), C4PlayerInfoList::GetFreePlayerSlotCount(), C4Network2::HandleJoinData(), C4GameLobby::MainDlg::HandlePacket(), C4Network2Players::HandlePlayerInfoUpdRequest(), Init(), InitControl(), InitDefs(), InitGame(), InitGoals(), C4Network2::InitHost(), C4Network2::InitLeague(), InitMaterialTexture(), C4GameControl::InitNetwork(), InitPlayers(), C4GameControl::InitReplay(), InitRules(), C4PlayerList::Join(), C4Network2Players::JoinLocalPlayer(), C4Network2::LeagueEnd(), C4Network2::LeagueNotifyDisconnect(), C4Network2::LeaguePlrAuthCheck(), C4Network2::LeagueSignupDisable(), C4Network2::LeagueStart(), C4MainMenu::MenuCommand(), OpenScenario(), Pause(), C4MessageInput::ProcessCommand(), C4Network2::RetrieveScenario(), C4Network2::SendJoinData(), C4Record::Start(), C4Record::StartStreaming(), C4Record::Stop(), C4Network2::StreamOut(), ToggleDebugMode(), Unpause(), and C4GameSaveRecord::WriteDesc().

PathFinder

C4PathFinder C4Game::PathFinder

Definition at line 84 of file C4Game.h.

Referenced by Clear(), Default(), C4Viewport::Draw(), and C4Command::MoveTo().

pCurrentScenarioSection

C4ScenarioSection * C4Game::pCurrentScenarioSection

Definition at line 91 of file C4Game.h.

Referenced by CloseScenario(), CreateSectionFromTempFile(), Default(), and LoadScenarioSection().

pFileMonitor

std::unique_ptr<C4FileMonitor> C4Game::pFileMonitor

Definition at line 97 of file C4Game.h.

Referenced by Clear(), InitGame(), InitGameFinal(), InitScriptEngine(), LoadAdditionalSystemGroup(), and OpenScenario().

pJoinReference

std::unique_ptr<C4Network2Reference> C4Game::pJoinReference

Definition at line 108 of file C4Game.h.

Referenced by Clear(), Default(), C4StartupNetDlg::DoOK(), and Init().

PlayerControlDefaultAssignmentSets

C4PlayerControlAssignmentSets C4Game::PlayerControlDefaultAssignmentSets

Definition at line 93 of file C4Game.h.

Referenced by Clear(), InitPlayerControlSettings(), InitPlayerControlUserSettings(), LoadAdditionalSystemGroup(), and OnKeyboardLayoutChanged().

PlayerControlDefs

C4PlayerControlDefs C4Game::PlayerControlDefs

Definition at line 92 of file C4Game.h.

Referenced by Clear(), InitPlayerControlSettings(), InitPlayerControlUserSettings(), LoadAdditionalSystemGroup(), OnKeyboardLayoutChanged(), C4ObjectMenu::OnUserClose(), C4ObjectMenu::OnUserEnter(), and C4ObjectMenu::OnUserSelectItem().

PlayerControlUserAssignmentSets

C4PlayerControlAssignmentSets C4Game::PlayerControlUserAssignmentSets

Definition at line 93 of file C4Game.h.

Referenced by Clear(), C4PlayerControlAssignmentSet::GetPicture(), C4Player::InitControl(), InitPlayerControlUserSettings(), C4StartupPlrPropertiesDlg::OnCtrlChangeLeft(), C4StartupPlrPropertiesDlg::OnCtrlChangeRight(), OnKeyboardLayoutChanged(), and C4StartupPlrPropertiesDlg::UserClose().

PlayerFilenames

char C4Game::PlayerFilenames[20 *_MAX_PATH_LEN]

Definition at line 104 of file C4Game.h.

Referenced by Clear(), C4Application::ClearCommandLine(), Default(), C4Console::FileOpenWPlrs(), Init(), C4Network2Players::Init(), InitControl(), C4PlayerInfoList::InitLocal(), and C4Application::ParseCommandLine().

PlayerInfos

C4PlayerInfoList& C4Game::PlayerInfos

Definition at line 71 of file C4Game.h.

Referenced by C4GameControl::ChangeToLocal(), C4Player::CreateGraphs(), C4Viewport::Execute(), C4Player::FindNewOwner(), C4PlayerInfoList::FindSavegameResumePlayerInfo(), C4Team::GetFirstUnjoinedPlayerID(), C4Player::GetInfo(), C4Team::GetNameWithParticipants(), C4TeamList::GetScriptPlayerName(), C4Player::GetType(), C4Team::HasWon(), C4Network2Players::Init(), C4Console::InitGame(), InitPlayers(), C4Player::IsInvisible(), C4PlayerList::JoinNew(), C4Network2::LeagueNotifyDisconnect(), C4Network2::LeagueUpdateProcessReply(), C4Network2Players::OnClientPart(), OnPlayerJoinFinished(), C4GameLobby::Countdown::OnSec1Timer(), C4Network2::OpenVoteDialog(), C4MessageInput::ProcessCommand(), C4TeamList::ReassignAllTeams(), C4Team::RecheckPlayers(), C4TeamList::RecheckTeams(), C4PlayerList::Remove(), C4GameSaveRecord::SaveComponents(), C4Player::ScenarioInit(), C4TeamList::SetTeamColors(), C4GameLobby::MainDlg::Start(), C4Record::Stop(), and C4GameSave::WriteDescPlayers().

PlayerNames

StdStrBuf C4Game::PlayerNames

Definition at line 81 of file C4Game.h.

Referenced by JoinPlayer().

pNetworkStatistics

std::unique_ptr<C4Network2Stats> C4Game::pNetworkStatistics

Definition at line 95 of file C4Game.h.

Referenced by Clear(), C4Network2Client::ClearGraphs(), C4Player::ClearGraphs(), C4Network2Client::CreateGraphs(), C4Player::CreateGraphs(), Default(), C4GameControl::Execute(), Init(), C4Player::Init(), and Ticks().

PointersDenumerated

bool C4Game::PointersDenumerated

Definition at line 141 of file C4Game.h.

Referenced by Clear(), and Default().

pParentGroup

C4Group* C4Game::pParentGroup

Definition at line 88 of file C4Game.h.

Referenced by C4MainMenu::ActivateSavegame(), CloseScenario(), Default(), and OpenScenario().

pScenarioObjectsScript

class C4ScenarioObjectsScriptHost* C4Game::pScenarioObjectsScript

Definition at line 90 of file C4Game.h.

Referenced by Clear(), CreateSectionFromTempFile(), InitScriptEngine(), LoadScenarioSection(), and C4ScenarioSection::ScenarioLoad().

pScenarioSections

C4ScenarioSection* C4Game::pScenarioSections

Definition at line 91 of file C4Game.h.

Referenced by C4ScenarioSection::C4ScenarioSection(), CloseScenario(), CreateSectionFromTempFile(), Default(), and LoadScenarioSection().

pSec1Timer

std::unique_ptr<C4GameSec1Timer> C4Game::pSec1Timer

Definition at line 98 of file C4Game.h.

QuitLogPos

size_t C4Game::QuitLogPos {0}

Definition at line 142 of file C4Game.h.

Referenced by Clear(), and C4Startup::DoStartup().

RandomSeed

int32_t C4Game::RandomSeed

Definition at line 135 of file C4Game.h.

Referenced by C4Sky::Init(), C4Landscape::Init(), InitControl(), C4Network2::LeagueStart(), LoadScenarioSection(), PreInit(), and Synchronize().

Record

bool C4Game::Record

Definition at line 124 of file C4Game.h.

Referenced by C4GameOptionButtons::C4GameOptionButtons(), C4StartupNetDlg::C4StartupNetDlg(), InitControl(), C4GameOptionButtons::OnBtnLeague(), C4StartupNetDlg::OnBtnRecord(), C4GameOptionButtons::OnBtnRecord(), C4Application::ParseCommandLine(), and C4Application::PreInit().

RecordDumpFile

StdStrBuf C4Game::RecordDumpFile

Definition at line 125 of file C4Game.h.

Referenced by Clear(), C4Playback::Open(), and C4Application::ParseCommandLine().

RecordStream

StdStrBuf C4Game::RecordStream

Definition at line 126 of file C4Game.h.

Referenced by Clear(), HasScenario(), OpenScenario(), and C4Application::ParseCommandLine().

RestorePlayerInfos

C4PlayerInfoList& C4Game::RestorePlayerInfos

Definition at line 72 of file C4Game.h.

Referenced by C4Network2Players::Init(), C4PlayerInfoList::InitLocal(), InitPlayers(), C4PlayerInfoList::ResolvePlayerAttributeConflicts(), C4GameLobby::MainDlg::Start(), and C4PlayerInfoList::UpdatePlayerAttributes().

RoundResults

C4RoundResults& C4Game::RoundResults

Definition at line 73 of file C4Game.h.

Referenced by C4GameOverDlg::C4GameOverDlg(), Clear(), Evaluate(), C4Player::Evaluate(), C4RoundResults::EvaluateLeague(), C4Network2Players::HandlePacket(), C4Network2::LeagueEnd(), C4MainMenu::MenuCommand(), C4Network2::OnClientDisconnect(), and C4PlayerList::Remove().

ScenarioFile

C4Group C4Game::ScenarioFile

Definition at line 86 of file C4Game.h.

Referenced by C4ControlReInitScenario::C4ControlReInitScenario(), CloseScenario(), C4ScenarioSection::EnsureTempStore(), C4Console::FileSaveAs(), C4ScenarioSection::GetGroupfile(), Init(), C4Sky::Init(), C4Player::Init(), InitControl(), InitDefs(), C4MusicSystem::InitForScenario(), InitMaterialTexture(), InitPlayers(), C4GameResList::Load(), LoadScenarioComponents(), OpenScenario(), C4MessageInput::ProcessCommand(), C4PlayerInfoList::RecreatePlayerFiles(), SaveGameTitle(), C4Console::SaveScenario(), and C4ScenarioSection::ScenarioLoad().

ScenarioFilename

char C4Game::ScenarioFilename[_MAX_PATH_LEN]

Definition at line 102 of file C4Game.h.

Referenced by C4MainMenu::ActivateSavegame(), Clear(), C4Network2::CreateDynamic(), Default(), C4StartupNetDlg::DoOK(), C4Player::GainScenarioAchievement(), C4Language::GetPackGroups(), HasScenario(), Init(), C4Console::InitGame(), C4StartupMainDlg::OnNetJoin(), OpenScenario(), C4Application::ParseCommandLine(), C4MessageInput::ProcessCommand(), QuickSave(), C4Console::SaveScenario(), and SetScenarioFilename().

ScenarioLangStringTable

C4LangStringTable C4Game::ScenarioLangStringTable

Definition at line 80 of file C4Game.h.

Referenced by Clear(), InitPlayers(), OpenScenario(), and C4ScenarioSection::ScenarioLoad().

ScenarioParameterDefs

class C4ScenarioParameterDefs& C4Game::ScenarioParameterDefs

Definition at line 75 of file C4Game.h.

Referenced by C4GameOptionsList::C4GameOptionsList(), Clear(), C4GameParameters::EnforceLeagueRules(), C4Network2::HandleJoinData(), OpenScenario(), and C4Network2::SendJoinData().

ScenarioTitle

StdCopyStrBuf C4Game::ScenarioTitle

Definition at line 103 of file C4Game.h.

Referenced by C4MainMenu::ActivateSavegame(), C4GameSaveRecord::AdjustCore(), Default(), C4UpperBoard::Draw(), C4LoaderScreen::Draw(), C4Player::Evaluate(), InitNetworkFromReference(), OpenScenario(), and C4GameSave::SaveDesc().

Scoreboard

C4Scoreboard C4Game::Scoreboard

Definition at line 94 of file C4Game.h.

Referenced by Clear(), CompileFunc(), Init(), InitKeyboard(), and C4GameOverDlg::OnShown().

ScriptGuiRoot

std::unique_ptr<C4ScriptGuiWindow> C4Game::ScriptGuiRoot

Definition at line 234 of file C4Game.h.

Referenced by Clear(), ClearPointers(), CompileFunc(), Default(), C4Viewport::Draw(), C4ScriptGuiWindowAction::Init(), C4MouseControl::Move(), and C4ViewportList::RecalculateViewports().

StartTime

int32_t C4Game::StartTime

Definition at line 133 of file C4Game.h.

Referenced by Default(), and Init().

StartupLogPos

size_t C4Game::StartupLogPos {0}

Definition at line 142 of file C4Game.h.

Referenced by C4Startup::DoStartup(), and Init().

StartupPlayerCount

int32_t C4Game::StartupPlayerCount

Definition at line 109 of file C4Game.h.

Referenced by CompileFunc(), C4Landscape::P::CreateMap(), C4Landscape::P::CreateMapS2(), Default(), C4Landscape::DrawMap(), and C4Player::ScenarioInit().

StartupScenarioParameters

class C4ScenarioParameters& C4Game::StartupScenarioParameters

Definition at line 68 of file C4Game.h.

Referenced by Clear(), OpenScenario(), C4Application::ParseCommandLine(), and C4StartupScenSelDlg::StartScenario().

StartupTeamCount

int32_t C4Game::StartupTeamCount

Definition at line 110 of file C4Game.h.

Referenced by CompileFunc(), and Default().

Teams

C4TeamList& C4Game::Teams

Definition at line 70 of file C4Game.h.

Referenced by C4MainMenu::ActivateMain(), C4PlayerInfoList::AddInfo(), C4Team::AddPlayer(), C4PlayerInfoList::AssignTeams(), C4GameOverDlg::C4GameOverDlg(), C4PlayerInfoList::CreateRestoreInfosForJoinedScriptPlayers(), C4MainMenu::DoRefillInternal(), C4Player::Execute(), C4Player::FindNewOwner(), C4PlayerInfo::GetLobbyColor(), C4Network2Players::HandlePlayerInfo(), C4PlayerInfo::HasTeamWon(), C4Player::Init(), C4PlayerInfoList::InitLocal(), C4GameLobby::MainDlg::MainDlg(), C4MainMenu::MenuCommand(), C4Network2Players::OnClientPart(), C4GameLobby::MainDlg::OnRightTabContext(), C4MessageInput::ProcessInput(), C4PlayerInfoList::RecheckAutoGeneratedTeams(), C4PlayerInfoList::RestoreSavegameInfos(), C4Player::ScenarioAndTeamInit(), C4Player::ScenarioInit(), C4PlayerInfoList::UpdatePlayerAttributes(), and C4GameSave::WriteDescPlayers().

TempScenarioFile

StdStrBuf C4Game::TempScenarioFile

Definition at line 127 of file C4Game.h.

Referenced by CloseScenario(), Init(), and C4Console::SaveScenario().

Time

int32_t C4Game::Time

Definition at line 132 of file C4Game.h.

Referenced by CompileFunc(), Default(), C4Player::Evaluate(), C4RoundResults::EvaluateGame(), C4Object::ExecLife(), C4UpperBoard::Execute(), C4UpperBoard::Init(), C4Player::Init(), C4Player::LocalSync(), C4GameSec1Timer::OnSec1Timer(), C4ObjectInfo::Recruit(), C4ObjectInfo::Retire(), C4Console::UpdateStatusBars(), and C4GameSave::WriteDescGameTime().

TimeGo

bool C4Game::TimeGo

Definition at line 131 of file C4Game.h.

Referenced by Default(), C4GameSec1Timer::OnSec1Timer(), and Ticks().

Title

C4ComponentHost C4Game::Title

Definition at line 77 of file C4Game.h.

Referenced by Clear(), and OpenScenario().

TransferZones

C4TransferZones C4Game::TransferZones

Definition at line 85 of file C4Game.h.

Referenced by Clear(), ClearPointers(), Default(), LoadScenarioSection(), C4Object::StatusDeactivate(), Synchronize(), and C4Command::Transfer().

---

The documentation for this class was generated from the following files:

• C4Game.h
• C4Game.cpp