dahjah/hostile-takeover
1
0
Fork 0
mirror of https://github.com/spiffcode/hostile-takeover.git synced 2025-12-16 12:08:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
hostile-takeover/game/Simulation.cpp

1230 lines
34 KiB
C++
Raw Permalink Blame History

#include "game/ht.h"
#include "game/wistrings.h"
#include "game/stateframe.h"
namespace wi {
CommandQueue gcmdq;
#ifdef STATS_DISPLAY
extern int gcBitmapsDrawn;
#endif
extern int gcMessagesPerUpdate;
extern bool gfDragSelecting;
//---------------------------------------------------------------------------
// Simulation implementation
Simulation::Simulation()
{
m_plvl = NULL;
m_fPaused = false;
m_nMiniMapScale = 1;
m_cgobVisible = 0;
m_wxViewSave = 0;
m_wyViewSave = 0;
m_cUpdatesSave = -1;
}
Simulation::~Simulation()
{
}
bool Simulation::OneTimeInit()
{
// Initialize all the Gob classes
Status("Parse GobTemplates.ini...");
IniReader *piniGobTemplates = LoadIniFile(gpakr, "GobTemplates.ini");
if (piniGobTemplates == NULL)
return false;
Status("Init SurfaceDecalGob...");
bool fSuccess = SurfaceDecalGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init SceneryGob...");
fSuccess = fSuccess && SceneryGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init SRInfantryGob...");
fSuccess = fSuccess && SRInfantryGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init HrcGob...");
fSuccess = fSuccess && HrcGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init ProcessorGob...");
fSuccess = fSuccess && ProcessorGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init ReactorGob...");
fSuccess = fSuccess && ReactorGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init MinerGob...");
fSuccess = fSuccess && MinerGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init VtsGob...");
fSuccess = fSuccess && VtsGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init RadarGob...");
fSuccess = fSuccess && RadarGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init HqGob...");
fSuccess = fSuccess && HqGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init ResearchGob...");
fSuccess = fSuccess && ResearchGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init LRInfantryGob...");
fSuccess = fSuccess && LRInfantryGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init LTankGob...");
fSuccess = fSuccess && LTankGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init MTankGob...");
fSuccess = fSuccess && MTankGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init RTankGob...");
fSuccess = fSuccess && RTankGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init GTankGob...");
fSuccess = fSuccess && GTankGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init SpInfantryGob...");
fSuccess = fSuccess && SpInfantryGob::InitClass(piniGobTemplates);
Status("Init OvermindGob...");
fSuccess = fSuccess && OvermindGob::InitClass(piniGobTemplates);
Status("Init TankShotGob...");
fSuccess = fSuccess && TankShotGob::InitClass(piniGobTemplates);
Status("Init RocketGob...");
fSuccess = fSuccess && RocketGob::InitClass(piniGobTemplates);
Status("Init BulletGob...");
fSuccess = fSuccess && BulletGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init AndyShotGob...");
fSuccess = fSuccess && AndyShotGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init WarehouseGob...");
fSuccess = fSuccess && WarehouseGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init GunTowerGob...");
fSuccess = fSuccess && GunTowerGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init RocketTowerGob...");
fSuccess = fSuccess && RocketTowerGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init MobileHqGob...");
fSuccess = fSuccess && MobileHqGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init ArtilleryGob...");
fSuccess = fSuccess && ArtilleryGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init ArtilleryShotGob...");
fSuccess = fSuccess && ArtilleryShotGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init ReplicatorGob...");
fSuccess = fSuccess && ReplicatorGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init AndyGob...");
fSuccess = fSuccess && AndyGob::InitClass(piniGobTemplates);
Assert(fSuccess);
Status("Init FoxGob...");
fSuccess = fSuccess && FoxGob::InitClass(piniGobTemplates);
Assert(fSuccess);
delete piniGobTemplates;
// Do some other one-time initialization that we didn't want to
// do at game startup because we want to startup snappily.
#ifdef DRAW_PATHS
// Load the direction arrow bitmaps
Status("Load path arrow bitmaps...");
LoadArrows();
#endif
return fSuccess;
}
void Simulation::OneTimeExit()
{
SRInfantryGob::ExitClass();
HrcGob::ExitClass();
ProcessorGob::ExitClass();
ReactorGob::ExitClass();
MinerGob::ExitClass();
VtsGob::ExitClass();
RadarGob::ExitClass();
HqGob::ExitClass();
ResearchGob::ExitClass();
LRInfantryGob::ExitClass();
LTankGob::ExitClass();
MTankGob::ExitClass();
RTankGob::ExitClass();
GTankGob::ExitClass();
SpInfantryGob::ExitClass();
TankShotGob::ExitClass();
RocketGob::ExitClass();
BulletGob::ExitClass();
AndyShotGob::ExitClass();
WarehouseGob::ExitClass();
GunTowerGob::ExitClass();
RocketTowerGob::ExitClass();
MobileHqGob::ExitClass();
ArtilleryGob::ExitClass();
ArtilleryShotGob::ExitClass();
ReplicatorGob::ExitClass();
AndyGob::ExitClass();
FoxGob::ExitClass();
#ifdef DRAW_PATHS
FreeArrows();
#endif
delete m_plvl;
m_plvl = NULL;
}
bool Simulation::PerLevelInit()
{
#ifdef DEBUG_HELPERS
void ClearLog();
ClearLog();
#endif
if (!gcmdq.Init())
return false;
m_wxView = m_wyView = 0;
m_cUpdates = -1;
m_tCurrent = 0;
m_fGameOver = false;
m_pbldm = new BuildMgr();
if (m_pbldm == NULL)
return false;
m_cupdTriggerMgrUpdateLast = 0;
// So visible gobs get recalced
m_wxViewSave = (WCoord)-1;
m_wyViewSave = (WCoord)-1;
m_cUpdatesSave = -2;
return true;
}
void Simulation::PerLevelExit()
{
gcmdq.Exit();
delete m_plvl;
m_plvl = NULL;
delete m_pbldm;
m_pbldm = NULL;
}
bool Simulation::LoadLevel(const char *pszLevelName)
{
Assert(m_plvl == NULL);
m_plvl = new Level();
if (!m_plvl->Init(pszLevelName)) {
delete m_plvl;
m_plvl = NULL;
return false;
}
// Initialize level-specific player info for each player
Player *pplr = gplrm.GetNextPlayer(NULL);
for (; pplr != NULL; pplr = gplrm.GetNextPlayer(pplr)) {
SideInfo *psidi = m_plvl->GetSideInfo(pplr->GetSide());
pplr->SetCredits(psidi->nInitialCredits, false);
// UNDONE: Level could (should?) provide this state
pplr->SetUpgrades(0);
if (pplr == gpplrLocal) {
// Center the view around the level-specified initial view position
Size siz;
gpupdSim->GetMapSize(&siz);
SetViewPos(psidi->wptInitialView.wx - (WcFromTc(siz.cx) / 2),
psidi->wptInitialView.wy - (WcFromTc(siz.cy) / 2), true);
}
// In a multiplayer game supporting a range of players (e.g. 2-4) dummy
// players are allocated for any 'human' sides that aren't in use by
// human players. The dummy players must be present so the level, which
// contains units for all sides, can load properly. Here as we load the
// level we remove all units owned by the unfulfilled players.
word wf = pplr->GetFlags();
if (wf & kfPlrUnfulfilled) {
Gob *pgobT;
for (pgobT = ggobm.GetFirstGob(); pgobT != NULL; ) {
// Get the next Gob BEFORE possibly deleting the one it points
// to
Gob *pgobNext = ggobm.GetNextGob(pgobT);
if (pgobT->GetOwner() == pplr) {
if (pgobT->GetFlags() & kfGobUnit) {
UnitGob *punt = (UnitGob *)pgobT;
punt->Deactivate();
punt->Delete();
// Don't count these units as ever having been built
pplr->DecUnitBuiltCount(punt->GetUnitType());
} else {
// Not a unit gob, but still owned by this player
// (for example, a tank shot). Remove / delete it.
ggobm.RemoveGob(pgobT);
delete pgobT;
}
}
pgobT = pgobNext;
}
}
}
return true;
}
#define knVerSimState 3
bool Simulation::LoadState(Stream *pstm)
{
// Do version handling
byte nVer = pstm->ReadByte();
if (nVer != knVerSimState)
return false;
// Load update count!
m_cUpdates = pstm->ReadDword();
// Load view
WCoord wxView = pstm->ReadWord();
WCoord wyView = pstm->ReadWord();
// Load Simulation tick count
m_tCurrent = pstm->ReadDword();
m_cupdTriggerMgrUpdateLast = pstm->ReadDword();
// Load level
Assert(m_plvl == NULL);
m_plvl = new Level();
if (m_plvl == NULL)
return false;
if (!m_plvl->LoadState(pstm)) {
delete m_plvl;
m_plvl = NULL;
return false;
}
// Load state machine mgr (delayed messages)
gsmm.LoadState(pstm);
// Save command queue (usually empty)
gcmdq.LoadState(pstm);
// Set view pos
SetViewPos(wxView, wyView, true);
// Done
return pstm->IsSuccess();
}
bool Simulation::SaveState(Stream *pstm)
{
// Save version
pstm->WriteByte(knVerSimState);
// Save update count
pstm->WriteDword(m_cUpdates);
// Save view x,y
pstm->WriteWord(m_wxView);
pstm->WriteWord(m_wyView);
// Save Simulation tick count
pstm->WriteDword((dword)m_tCurrent);
pstm->WriteDword(m_cupdTriggerMgrUpdateLast);
// Save level
m_plvl->SaveState(pstm);
// Save state machine mgr (delayed messages...)
gsmm.SaveState(pstm);
// Save command queue (usually empty, but just in case...)
gcmdq.SaveState(pstm);
return pstm->IsSuccess();
}
long Simulation::GetTickCount()
{
return m_tCurrent;
}
void Simulation::AddTimer(Timer *ptmr, long ct)
{
// fyi you are the first user of a timer based on simulation time.
// you'll need to add code to LoadState & SaveState to preserve
// your timer times because simulation time is preserved across load/save
Assert(false);
AddTimer(ptmr, ct);
}
// The tCurrent increment can't really ever be anything other than 8 (80 ms)
// because Gobs assume it as their update rate and increment animations, etc
// every time they're Updated.
void Simulation::Update(CommandQueue *pcmdq)
{
if (m_fPaused)
return;
// Give some time to sound servicing
HostSoundServiceProc();
// Advance Simulation time
m_tCurrent += kcmsUpdate / 10;
m_cUpdates++;
// Update triggers. This is done here so the triggers act on what the
// player is currently seeing (e.g., Credits will show >= NNNN when
// >= NNNN Credits condition is satisfied).
// PostEvent so that modal actions can occur
// Note - CountdownTimer trigger depends on this being better than once a second.
// TUNE:
#define kcupdTriggerMgrUpdate 6
if (m_cupdTriggerMgrUpdateLast == 0 || abs(m_cUpdates - m_cupdTriggerMgrUpdateLast) >= kcupdTriggerMgrUpdate) {
m_cupdTriggerMgrUpdateLast = m_cUpdates;
ggame.ScheduleUpdateTriggers();
}
// Update Players
gplrm.Update(m_cUpdates);
// Update unit groups.
m_plvl->GetUnitGroupMgr()->Update();
// Update Build Manager
// OPT: this doesn't have to be done every update
m_pbldm->Update();
// Process all queued commands
#ifdef DEBUG_HELPERS
extern void UpdateCommandQueueViewer();
UpdateCommandQueueViewer();
#endif
int cmsg = pcmdq->GetCount();
#ifdef STATS_DISPLAY
extern int gcbCommandsQueued;
gcbCommandsQueued += cmsg * sizeof(Message);
#endif
int i = 0;
Message *pmsg = pcmdq->GetFirst();
for (; i < cmsg; i++, pmsg++) {
// Disconnect is processed in order, by all clients, at the same time.
// To do this, it is turned into a message, since messages have a
// synchronization mechanism.
if (pmsg->mid == kmidPlayerDisconnect) {
HandlePlayerDisconnect(pmsg);
continue;
}
gsmm.RouteMessage(pmsg);
}
pcmdq->Clear();
gcMessagesPerUpdate = 0;
ScanDispatch(m_tCurrent);
// Send Update messages to all Gobs with state machines
Message msgUpdate;
memset(&msgUpdate, 0, sizeof(msgUpdate));
msgUpdate.mid = kmidReservedUpdate;
msgUpdate.smidSender = ksmidNull;
// Snapshot the gids of the Gobs we care about so we aren't vulnerable
// to the insertion or deletion of elements on the Gob list during the
// kmidReserveUpdate callbacks.
Gid agid[kcpgobMax];
Gid *pgidT = agid;
int cgid = 0;
Gob *pgobT;
for (pgobT = ggobm.GetFirstGob(); pgobT != NULL; pgobT = ggobm.GetNextGob(pgobT)) {
if (pgobT->GetFlags() & kfGobStateMachine) {
*pgidT++ = pgobT->GetId();
cgid++;
}
}
pgidT = agid;
for (i = 0; i < cgid; i++, pgidT++) {
// Gob might have been destroyed as a consequence of an earlier
// Gob's Update. If so, skip it.
pgobT = ggobm.GetGob(*pgidT, false);
if (pgobT == NULL)
continue;
#ifdef MP_DEBUG_SHAREDMEM
gsideCurrent = pgobT->GetOwner()->GetSide();
ggidCurrent = pgobT->GetId();
gcupdCurrent = m_cUpdates;
ggtCurrent = pgobT->GetType();
#endif
UpdateInterval *punvl = pgobT->GetUpdateInterval();
if (punvl->Decrement()) {
msgUpdate.smidReceiver = *pgidT;
gsmm.SendMsg(&msgUpdate);
#ifdef PIL
if (gfOS5Pa1Device) {
if ((i & 15) == 0)
HostSoundServiceProc();
}
#endif
}
}
// Delayed messages are dispatched AFTER Update messages are sent so if
// respondants create new Gobs they won't receive an immediate Update
// before their first paint. This is important for cases like delayed shots.
#ifdef DEBUG_HELPERS
extern void UpdateDelayedMessageViewer();
UpdateDelayedMessageViewer();
#endif
gsmm.DispatchDelayedMessages();
long tCurrent = HostGetTickCount();
// Sound effects
// Credits increasing or decreasing?
#if 0
switch (gpplrLocal->GetCreditsDirection()) {
case 0:
break;
case 1:
gsndm.PlaySfx(ksfxGameCreditsIncreasing);
break;
case -1:
// If the credits user is for repair, only play decrease sound over a longer interval
// TODO: figure out ultimate approach for managing interval for credit spending
// TUNE:
#define kctIntervalRepairNotify (75)
if (true) { // gpplrLocal->GetCreditsConsumer() == knConsumerRepair) {
static long s_tLastRepairNotify = 0;
if (s_tLastRepairNotify == 0 || abs(tCurrent - s_tLastRepairNotify) >= kctIntervalRepairNotify) {
s_tLastRepairNotify = tCurrent;
gsndm.PlaySfx(ksfxGameCreditsDecreasing);
}
} else {
gsndm.PlaySfx(ksfxGameCreditsDecreasing);
}
break;
}
#endif
// Base under attack?
// TUNE:
#define kctIntervalAttackNotify (30 * 100)
if (gpplrLocal->GetFlags() & kfPlrStructureAttacked) {
gpplrLocal->SetFlags(gpplrLocal->GetFlags() & ~kfPlrStructureAttacked);
static long s_tLastAttackNotify = 0;
if (s_tLastAttackNotify == 0 || abs((int)(tCurrent - s_tLastAttackNotify)) >= kctIntervalAttackNotify) {
s_tLastAttackNotify = tCurrent;
gsndm.PlaySfx(ksfxGameBaseUnderAttack);
ShowAlert(kidsBaseUnderAttack);
}
}
// Power too low?
// TUNE:
#define kctIntervalPowerLowNotify (30 * 100)
if (gpplrLocal->GetPowerDemand() != 0 && gpplrLocal->GetPowerDemand() > gpplrLocal->GetPowerSupply()) {
static long s_tLastPowerLowNotify = 0;
if (s_tLastPowerLowNotify == 0 || (tCurrent - s_tLastPowerLowNotify) >= kctIntervalPowerLowNotify) {
s_tLastPowerLowNotify = tCurrent;
gsndm.PlaySfx(ksfxReactorPowerTooLow);
ShowAlert(kidsLowPower);
}
}
#ifdef MP_STRESS
// Has to be at the end of Update() because gcmdq serves the needs of both
// collecting client commands and collecting multiplayer commands. This
// role switching occurs in in knmidScUpdate handling in
// SimUIForm::OnReceive.
extern void MPStressUpdate();
MPStressUpdate();
#endif
}
void Simulation::HandlePlayerDisconnect(Message *pmsg) {
// Re-route this as a NetMessage to get proper handling
if (gptra == NULL) {
return;
}
IGameCallback *pgcb = gptra->GetGameCallback();
if (pgcb == NULL) {
return;
}
// This must not be modal
PlayerDisconnectNetMessage pdnm;
pdnm.pid = pmsg->PlayerDisconnect.pid;
pdnm.nReason = pmsg->PlayerDisconnect.nReason;
NetMessage *pnm = &pdnm;
pgcb->OnNetMessage(&pnm);
}
#ifdef TRACKSTATE
void Simulation::TrackState(StateFrame *frame) {
// Sim stuff
int i = frame->AddCountedValue('SIMU');
frame->AddValue('SEED', (dword)GetRandomSeed(), i);
frame->AddValue('CMPU', (dword)gcMessagesPerUpdate, i);
frame->AddValue('CUPD', (dword)m_cUpdates, i);
// gobs
Gob *pgobT;
for (pgobT = ggobm.GetFirstGob(); pgobT != NULL;
pgobT = ggobm.GetNextGob(pgobT)) {
if (!(pgobT->GetFlags() & kfGobStateMachine)) {
continue;
}
pgobT->TrackState(frame);
}
// players
gplrm.TrackState(frame);
}
#endif
void Simulation::SetSelection(Rect *prc)
{
if (gfLassoSelection || !gfDragSelecting) {
return;
}
for (Gob *pgobT = ggobm.GetFirstGob(); pgobT != NULL;
pgobT = ggobm.GetNextGob(pgobT)) {
dword ff = pgobT->GetFlags();
// If were in select mode then only Gobs inside the selection rectangle
// get to be selected.
if ((ff & kfGobUnit) == 0) {
continue;
}
bool fSelect = false;
UnitGob *punt = (UnitGob *)pgobT;
if ((gfGodMode || punt->GetOwner() == gpplrLocal) &&
((ff & (kfGobActive | kfGobUnit)) == (kfGobActive | kfGobUnit))) {
if ((ff & kfGobStructure) == 0 ||
(punt->GetConsts()->um & kumTowers) != 0) {
WPoint wptGobCenter;
punt->GetCenter(&wptGobCenter);
if (prc->PtIn(wptGobCenter.wx, wptGobCenter.wy)) {
fSelect = true;
}
}
}
punt->Select(fSelect);
}
}
void Simulation::ClearGobSelection()
{
// Deselect any selected Gobs
for (Gob *pgobT = ggobm.GetFirstGob(); pgobT != NULL; pgobT = ggobm.GetNextGob(pgobT)) {
dword ff = pgobT->GetFlags();
if ((ff & (kfGobSelected | kfGobUnit)) == (kfGobSelected | kfGobUnit))
((UnitGob *)pgobT)->Select(false);
}
}
void Simulation::SetGobSelected(Gob *pgob)
{
ClearGobSelection();
if ((pgob->GetFlags() & (kfGobSelected | kfGobUnit)) == kfGobUnit)
((UnitGob *)pgob)->Select(true);
}
void Simulation::SelectSameUnitTypes(UnitGob *punt, TRect *ptrc)
{
Player *pplr = punt->GetOwner();
if (pplr != gpplrLocal)
return;
UnitType ut = punt->GetUnitType();
// Store the gobs on the stack.
Gob *apgob[kcpgobMax / 2];
int cpgob = ggobm.FindGobs(ptrc, apgob, ARRAYSIZE(apgob));
for (int i = 0; i < cpgob; i++) {
MobileUnitGob *pmuntT = (MobileUnitGob *)apgob[i];
dword ff = pmuntT->GetFlags();
if (!(ff & kfGobMobileUnit))
continue;
if (pmuntT->GetOwner() != pplr)
continue;
if (pmuntT->GetUnitType() != ut)
continue;
pmuntT->Select(true);
}
}
void Simulation::FindVisibleGobs(Gob ***pppgobVisible, int *pcgobVisible)
{
// Reuse the gob list if it's the same update count and view pos
if (m_wxView != m_wxViewSave || m_wyView != m_wyViewSave || m_cUpdates != m_cUpdatesSave) {
// Get visible gobs / refresh cache info
Size siz;
ggame.GetPlayfieldSize(&siz);
short xView = PcFromUwc(m_wxView) & 0xfffe;
short yView = PcFromUwc(m_wyView) & 0xfffe;
Rect rcVisible;
rcVisible.left = xView;
rcVisible.top = yView;
rcVisible.right = xView + siz.cx;
rcVisible.bottom = yView + siz.cy;
m_cgobVisible = ggobm.FindGobs(&rcVisible, m_apgobVisible, ARRAYSIZE(m_apgobVisible), m_plvl->GetFogMap()->GetMapPtr());
m_wxViewSave = m_wxView;
m_wyViewSave = m_wyView;
m_cUpdatesSave = m_cUpdates;
}
// Return if asked
if (pppgobVisible != NULL)
*pppgobVisible = m_apgobVisible;
if (pcgobVisible != NULL)
*pcgobVisible = m_cgobVisible;
}
void Simulation::DrawBackground(UpdateMap *pupd, DibBitmap *pbm)
{
// Draw tiles where the updatemap is invalid
short xView = PcFromUwc(m_wxView) & 0xfffe;
short yView = PcFromUwc(m_wyView) & 0xfffe;
FogMap *pfogm = m_plvl->GetFogMap();
TileMap *ptmap = m_plvl->GetTileMap();
Size sizDib;
pbm->GetSize(&sizDib);
ptmap->Draw(pbm, 0, 0, sizDib.cx, sizDib.cy, xView, yView, pfogm->GetMapPtr(), pupd);
HostSoundServiceProc();
// Draw galaxite where the updatemap is invalid
pfogm->DrawGalaxite(pbm, xView, yView, pupd, m_plvl->GetTerrainMap()->GetMapPtr());
HostSoundServiceProc();
}
void Simulation::Draw(UpdateMap *pupd, DibBitmap *pbm)
{
// Maps only draw on even coords
// OPT: can this be streamlined?
short xView = PcFromUwc(m_wxView) & 0xfffe;
short yView = PcFromUwc(m_wyView) & 0xfffe;
WCoord wxView = WcFromUpc(xView);
WCoord wyView = WcFromUpc(yView);
//
// Normal full-size map (not mini-map)
//
// Set the view origin so that blt-style map scrolling is possible
pupd->SetViewOrigin(xView, yView);
// Give some time to sound servicing
HostSoundServiceProc();
// Find visible Gobs
FindVisibleGobs();
#ifdef STATS_DISPLAY
gcBitmapsDrawn = 0;
#endif
#ifdef DRAW_PATHS
if (gfDrawPaths) {
// Draw paths
for (Gob *pgob = ggobm.GetFirstGob(); pgob != NULL; pgob = ggobm.GetNextGob(pgob)) {
if ((pgob->GetFlags() & kfGobMobileUnit) && ((MobileUnitGob *)pgob)->m_ppathUnit != NULL)
((MobileUnitGob *)pgob)->DrawPath(pbm, wxView, wyView);
}
}
#endif
HostSoundServiceProc();
// Figure out what layers are in use. Much of the time only 1 or 2 layers are in use
dword ffLayers = 0;
Gob **ppgobStop = &m_apgobVisible[m_cgobVisible];
Gob **ppgobT;
for (ppgobT = m_apgobVisible; ppgobT < ppgobStop; ppgobT++)
ffLayers |= (*ppgobT)->GetFlags();
ffLayers &= kfGobLayerMask;
// Turn off symbols layers if off
if (!(gwfPerfOptions & kfPerfSymbolFlashing))
ffLayers &= ~kfGobLayerSymbols;
// Draw gobs. Skip layers that aren't in use; only call a gob if it wants to draw on
// this layer
dword ffLayerT = kfGobLayerSurfaceDecal;
for (int nLayer = knLayerSurfaceDecal; nLayer <= knLayerEnd; nLayer++, ffLayerT <<= 1) {
if (!(ffLayerT & ffLayers))
continue;
int cT = 0;
for (ppgobT = m_apgobVisible; ppgobT < ppgobStop; ppgobT++) {
Gob *pgobT = *ppgobT;
dword ff = pgobT->GetFlags();
// If gob is marked for redraw...
if (ff & kfGobRedraw) {
// If gob is painting on this layer then paint
if (ff & ffLayerT) {
pgobT->Draw(pbm, xView, yView, nLayer);
#ifdef PIL
if (gfOS5Pa1Device) {
cT++;
if ((cT & 15) == 0)
HostSoundServiceProc();
}
#endif
}
}
}
}
// Give some time to sound servicing
HostSoundServiceProc();
// Clear kfGobRedraw since the gobs are now "valid".
// Do this after painting because some painting code ends up setting this bit
for (ppgobT = m_apgobVisible; ppgobT < ppgobStop; ppgobT++) {
Gob *pgobT = *ppgobT;
pgobT->SetFlags(pgobT->GetFlags() & ~kfGobRedraw);
}
#ifdef DRAW_LINES
if (gfDrawLines) {
// Draw target lines
for (Gob *pgob = ggobm.GetFirstGob(); pgob != NULL; pgob = ggobm.GetNextGob(pgob)) {
// Total hack-o-rama
if ((pgob->GetFlags() & kfGobMobileUnit) && ((MobileUnitGob *)pgob)->m_wptTarget.wx != kwxInvalid)
((MobileUnitGob *)pgob)->DrawTargetLine(pbm, xView, yView);
if ((pgob->GetType() == kgtRocketTower || pgob->GetType() == kgtMachineGunTower) &&
((TowerGob *)pgob)->m_wptTarget.wx != kwxInvalid)
((TowerGob *)pgob)->DrawTargetLine(pbm, xView, yView);
}
}
#endif
#ifdef MARK_TILE_BOUNDARIES
{
Color clr = GetColor(kiclrWhite);
Size sizT;
ggame.GetPlayfieldSize(&sizT);
for (int y = -PcFromUwc(WcFrac(wyView)); y < sizT.cy; y += gcyTile) {
for (int x = -PcFromUwc(WcFrac(wxView)); x < sizT.cx; x += gcxTile) {
pbm->Fill(x, y, 2, 2, clr);
}
}
}
#endif
#ifdef MARK_OCCUPIED_TILES
{
Color clr = GetColor(kiclrWhite);
Size sizT;
ggame.GetPlayfieldSize(&sizT);
int ctxView = sizT.cx / gcxTile + 1;
int ctyView = sizT.cy / gcyTile + 1;
TerrainMap *ptrmap = m_plvl->GetTerrainMap();
int xView = PcFromWc(wxView);
int yView = PcFromWc(wyView);
TCoord txView = TcFromWc(wxView);
TCoord tyView = TcFromWc(wyView);
for (TCoord ty = tyView; ty < tyView + ctyView; ty++) {
for (TCoord tx = txView; tx < txView + ctxView; tx++) {
if (ptrmap->IsOccupied(tx, ty, 1, 1)) {
int x = PcFromTc(tx) - xView;
int y = PcFromTc(ty) - yView;
pbm->Fill(x + gcxTile / 2 - 1, y + gcyTile / 2 - 1, 2, 2, clr);
}
}
}
}
#endif
pupd->SetViewOrigin(0, 0);
HostSoundServiceProc();
// If the screen is larger than the map size we clear those areas to black color
Size sizDib;
pbm->GetSize(&sizDib);
Size sizMap;
m_plvl->GetTileMap()->GetMapSize(&sizMap);
if (sizMap.cx < sizDib.cx) {
Rect rc;
rc.Set(sizMap.cx, 0, sizDib.cx, sizMap.cy);
FillHelper(pbm, pupd, &rc, GetColor(kiclrBlack));
}
if (sizMap.cy < sizDib.cy) {
Rect rc;
rc.Set(0, sizMap.cy, sizDib.cx, sizDib.cy);
FillHelper(pbm, pupd, &rc, GetColor(kiclrBlack));
}
}
void Simulation::DrawFog(UpdateMap *pupd, DibBitmap *pbm)
{
// Draw fog map
short xView = PcFromUwc(m_wxView) & 0xfffe;
short yView = PcFromUwc(m_wyView) & 0xfffe;
m_plvl->GetFogMap()->Draw(pbm, xView, yView, pupd);
HostSoundServiceProc();
}
bool Simulation::SetViewPos(WCoord wx, WCoord wy, bool fInit)
{
// Pin the passed position to the bounds of the map
Size sizMap;
m_plvl->GetTileMap()->GetMapSize(&sizMap);
Size sizPlayfield;
ggame.GetPlayfieldSize(&sizPlayfield);
WCoord wcxMax, wcyMax;
int cxMax = sizMap.cx - sizPlayfield.cx;
int cyyMax = sizMap.cy - sizPlayfield.cy;
if (cxMax <= 0 || cxMax > kpcMax)
wcxMax = 0;
else
wcxMax = WcFromUpc(cxMax);
if (cyyMax <= 0 || cyyMax > kpcMax)
wcyMax = 0;
else
wcyMax = WcFromUpc(cyyMax);
if (wx < 0)
wx = 0;
else if (wx > wcxMax)
wx = wcxMax;
if (wy < 0)
wy = 0;
else if (wy > wcyMax)
wy = wcyMax;
// If we're initing, we're loading a new level. Invalidate and
// set the map offset
if (fInit) {
gpupdSim->Reset();
gpdisp->ResetScrollOffset();
m_wxView = WcFromPc(0);
m_wyView = WcFromPc(0);
}
if (m_wxView == wx && m_wyView == wy)
return false;
// Otherwise scroll the map
int dx = (PcFromWc(m_wxView) & 0xfffe) - (PcFromWc(wx) & 0xfffe);
int dy = (PcFromWc(m_wyView) & 0xfffe) - (PcFromWc(wy) & 0xfffe);
gpfrmmSim->Scroll(dx, dy);
// Set the new view pos
m_wxView = wx;
m_wyView = wy;
// Force redraw before next update
gevm.SetRedrawFlags(kfRedrawDirty | kfRedrawBeforeTimer);
// Debug
// Trace("View: %d,%d", PcFromWc(m_wxView) & 0xfffe, PcFromWc(m_wyView) & 0xfffe);
return true;
}
void Simulation::GetViewPos(WCoord *pwx, WCoord *pwy)
{
Assert(pwx != NULL);
Assert(pwy != NULL);
*pwx = m_wxView;
*pwy = m_wyView;
}
// Passed coordinates are in world coordinates
bool Simulation::HitTest(Enum *penm, WCoord wx, WCoord wy, word wf, Gob **ppgob)
{
if (penm->m_pvNext == (void *)kEnmFirst) {
FindVisibleGobs();
penm->m_dwUser = 0;
}
for (; (int)penm->m_dwUser < m_cgobVisible; penm->m_dwUser++) {
Gob *pgob = m_apgobVisible[penm->m_dwUser];
if ((pgob->GetFlags() & wf) != wf)
continue;
WRect wrcT;
pgob->GetUIBounds(&wrcT);
if (!wrcT.PtIn(wx, wy))
continue;
*ppgob = pgob;
penm->m_dwUser++;
return true;
}
return false;
}
// Passed coordinates are in world coordinates
Gob *Simulation::FingerHitTest(WCoord wx, WCoord wy, word wf,
bool *pfHitSurrounding)
{
// Finger hit testing is tricky, because currently at least,
// a given tile is smaller than a finger. It's difficult to pick
// a cell on a grid, when the cells are smaller than a finger. One
// solution is to make the tiles larger. Instead, the gobs will be
// hit-tested specially, so that close hits register, while taking
// special precaution for open terrain between closely packed
// gobs.
// Calc the world rect of the tile being hit
WRect wrcTileHit;
wrcTileHit.left = WcTrunc(wx);
wrcTileHit.top = WcTrunc(wy);
wrcTileHit.right = wrcTileHit.left + kwcTile;
wrcTileHit.bottom = wrcTileHit.top + kwcTile;
WRect wrcTileHitAccum;
wrcTileHitAccum.SetEmpty();
// Find the "closest" gob being hit, and keep track of hit area overlap
// with the tile being hit.
Gob *pgobHitBest = NULL;
WCoord wcDistanceBest = kwcMax;
FindVisibleGobs();
for (int i = 0; i < m_cgobVisible; i++) {
Gob *pgobHit = m_apgobVisible[i];
if ((pgobHit->GetFlags() & wf) != wf) {
continue;
}
// Calc the inside rect - at least a tile's width and height
// The inside rect is a direct hit on the gob. Return the
// first direct hit, if there is one.
WRect wrcInside;
pgobHit->GetUIBounds(&wrcInside);
WCoord cwxInflate = 0;
if (wrcInside.Width() < kwcTile) {
cwxInflate += (kwcTile - wrcInside.Width()) / 2;
}
WCoord cwyInflate = 0;
if (wrcInside.Height() < kwcTile) {
cwyInflate += (kwcTile - wrcInside.Height()) / 2;
}
wrcInside.Inflate(cwxInflate, cwyInflate);
// Calc distance to this. If 0, we're inside and we're done
// Remember "closest" gob.
WCoord wcDistance = wrcInside.GetDistance(wx, wy);
if (wcDistance == 0) {
*pfHitSurrounding = false;
return pgobHit;
}
if (wcDistance < wcDistanceBest) {
wcDistanceBest = wcDistance;
pgobHitBest = pgobHit;
}
// Calc the outside rect - accumulate overlap with the tile rect.
WRect wrcOutside = wrcInside;
cwxInflate = 0;
if (wrcOutside.Width() < kwcTile * 2) {
cwxInflate += (kwcTile * 2 - wrcOutside.Width()) / 2;
}
cwyInflate = 0;
if (wrcOutside.Height() < kwcTile * 2) {
cwyInflate += (kwcTile * 2 - wrcOutside.Height()) / 2;
}
wrcOutside.Inflate(cwxInflate, cwyInflate);
// Intersect and accumlate with tile rect.
WRect wrcT;
if (wrcT.Intersect(&wrcTileHit, &wrcOutside)) {
if (wrcTileHitAccum.IsEmpty()) {
wrcTileHitAccum = wrcT;
} else {
wrcTileHitAccum.Union(&wrcT);
}
}
}
// If no gob or hit too far away, no hit.
if (pgobHitBest == NULL) {
return NULL;
}
// Structures get no slop since they are big already
if (pgobHitBest->GetFlags() & kfGobStructure) {
if (wcDistanceBest != 0) {
return NULL;
}
}
// Check if this is a mobile headquarters that is moving. In this case,
// selection is prioritized over local targetting, so that transforming
// is easier. Local targetting is higher priority if the mobile HQ
// is not moving.
if (pgobHitBest->GetType() == kgtMobileHeadquarters) {
MobileUnitGob *pmunt = (MobileUnitGob *)pgobHitBest;
if (pmunt->IsMobile()) {
if (wcDistanceBest <= kwcTile) {
*pfHitSurrounding = true;
return pgobHitBest;
}
}
}
// See if the unit is close enough to qualify for being hit on.
if (wcDistanceBest > kwcTileHalf) {
return NULL;
}
// Check to see if the tile hit is completely obscured by overlapping
// hit regions. If yes, then leave as open terrain (so that terrain can
// be hit between closely packed gobs).
if (wrcTileHitAccum.Equal(&wrcTileHit)) {
return NULL;
}
// Independent of hit thumbprint, if a gob is already selected, allow
// the terrain next to it to be selected.
if (pgobHitBest->GetFlags() & kfGobSelected) {
return NULL;
}
// Structures are big enough to hit the regular bounds.
if (pgobHitBest->GetFlags() & kfGobStructure) {
return NULL;
}
// This gob has been hit, in the "surrounding" area.
*pfHitSurrounding = true;
return pgobHitBest;
}
void Simulation::Pause(bool fPause)
{
m_fPaused = fPause;
}
bool Simulation::IsPaused()
{
return m_fPaused;
}
} // namespace wi
Reference in New Issue View Git Blame Copy Permalink