vwemirror/RP412
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial import of Red Planet v4.10 Win32 source

Browse Source 
Imports the current Win32 source for the pod-racing game 'Red Planet',
built on the MUNGA engine and its L4 (Win32/DirectX) platform layer:

- MUNGA / MUNGA_L4: cross-platform engine core and Win32 backend
- RP / RP_L4: Red Planet game logic and Win32 application
- DivLoader, Setup1: asset loader and installer project
- lib, MUNGA_L4/openal, MUNGA_L4/sos: third-party audio dependencies

Removed stale Subversion metadata and added .gitignore/.gitattributes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Cyd
2026-06-30 07:59:51 -05:00
co-authored by Claude Opus 4.8
commit 4abbf8879f
551 changed files with 254956 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MUNGA/EXPTBL.cpp
+605
View File
@@ -0,0 +1,605 @@
#include "munga.h"
#pragma hdrstop
#include "exptbl.h"
#include "namelist.h"
#include "registry.h"
#include "app.h"
#include "explode.h"
#include "damage.h"
#include "notation.h"
#include "fileutil.h"
#include "renderer.h"
//##############################################################################
//###################### Class ExplosionTableEntry ########################
//##############################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
ExplosionTableEntry::CreateExplosion(
const EntityID &entity_hit_ID,
const EntityID &creating_entity_ID,
const Point3D &explode_position
)
{
Check(this);
Origin explode_origin(Origin::Identity);
explode_origin = explode_position;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Create the explosion MakeMessage
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Explosion::MakeMessage exp_message(
Explosion::MakeMessageID,
sizeof(Explosion::MakeMessage),
RegisteredClass::ExplosionClassID,
EntityID::Null,
explosionResourceID,
Explosion::DefaultFlags,
explode_origin,
entity_hit_ID,
creating_entity_ID
);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Calculate actual time based on time_delay
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Time when = Now();
when += timeDelay;
Check(application);
Registry *registry;
registry = application->GetRegistry();
Check_Pointer(registry);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Create a MakeEntityMessage
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Registry::MakeEntityMessage *registry_message;
registry_message = Registry::MakeEntityMessage::Make(&exp_message);
Register_Object(registry_message);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Post entity message to the registry
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#if 0 // ECH 1/28/96
application->Post(
DefaultEventPriority,
registry,
registry_message,
when
);
#else
application->Post(
CreationEventPriority,
registry,
registry_message,
when
);
#endif
Unregister_Object(registry_message);
delete registry_message;
Check_Fpu();
}
//##############################################################################
// Construction/Destruction
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTableEntry::ExplosionTableEntry(MemoryStream *exp_stream)
{
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Read in the data from the stream
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
*exp_stream >> damageLevel >> explosionResourceID >> graphicState;
*exp_stream >> timeDelay;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTableEntry::~ExplosionTableEntry()
{
}
//##############################################################################
// Tool Support
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Logical
ExplosionTableEntry::CreateStreamedExplosion(
ResourceFile *resource_file,
CString exp_file_name,
NotationFile *exp_file,
CString exp_page_name,
MemoryStream *explosion_stream
)
{
Check(exp_file);
//
//~~~~~~~~~~~~~~~~~~~~
// Get the DamageLevel
//~~~~~~~~~~~~~~~~~~~~
//
Scalar damage_level;
if (!exp_file->GetEntry(
exp_page_name,
"DamageLevel",
&damage_level
)
)
{
damage_level = -1.0f;
}
*explosion_stream << damage_level;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Get the Explosion Model File
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
const char *explosion_model_file;
if (!exp_file->GetEntry(
exp_page_name,
"ExplosionModelFile",
&explosion_model_file
)
)
{
DEBUG_STREAM <<exp_file_name<<" : "<<exp_page_name<<" missing ExplosionModelFile!"<<std::endl << std::flush;
return False;
}
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Hunt for Model file in ResourceFile
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ResourceDescription *res;
res = resource_file->FindResourceDescription(
explosion_model_file,
ResourceDescription::ModelListResourceType
);
if (!res)
{
std::cout << exp_file_name << " cannot find " << explosion_model_file
<< " in resource file!\n";
return False;
}
//
//~~~~~~~~~~~~~~~~~~~~~~~~~
// Write out the resourceID
//~~~~~~~~~~~~~~~~~~~~~~~~~
//
*explosion_stream << res->resourceID;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~
// Read in the Graphic State
//~~~~~~~~~~~~~~~~~~~~~~~~~~
//
const char *graphic_state_char;
Enumeration graphic_state;
if (exp_file->GetEntry(
exp_page_name,
"GraphicState",
&graphic_state_char
)
)
{
if (!strcmp(graphic_state_char, "Destroyed"))
{
graphic_state = DamageZone::DestroyedGraphicState;
}
else if (!strcmp(graphic_state_char, "Gone"))
{
graphic_state = DamageZone::GoneGraphicState;
}
}
else
{
graphic_state = DamageZone::ExistsGraphicState;
}
*explosion_stream << graphic_state;
//
//~~~~~~~~~~~~~~~~~~~~
// Get the TimeDelay
//~~~~~~~~~~~~~~~~~~~~
//
Scalar time_delay;
if (!exp_file->GetEntry(
exp_page_name,
"TimeDelay",
&time_delay
)
)
{
time_delay = 0.0f;
}
*explosion_stream << time_delay;
return True;
}
//##############################################################################
//######################## Class ExplosionTable ###########################
//##############################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Logical
ExplosionTable::CrossedDamageLevelThreshold(
Scalar old_value,
Scalar new_value
)
{
ExplosionTableIterator iterator(this);
ExplosionTableEntry *current_exp;
while ((current_exp = iterator.ReadAndNext()) != NULL)
{
if (
(old_value < current_exp->GetDamageLevel()) &&
(new_value >= current_exp->GetDamageLevel())
)
{
return True;
}
}
return False;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTableEntry*
ExplosionTable::SelectDamageLevelEntry(Scalar damage_level)
{
ExplosionTableIterator iterator(this);
ExplosionTableEntry *current_exp;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Choose ExplosionTableEntry by damage Level
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
while ((current_exp = iterator.ReadAndNext()) != NULL)
{
if (damage_level < current_exp->GetDamageLevel())
{
Check_Fpu();
return current_exp;
}
}
Check_Fpu();
return NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTableEntry*
ExplosionTable::SelectGraphicStateEntry(Enumeration graphic_state)
{
ExplosionTableIterator iterator(this);
ExplosionTableEntry *current_entry;
while((current_entry = iterator.ReadAndNext() ) != NULL)
{
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Display Explosion if an Entry Exists
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
if (current_entry->GetGraphicState() == graphic_state)
{
Check_Fpu();
return current_entry;
}
}
Check_Fpu();
return NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
ExplosionTable::CreateExplosion(
ExplosionTableEntry *explosion_entry,
const EntityID &entity_hit_ID,
const EntityID &creating_entity_ID,
Point3D explode_position
)
{
Check(this);
Check(explosion_entry);
explosion_entry->CreateExplosion(
entity_hit_ID,
creating_entity_ID,
explode_position
);
}
//##############################################################################
// Construction/Destruction
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTable::ExplosionTable(MemoryStream *exp_stream):
TableOf<ExplosionTableEntry*, int>(NULL, True)
{
int entry_count;
*exp_stream >> entry_count;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Create all of the ExplosionTableEntries
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTableEntry *exp_entry;
for(int ii=0;ii<entry_count;++ii)
{
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Create a new ExplosionTableEntry
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
exp_entry = new ExplosionTableEntry(exp_stream);
Register_Object(exp_entry);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Add the entry the the ExplosionTable
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
AddValue(exp_entry, ii);
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTable::~ExplosionTable()
{
ExplosionTableIterator iterator(this);
iterator.DeletePlugs();
}
//##############################################################################
// Tool Support
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Logical
ExplosionTable::CreateStreamedExplosionTable(
ResourceFile *resource_file,
CString model_name,
NotationFile *exp_file,
CString exp_filename,
MemoryStream *explosion_stream
)
{
Check(resource_file);
Check(exp_file);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Make a namelist of all Explosion Entries
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
NameList *exp_namelist = exp_file->MakePageList();
Register_Object(exp_namelist);
if (!exp_namelist->EntryCount())
{
DEBUG_STREAM << exp_file << " is empty or missing \n"<<std::endl << std::flush;
Unregister_Object(exp_namelist);
delete exp_namelist;
return False;
}
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Write the Number of Explosion Entries for this Entity
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
int entry_count = exp_namelist->EntryCount();
*explosion_stream << entry_count;
NameList::Entry *exp_entry = exp_namelist->GetFirstEntry();
while(exp_entry)
{
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// While more pages Add ExplosionEntries to the stream
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
ExplosionTableEntry::CreateStreamedExplosion(
resource_file,
exp_filename,
exp_file,
exp_entry->GetName(),
explosion_stream
);
exp_entry = exp_entry->GetNextEntry();
}
Unregister_Object(exp_namelist);
delete exp_namelist;
return True;
}
//##########################################################################
//###################### EntityEffectWatcher #########################
//##########################################################################
//##############################################################################
// Construction/Destruction
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
EntityEffectWatcher::EntityEffectWatcher(
Entity *entity_watched
)
{
entityWatched = entity_watched;
entityWatched->AddEffectWatcher(this);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Init array to hold previous damageLevel values
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Verify(entityWatched->damageZoneCount > 0);
oldDamageLevel = new Scalar[entityWatched->damageZoneCount];
Register_Pointer(oldDamageLevel);
for(int ii=0;ii<entityWatched->damageZoneCount;++ii)
{
oldDamageLevel[ii] = 0.0f;
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
EntityEffectWatcher::~EntityEffectWatcher()
{
Unregister_Pointer(oldDamageLevel);
delete[] oldDamageLevel;
}
//##############################################################################
// Execute
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
EntityEffectWatcher::Execute()
{
Check(this);
Check(entityWatched);
Check_Pointer(entityWatched->damageZones);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Check the flags to see if any damageZones
// have been modified since the last Execute was called
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
DamageZone *current_zone;
ExplosionTable *exp_table;
ExplosionTableEntry *exp_entry(NULL);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Traverse damageZones looking for Changes
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
for (int ii=0;ii<entityWatched->damageZoneCount; ++ii)
{
current_zone = entityWatched->damageZones[ii];
Check(current_zone);
ResourceDescription::ResourceID exp_res;
exp_table = current_zone->GetExplosionTable();
Check(exp_table);
//
//~~~~~~~~~~~~~~~~~~~
// Check Damage Level
//~~~~~~~~~~~~~~~~~~~
//
if (current_zone->DamageLevelChanged())
{
exp_entry = exp_table->SelectDamageLevelEntry(current_zone->damageLevel);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// If delta was large enough signal an update
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
if (
exp_table->CrossedDamageLevelThreshold(
oldDamageLevel[ii],
current_zone->damageLevel
) &&
(entityWatched->GetInstance() == Entity::MasterInstance)
)
{
entityWatched->ForceUpdate(Entity::DamageZoneUpdateModelFlag);
}
oldDamageLevel[ii] = current_zone->damageLevel;
}
//
//~~~~~~~~~~~~~~~~~~~~
// Check Graphic State
//~~~~~~~~~~~~~~~~~~~~
//
if (current_zone->GraphicStateChanged())
{
exp_entry = exp_table->SelectGraphicStateEntry(
current_zone->GetGraphicState()
);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Always update for a graphic state change
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
if (entityWatched->GetInstance() == Entity::MasterInstance)
{
entityWatched->ForceUpdate(Entity::DamageZoneUpdateModelFlag);
}
}
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Notify RendererManager of Any Change
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
if (exp_entry)
{
Check(exp_entry);
exp_res = exp_entry->GetExplosionResourceID();
Check(application);
Check(application->GetRendererManager());
application->GetRendererManager()->StartEntityEffect(
entityWatched,
current_zone,
exp_res
);
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Reset the DamageZone::changedFlags if
// I am a master and no update occurred OR
// if I am a replicant
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
if (
(
(entityWatched->GetInstance() == Entity::MasterInstance) &&
!entityWatched->DamageZoneUpdateModelFlagSet()
) ||
(
(entityWatched->GetInstance() == Entity::ReplicantInstance)
)
)
{
current_zone->ResetChangedFlags();
}
}
exp_entry = NULL;
}
Check_Fpu();
}
//##############################################################################
// Test Support
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Logical
EntityEffectWatcher::TestInstance() const
{
Check(entityWatched);
return True;
}