marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
openclonk/src/player/C4Player.cpp

1941 lines
55 KiB
C++
Raw Blame History

/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 1998-2000, Matthes Bender
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2009-2016, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
/* Player data at runtime */
#include "C4Include.h"
#include "player/C4Player.h"
#include "control/C4GameControl.h"
#include "game/C4Application.h"
#include "game/C4FullScreen.h"
#include "game/C4GraphicsSystem.h"
#include "game/C4Viewport.h"
#include "graphics/C4GraphicsResource.h"
#include "gui/C4GameMessage.h"
#include "gui/C4GameOverDlg.h"
#include "gui/C4MessageInput.h"
#include "gui/C4MouseControl.h"
#include "landscape/C4Landscape.h"
#include "lib/C4Random.h"
#include "network/C4League.h"
#include "network/C4Network2Stats.h"
#include "object/C4Command.h"
#include "object/C4Def.h"
#include "object/C4DefList.h"
#include "object/C4GameObjects.h"
#include "object/C4Object.h"
#include "object/C4ObjectInfo.h"
#include "object/C4ObjectMenu.h"
#include "platform/C4GamePadCon.h"
#include "player/C4PlayerList.h"
C4Player::C4Player() : C4PlayerInfoCore()
{
Filename[0] = 0;
Number = C4P_Number_None;
ID = 0;
Team = 0;
DefaultRuntimeData();
Menu.Default();
Crew.Default();
CrewInfoList.Default();
LocalControl = false;
BigIcon.Default();
Next = nullptr;
fFogOfWar = true;
LeagueEvaluated = false;
GameJoinTime = 0; // overwritten in Init
pstatControls = pstatActions = nullptr;
ControlCount = ActionCount = 0;
LastControlType = PCID_None;
LastControlID = 0;
pMsgBoardQuery = nullptr;
NoEliminationCheck = false;
Evaluated = false;
ZoomLimitMinWdt = ZoomLimitMinHgt = ZoomLimitMaxWdt = ZoomLimitMaxHgt = ZoomWdt = ZoomHgt = 0;
ZoomLimitMinVal = ZoomLimitMaxVal = ZoomVal = Fix0;
ViewLock = true;
SoundModifier.Set0();
}
C4Player::~C4Player()
{
ClearGraphs();
Menu.Clear();
SetSoundModifier(nullptr);
while (pMsgBoardQuery)
{
C4MessageBoardQuery *pNext = pMsgBoardQuery->pNext;
delete pMsgBoardQuery;
pMsgBoardQuery = pNext;
}
ClearControl();
}
bool C4Player::ObjectInCrew(C4Object *tobj)
{
if (!tobj) return false;
for (C4Object *cobj : Crew)
if (cobj==tobj) return true;
return false;
}
void C4Player::ClearPointers(C4Object *pObj, bool fDeath)
{
// Crew
while (Crew.Remove(pObj)) {}
// View-Cursor
if (ViewCursor==pObj) ViewCursor = nullptr;
// View
if (ViewTarget==pObj) ViewTarget=nullptr;
// Cursor
if (Cursor == pObj)
{
// object is to be deleted; do NOT do script calls (like in Cursor->UnSelect(true))
Cursor = nullptr; AdjustCursorCommand(); // also selects and eventually does a script call!
}
// Menu
Menu.ClearPointers(pObj);
// messageboard-queries
RemoveMessageBoardQuery(pObj);
}
bool C4Player::ScenarioAndTeamInit(int32_t idTeam)
{
C4PlayerInfo *pInfo = GetInfo();
if (!pInfo) return false;
C4Team *pTeam;
if (idTeam == TEAMID_New)
{
// creation of a new team only if allowed by scenario
if (!Game.Teams.IsAutoGenerateTeams())
pTeam = nullptr;
else
{
if ((pTeam = Game.Teams.GetGenerateTeamByID(idTeam))) idTeam = pTeam->GetID();
}
}
else
{
// uage of an existing team
pTeam = Game.Teams.GetTeamByID(idTeam);
}
C4Team *pPrevTeam = Game.Teams.GetTeamByID(Team);
// check if join to team is possible; e.g. not too many players
if (pPrevTeam != pTeam && idTeam)
{
if (!Game.Teams.IsJoin2TeamAllowed(idTeam, pInfo->GetType()))
{
pTeam = nullptr;
}
}
if (!pTeam && idTeam)
{
OnTeamSelectionFailed();
return false;
}
// team selection OK; execute it!
if (pPrevTeam) pPrevTeam->RemovePlayerByID(pInfo->GetID());
if (pTeam) pTeam->AddPlayer(*pInfo, true);
if (!ScenarioInit()) return false;
if (!FinalInit(false)) return false;
// perform any pending InitializePlayers() callback
::Game.OnPlayerJoinFinished();
return true;
}
void C4Player::Execute()
{
if (!Status) return;
// Open/refresh team menu if desired
if (Status==PS_TeamSelection)
{
int32_t idSelectedTeam;
if ((idSelectedTeam = Game.Teams.GetForcedTeamSelection(ID)))
{
// There's only one team left to join? Join there immediately.
if (Menu.IsActive() && Menu.GetIdentification() == C4MN_TeamSelection) Menu.TryClose(false, false);
if (LocalControl && !::Control.isReplay())
{
// team selection done through queue because TeamSelection-status may not be in sync (may be TeamSelectionPending!)
DoTeamSelection(idSelectedTeam);
}
}
else if (!Menu.IsActive()) ActivateMenuTeamSelection(false);
else
{
// during team selection: Update view to selected team, if it has a position assigned
C4MenuItem *pSelectedTeamItem;
if ((pSelectedTeamItem = Menu.GetSelectedItem()))
{
int32_t idSelectedTeam = atoi(pSelectedTeamItem->GetCommand()+8);
if (idSelectedTeam)
{
C4Team *pSelectedTeam;
if ((pSelectedTeam = Game.Teams.GetTeamByID(idSelectedTeam)))
{
int32_t iPlrStartIndex = pSelectedTeam->GetPlrStartIndex();
if (iPlrStartIndex && Inside<int32_t>(iPlrStartIndex, 1, C4S_MaxPlayer))
{
if (Game.C4S.PlrStart[iPlrStartIndex-1].Position[0] > -1)
{
// player has selected a team that has a valid start position assigned
// set view to this position!
ViewX = Game.C4S.PlrStart[iPlrStartIndex-1].Position[0] * ::Landscape.GetMapZoom();
ViewY = Game.C4S.PlrStart[iPlrStartIndex-1].Position[1] * ::Landscape.GetMapZoom();
}
}
}
}
}
}
}
else if (Menu.IsActive() && Menu.GetIdentification() == C4MN_TeamSelection)
{
Menu.TryClose(false, false);
}
// Do we have a gamepad?
if (pGamepad)
{
// Check whether it's still connected.
if (!pGamepad->IsAttached())
{
// Allow the player to plug the gamepad back in. This allows
// battery replacement or plugging the controller back
// in after someone tripped over the wire.
if (!FindGamepad())
{
LogF("%s: No gamepad available.", Name.getData());
::Game.Pause();
}
}
}
// Should we have one? The player may have started the game
// without turning their controller on, only noticing this
// after the game started.
else if (LocalControl && ControlSet && ControlSet->HasGamepad())
{
FindGamepad();
}
// Tick1
UpdateView();
ExecuteControl();
Menu.Execute();
// ::Game.iTick35
if (!::Game.iTick35 && Status==PS_Normal)
{
ExecBaseProduction();
CheckElimination();
if (pMsgBoardQuery && LocalControl) ExecMsgBoardQueries();
}
// Delays
if (MessageStatus>0) MessageStatus--;
if (RetireDelay>0) RetireDelay--;
if (CursorFlash>0) CursorFlash--;
}
bool C4Player::Init(int32_t iNumber, int32_t iAtClient, const char *szAtClientName,
const char *szFilename, bool fScenarioInit, class C4PlayerInfo *pInfo, C4ValueNumbers * numbers)
{
// safety
if (!pInfo)
{
LogF("ERROR: Init player %s failed: No info!", szFilename);
assert(false);
return false;
}
// Status init
Status=PS_Normal;
Number = iNumber;
ID = pInfo->GetID();
Team = pInfo->GetTeam();
NoEliminationCheck = pInfo->IsNoEliminationCheck();
// At client
AtClient=iAtClient; SCopy(szAtClientName,AtClientName,C4MaxTitle);
if (szFilename)
{
// Load core & crew info list
if (!Load(szFilename, !fScenarioInit)) return false;
}
else
{
// no core file present: Keep defaults
// This can happen for script players only
assert(pInfo->GetType() == C4PT_Script);
}
// Take player name from player info; forcing overloads by the league or because of doubled player names
Name.Copy(pInfo->GetName());
// view pos init: Start at center pos
ViewX = ::Landscape.GetWidth()/2; ViewY = ::Landscape.GetHeight()/2;
// Scenario init
if (fScenarioInit)
{
// mark player join in player info list
// for non-scenarioinit, player should already be marked as joined
pInfo->SetJoined(iNumber);
// Number might have changed: Recheck list sorting before scenarioinit, which will do script calls
::Players.RecheckPlayerSort(this);
// check for a postponed scenario init, if no team is specified (post-lobby-join in network, or simply non-network)
C4Team *pTeam = nullptr;
if (Team)
{
if (Game.Teams.IsAutoGenerateTeams())
pTeam = Game.Teams.GetGenerateTeamByID(Team);
else
pTeam = Game.Teams.GetTeamByID(Team);
}
if (!pTeam && Game.Teams.IsRuntimeJoinTeamChoice())
{
if (pInfo->GetType() == C4PT_Script)
{
// script player without team: This can usually not happen, because RecheckPlayerInfoTeams should have been executed
// just leave this player without the team
assert(false);
}
else
{
// postponed init: Chose team first
Status = PS_TeamSelection;
}
}
// Init control method before scenario init, because script callbacks may need to know it!
ClearControl();
InitControl();
// defaultdisabled controls
Control.Init();
// Special: Script players may skip scenario initialization altogether, and just desire a single callback to all objects
// of a given ID
if (!pInfo->IsScenarioInitDesired())
{
// only initialization that's done anyway is team hostility
if (Team) SetTeamHostility();
// callback definition passed?
C4ID idCallback = pInfo->GetScriptPlayerExtraID();
C4Def *pDefCallback;
if (idCallback && (pDefCallback = C4Id2Def(idCallback)))
{
pDefCallback->Call(PSF_InitializeScriptPlayer, &C4AulParSet(Number, Team));
}
}
else
{
// player preinit: In case a team needs to be chosen first, no InitializePlayer-broadcast is done
// this callback shall give scripters a chance to do stuff like starting an intro or enabling FoW, which might need to be done
::Game.GRBroadcast(PSF_PreInitializePlayer, &C4AulParSet(Number));
// direct init
if (Status != PS_TeamSelection) if (!ScenarioInit()) return false;
}
}
// Load runtime data
else
{
assert(pInfo->IsJoined());
assert(numbers);
// (compile using DefaultRuntimeData) - also check if compilation returned sane results, i.e. ID assigned
if (!LoadRuntimeData(Game.ScenarioFile, numbers) || !ID)
{
// for script players in non-savegames, this is OK - it means they get restored using default values
// this happens when the users saves a scenario using the "Save scenario"-option while a script player
// was joined
if (!Game.C4S.Head.SaveGame && pInfo->GetType() == C4PT_Script)
{
Number = pInfo->GetInGameNumber();
ColorDw = pInfo->GetColor();
ID = pInfo->GetID();
Team = pInfo->GetTeam();
}
else
return false;
}
// Reset values default-overriden by old runtime data load (safety?)
if (Number==C4P_Number_None) Number=iNumber;
if (szFilename) SCopy(Config.AtUserDataPath(szFilename),Filename); else *Filename='\0';
// NET2: Direct joins always send accurate client IDs and names in params
// do not overwrite them with savegame data, because players might as well
// change clients
// (only call should be savegame recreation by C4PlayerInfoList::RecreatePlayers)
AtClient = iAtClient;
SCopy(szAtClientName,AtClientName,C4MaxTitle);
// Number might have changed: Recheck list sorting
::Players.RecheckPlayerSort(this);
// Init control after loading runtime data, because control init will overwrite some of the values
InitControl();
}
// store game joining time
GameJoinTime = Game.Time;
// Init FoW-viewobjects: NO_OWNER-FoW-repellers might need to be added
for (C4Object *pObj : Objects)
{
if ((pObj->lightRange || pObj->lightFadeoutRange) && pObj->Owner == NO_OWNER)
pObj->UpdateLight();
}
// init graphs
if (Game.pNetworkStatistics) CreateGraphs();
// init sound mod
SetSoundModifier(SoundModifier.getPropList());
return true;
}
bool C4Player::Save()
{
C4Group hGroup;
// Regular player saving need not be done for script players
if (GetType() == C4PT_Script) return false;
// Log
LogF(LoadResStr("IDS_PRC_SAVEPLR"), Config.AtRelativePath(Filename));
::GraphicsSystem.MessageBoard->EnsureLastMessage();
// copy player to save somewhere else
char szPath[_MAX_PATH + 1];
SCopy(Config.AtTempPath(C4CFN_TempPlayer), szPath, _MAX_PATH);
MakeTempFilename(szPath);
// For local players, we save over the old player file, as there might
// be all kinds of non-essential stuff in it. For non-local players, we
// just re-create it every time (it's temporary anyway).
if (LocalControl)
{
// But make sure to copy it first so full hard (flgr stupid) disks
// won't corrupt any player files...
C4Group_CopyItem(Filename, szPath);
}
else
{
// For non-local players, we can actually use the loaded definition
// list to strip out all non-existant definitions. This is only valid
// because we know the file to be temporary.
CrewInfoList.Strip(::Definitions);
}
// Open group
if (!hGroup.Open(szPath,true))
return false;
// Save
if (!Save(hGroup, false, !LocalControl))
{ hGroup.Close(); return false; }
// Close group
if (!hGroup.Close()) return false;
// resource
C4Network2Res::Ref pRes = ::Network.ResList.getRefRes(Filename),
pDRes = nullptr;
bool fOfficial = pRes && ::Control.isCtrlHost();
if (pRes) pDRes = pRes->Derive();
// move back
if (ItemExists(Filename)) EraseItem(Filename);
if (!C4Group_MoveItem(szPath, Filename)) return false;
// finish update
if (pDRes && fOfficial) pDRes->FinishDerive();
// Success
return true;
}
bool C4Player::Save(C4Group &hGroup, bool fSavegame, bool fStoreTiny)
{
// Save core
if (!C4PlayerInfoCore::Save(hGroup))
return false;
// Save crew
C4DefList *pDefs = &::Definitions;
if (!CrewInfoList.Save(hGroup, fSavegame, fStoreTiny, pDefs))
{ hGroup.Close(); return false; }
// Sort
hGroup.Sort(C4FLS_Player);
return true;
}
void C4Player::PlaceReadyCrew(int32_t tx1, int32_t tx2, int32_t ty, C4Object *FirstBase)
{
int32_t cnt,ctx,cty;
C4Object *nobj;
C4ObjectInfo *pInfo;
C4Def *pDef;
// Place crew
int32_t iCount;
C4ID id;
for (cnt=0; (id=Game.C4S.PlrStart[PlrStartIndex].ReadyCrew.GetID(cnt,&iCount)); cnt++)
{
// Minimum one clonk if empty id
iCount = std::max<int32_t>(iCount,1);
for (int32_t cnt2=0; cnt2<iCount; cnt2++)
{
// Select member from home crew, add new if necessary
while (!(pInfo=CrewInfoList.GetIdle(id,::Definitions)))
if (!CrewInfoList.New(id,&::Definitions))
break;
// Safety
if (!pInfo || !(pDef=C4Id2Def(pInfo->id))) continue;
// Crew placement location
ctx=tx1+Random(tx2-tx1); cty=ty;
if (!Game.C4S.PlrStart[PlrStartIndex].EnforcePosition)
FindSolidGround(ctx,cty,pDef->Shape.Wdt*3);
// Create object
if ((nobj=Game.CreateInfoObject(pInfo,Number,ctx,cty)))
{
// Add object to crew
Crew.Add(nobj, C4ObjectList::stNone);
// add visibility range
nobj->SetLightRange(C4FOW_DefLightRangeX, C4FOW_DefLightFadeoutRangeX);
// If base is present, enter base
if (FirstBase) { nobj->Enter(FirstBase); nobj->SetCommand(C4CMD_Exit); }
// OnJoinCrew callback
{
C4DebugRecOff DbgRecOff{ !DEBUGREC_RECRUITMENT };
C4AulParSet parset(Number);
nobj->Call(PSF_OnJoinCrew, &parset);
}
}
}
}
}
void C4Player::PlaceReadyBase(int32_t &tx, int32_t &ty, C4Object **pFirstBase)
{
int32_t cnt,cnt2,ctx,cty;
C4Def *def;
C4ID cid;
C4Object *cbase;
// Create ready base structures
for (cnt=0; (cid=Game.C4S.PlrStart[PlrStartIndex].ReadyBase.GetID(cnt)); cnt++)
{
if ((def=C4Id2Def(cid)))
for (cnt2=0; cnt2<Game.C4S.PlrStart[PlrStartIndex].ReadyBase.GetCount(cnt); cnt2++)
{
ctx=tx; cty=ty;
if (Game.C4S.PlrStart[PlrStartIndex].EnforcePosition
|| FindConSiteSpot(ctx,cty,def->Shape.Wdt,def->Shape.Hgt,20))
if ((cbase=Game.CreateObjectConstruction(C4Id2Def(cid),nullptr,Number,ctx,cty,FullCon,true)))
{
// FirstBase
if (!(*pFirstBase)) if ((cbase->Def->Entrance.Wdt>0) && (cbase->Def->Entrance.Hgt>0))
{ *pFirstBase=cbase; tx=(*pFirstBase)->GetX(); ty=(*pFirstBase)->GetY(); }
}
}
}
}
void C4Player::PlaceReadyVehic(int32_t tx1, int32_t tx2, int32_t ty, C4Object *FirstBase)
{
int32_t cnt,cnt2,ctx,cty;
C4Def *def; C4ID cid; C4Object *cobj;
for (cnt=0; (cid=Game.C4S.PlrStart[PlrStartIndex].ReadyVehic.GetID(cnt)); cnt++)
{
if ((def=C4Id2Def(cid)))
for (cnt2=0; cnt2<Game.C4S.PlrStart[PlrStartIndex].ReadyVehic.GetCount(cnt); cnt2++)
{
ctx=tx1+Random(tx2-tx1); cty=ty;
if (!Game.C4S.PlrStart[PlrStartIndex].EnforcePosition)
FindLevelGround(ctx,cty,def->Shape.Wdt,6);
if ((cobj=Game.CreateObject(cid,nullptr,Number,ctx,cty)))
{
if (FirstBase) // First base overrides target location
{ cobj->Enter(FirstBase); cobj->SetCommand(C4CMD_Exit); }
}
}
}
}
void C4Player::PlaceReadyMaterial(int32_t tx1, int32_t tx2, int32_t ty, C4Object *FirstBase)
{
int32_t cnt,cnt2,ctx,cty;
C4Def *def; C4ID cid;
// In base
if (FirstBase)
{
FirstBase->CreateContentsByList(Game.C4S.PlrStart[PlrStartIndex].ReadyMaterial);
}
// Outside
else
{
for (cnt=0; (cid=Game.C4S.PlrStart[PlrStartIndex].ReadyMaterial.GetID(cnt)); cnt++)
{
if ((def=C4Id2Def(cid)))
for (cnt2=0; cnt2<Game.C4S.PlrStart[PlrStartIndex].ReadyMaterial.GetCount(cnt); cnt2++)
{
ctx=tx1+Random(tx2-tx1); cty=ty;
if (!Game.C4S.PlrStart[PlrStartIndex].EnforcePosition)
FindSolidGround(ctx,cty,def->Shape.Wdt);
Game.CreateObject(cid,nullptr,Number,ctx,cty);
}
}
}
}
bool C4Player::ScenarioInit()
{
int32_t ptx,pty;
// player start index by team, if specified. Otherwise by player number
PlrStartIndex = Number % C4S_MaxPlayer;
C4Team *pTeam; int32_t i;
if (Team && (pTeam = Game.Teams.GetTeamByID(Team))) if ((i=pTeam->GetPlrStartIndex())) PlrStartIndex=i-1;
C4PlayerInfo *pInfo = GetInfo();
if (!pInfo) { assert(false); LogF("Internal error: ScenarioInit for ghost player %s!", GetName()); return false; }
// set color by player info class
// re-setting, because runtime team choice may have altered color
ColorDw = pInfo->GetColor();
// any team selection is over now
Status = PS_Normal;
// Wealth, home base materials, abilities
Wealth=Game.C4S.PlrStart[PlrStartIndex].Wealth.Evaluate();
BaseMaterial=Game.C4S.PlrStart[PlrStartIndex].BaseMaterial;
BaseMaterial.ConsolidateValids(::Definitions);
BaseProduction=Game.C4S.PlrStart[PlrStartIndex].BaseProduction;
BaseProduction.ConsolidateValids(::Definitions);
Knowledge=Game.C4S.PlrStart[PlrStartIndex].BuildKnowledge;
Knowledge.ConsolidateValids(::Definitions);
// Starting position
ptx = Game.C4S.PlrStart[PlrStartIndex].Position[0];
pty = Game.C4S.PlrStart[PlrStartIndex].Position[1];
// Zoomed position
if (ptx>-1) ptx = Clamp<int32_t>( ptx * Game.C4S.Landscape.MapZoom.Evaluate(), 0, ::Landscape.GetWidth()-1 );
if (pty>-1) pty = Clamp<int32_t>( pty * Game.C4S.Landscape.MapZoom.Evaluate(), 0, ::Landscape.GetHeight()-1 );
// Standard position (PrefPosition)
if (ptx<0)
if (Game.StartupPlayerCount>=2)
{
int32_t iMaxPos=Game.StartupPlayerCount;
// Try to initialize PrefPosition using teams. This should put players of a team next to each other.
int PrefPosition = 0;
C4PlayerInfo *plr;
for (int i = 0; (plr = Game.PlayerInfos.GetPlayerInfoByIndex(i)) != nullptr; i++)
{
if (plr->GetTeam() < Team)
PrefPosition++;
}
// Map preferred position to available positions
int32_t iStartPos=Clamp(PrefPosition*iMaxPos/C4P_MaxPosition,0,iMaxPos-1);
int32_t iPosition=iStartPos;
// Distribute according to availability
while (::Players.PositionTaken(iPosition))
{
++iPosition;
iPosition %= iMaxPos;
if (iPosition == iStartPos)
break;
}
Position=iPosition;
// Set x position
ptx=Clamp(16+Position*(::Landscape.GetWidth()-32)/(iMaxPos-1),0,::Landscape.GetWidth()-16);
}
// All-random position
if (ptx<0) ptx=16+Random(::Landscape.GetWidth()-32);
if (pty<0) pty=16+Random(::Landscape.GetHeight()-32);
// Place to solid ground
if (!Game.C4S.PlrStart[PlrStartIndex].EnforcePosition)
{
// Use nearest above-ground...
FindSolidGround(ptx,pty,30);
// Might have hit a small lake, or similar: Seach a real site spot from here
FindConSiteSpot(ptx, pty, 30, 50, 400);
}
// Place Readies
C4Object *FirstBase = nullptr;
PlaceReadyBase(ptx,pty,&FirstBase);
PlaceReadyMaterial(ptx-10,ptx+10,pty,FirstBase);
PlaceReadyVehic(ptx-30,ptx+30,pty,FirstBase);
PlaceReadyCrew(ptx-30,ptx+30,pty,FirstBase);
// set initial hostility by team info
if (Team) SetTeamHostility();
// Scenario script initialization
::Game.GRBroadcast(PSF_InitializePlayer, &C4AulParSet(Number,
ptx,
pty,
FirstBase,
Team,
C4Id2Def(GetInfo()->GetScriptPlayerExtraID())));
return true;
}
bool C4Player::FinalInit(bool fInitialScore)
{
if (!Status) return true;
// Init player's mouse control
if (LocalControl)
if (MouseControl)
::MouseControl.Init(Number);
// Set initial score
if (fInitialScore)
{
InitialScore=CurrentScore;
}
// Cursor
if (!Cursor) AdjustCursorCommand();
// Update counts, pointers, views
Execute();
return true;
}
void C4Player::SetFoW(bool fEnable)
{
// set flag
fFogOfWar = fEnable;
}
bool C4Player::DoWealth(int32_t iChange)
{
if (LocalControl)
{
if (iChange>0) StartSoundEffect("UI::Cash");
if (iChange<0) StartSoundEffect("UI::UnCash");
}
SetWealth(Wealth+iChange);
return true;
}
bool C4Player::SetWealth(int32_t iVal)
{
if (iVal == Wealth) return true;
Wealth=Clamp<int32_t>(iVal,0,1000000000);
::Game.GRBroadcast(PSF_OnWealthChanged,&C4AulParSet(Number));
return true;
}
bool C4Player::SetKnowledge(C4ID id, bool fRemove)
{
if (fRemove)
{
long iIndex = Knowledge.GetIndex(id);
if (iIndex<0) return false;
return Knowledge.DeleteItem(iIndex);
}
else
{
if (!C4Id2Def(id)) return false;
return Knowledge.SetIDCount(id, 1, true);
}
}
void C4Player::SetViewMode(int32_t iMode, C4Object *pTarget, bool immediate_position)
{
// safe back
ViewMode=iMode; ViewTarget=pTarget;
// immediate position set desired?
if (immediate_position)
{
UpdateView();
C4Viewport *vp = ::Viewports.GetViewport(this->Number);
if (vp) vp->AdjustPosition(true);
}
}
void C4Player::ResetCursorView(bool immediate_position)
{
// reset view to cursor if any cursor exists
if (!ViewCursor && !Cursor) return;
SetViewMode(C4PVM_Cursor, nullptr, immediate_position);
}
void C4Player::Evaluate()
{
// do not evaluate twice
if (Evaluated) return;
const int32_t SuccessBonus=100;
// Set last round
LastRound.Title = Game.ScenarioTitle;
time(reinterpret_cast<time_t *>(&LastRound.Date));
LastRound.Duration = Game.Time;
LastRound.Won = !Eliminated;
// Melee: personal value gain score ...check ::Objects(C4D_Goal)
if (Game.C4S.Game.IsMelee()) LastRound.Score = std::max<int32_t>(CurrentScore-InitialScore,0);
// Cooperative: shared score
else LastRound.Score = std::max(::Players.AverageScoreGain(),0);
LastRound.Level = 0; // unknown...
LastRound.Bonus = SuccessBonus * LastRound.Won;
LastRound.FinalScore = LastRound.Score + LastRound.Bonus;
LastRound.TotalScore = TotalScore + LastRound.FinalScore;
// Update player
Rounds++;
if (LastRound.Won) RoundsWon++; else RoundsLost++;
TotalScore=LastRound.TotalScore;
TotalPlayingTime+=Game.Time-GameJoinTime;
// Crew
CrewInfoList.Evaluate();
// league
if (Game.Parameters.isLeague())
EvaluateLeague(false, Game.GameOver && !Eliminated);
// Player is now evaluated
Evaluated = true;
// round results
Game.RoundResults.EvaluatePlayer(this);
}
void C4Player::Surrender()
{
if (Surrendered) return;
Surrendered=true;
Eliminated=true;
RetireDelay=C4RetireDelay;
StartSoundEffect("UI::Eliminated");
Log(FormatString(LoadResStr("IDS_PRC_PLRSURRENDERED"),GetName()).getData());
}
bool C4Player::SetHostility(int32_t iOpponent, int32_t hostile, bool fSilent)
{
assert(hostile == 0 || hostile == 1);
// Check opponent valid
C4Player *opponent = ::Players.Get(iOpponent);
if (!opponent || opponent == this)
return false;
// Set hostility
if (hostile)
Hostility.insert(opponent);
else
Hostility.erase(opponent);
// no announce in first frame, or if specified
if (!Game.FrameCounter || fSilent) return true;
// Announce
StartSoundEffect("UI::Trumpet");
Log(FormatString(LoadResStr(hostile ? "IDS_PLR_HOSTILITY" : "IDS_PLR_NOHOSTILITY"),
GetName(),opponent->GetName()).getData());
// Success
return true;
}
bool C4Player::IsHostileTowards(const C4Player *plr) const
{
assert(plr);
if (!plr) return false;
return Hostility.find(plr) != Hostility.end();
}
C4Object* C4Player::GetHiExpActiveCrew()
{
C4Object *hiexp=nullptr;
int32_t iHighestExp=-2, iExp;
for (C4Object *cobj : Crew)
{
if (!cobj->CrewDisabled)
{
if (cobj->Info) iExp = cobj->Info->Experience; else iExp=-1;
if (!hiexp || (iExp>iHighestExp))
{
hiexp=cobj;
iHighestExp=iExp;
}
}
}
return hiexp;
}
C4Object* C4Player::GetHiRankActiveCrew()
{
C4Object *hirank=nullptr;
int32_t iHighestRank=-2, iRank;
for (C4Object *cobj : Crew)
{
if (!cobj->CrewDisabled)
{
if (cobj->Info) iRank = cobj->Info->Rank; else iRank=-1;
if (!hirank || (iRank>iHighestRank))
{
hirank=cobj;
iHighestRank=iRank;
}
}
}
return hirank;
}
void C4Player::CheckCrewExPromotion()
{
C4Object *hirank;
if ((hirank=GetHiRankActiveCrew()))
if (hirank->Info)
if (hirank->Info->Rank<1) // No Fähnrich -> except. promo.
if ((hirank=GetHiExpActiveCrew()))
hirank->Promote(1,true,false);
}
void C4Player::SetTeamHostility()
{
// team only
if (!Team) return;
// set hostilities
for (C4Player *pPlr = ::Players.First; pPlr; pPlr = pPlr->Next)
if (pPlr != this)
{
bool fHostile = (pPlr->Team != Team);
SetHostility(pPlr->Number, fHostile, true);
pPlr->SetHostility(Number, fHostile, true);
}
}
bool C4Player::Message(const char *szMsg)
{
if (!szMsg) return false;
SCopy(szMsg,MessageBuf,256);
MessageStatus=SLen(szMsg)*2;
return true;
}
bool C4Player::Load(const char *szFilename, bool fSavegame)
{
C4Group hGroup;
// Open group
if (!Reloc.Open(hGroup, szFilename)) return false;
// Remember filename
SCopy(hGroup.GetFullName().getData(), Filename, _MAX_PATH);
// Load core
if (!C4PlayerInfoCore::Load(hGroup))
{ hGroup.Close(); return false; }
// Load BigIcon
if (hGroup.FindEntry(C4CFN_BigIcon)) BigIcon.Load(hGroup, C4CFN_BigIcon, C4FCT_Full, C4FCT_Full, false, 0);
// Load crew info list
CrewInfoList.Load(hGroup);
// Close group
hGroup.Close();
// Success
return true;
}
bool C4Player::Strip(const char *szFilename, bool fAggressive)
{
// Open group
C4Group Grp;
if (!Grp.Open(szFilename))
return false;
// Which type of stripping?
if (!fAggressive)
{
// remove bigicon, if the file size is too large
size_t iBigIconSize=0;
if (Grp.FindEntry(C4CFN_BigIcon, nullptr, &iBigIconSize))
if (iBigIconSize > C4NetResMaxBigicon*1024)
Grp.Delete(C4CFN_BigIcon);
Grp.Close();
}
else
{
// Load info core and crew info list
C4PlayerInfoCore PlrInfoCore;
C4ObjectInfoList CrewInfoList;
if (!PlrInfoCore.Load(Grp) || !CrewInfoList.Load(Grp))
return false;
// Strip crew info list (remove object infos that are invalid for this scenario)
CrewInfoList.Strip(::Definitions);
// Create a new group that receives the bare essentials
Grp.Close();
if (!EraseItem(szFilename) ||
!Grp.Open(szFilename, true))
return false;
// Save info core & crew info list to newly-created file
if (!PlrInfoCore.Save(Grp) || !CrewInfoList.Save(Grp, true, true, &::Definitions))
return false;
Grp.Close();
}
return true;
}
void C4Player::DrawHostility(C4Facet &cgo, int32_t iIndex)
{
C4Player *pPlr;
if ((pPlr=::Players.GetByIndex(iIndex)))
{
::GraphicsResource.fctCrewClr.DrawClr(cgo, true, pPlr->ColorDw);
// Other player and hostile
if (pPlr != this)
if (Hostility.find(pPlr) != Hostility.end())
::GraphicsResource.fctMenu.GetPhase(7).Draw(cgo);
}
}
bool C4Player::MakeCrewMember(C4Object *pObj, bool fForceInfo, bool fDoCalls)
{
C4ObjectInfo *cInf = nullptr;
if (!pObj || !pObj->Def->CrewMember || !pObj->Status) return false;
// only if info is not yet assigned
if (!pObj->Info && fForceInfo)
{
// Find crew info by name
if (pObj->nInfo)
cInf = CrewInfoList.GetIdle(pObj->nInfo.getData());
// Find crew info by id
if (!cInf)
while (!( cInf = CrewInfoList.GetIdle(pObj->id,::Definitions) ))
if (!CrewInfoList.New(pObj->id,&::Definitions))
return false;
// Set object info
pObj->Info = cInf;
pObj->SetName(cInf->Name);
}
// Add to crew
if (!Crew.GetLink(pObj))
Crew.Add(pObj, C4ObjectList::stNone);
// add light
if (!pObj->lightRange)
pObj->SetLightRange(C4FOW_DefLightRangeX, C4FOW_DefLightFadeoutRangeX);
else
pObj->UpdateLight();
// controlled by the player
pObj->Controller = Number;
// OnJoinCrew callback
if (fDoCalls)
{
C4AulParSet parset(Number);
pObj->Call(PSF_OnJoinCrew, &parset);
}
return true;
}
void C4Player::ExecuteControl()
{
Control.Execute();
}
void C4Player::AdjustCursorCommand()
{
// Reset view
ResetCursorView();
// Default cursor to hirank clonk
if (!Cursor || Cursor->CrewDisabled)
{
C4Object *pHiRank = GetHiRankActiveCrew();
if (!pHiRank)
return;
SetCursor(pHiRank,true);
UpdateView();
}
}
void C4Player::CompileFunc(StdCompiler *pComp, C4ValueNumbers * numbers)
{
assert(ID);
pComp->Value(mkNamingAdapt(Status, "Status", 0));
pComp->Value(mkNamingAdapt(AtClient, "AtClient", C4ClientIDUnknown));
pComp->Value(mkNamingAdapt(toC4CStr(AtClientName),"AtClientName", "Local"));
pComp->Value(mkNamingAdapt(Number, "Index", C4P_Number_None));
pComp->Value(mkNamingAdapt(ID, "ID", 0));
pComp->Value(mkNamingAdapt(Eliminated, "Eliminated", 0));
pComp->Value(mkNamingAdapt(Surrendered, "Surrendered", 0));
pComp->Value(mkNamingAdapt(Evaluated, "Evaluated", false));
pComp->Value(mkNamingAdapt(ColorDw, "ColorDw", 0u));
pComp->Value(mkNamingAdapt(Position, "Position", 0));
pComp->Value(mkNamingAdapt(ViewMode, "ViewMode", C4PVM_Cursor));
pComp->Value(mkNamingAdapt(ViewX, "ViewX", 0));
pComp->Value(mkNamingAdapt(ViewY, "ViewY", 0));
pComp->Value(mkNamingAdapt(ViewLock, "ViewLock", true));
pComp->Value(mkNamingAdapt(ZoomLimitMinWdt, "ZoomLimitMinWdt", 0));
pComp->Value(mkNamingAdapt(ZoomLimitMinHgt, "ZoomLimitMinHgt", 0));
pComp->Value(mkNamingAdapt(ZoomLimitMaxWdt, "ZoomLimitMaxWdt", 0));
pComp->Value(mkNamingAdapt(ZoomLimitMaxHgt, "ZoomLimitMaxHgt", 0));
pComp->Value(mkNamingAdapt(ZoomWdt, "ZoomWdt", 0));
pComp->Value(mkNamingAdapt(ZoomHgt, "ZoomHgt", 0));
pComp->Value(mkNamingAdapt(ZoomLimitMinVal, "ZoomLimitMinVal", Fix0));
pComp->Value(mkNamingAdapt(ZoomLimitMaxVal, "ZoomLimitMaxVal", Fix0));
pComp->Value(mkNamingAdapt(ZoomVal, "ZoomVal", Fix0));
pComp->Value(mkNamingAdapt(fFogOfWar, "FogOfWar", false));
pComp->Value(mkNamingAdapt(ShowStartup, "ShowStartup", false));
pComp->Value(mkNamingAdapt(Wealth, "Wealth", 0));
pComp->Value(mkNamingAdapt(CurrentScore, "Score", 0));
pComp->Value(mkNamingAdapt(InitialScore, "InitialScore", 0));
pComp->Value(mkNamingAdapt(ObjectsOwned, "ObjectsOwned", 0));
pComp->Value(mkNamingAdapt(Hostility, "Hostile" ));
pComp->Value(mkNamingAdapt(ProductionDelay, "ProductionDelay", 0));
pComp->Value(mkNamingAdapt(ProductionUnit, "ProductionUnit", 0));
pComp->Value(mkNamingAdapt(CursorFlash, "CursorFlash", 0));
pComp->Value(mkNamingAdapt(Cursor, "Cursor", C4ObjectPtr::Null));
pComp->Value(mkNamingAdapt(ViewCursor, "ViewCursor", C4ObjectPtr::Null));
pComp->Value(mkNamingAdapt(MessageStatus, "MessageStatus", 0));
pComp->Value(mkNamingAdapt(toC4CStr(MessageBuf),"MessageBuf", ""));
pComp->Value(mkNamingAdapt(BaseMaterial, "BaseMaterial" ));
pComp->Value(mkNamingAdapt(BaseProduction, "BaseProduction" ));
pComp->Value(mkNamingAdapt(Knowledge, "Knowledge" ));
pComp->Value(mkNamingAdapt(mkParAdapt(Crew, numbers), "Crew" ));
pComp->Value(mkNamingAdapt(CrewInfoList.iNumCreated, "CrewCreated", 0));
pComp->Value(mkNamingPtrAdapt( pMsgBoardQuery, "MsgBoardQueries" ));
pComp->Value(mkNamingAdapt(mkParAdapt(SoundModifier, numbers), "SoundModifier", C4Value()));
if (pComp->isDeserializer())
{
SoundModifier.Denumerate(numbers);
}
// Keys held down
pComp->Value(Control);
}
bool C4Player::LoadRuntimeData(C4Group &hGroup, C4ValueNumbers * numbers)
{
const char *pSource;
// Use loaded game text component
if (!(pSource = Game.GameText.GetData())) return false;
// safety: Do nothing if player section is not even present (could kill initialized values)
if (!SSearch(pSource, FormatString("[Player%i]", ID).getData())) return false;
// Compile (Search player section - runtime data is stored by unique player ID)
// Always compile exact. Exact data will not be present for savegame load, so it does not matter
assert(ID);
if (!CompileFromBuf_LogWarn<StdCompilerINIRead>(
mkNamingAdapt(mkParAdapt(*this, numbers), FormatString("Player%i", ID).getData()),
StdStrBuf(pSource),
Game.GameText.GetFilePath()))
return false;
// Denumerate pointers
DenumeratePointers();
// Success
return true;
}
void C4Player::ExecBaseProduction()
{
const int32_t MaxBaseProduction = 25;
ProductionDelay++;
if (ProductionDelay>=60) // Minute Production Unit
{
ProductionDelay=0; ProductionUnit++;
for (int32_t cnt=0; BaseProduction.GetID(cnt); cnt++)
if (BaseProduction.GetCount(cnt)>0)
if (ProductionUnit % Clamp<int32_t>(11-BaseProduction.GetCount(cnt),1,10) ==0)
if (BaseMaterial.GetIDCount(BaseProduction.GetID(cnt)) < MaxBaseProduction)
BaseMaterial.IncreaseIDCount(BaseProduction.GetID(cnt));
}
}
void C4Player::CheckElimination()
{
// Standard elimination: no crew
if (!Crew.GetFirstObject())
// Already eliminated safety
if (!Eliminated)
// No automatic elimination desired?
if (!NoEliminationCheck)
// Do elimination!
Eliminate();
}
void C4Player::UpdateView()
{
// view target/cursor
switch (ViewMode)
{
case C4PVM_Cursor:
{
C4Object *pViewObj;
if (!(pViewObj=ViewCursor)) pViewObj=Cursor;
if (pViewObj)
{
ViewX=pViewObj->GetX(); ViewY=pViewObj->GetY();
}
break;
}
case C4PVM_Target:
if (ViewTarget)
{
ViewX=ViewTarget->GetX(); ViewY=ViewTarget->GetY();
}
break;
case C4PVM_Scrolling:
break;
}
}
void C4Player::DefaultRuntimeData()
{
Status=0;
Eliminated=0;
Surrendered=0;
AtClient=C4ClientIDUnknown;
SCopy("Local",AtClientName);
ControlSet = nullptr;
ControlSetName.Clear();
MouseControl=false;
Position=-1;
PlrStartIndex=0;
RetireDelay=0;
ViewMode=C4PVM_Cursor;
ViewX=ViewY=0;
ViewTarget=nullptr;
ShowStartup=true;
Wealth=0;
CurrentScore=InitialScore=0;
ObjectsOwned=0;
ProductionDelay=ProductionUnit=0;
Cursor=ViewCursor=nullptr;
CursorFlash=30;
MessageStatus=0;
MessageBuf[0]=0;
Hostility.clear();
BaseMaterial.Default();
BaseProduction.Default();
Knowledge.Default();
FlashCom=0;
}
bool C4Player::ActivateMenuTeamSelection(bool fFromMain)
{
// Menu symbol/init
bool fSwitch = !(Status==PS_TeamSelection);
Menu.InitRefSym(C4GUI::Icon::GetIconFacet(C4GUI::Ico_Team),LoadResStr("IDS_MSG_SELTEAM"),Number, C4MN_Extra_None, 0, fSwitch ? C4MN_TeamSwitch : C4MN_TeamSelection);
Menu.SetAlignment(fSwitch ? C4MN_Align_Left | C4MN_Align_Bottom : 0);
Menu.Refill();
// Go back to options menu on close
if (fFromMain) Menu.SetCloseCommand("ActivateMenu:Main");
return true;
}
void C4Player::DoTeamSelection(int32_t idTeam)
{
// stop team selection. This might close the menu forever if the control gets lost
// let's hope it doesn't!
Status = PS_TeamSelectionPending;
::Control.DoInput(CID_PlrAction, C4ControlPlayerAction::InitScenarioPlayer(this, idTeam), CDT_Queue);
}
void C4Player::DenumeratePointers()
{
// Crew
Crew.DenumeratePointers();
// Cursor
Cursor.DenumeratePointers();
// ViewCursor
ViewCursor.DenumeratePointers();
// messageboard-queries
for (C4MessageBoardQuery *pCheck = pMsgBoardQuery; pCheck; pCheck = pCheck->pNext)
pCheck->CallbackObj.DenumeratePointers();
}
void C4Player::RemoveCrewObjects()
{
C4Object *pCrew;
// Remove all crew objects
while ((pCrew = Crew.GetObject())) pCrew->AssignRemoval(true);
}
int32_t C4Player::FindNewOwner() const
{
int32_t iNewOwner = NO_OWNER;
C4Team *pTeam;
if (Team) if ((pTeam = Game.Teams.GetTeamByID(Team)))
{
for (int32_t i=0; i<pTeam->GetPlayerCount(); ++i)
{
int32_t iPlrID = pTeam->GetIndexedPlayer(i);
if (iPlrID && iPlrID != ID)
{
C4PlayerInfo *pPlrInfo = Game.PlayerInfos.GetPlayerInfoByID(iPlrID);
if (pPlrInfo) if (pPlrInfo->IsJoined())
{
// this looks like a good new owner
iNewOwner = pPlrInfo->GetInGameNumber();
break;
}
}
}
}
// if noone from the same team was found, try to find another non-hostile player
// (necessary for cooperative rounds without teams)
if (iNewOwner == NO_OWNER)
for (C4Player *pOtherPlr = ::Players.First; pOtherPlr; pOtherPlr = pOtherPlr->Next)
if (pOtherPlr != this) if (!pOtherPlr->Eliminated)
if (!::Players.Hostile(pOtherPlr->Number, Number))
iNewOwner = pOtherPlr->Number;
return iNewOwner;
}
void C4Player::NotifyOwnedObjects()
{
int32_t iNewOwner = FindNewOwner();
// notify objects in all object lists
for (C4ObjectList *pList = &::Objects; pList; pList = ((pList == &::Objects) ? &::Objects.InactiveObjects : nullptr))
{
for (C4Object *cobj : *pList)
{
if (cobj->Status && cobj->Owner == Number)
{
C4AulFunc *pFn = cobj->GetFunc(PSF_OnOwnerRemoved);
if (pFn)
{
C4AulParSet pars(iNewOwner);
pFn->Exec(cobj, &pars);
}
else
{
// crew members: Those are removed later (AFTER the player has been removed, for backwards compatiblity with relaunch scripting)
if (Crew.IsContained(cobj))
continue;
// Regular objects: Try to find a new, suitable owner from the same team
// Ignore StaticBack, because this would not be compatible with many internal objects such as team account
if ((cobj->Category & C4D_StaticBack) == 0)
cobj->SetOwner(iNewOwner);
}
}
}
}
}
bool C4Player::DoScore(int32_t iChange)
{
CurrentScore = Clamp<int32_t>( CurrentScore+iChange, -100000, 100000 );
return true;
}
void C4Player::SetCursor(C4Object *pObj, bool fSelectArrow)
{
// check disabled
if (pObj) if (pObj->CrewDisabled) return;
bool fChanged = pObj != Cursor;
C4Object *pPrev = Cursor;
// Set cursor
Cursor=pObj;
// unselect previous
if (pPrev && fChanged) pPrev->UnSelect();
// Select object
if (fChanged && Cursor) { Cursor->DoSelect(); }
// View flash
if (fSelectArrow) CursorFlash=30;
}
void C4Player::ScrollView(float iX, float iY, float ViewWdt, float ViewHgt)
{
if (ViewLock) return;
SetViewMode(C4PVM_Scrolling);
float ViewportScrollBorder = Application.isEditor ? 0 : C4ViewportScrollBorder;
ViewX = Clamp<C4Real>( ViewX+ftofix(iX), ftofix(ViewWdt/2.0f-ViewportScrollBorder), ftofix(::Landscape.GetWidth()+ViewportScrollBorder-ViewWdt/2.0f) );
ViewY = Clamp<C4Real>( ViewY+ftofix(iY), ftofix(ViewHgt/2.0f-ViewportScrollBorder), ftofix(::Landscape.GetHeight()+ViewportScrollBorder-ViewHgt/2.0f) );
}
void C4Player::ClearControl()
{
// Mark any control set as unused
Control.Clear();
// Reset control
LocalControl = false;
ControlSetName.Clear();
ControlSet=nullptr;
MouseControl = false;
if (pGamepad)
{
pGamepad->SetPlayer(NO_OWNER);
pGamepad.reset();
}
// no controls issued yet
ControlCount = ActionCount = 0;
LastControlType = PCID_None;
LastControlID = 0;
}
void C4Player::InitControl()
{
// Check local control
if (AtClient == ::Control.ClientID())
if (!GetInfo() || GetInfo()->GetType() == C4PT_User)
if (!::Control.isReplay())
LocalControl=true;
// needs to init control for local players only
if (LocalControl)
{
// Preferred control
ControlSetName = PrefControl;
ControlSet = Game.PlayerControlUserAssignmentSets.GetSetByName(ControlSetName.getData());
// control set unassigned/not known? fallback to some default then (=first defined control set)
if (!ControlSet) ControlSet = Game.PlayerControlUserAssignmentSets.GetDefaultSet();
// gamepad control safety (assuming the default control set is not using gamepad)
if (ControlSet && ControlSet->HasGamepad() && !Config.General.GamepadEnabled)
{
ControlSet = Game.PlayerControlUserAssignmentSets.GetDefaultSet();
}
// Choose next while control taken
// TODO
// init gamepad
if (ControlSet && ControlSet->HasGamepad())
{
if (!FindGamepad())
{
LogF("No gamepad available for %s, please plug one in!", Name.getData());
::Game.Pause();
}
}
// Mouse
if (ControlSet && ControlSet->HasMouse() && PrefMouse)
if (!::Players.MouseControlTaken())
MouseControl=true;
// Some controls such as gamepad control need special synced GUI elements
// Do a script callback for selected control
::Control.DoInput(CID_PlrAction, C4ControlPlayerAction::InitPlayerControl(this, ControlSet), CDT_Queue);
}
// clear old control method and register new
Control.RegisterKeyset(Number, ControlSet);
}
bool C4Player::FindGamepad()
{
auto newPad = Application.pGamePadControl->GetAvailableGamePad();
if (!newPad) return false;
newPad->SetPlayer(ID);
// Release the old gamepad.
if (pGamepad) pGamepad->SetPlayer(NO_OWNER);
pGamepad = newPad;
LogF("%s: Using gamepad #%d.", Name.getData(), pGamepad->GetID());
return true;
}
int igOffX, igOffY;
int VisibilityCheck(int iVis, int sx, int sy, int cx, int cy)
{
sx -= igOffX; sy -= igOffY; cx -= igOffX; cy -= igOffY;
int st = std::max(1, std::max(Abs(sx - cx), Abs(sy - cy)));
for (int i = 0; i <= st; i++)
{
int x = (sx * (st - i) + cx * i) / st, y = (sy * (st - i) + cy * i) / st;
if (GBackSolid(x, y))
{
if ((iVis -= 2) <= 0)
return 0;
}
}
return iVis;
}
void C4Player::CloseMenu()
{
// cancel all player menus
Menu.Close(false);
}
void C4Player::Eliminate()
{
if (Eliminated) return;
Eliminated=true;
RetireDelay=C4RetireDelay;
StartSoundEffect("UI::Eliminated");
Log(FormatString(LoadResStr("IDS_PRC_PLRELIMINATED"),GetName()).getData());
// Early client deactivation check
if (::Control.isCtrlHost() && AtClient > C4ClientIDHost && !::Application.isEditor)
{
// Check: Any player left at this client?
C4Player *pPlr = nullptr;
for (int i = 0; (pPlr = ::Players.GetAtClient(AtClient, i)); i++)
if (!pPlr->Eliminated)
break;
// If not, deactivate the client
if (!pPlr)
::Control.DoInput(CID_ClientUpdate,
new C4ControlClientUpdate(AtClient, CUT_Activate, false),
CDT_Sync);
}
}
int32_t C4Player::ActiveCrewCount()
{
// get number of objects in crew that is not disabled
int32_t iNum=0;
for (C4Object *cObj : Crew)
if (cObj)
if (!cObj->CrewDisabled)
++iNum;
// return it
return iNum;
}
int32_t C4Player::GetSelectedCrewCount()
{
if (Cursor && !Cursor->CrewDisabled)
return 1;
return 0;
}
void C4Player::EvaluateLeague(bool fDisconnected, bool fWon)
{
// already evaluated?
if (LeagueEvaluated) return;
LeagueEvaluated=true;
// set fate
C4PlayerInfo *pInfo = GetInfo();
if (pInfo)
{
if (fDisconnected)
pInfo->SetDisconnected();
if (fWon)
pInfo->SetWinner();
}
}
bool C4Player::LocalSync()
{
// local sync not necessary for script players
if (GetType() == C4PT_Script) return true;
// evaluate total playing time
TotalPlayingTime+=Game.Time-GameJoinTime;
GameJoinTime = Game.Time;
// evaluate total playing time of all the crew
for (C4ObjectInfo *pInf = CrewInfoList.GetFirst(); pInf; pInf=pInf->Next)
if (pInf->InAction)
{
pInf->TotalPlayingTime+=(Game.Time-pInf->InActionTime);
pInf->InActionTime = Game.Time;
}
// save player
if (!Save())
return false;
// done, success
return true;
}
C4PlayerInfo *C4Player::GetInfo()
{
return Game.PlayerInfos.GetPlayerInfoByID(ID);
}
bool C4Player::SetObjectCrewStatus(C4Object *pCrew, bool fNewStatus)
{
// either add...
if (fNewStatus)
{
// is in crew already?
if (Crew.IsContained(pCrew)) return true;
return MakeCrewMember(pCrew, false);
}
else
{
// already outside?
if (!Crew.IsContained(pCrew)) return true;
// ...or remove
Crew.Remove(pCrew);
C4AulParSet parset(Number);
pCrew->Call(PSF_OnRemoveCrew, &parset);
// remove info, if assigned to this player
// theoretically, info objects could remain when the player is deleted
// but then they would be reassigned to the player crew when loaded in a savegame
// by the crew-assignment code kept for backwards compatibility with pre-4.95.2-savegames
if (pCrew->Info && CrewInfoList.IsElement(pCrew->Info))
{
pCrew->Info->Retire();
pCrew->Info = nullptr;
}
}
// done, success
return true;
}
void C4Player::CreateGraphs()
{
// del prev
ClearGraphs();
// create graphs
if (Game.pNetworkStatistics)
{
DWORD dwGraphClr = ColorDw;
C4PlayerInfo *pInfo;
if (ID && (pInfo = Game.PlayerInfos.GetPlayerInfoByID(ID)))
{
// set color by player info class
dwGraphClr = pInfo->GetColor();
}
C4GUI::MakeColorReadableOnBlack(dwGraphClr); dwGraphClr &= 0xffffff;
pstatControls = new C4TableGraph(C4TableGraph::DefaultBlockLength * 20, Game.pNetworkStatistics->ControlCounter);
pstatControls->SetColorDw(dwGraphClr);
pstatControls->SetTitle(GetName());
pstatActions = new C4TableGraph(C4TableGraph::DefaultBlockLength * 20, Game.pNetworkStatistics->ControlCounter);
pstatActions->SetColorDw(dwGraphClr);
pstatActions->SetTitle(GetName());
// register into
Game.pNetworkStatistics->statControls.AddGraph(pstatControls);
Game.pNetworkStatistics->statActions.AddGraph(pstatActions);
}
}
void C4Player::ClearGraphs()
{
// del all assigned graphs
if (pstatControls)
{
if (Game.pNetworkStatistics) Game.pNetworkStatistics->statControls.RemoveGraph(pstatControls);
delete pstatControls;
pstatControls = nullptr;
}
if (pstatActions)
{
if (Game.pNetworkStatistics) Game.pNetworkStatistics->statActions.RemoveGraph(pstatActions);
delete pstatActions;
pstatActions = nullptr;
}
}
void C4Player::CountControl(ControlType eType, int32_t iID, int32_t iCntAdd)
{
// count it
ControlCount += iCntAdd;
// catch doubles
if (eType == LastControlType && iID == LastControlID) return;
// no double: count as action
LastControlType = eType;
LastControlID = iID;
ActionCount += iCntAdd;
// and give experience
if (Cursor && Cursor->Info)
{
if (Cursor->Info)
{
Cursor->Info->ControlCount++; if ((Cursor->Info->ControlCount%5) == 0) Cursor->DoExperience(+1);
}
}
}
void C4Player::ExecMsgBoardQueries()
{
// already active?
if (::MessageInput.IsTypeIn()) return;
// find an un-evaluated query
C4MessageBoardQuery *pCheck = pMsgBoardQuery;
while (pCheck) if (!pCheck->fAnswered) break; else pCheck = pCheck->pNext;
if (!pCheck) return;
// open it
::MessageInput.StartTypeIn(true, pCheck->CallbackObj, pCheck->fIsUppercase, false, Number, pCheck->sInputQuery);
}
void C4Player::CallMessageBoard(C4Object *pForObj, const StdStrBuf &sQueryString, bool fIsUppercase)
{
// remove any previous query for the same object
RemoveMessageBoardQuery(pForObj);
// sort new query to end of list
C4MessageBoardQuery **ppTarget = &pMsgBoardQuery;
while (*ppTarget) ppTarget = &((*ppTarget)->pNext);
*ppTarget = new C4MessageBoardQuery(pForObj, sQueryString, fIsUppercase);
}
bool C4Player::RemoveMessageBoardQuery(C4Object *pForObj)
{
// get matching query
C4MessageBoardQuery **ppCheck = &pMsgBoardQuery, *pFound;
while (*ppCheck) if ((*ppCheck)->CallbackObj == pForObj) break; else ppCheck = &((*ppCheck)->pNext);
pFound = *ppCheck;
if (!pFound) return false;
// remove it
*ppCheck = (*ppCheck)->pNext;
delete pFound;
return true;
}
bool C4Player::MarkMessageBoardQueryAnswered(C4Object *pForObj)
{
// get matching query
C4MessageBoardQuery *pCheck = pMsgBoardQuery;
while (pCheck) if (pCheck->CallbackObj == pForObj && !pCheck->fAnswered) break; else pCheck = pCheck->pNext;
if (!pCheck) return false;
// mark it
pCheck->fAnswered = true;
return true;
}
bool C4Player::HasMessageBoardQuery()
{
// return whether any object has a messageboard-query
return !!pMsgBoardQuery;
}
void C4Player::OnTeamSelectionFailed()
{
// looks like a selected team was not available: Go back to team selection if this is not a mislead call
if (Status == PS_TeamSelectionPending)
Status = PS_TeamSelection;
}
void C4Player::SetPlayerColor(uint32_t dwNewClr)
{
// no change?
if (dwNewClr == ColorDw) return;
// reflect change in all active, player-owned objects
// this can never catch everything (thinking of overlays, etc.); scenarios that allow team changes should take care of the rest
uint32_t dwOldClr = ColorDw;
ColorDw = dwNewClr;
for (C4Object *pObj : Objects)
if (pObj && pObj->Status && pObj->Owner == Number)
{
if ((pObj->Color & 0xffffff) == (dwOldClr & 0xffffff))
pObj->Color = (pObj->Color & 0xff000000u) | (dwNewClr & 0xffffff);
}
}
C4PlayerType C4Player::GetType() const
{
// type by info
C4PlayerInfo *pInfo = Game.PlayerInfos.GetPlayerInfoByID(ID);
if (pInfo) return pInfo->GetType(); else { assert(false); return C4PT_User; }
}
bool C4Player::IsInvisible() const
{
// invisible by info
C4PlayerInfo *pInfo = Game.PlayerInfos.GetPlayerInfoByID(ID);
if (pInfo) return pInfo->IsInvisible(); else { assert(false); return false; }
}
void C4Player::ToggleMouseControl()
{
// Activate mouse control if it's available
if (!MouseControl && !::Players.MouseControlTaken())
{
::MouseControl.Init(Number);
MouseControl=true;
}
// Deactivate mouse control
else if (MouseControl)
{
::MouseControl.Clear();
::MouseControl.Default();
MouseControl = 0;
// Scrolling isn't possible any more
if (ViewMode == C4PVM_Scrolling)
SetViewMode(C4PVM_Cursor);
}
}
bool C4Player::ActivateMenuMain()
{
// Not during game over dialog
if (C4GameOverDlg::IsShown()) return false;
// Open menu
return !!Menu.ActivateMain(Number);
}
void C4Player::HostilitySet::CompileFunc(StdCompiler *pComp)
{
int entries = size();
if (pComp->isDeserializer())
{
clear();
pComp->Value(entries);
while (entries--)
{
int number;
pComp->Value(number);
assert(::Players.Valid(number));
C4Player *plr = ::Players.Get(number);
if (plr)
insert(plr);
}
}
else
{
pComp->Value(entries);
for (auto it : *this)
{
int32_t num = it->Number;
pComp->Value(num); // Can't use (*it)->Number directly because StdCompiler is dumb about constness
}
}
}
void C4Player::SetZoomByViewRange(int32_t range_wdt, int32_t range_hgt, bool direct, bool no_increase, bool no_decrease)
{
AdjustZoomParameter(&ZoomWdt, range_wdt, no_increase, no_decrease);
AdjustZoomParameter(&ZoomHgt, range_hgt, no_increase, no_decrease);
ZoomToViewports(direct, no_decrease, no_increase); // inc/dec swapped for zoom, because it's inversely proportional to range
}
void C4Player::SetMinZoomByViewRange(int32_t range_wdt, int32_t range_hgt, bool no_increase, bool no_decrease)
{
AdjustZoomParameter(&ZoomLimitMinWdt, range_wdt, no_increase, no_decrease);
AdjustZoomParameter(&ZoomLimitMinHgt, range_hgt, no_increase, no_decrease);
ZoomLimitsToViewports();
}
void C4Player::SetMaxZoomByViewRange(int32_t range_wdt, int32_t range_hgt, bool no_increase, bool no_decrease)
{
AdjustZoomParameter(&ZoomLimitMaxWdt, range_wdt, no_increase, no_decrease);
AdjustZoomParameter(&ZoomLimitMaxHgt, range_hgt, no_increase, no_decrease);
ZoomLimitsToViewports();
}
void C4Player::SetZoom(C4Real zoom, bool direct, bool no_increase, bool no_decrease)
{
AdjustZoomParameter(&ZoomVal, zoom, no_increase, no_decrease);
ZoomToViewports(direct, no_increase, no_decrease);
}
void C4Player::SetMinZoom(C4Real zoom, bool no_increase, bool no_decrease)
{
AdjustZoomParameter(&ZoomLimitMinVal, zoom, no_increase, no_decrease);
ZoomLimitsToViewports();
}
void C4Player::SetMaxZoom(C4Real zoom, bool no_increase, bool no_decrease)
{
AdjustZoomParameter(&ZoomLimitMaxVal, zoom, no_increase, no_decrease);
ZoomLimitsToViewports();
}
void C4Player::ZoomToViewports(bool direct, bool no_increase, bool no_decrease)
{
C4Viewport *vp = nullptr;
while((vp = ::Viewports.GetViewport(Number, vp)) != nullptr)
ZoomToViewport(vp, direct, no_increase, no_decrease);
}
void C4Player::ZoomToViewport(C4Viewport* vp, bool direct, bool no_increase, bool no_decrease)
{
float new_zoom = ZoomVal ? fixtof(ZoomVal) : vp->GetZoomByViewRange((ZoomWdt || ZoomHgt) ? ZoomWdt : C4VP_DefViewRangeX,ZoomHgt);
float old_zoom = vp->GetZoomTarget();
if (new_zoom > old_zoom && no_increase) return;
if (new_zoom < old_zoom && no_decrease) return;
vp->SetZoom(new_zoom, direct);
}
void C4Player::ZoomLimitsToViewports()
{
C4Viewport *vp = nullptr;
while((vp = ::Viewports.GetViewport(Number, vp)) != nullptr)
ZoomLimitsToViewport(vp);
}
void C4Player::ZoomLimitsToViewport(C4Viewport* vp)
{
float zoom_max = ZoomLimitMaxVal ? fixtof(ZoomLimitMaxVal) : vp->GetZoomByViewRange((ZoomLimitMinWdt || ZoomLimitMinHgt) ? ZoomLimitMinWdt : C4VP_DefMinViewRangeX,ZoomLimitMinHgt);
float zoom_min = ZoomLimitMinVal ? fixtof(ZoomLimitMinVal) : vp->GetZoomByViewRange((ZoomLimitMaxWdt || ZoomLimitMaxHgt) ? ZoomLimitMaxWdt : C4VP_DefMaxViewRangeX,ZoomLimitMaxHgt);
vp->SetZoomLimits(zoom_min, zoom_max);
}
bool C4Player::AdjustZoomParameter(int32_t *range_par, int32_t new_val, bool no_increase, bool no_decrease)
{
// helper function: Adjust *range_par to new_val if increase/decrease not forbidden
if (new_val < *range_par)
{
if (!no_decrease) *range_par = new_val;
return !no_decrease;
}
else if(new_val > *range_par)
{
if (!no_increase) *range_par = new_val;
return !no_increase;
}
return true;
}
bool C4Player::AdjustZoomParameter(C4Real *zoom_par, C4Real new_val, bool no_increase, bool no_decrease)
{
// helper function: Adjust *zoom_par to new_val if increase/decrease not forbidden
if (new_val < *zoom_par)
{
if (!no_decrease) *zoom_par = new_val;
return !no_decrease;
}
else if(new_val > *zoom_par)
{
if (!no_increase) *zoom_par = new_val;
return !no_increase;
}
return true;
}
void C4Player::SetViewLocked(bool to_val)
{
if ((ViewLock = to_val))
{
// view was locked - cancel any scrolling
if (ViewMode == C4PVM_Scrolling) SetViewMode(C4PVM_Cursor);
}
}
bool C4Player::GainScenarioAchievement(const char *achievement_id, int32_t value, const char *scen_name_override)
{
// Determine full ID of achievement
if (!scen_name_override)
{
if (::Game.C4S.Head.Origin.getLength())
scen_name_override = ::Game.C4S.Head.Origin.getData();
else
scen_name_override = ::Game.ScenarioFilename;
}
StdStrBuf sAchvID = C4ScenarioParameters::AddFilename2ID(scen_name_override, achievement_id);
// Gain achievement iff it's an improvement
Achievements.SetValue(sAchvID.getData(), value, true);
return true;
}
void C4Player::SetSoundModifier(C4PropList *new_modifier)
{
// set modifier to be applied to all new sounds being played in a player's viewport
// update prop list parameter
C4SoundModifier *mod;
if (new_modifier)
{
SoundModifier.SetPropList(new_modifier);
mod = ::Application.SoundSystem.Modifiers.Get(new_modifier, true);
}
else
{
SoundModifier.Set0();
mod = nullptr;
}
// update in sound system
::Application.SoundSystem.Modifiers.SetGlobalModifier(mod, Number);
}
Reference in New Issue View Git Blame Copy Permalink