vwemirror/firestorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2cfb14ab983b3e4e870f415133f2016f19a2fa0b
firestorm/Gameleap/code/mw4/Code/MW4GameEd2/GameInterface.cpp
T
Cyd 2b8ca921cb Initial full mirror of c:\VWE (source + assets + toolchain + outputs) via Git LFS 
Complete disaster-recovery snapshot: engine/game source, game data assets,
VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive.
Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false,
no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
2026-06-24 21:28:16 -05:00

3158 lines
84 KiB
C++
Raw Blame History

#include "stdafx.h"
#include <MW4\MW4.hpp>
#include <MW4\MW4.hpp>
#include <MFCPlatform\MFCPlatform.hpp>
#include <GameOS\ToolOS.hpp>
#include <Stuff\Stuff.hpp>
#include <MLR\MLR.hpp>
#include <GosFx\GosFx.hpp>
#include <GosFx\EffectLibrary.hpp>
#include <ElementRenderer\ElementRenderer.hpp>
#include <Adept\Adeptheaders.hpp>
#include <Adept\EntityManager.hpp>
#include <Adept\CollisionGrid.hpp>
#include <ElementRenderer\GridElement.hpp>
#include <Adept\Tile.hpp>
#include <MW4\MWMission.hpp>
#include <MW4\MWMap.hpp>
#include <Adept\Zone.hpp>
#include <MW4\Turret.hpp>
#include <MW4\Path.hpp>
#include <MW4\MWTable.hpp>
#include <MW4\WaterCultural.hpp>
#include <Compost\Compost.hpp>
#include <MW4\CameraShip.hpp>
#include <MW4\Objective.hpp>
#include <MW4\EffectGenerator.hpp>
#include <MW4\Flag.hpp>
#include <MW4\Team.hpp>
#include <Adept\ResourceEffectLibrary.hpp>
#include <Adept\CollisionVolume.hpp>
#include "GlobalDefines.h"
#include "UndoManager.h"
#include "NameManager.h"
#include "EdObjective.h"
#include <Adept\LightManager.hpp>
#include <MLR\MLRLight.hpp>
#include "GUILight.h"
#include "GUIFXGenerator.h"
#include "resource.h"
#include <Adept\VideoHeaders.hpp>
#include <ElementRenderer\ElementRenderer.hpp>
#include <ElementRenderer\StateChange.hpp>
#include <direct.h>
char *LocalIPAddress;
// This block may not be needed
using namespace MechWarrior4;
#include <MW4\Vehicle.hpp>
#include <MW4\Building.hpp>
#include <MW4\NonCom.hpp>
#include <MW4\Navpoint.hpp>
#include <MW4\Cultural.hpp>
#include <Adept\Dropzone.hpp>
#include <MW4\MWTool.hpp>
#include <MW4\SearchLight.hpp>
#include <MW4DedicatedUI\DedicatedUI.hpp>
#include <MW4\AI.hpp>
using namespace Stuff;
using namespace MW4AI;
using namespace Adept;
using namespace MidLevelRenderer;
#include <Buildnum\BuildNum.h>
#include <Adept\Map.hpp>
#include <MW4\MWTool.hpp>
#include <Adept\Tool.hpp>
#include <MW4\MWPlayer.hpp>
#include <mw4\mwapplication.hpp>
#include "EditorApplication.h"
#include "ObjectManager.h"
#include "OverviewWindow.h"
#include "NVGameObject.h"
#include "GUIDropZone.h"
#include "GUILattice.h"
#include "GUICamera.h"
#include "MissionReport.h"
#include "BldResDlg.h"
extern bool Immediate_Draw;
bool NeedResourceBuild=true;
bool AllowBuild=true;
bool AllowBldSkies=false; // jcem
bool NoBldMissions=false; // jcem
bool MissionLoaded=false;
extern bool gNoDialogs;
extern bool AllowFail;
#define USEEXTERNALLY
#ifdef USEEXTERNALLY
#define BUILDFILENAME "Content\\MW4Editor.Build"
#else
#define BUILDFILENAME "Content\\MechWarrior4.Build"
#endif
bool GameInitilized=false;
#include "GameInterface.h"
void SetMissionName(CString old_mission_name,CString new_mission_name);
void GameInit(HINSTANCE inst,HWND win,char *Comline)
{
InitGameOS(inst,win,Comline);
}
void InitClasses()
{
Stuff::InitializeClasses();
MidLevelRenderer::InitializeClasses(NULL, 2048*8);
Compost::InitializeClasses();
gosFX::InitializeClasses();
ElementRenderer::InitializeClasses();
Adept::InitializeClasses();
Map::LoadRadius = 8;
MechWarrior4::InitializeClasses();
EditorApplication::InitializeClass();
Immediate_Draw=false;
Adept::Tool::Instance = new MechWarrior4::MWTool();
Check_Object(Tool::Instance);
EditorApplication *MW4GameEd_Application = new EditorApplication;
Check_Object(MW4GameEd_Application);
GlobalPointers::AddGlobalPointer(MW4GameEd_Application, ApplicationGlobalPointerIndex);
MW4GameEd_Application->Initialize();
CollisionGrid::s_ignoreOBBCollisions=true;
Verify(!Network::GetInstance());
GlobalPointers::AddGlobalPointer(new Network, NetworkGlobalPointerIndex);
Check_Object(Network::GetInstance());
gos_EnableSetting(gos_Set_NumLockMode,2);
GameInitilized = true;
}
void TermClasses()
{
gNoDialogs=true;
AllowFail=true;
GameInitilized = false;
Check_Object(Adept::Application::GetInstance());
delete Adept::Application::GetInstance();
GlobalPointers::ClearPointer(ApplicationGlobalPointerIndex);
if (Tool::Instance)
{
Check_Object(Tool::Instance);
delete Tool::Instance;
}
EditorApplication::TerminateClass();
MechWarrior4::TerminateClasses();
Adept::TerminateClasses();
ElementRenderer::TerminateClasses();
gosFX::TerminateClasses();
Compost::TerminateClasses();
MidLevelRenderer::TerminateClasses();
Stuff::TerminateClasses();
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void _stdcall TerminateGameEngine()
{
Check_Object(ResourceManager::Instance);
delete ResourceManager::Instance;
ResourceManager::Instance=NULL;
Check_Object(Adept::Application::GetInstance());
Adept::Application::GetInstance()->Terminate();
TermClasses();
ExitGameOS();
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void _stdcall InitializeGameEngine()
{
// Stuff::ArmorLevel = 1;
InitClasses();
}
void LoadResourceForBuild(const char *resource_file_name,int level)
{
FileDependencies deps;
// PushFilePath(&parse_file);
ResourceFile *res_file =
ResourceManager::Instance->OpenResourceFile(
resource_file_name,
// dep_filename,
NULL,
level,
VER_CONTENTVERSION,
true,
false
);
/*
//
//-------------------------------------------------------
// If we have dependencies, write them into resource zero
//-------------------------------------------------------
//
{
Resource build_dependencies(resource_file_name);
if (!build_dependencies.DoesResourceExist())
{
unsigned length = dependencies->m_fileNameStream.GetBytesUsed();
if (length>0)
{
MemoryStream chain(
static_cast<BYTE*>(dependencies->m_fileNameStream.GetPointer()) - length,
length,
length
);
build_dependencies.Save(&chain, dependencies);
}
else
{
MemoryStream chain("", 1, 1);
build_dependencies.Save(&chain, NULL);
}
}
Verify(build_dependencies.GetResourceID().GetRecordID() == ResourceID::BuildDependenciesRecordID);
}
*/
// PopFilePath();
}
extern HGOSHEAP CurrentHeap;
void __stdcall
EdGetFileForGOS(
const char* file_name,
BYTE** memory,
DWORD* size
)
{
if(Tool::FindFileForGOS(file_name))
{
Tool::GetFileForGOS(file_name,memory,size);
}
else if(Application::FindFileForGOS(file_name))
{
Application::GetFileForGOS(file_name,memory,size);
BYTE *oldbuf=*memory;
*memory=(BYTE *)gos_Malloc(*size>0?*size:4,CurrentHeap);
CopyMemory(*memory,oldbuf,*size);
}
else STOP(("%s File Not found",file_name));
}
bool __stdcall EdFindFileForGOS(const char* filename)
{
return Application::FindFileForGOS(filename) || Tool::FindFileForGOS(filename);
}
void ObjectManager::BuildResources()
{
CBldResDlg dlg;
Environment.HookGetFile = Adept::Tool::GetFileForGOS;
Environment.HookDoesFileExist = Adept::Tool::FindFileForGOS;
gos_PushCurrentHeap(gosFX::Heap);
if(gosFX::EffectLibrary::Instance!=NULL)
{
delete gosFX::EffectLibrary::Instance;
gosFX::EffectLibrary::Instance=NULL;
}
gosFX::EffectLibrary::Instance = new ResourceEffectLibrary;
gos_PopCurrentHeap();
ResourceManager::Instance = new ResourceManager;
Check_Object(ResourceManager::Instance);
//
//--------------------------------------------------------
// We have disabled building, so load up the required data
//--------------------------------------------------------
//
LoadResourceForBuild("Resource\\textures.mw4",TexturesResourceFileID);
LoadResourceForBuild("Resource\\core.mw4",CoreResourceFileID);
LoadResourceForBuild("Resource\\props.mw4",PropsResourceFileID);
//LoadResourceForBuild("Resource\\skies.mw4",MissionResourceFileID+1);
//
//-------------------------
// Load up the core effects
//-------------------------
//
Resource libraries("{effects}");
Verify(libraries.DoesResourceExist());
libraries.LoadData();
ResourceID *lib = Cast_Pointer(ResourceID*, libraries.GetPointer());
for (unsigned i=0; i<libraries.GetSize()/sizeof(ResourceID); ++i, ++lib)
{
Resource library(*lib);
gosFX::EffectLibrary::Instance->Load(&library);
}
if(AllowBuild || AllowBldSkies) // jcem
{
FileDependencies deps;
Stuff::NotationFile build_script;
Stuff::NotationFile blank_nfile;
blank_nfile.SetPage("");
Page *bpage=build_script.SetPage("");
Check_Object(bpage);
bpage->SetEntry("skies.build",&blank_nfile);
if (AllowBuild) { // jcem
WIN32_FIND_DATA file_data;
HANDLE file_find;
file_find=FindFirstFile("Content\\Maps\\*.*",&file_data);
if(file_find != INVALID_HANDLE_VALUE)
{
CString map_name;
do
{
map_name=file_data.cFileName;
if(file_data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY &&
map_name!="." && map_name!=".." )
{
CString buildfname="Maps\\"+map_name+"\\"+map_name+".build";
bpage->SetEntry(buildfname,&blank_nfile);
}
}
while (FindNextFile(file_find,&file_data));
}
}
Application::BuildOK=true;
Tool::Instance->BuildResources(&build_script, VER_CONTENTVERSION, &deps,2);
build_script.IgnoreChanges();
}
Application::BuildOK=false;
gos_CreateDirectory("Resource\\UserMissions");
if (!NoBldMissions) { // jcem
bool maploaded=false;
WIN32_FIND_DATA file_data;
HANDLE file_find;
file_find=FindFirstFile("Content\\Missions\\*.*",&file_data);
if(file_find != INVALID_HANDLE_VALUE)
{
CString mis_name;
do
{
mis_name=file_data.cFileName;
if(file_data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY &&
mis_name!="." && mis_name!=".." )
{
CString instfname="Content\\Missions\\"+mis_name+"\\"+mis_name+".instance";
Stuff::NotationFile instfile(instfname);
Page *mis_page=instfile.GetPage(mis_name);
Check_Object(mis_page);
const char *mapentry;
mis_page->GetEntry("Map",&mapentry);
CString mapname=mapentry;
mapname=mapname.Mid(mapname.ReverseFind('\\')+1);
mapname=mapname.Left(mapname.ReverseFind('.'));
if(maploaded)
{
delete ResourceManager::Instance->GetResourceFile(MapResourceFileID);
maploaded=false;
}
LoadResourceForBuild("Resource\\Maps\\"+mapname+".mw4",MapResourceFileID);
maploaded=true;
// gos_CreateDirectory("Resource\\UserMissions");
if(AllowBuild)
{
CString mispath="Content\\Missions\\"+mis_name;
CString buildfname=mispath+"\\"+mis_name+".build";
//Stuff::NotationFile build_script(buildfname);
Stuff::NotationFile build_script(buildfname);
Stuff::NotationFile blank_nfile;
blank_nfile.SetPage("");
Page *bpage=build_script.SetPage("");
Check_Object(bpage);
bpage->SetEntry(buildfname,&blank_nfile);
Application::BuildOK=true;
Environment.HookGetFile = EdGetFileForGOS;
Environment.HookDoesFileExist = EdFindFileForGOS;
FileDependencies deps;
deps.AddDependency("Resource\\Maps\\"+mapname+".mw4");
// Tool::Instance->PushFilePath(&build_script);
Tool::Instance->BuildResources(&build_script, VER_CONTENTVERSION, &deps,3);
// Tool::Instance->PopFilePath();
Environment.HookGetFile = Adept::Tool::GetFileForGOS;
Environment.HookDoesFileExist = Adept::Tool::FindFileForGOS;
build_script.IgnoreChanges();
}
Application::BuildOK=false;
}
}
while (FindNextFile(file_find,&file_data));
}
delete ResourceManager::Instance->GetResourceFile(MapResourceFileID);
}
NeedResourceBuild=false;
ResourceManager::Instance->OpenResourceFile(
"Resource\\skies.mw4",
NULL,
MissionResourceFileID+1,
VER_CONTENTVERSION,
true,
false
);
delete gosFX::EffectLibrary::Instance;
gosFX::EffectLibrary::Instance=NULL;
MWApplication::GetInstance()->LoadLookupTables();
Environment.HookGetFile = Application::GetFileForGOS;
Environment.HookDoesFileExist = Application::FindFileForGOS;
}
void __stdcall GetGameOSEnvironment(char* CommandLine)
{
Environment.applicationName = "MW4GameEd2";
Environment.directoryPath = "code\\MW4GameEd2;Binaries\\MW4";
Environment.screenWidth = 640;
Environment.screenHeight = 480;
Environment.fullScreen = FALSE;
Environment.bitDepth = 16;
Environment.debugLog = "DebugLog.txt";
Environment.spew = "GameOS_Memory"; //GROUP_ADEPT_RESOURCE;
Environment.memoryTraceLevel = 10;
Environment.TimeStampSpew = false;
Environment.DoGameLogic = &MWApplication::DoGameLogic;
Environment.UpdateRenderers = &Application::UpdateDisplay;
Environment.InitializeGameEngine = InitializeGameEngine;
Environment.TerminateGameEngine = TerminateGameEngine;
Environment.Key_FullScreen = 0;
Environment.Key_SwitchMonitors = 0; //KEY_F5;
Environment.Key_Exit = 0;
Environment.Renderer = 0;
Environment.FullScreenDevice = 0;
Environment.AntiAlias = 0; // true/false - Enable full screen antialiasing
Environment.NetworkGame = false;
Environment.NetworkMaxPlayers = 2;
Environment.Texture_S_256 = 13;
Environment.Texture_S_128 = 12;
Environment.Texture_S_64 = 1;
Environment.Texture_S_32 = 1;
Environment.Texture_S_16 = 1;
Environment.Texture_K_256 = 1;
Environment.Texture_K_128 = 1;
Environment.Texture_K_64 = 1;
Environment.Texture_K_32 = 1;
Environment.Texture_K_16 = 1;
Environment.Texture_A_256 = 1;
Environment.Texture_A_128 = 1;
Environment.Texture_A_64 = 1;
Environment.Texture_A_32 = 1;
Environment.Texture_A_16 = 1;
Environment.soundChannels = 32;
Environment.soundDisable = true;
Environment.soundHiFi = false;
Environment.dontClearRegistry = true;
Environment.MaxTimeDelta = 0.25f;
}
#define COLSTART 600.0f
float ComputeTerrainElevation(float x,float z,Entity *ignore_entity)
{
if (!GameInitilized || !MissionLoaded)
return 0.0f;
if ((Mission::GetInstance() == 0)) return 0.0f;
Entity::CollisionMask collisionType = Entity::CanBeWalkedOnFlag;
Stuff::Line3D line;
Point3D point;
point.x = x;
point.z = z;
point.y = COLSTART;
line.m_length = 1000.0f;
line.m_direction = Vector3D::Down;
line.SetOrigin(point);
//
// Prepare query
//
Stuff::Normal3D inormal;
Stuff::Line3D iline;
Stuff::Normal3D normal;
Entity *entity_hit;
Check_Object(CollisionGrid::Instance);
Entity::CollisionQuery query(&line, &normal, collisionType,ignore_entity);
entity_hit = CollisionGrid::Instance->ProjectLine(&query);
if(entity_hit != NULL)
{
line.FindEnd(&point);
}
return (point.y);
}
Entity *GetTopEntity(float x,float z,float& height)
{
if (Mission::GetInstance() == 0) return NULL;
Entity::CollisionMask collisionType = Entity::CanBeShotFlag;
Stuff::Line3D line;
Point3D point;
point.x = x;
point.z = z;
point.y = COLSTART;
line.m_length = 1000.0f;
line.m_direction = Vector3D::Down;
line.SetOrigin(point);
//
// Prepare query
//
Stuff::Normal3D inormal;
Stuff::Line3D iline;
Stuff::Normal3D normal;
Check_Object(CollisionGrid::Instance);
Entity::CollisionQuery query(&line, &normal, collisionType,NULL);
Entity *entity;
entity=CollisionGrid::Instance->ProjectLine(&query);
if (entity != 0)
{
Stuff::Point3D end;
query.m_line->FindEnd(&end);
height = end.y;
}
if(entity->IsDerivedFrom(MWMover::DefaultData))
{
MWMover *mover;
mover = Cast_Object(MWMover *, entity);
if(mover->myParentVehicle)
return mover->myParentVehicle;
}
return entity;
}
CString GetMissionScriptName()
{
if ((Mission::GetInstance() == 0) ||
(Mission::GetInstance()->IsDerivedFrom(MWMission::DefaultData) == false))
{
return ("");
}
MWMission* mwmission = Cast_Object(MWMission*,Mission::GetInstance());
return (mwmission->scriptName);
}
void SetMissionScriptName(const CString& script_name)
{
if ((Mission::GetInstance() == 0) ||
(Mission::GetInstance()->IsDerivedFrom(MWMission::DefaultData) == false))
{
return;
}
MWMission* mwmission = Cast_Object(MWMission*,Mission::GetInstance());
strcpy(mwmission->scriptName,script_name);
}
void ObjectManager::CheckScripts()
{
Environment.HookGetFile = EdGetFileForGOS;
Environment.HookDoesFileExist = EdFindFileForGOS;
if (Mission::GetInstance() == 0) return;
MWMission *mission = Cast_Object(MWMission*,Mission::GetInstance());
mission->UnloadScript();
MWMap *inst;
AI *ai;
inst = Cast_Object(MWMap *,Map::GetInstance());
ChainIteratorOf<AI *> iterator2(&inst->m_executingAIs);
iterator2.First();
while ((ai = iterator2.ReadAndNext()) != NULL)
{
Check_Object(ai);
ai->UnloadScript();
}
ABL::ABLError error;
CString errstr;
CString filename;
CString cmdline,line;
char errMessage[500];
if (!mission->ReloadABL (&error))
{
sprintf(errMessage, "SYNTAX ERROR %s [line %d] - (type %d) %s\n", error.File (), error.Line (),error.Code (), error.String ());
MessageBox (NULL,errMessage,"ABL Error",MB_OK);
filename = error.File ();
// cmdline = "c:\\vslick\\win\\vs ";
cmdline = "vs ";
cmdline += "\"";
_getcwd (errMessage,500);
if (filename[1] != ':')
{
cmdline += errMessage;
cmdline += "\\";
}
cmdline += filename;
cmdline += "\"";
cmdline += " -#";
itoa (error.Line (),errMessage,10);
cmdline += errMessage;
// system ((LPCTSTR) cmdline);
if (WinExec ((LPCTSTR) cmdline,SW_SHOW) <= 31) // old function but it works
{
MessageBox (NULL,"Unable to start SlickEdit, make sure it's in your path","error",MB_OK);
}
// CreateProcess (NULL,cmdline,NULL,NULL,FALSE,0,NULL,NULL,NULL,NULL);
return;
}
if (!mission->ReloadScript (&error))
{
sprintf(errMessage, "SYNTAX ERROR %s [line %d] - (type %d) %s\n", error.File (), error.Line (),error.Code (), error.String ());
MessageBox(NULL,errMessage,"ABL Error",MB_OK);
filename = error.File ();
// cmdline = "c:\\vslick\\win\\vs ";
cmdline = "vs ";
cmdline += "\"";
_getcwd(errMessage,500);
if (filename[1] != ':')
{
cmdline += errMessage;
cmdline += "\\";
}
cmdline += filename;
cmdline += "\"";
cmdline += " -#";
itoa (error.Line(),errMessage,10);
cmdline += errMessage;
// system ((LPCTSTR) cmdline);
if (WinExec((LPCTSTR) cmdline,SW_SHOW) <= 31) // old function but it works
MessageBox (NULL,"Unable to start SlickEdit. Make sure it's in your path","Error",MB_OK);
// CreateProcess (NULL,cmdline,NULL,NULL,FALSE,0,NULL,NULL,NULL,NULL);
return;
}
iterator2.First();
while ((ai = iterator2.ReadAndNext()) != NULL)
{
{
if (!ai->ReloadScript(&error))
{
sprintf(errMessage, "SYNTAX ERROR %s [line %d] - (type %d) %s\n", error.File (), error.Line (),error.Code (), error.String ());
MessageBox(NULL,errMessage,"ABL Error",MB_OK);
filename = error.File();
cmdline = "vs ";
// cmdline = "c:\\vslick\\win\\vs ";
cmdline += "\"";
_getcwd(errMessage,500);
if (filename[1] != ':')
{
cmdline += errMessage;
cmdline += "\\";
}
cmdline += filename;
cmdline += "\"";
cmdline += " -#";
itoa(error.Line(),errMessage,10);
cmdline += errMessage;
// system ((LPCTSTR) cmdline);
if (WinExec((LPCTSTR) cmdline,SW_SHOW) <= 31) // old function but it works
{
MessageBox(NULL,"Unable to start SlickEdit. Make sure it's in your path.","Error",MB_OK);
}
// CreateProcess (NULL,cmdline,NULL,NULL,FALSE,0,NULL,NULL,NULL,NULL);
return;
}
}
}
CheckAlternativeScripts();
Environment.HookGetFile = Application::GetFileForGOS;
Environment.HookDoesFileExist = Application::FindFileForGOS;
}
// **************************************************************************
// ObjectManager Game Related Code
// **************************************************************************
EdGUIObject *ObjectManager::AttachGameObject(Entity *entity)
{
Check_Object(entity);
EdGameObject *obj=NULL;
if(entity->IsDerivedFrom(Vehicle::DefaultData) || // Visual Objects
entity->IsDerivedFrom(Building::DefaultData) ||
entity->IsDerivedFrom(Cultural::DefaultData) ||
entity->IsDerivedFrom(NonCom::DefaultData)
)
{
if(!entity->IsPlayerVehicle())
{
obj=new EdGameObject;
obj->AssociateTo(entity);
AddObject(obj);
return obj;
}
}
else if(entity->IsDerivedFrom(Path::DefaultData))
{
GUIPath *pobj=new GUIPath;
pobj->AssociateTo(Cast_Object(Path*,entity));
AddObject(pobj);
return pobj;
}
else if(entity->IsDerivedFrom(DropZone::DefaultData))
{
GUIDropZone *dzobj=new GUIDropZone;
dzobj->AssociateTo(Cast_Object(DropZone*,entity));
AddObject(dzobj);
return dzobj;
}
else if(entity->IsDerivedFrom(NavPoint::DefaultData) ||
entity->IsDerivedFrom(Flag::DefaultData) ||
entity->IsDerivedFrom(Team::DefaultData) )
{
obj=new NVGameObject;
obj->AssociateTo(entity);
AddObject(obj);
return obj;
}
else if(entity->IsDerivedFrom(CameraShip::DefaultData) )
{
GUICamera *cam=new GUICamera();
cam->AssociateTo(entity);
AddObject(cam);
return cam;
}
else if(entity->IsDerivedFrom(Objective::DefaultData) )
{
EdObjective *obj=new EdObjective();
obj->AssociateTo(entity);
ObjectiveList.AddObject(obj);
return obj;
}
else if(entity->IsDerivedFrom(EffectGenerator::DefaultData) )
{
GUIFXGenerator *obj=new GUIFXGenerator();
obj->AssociateTo(entity);
AddObject(obj);
return obj;
}
if(HasCollsion(entity))
{
obj=new EdGameObject;
obj->AssociateTo(entity);
AddObject(obj);
return obj;
}
return NULL;
}
void ObjectManager::SyncToGame(ViewWindowInfo *vinf)
{
NameTable::GetInstance()->IsValid();
Verify(IsLoaded());
Dissociate();
DeleteAllObjects();
if(UndoMan) {delete UndoMan; UndoMan=NULL;}
UndoMan=new UndoManager;
// Set Mission Name
CString misname(MWApplication::GetInstance()->GetMissionName());
misname=misname.Left(misname.ReverseFind('.'));
misname=misname.Mid(misname.ReverseFind('\\')+1);
Name=misname;
MapName=(char *)Map::GetInstance()->GetDataListResource()->GetName();
MapName=MapName.Left(MapName.ReverseFind('.'));
MapName=MapName.Mid(MapName.ReverseFind('\\')+1);
// Make GUI Objects for Game Objects
Map::GetInstance()->GetDataListResource()->LoadData();
ChainIteratorOf<Entity *> iterator(&Map::GetInstance()->childEntityChain);
Entity *entity;
while((entity = iterator.ReadAndNext()) != NULL)
{
AttachGameObject(entity);
}
gosFX::Light* gamelight;
GUILight *edlight;
ChainIteratorOf<gosFX::Light*> lightiterator(&Mission::GetInstance()->m_staticLights);
while((gamelight = lightiterator.ReadAndNext()) != NULL)
{
switch (gamelight->m_light->GetLightType())
{
case MLRLight::AmbientLight:
edlight=new GUIAmbientLight("Ambient Light");
break;
case MLRLight::InfiniteLight:
edlight=new GUIInfiniteLight("Infinite Light");
break;
case MLRLight::PointLight:
edlight=new GUIPointLight("Point Light");
break;
case MLRLight::SpotLight:
edlight=new GUISpotLight("Spot Light");
break;
case MLRLight::LookUpLight:
Verify(LLight==NULL);
LLight=new GUILookUpLight("LookUp Light");
LLight->AssociateTo(gamelight);
AddObject(LLight);
default:
edlight=NULL;
}
if(edlight)
{
edlight->AssociateTo(gamelight);
AddObject(edlight);
}
}
// Get the Map Size
BYTE rows, cols;
Map::GetInstance()->GetElement()->GetSize(&rows, &cols);
// Save the MapSize
MapSize=Point3D(rows*c_ZoneSize,0.0f,cols*c_ZoneSize);
vinf->SetMapSize(MapSize);
vinf->SetZoneSize(c_ZoneSize);
vinf->SetTileSize(c_TileSize);
int i;
// Load missionBounds
DynamicArrayOf<Stuff::Vector2DOf<Stuff::Scalar> > Bound;
Mission::GetInstance()->GetMissionPolygon(Bound);
for (i = 0; i < Bound.GetLength(); i++)
{
Bound[i].x /= Map::GetInstance()->GetColumnZoneScale();
Bound[i].y /= Map::GetInstance()->GetRowZoneScale();
Bound[i].x -= MapSize.x*0.5f;
Bound[i].y -= MapSize.z*0.5f;
}
MissionBound->SetBoundData(Bound);
// Load warningBounds
Mission::GetInstance()->GetWarningPolygon(Bound);
for (i = 0; i < Bound.GetLength(); i++)
{
Bound[i].x /= Map::GetInstance()->GetColumnZoneScale();
Bound[i].y /= Map::GetInstance()->GetRowZoneScale();
Bound[i].x -= MapSize.x*0.5f;
Bound[i].y -= MapSize.z*0.5f;
}
WarningBound->SetBoundData(Bound);
// Load The Terrain Textures
CString MapName(CString(Map::GetInstance()->GetDataListResource()->GetName()));
MapName=MapName.Left(MapName.ReverseFind('.'));
MapName=MapName.Mid(MapName.ReverseFind('\\')+1);
TerrainTexture.CreateBlank(cols*256,rows*256,ITYPE_RGB,24,RGBMask(0xff0000,0x00ff00,0x0000ff));
LoadTerrainTexture(&TerrainTexture);
Point3D map_scale;
HField.CreateBlank(256,256,ITYPE_RGB,24);
map_scale=BuildHFFromMap(&HField);
SlopeMap=HField;
MakeSlopeMap(&SlopeMap,map_scale);
MisDat.SyncToGame();
AddObject(Lattice=new GUILattice(MW4AI::g_MissionGraph));
ClearModifyFlags();
}
#define Round(x) floor((x)+.5f)
void ObjectManager::LoadTerrainTexture(Image *img)
{
BYTE rows, cols;
Map::GetInstance()->GetElement()->GetSize(&rows, &cols);
int texturesize=256;
CString map_texture_path;
int xblock,yblock;
xblock=img->GetWidth()/cols;
yblock=img->GetHeight()/rows;
char rowchar,colchar;
BYTE currow,curcol;
Image oimg;
for(currow=0;currow<rows;currow++)
for(curcol=0;curcol<cols;curcol++)
{
rowchar='A'+currow;
colchar='A'+curcol;
int bltlocx,bltlocy;
bltlocx=((cols-1)-curcol)*xblock;
bltlocy=((rows-1)-currow)*yblock;
map_texture_path.Format("Content\\Textures\\Maps\\%s\\%c%c\\%s_%c%c_0_0000.png",MapName,rowchar,colchar,MapName,rowchar,colchar);
if(!gos_DoesFileExist(map_texture_path))
{
map_texture_path.Format("Content\\Textures\\Maps\\%s\\%c%c\\%s_%c%c_0_0000.tga",MapName,rowchar,colchar,MapName,rowchar,colchar);
if(gos_DoesFileExist(map_texture_path))
{
oimg.LoadTga((char *)(LPCSTR)map_texture_path);
}
else
{
PAUSE(("Map Texture %s Missing",(char *)(LPCSTR)map_texture_path));
}
}
else
{
oimg.LoadPng((char *)(LPCSTR)map_texture_path);
}
img->Blt(oimg,
CRect(bltlocx,bltlocy,bltlocx+xblock,bltlocy+yblock),
CRect(0,0,texturesize,texturesize));
}
img->AutoAdjust();
}
Point3D ObjectManager::BuildHFFromMap(Image *img)
{
Verify(IsLoaded());
int imgxlen,imgylen;
imgxlen=img->GetWidth();
imgylen=img->GetHeight();
int imgsize=imgxlen*imgylen;
Scalar *fmap=new Scalar[imgsize];
int x,y;
Scalar fx,fz,xinc,zinc,hmin,hmax,val;
xinc=MapSize.x/img->GetWidth();
zinc=MapSize.z/img->GetHeight();
hmin=hmax=ComputeTerrainElevation(0,0,NULL);
for(y=0,fz=MapSize.z*0.5f-zinc*0.5f;y<imgsize;fz-=zinc,y+=imgxlen)
for(x=0,fx=MapSize.x*0.5f-xinc*0.5f;x<imgxlen;fx-=xinc,x++)
{
val=ComputeTerrainElevation(fx,fz,NULL);
if(val<hmin) hmin=val;
if(val>hmax) hmax=val;
fmap[x+y]=val;
Verify(fmap[x+y]<COLSTART);
}
BYTE *dtp=img->Lock();
ImgRGBColor col;
Scalar mval=255/(hmax-hmin);
int imgy,imgx;
BYTE ival;
for(y=imgy=0;y<imgsize;imgy+=imgxlen*3,y+=imgxlen)
for(imgx=x=0;x<imgxlen;x++,imgx+=3)
{
ival=(BYTE)Round((fmap[x+y]-hmin)*mval);
dtp[imgx+imgy+0]=ival;
dtp[imgx+imgy+1]=ival;
dtp[imgx+imgy+2]=ival;
// col.r=col.g=col.b=(int)Round((fmap[x+y]-hmin)*mval);
// ((RGBPixel *)(dtp+x+imgy))->Set(col,img->Mask);
}
img->UnLock();
delete fmap;
return Point3D(MapSize.x/imgxlen,(hmax-hmin)/256,MapSize.z/imgylen);
}
void ObjectManager::MakeSlopeMap(Image *img,Point3D map_scale)
{
img->MakeContourMap(map_scale.x,
map_scale.z,
map_scale.y,
10,
ImgRGBColor(64,64,64),
ImgRGBColor(200,100,0),ImgRGBColor(0,255,0)
);
img->MakeRGB24();
}
void MakeMissionNight(bool night);
bool IsMissionNight();
bool ObjectManager::OpenMission(CString missionFileName,bool night)
{
if(IsLoaded())
{
if(!CloseMission()) return false;
}
Verify(!::MissionLoaded);
Verify(!IsLoaded());
Check_Object(ResourceManager::Instance);
if(NeedResourceBuild)
{
BuildResources();
}
Environment.HookGetFile = Application::GetFileForGOS;
Environment.HookDoesFileExist = Application::FindFileForGOS;
Check_Object(Application::GetInstance());
CString game_name=missionFileName;
game_name=game_name.Left(game_name.ReverseFind('.'));
game_name=game_name.Mid(game_name.ReverseFind('\\')+1);
((MWApplication *)Application::GetInstance())->m_isNight=night;
if( missionFileName.Find("Content") != -1)
{
DynamicMemoryStream request_vehicle_stream;
bool custom = false;
request_vehicle_stream.WriteBytes(&custom, 1);
short file_id = 0;
short record_id = 0;
request_vehicle_stream.WriteBytes(&file_id, 4);
request_vehicle_stream.WriteBytes(&record_id, 4);
MWApplication::GetInstance()->SetMissionName(missionFileName);
request_vehicle_stream.Rewind();
// request our mech...
//Network::GetInstance()->SendNetMessage(Connection::Server->GetID(), MWApplication::RequestPlayerVehicleMessageID, &request_vehicle_stream, true);
//Network::GetInstance()->SendNetMessage(Connection::Server->GetID(), MWApplication::ReadyToLaunchMessageID, NULL, true);
MWApplication::GetInstance()->RequestPlayerVehicleMessageHandler(Connection::Server->GetID(), &request_vehicle_stream);
MWApplication::GetInstance()->ReadyToLaunchMessageHandler(Connection::Server->GetID(), NULL);
MWApplication::GetInstance()->LaunchGame();
Network::GetInstance()->SendNetMessage(Connection::Server->GetID(), MWApplication::ClientLoadedMessageID, NULL, true);
Check_Object(EntityManager::GetInstance());
EntityManager::GetInstance()->SuspendExecution();
// This is bad since the map isn't guaranteed to be loaded until
// the application enters into the running state.
// but we can work around this!
while (Network::GetInstance()->RouteLocalPacket())
{
}
Check_Object(Map::GetInstance());
ChainIteratorOf<Entity *> iterator(&Map::GetInstance()->childEntityChain);
Entity* entity;
CString game_base_path(game_name),contents_path;
game_base_path=game_base_path.Left(game_base_path.ReverseFind('.'));
contents_path=game_base_path+".contents";
Stuff::NotationFile contentsfile((LPCSTR)contents_path);
while((entity = iterator.ReadAndNext()) != NULL)
{
if(entity->GetPropType() == Entity::MapPropType)
{
EntityManager::GetInstance()->GetNameSocket()->AddValue(entity, entity->instanceName);
}
}
}
ClearModifyFlags();
SourceMission="";
GeneralEventQueue::Instance->ProcessAllEvents();
RemoveEntityFromNameTable(Player::GetInstance()->vehicle);
::MissionLoaded=true;
MapLoaded=true;
return true;
}
bool ObjectManager::CloseMission()
{
if(!::MissionLoaded) return true;
Check_Object(Application::GetInstance());
ClipBoard.DeleteAllObjects();
if(UndoMan) {delete UndoMan; UndoMan=NULL;}
Dissociate();
DeleteAllObjects();
ObjectiveList.Dissociate();
ObjectiveList.DeleteAllObjects();
MapName="";
// NameManager::GetInstance()->RemoveString(Name);
Name="";
for(int i=0;i<GT_TOTALGAMES;i++)
MPGames[i]=MPGame();
// try
{
Application::GetInstance()->StopGame();
Verify(!Network::GetInstance());
GlobalPointers::AddGlobalPointer(new Network, NetworkGlobalPointerIndex);
Check_Object(Network::GetInstance());
delete gosFX::EffectLibrary::Instance;
gosFX::EffectLibrary::Instance=NULL;
ResourceManager::Instance->CloseAllButCore();
MapLoaded=false;
::MissionLoaded=false;
}
// catch(...)
{
// return false;
}
return true;
}
void ObjectManager::SaveMission(CString fname,bool textout)
{
SetName(fname);
SaveMission(textout);
/*
CString old_name=GetName();
SetName(fname);
CString mis_name=GetName();
CString mis_res_name;
mis_res_name.Format("Resource\\UserMissions\\%s.mw4",mis_name);
ResourceFile *new_mis_file=ResourceManager::Instance->GetResourceFile(MissionResourceFileID);
new_mis_file->SaveAs(mis_res_name);
CloseMission();
CString mis_path;
mis_path.Format("Content\\Missions\\%s\\%s.Instance",mis_name,mis_name);
OpenMission(mis_path);
SourceMission=old_name;
SaveMission(textout);
*/
}
void ObjectManager::SaveMission(bool textout)
{
Environment.HookGetFile = Adept::Tool::GetFileForGOS;
Environment.HookDoesFileExist = Adept::Tool::FindFileForGOS;
if((SourceMission!="" && !gos_DoesFileExist("Content\\Missions\\"+SourceMission)))
{
ClearModifyFlags();
MessageBox(NULL,"This Mission is based on a mission the does not exist on disk in text format, it cannot be saved","Save Error",MB_OK|MB_ICONHAND);
return;
}
else if(SourceMission=="" && !gos_DoesFileExist("Content\\Missions\\"+GetName()))
{
ClearModifyFlags();
MessageBox(NULL,"A Mission cannot be saved unless it orginated from text","Save Error",MB_OK|MB_ICONHAND);
return;
}
if(!IsLoaded()) return;
Check_Object(Mission::GetInstance());
Check_Object(Application::GetInstance());
Check_Object(Map::GetInstance());
Check_Object(NameTable::GetInstance());
CString msg;
if(AddEssentialObjects(msg))
{
MessageBox(NULL,msg,"Mission Modified",MB_OK);
}
CString mis_res_name;
mis_res_name.Format("Resource\\UserMissions\\%s.mw4",GetName());
Stuff::MString missionname = (const char *)mis_res_name;
if (MWApplication::TranslateMissionNameIfNecessary(missionname))
{
mis_res_name = (const char *)missionname;
}
SetMissionScriptName("Content\\Missions\\"+GetName()+"\\Scripts\\"+GetName()+".abl");
ResourceFile *new_mis_file=ResourceManager::Instance->GetResourceFile(MissionResourceFileID);
new_mis_file->SaveAs(mis_res_name);
if(textout)
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
CreateDirectory(mis_path,NULL);
CreateDirectory(mis_path+"\\Scripts",NULL);
CreateDirectory(mis_path+"\\DropZones",NULL);
CreateDirectory(mis_path+"\\Paths",NULL);
//Copy Default Script
CString script_name;
script_name.Format("%s\\scripts\\%s.abl",mis_path,mis_name);
if(!gos_DoesFileExist(script_name))
{
if(SourceMission=="")
CopyFile("Content\\Missions\\EditorTemplate\\Scripts\\EditorTemplate.ABL",script_name,NULL);
else
CopyFile("Content\\Missions\\"+SourceMission+"\\Scripts\\"+SourceMission+".ABL",script_name,NULL);
}
script_name.Format("%s\\scripts\\player.abl",mis_path,mis_name);
if(!gos_DoesFileExist(script_name))
{
if(SourceMission=="")
CopyFile("Content\\Missions\\EditorTemplate\\Scripts\\player.ABL",script_name,NULL);
else
CopyFile("Content\\Missions\\"+SourceMission+"\\Scripts\\player.ABL",script_name,NULL);
}
//Copy Default Audio
CString audio_name;
audio_name.Format("%s\\%s.sounds",mis_path,mis_name);
if(!gos_DoesFileExist(audio_name))
{
if(SourceMission=="")
CopyFile("Content\\Missions\\EditorTemplate\\EditorTemplate.sounds",audio_name,NULL);
else
CopyFile("Content\\Missions\\"+SourceMission+"\\"+SourceMission+".sounds",audio_name,NULL);
}
//Copy Default Lights
CString lights_name;
lights_name.Format("%s\\%s.lights",mis_path,mis_name);
if(!gos_DoesFileExist(lights_name))
{
if(SourceMission=="")
CopyFile("Content\\Missions\\EditorTemplate\\EditorTemplate.lights",lights_name,NULL);
else
{
CopyFile("Content\\Missions\\"+SourceMission+"\\"+SourceMission+".lights",lights_name,NULL);
NotationFile lights_file(lights_name);
NotationFile::PageIterator *pages=lights_file.MakePageIterator();
Page *page;
while(page=pages->ReadAndNext())
{
Note *note=page->FindNote("MapName");
if(note)
{
const char *str;
note->GetEntry(&str);
CString lnt=str;
CString new_rname="Content\\Missions\\"+mis_name+"\\"+mis_name+".raw";
CopyFile(lnt,new_rname,NULL);
note->SetEntry(new_rname);
}
}
lights_file.Save();
}
}
//Copy Night Lights
lights_name.Format("%s\\%snight.lights",mis_path,mis_name);
if(!gos_DoesFileExist(lights_name))
{
if(SourceMission=="")
CopyFile("Content\\Missions\\EditorTemplate\\EditorTemplatenight.lights",lights_name,NULL);
else
{
CopyFile("Content\\Missions\\"+SourceMission+"\\"+SourceMission+"night.lights",lights_name,NULL);
NotationFile lights_file(lights_name);
NotationFile::PageIterator *pages=lights_file.MakePageIterator();
Page *page;
while(page=pages->ReadAndNext())
{
Note *note=page->FindNote("MapName");
if(note)
{
const char *str;
note->GetEntry(&str);
CString lnt=str;
CString new_rname="Content\\Missions\\"+mis_name+"\\"+mis_name+".raw";
CopyFile(lnt,new_rname,NULL);
note->SetEntry(new_rname);
}
}
lights_file.Save();
}
}
SaveOverViewMap("Resource\\UserMissions\\"+GetName()+".tga",CSize(112,112));
SaveContentsTextFile();
SaveNameTable();
SaveRailGraph();
SaveBounds();
SaveInstanceTextFile();
SaveDataTextFile();
SaveLightsTextFile();
SaveBuildFile();
UpdateNFOFile();
// if(!InBuildFile()) AddToBuildFile();
// Verify(InBuildFile());
}
else
{
STOP(("Unimplemented"));
}
CString inifilename("Content\\Missions\\"+GetName()+"\\"+GetName()+".ini");
NotationFile info_file((LPCSTR)(inifilename));
MakeFileWriteable(inifilename);
SaveTextInfo(&info_file);
info_file.Save();
NeedResourceBuild=true;
SourceMission="";
ClearModifyFlags();
// DeleteFile("Resource\\UserMissions\\"+GetName()+".mw4");
DeleteFile("Resource\\UserMissions\\"+GetName()+".dep");
Environment.HookGetFile = Application::GetFileForGOS;
Environment.HookDoesFileExist = Application::FindFileForGOS;
}
void ObjectManager::SaveBuildFile()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
//Make Build File
CString bf_name;
bf_name.Format("%s\\%s.build",mis_path,mis_name);
MakeFileWriteable(bf_name);
CString page_name;
NotationFile build_file((LPCSTR)bf_name);
Page *page;
NotationFile::PageIterator *pages=build_file.MakePageIterator();
page=pages->ReadAndNext();
if(page!=NULL)
{
page_name=page->GetName();
}
else
{
page_name="Resource\\UserMissions\\"+mis_name+".mw4";
}
build_file.DeleteAllPages();
page=build_file.SetPage(page_name);
Check_Object(page);
CString hint_path;
hint_path.Format("%s\\%s.hint",mis_path,mis_name);
page->SetEntry("texturepool",hint_path);
CString inst_name;
inst_name.Format("Content\\Missions\\%s\\%s.instance",mis_name,mis_name);
page->SetEntry("Instance",(char *)(LPCSTR)inst_name);
page->AppendEntry("directory","Content\\Missions\\"+mis_name+"\\scripts");
page->SetEntry("Soundpool","Content\\Missions\\"+mis_name+"\\"+mis_name+".sounds");
build_file.Save();
}
void SetMapTo(const CString& map_name)
{
CString map_res_name;
map_res_name.Format("Resource\\Maps\\%s.mw4",map_name);
Resource deps(ResourceID(MissionResourceFileID, ResourceID::BuildDependenciesRecordID));
Verify(deps.DoesResourceExist());
DynamicMemoryStream stream;
MString map_dep_name_m = (LPCSTR)map_res_name;
stream << (char*)map_dep_name_m;
stream << '\0';
Stuff::FileDependencies build_dependancies;
build_dependancies.AddDependency("");
// deps.Save(&stream,NULL);
deps.Save(&stream,&build_dependancies);
}
void ObjectManager::NewMission(CString mis_name,CString map_name)
{
if(IsLoaded())
CloseMission();
CString template_mis_name="editortemplate";
CString mis_res_name;
CString temp_res_name;
mis_res_name.Format("Resource\\UserMissions\\%s.mw4",mis_name);
Stuff::MString missionname = (const char *)mis_res_name;
if (MWApplication::TranslateMissionNameIfNecessary(missionname))
{
mis_res_name = (const char *)missionname;
}
temp_res_name.Format("Resource\\Missions\\%s.mw4",template_mis_name);
missionname = (const char *)temp_res_name;
if (MWApplication::TranslateMissionNameIfNecessary(missionname))
{
temp_res_name = (const char *)missionname;
}
ResourceFile *new_mis_file=ResourceManager::Instance->OpenResourceFile(
(LPCSTR)temp_res_name,NULL,MissionResourceFileID,VER_CONTENTVERSION,true,false);
SetMapTo(map_name);
{
CString old_mission_name=template_mis_name;
CString new_mission_name=mis_name;
CString old_name,resource_name;
Resource mission_resource;
mission_resource.First(new_mis_file);
//Skip the first one since it is the dependancies structure
mission_resource.ReadAndNext();
while(mission_resource.ReadAndNext())
{
mission_resource.LoadData();
resource_name=mission_resource.GetName();
resource_name.MakeLower();
resource_name.Replace(old_mission_name,new_mission_name);
mission_resource.ChangeName(resource_name);
}
}
new_mis_file->SaveAs(mis_res_name);
delete ResourceManager::Instance->GetResourceFile(MissionResourceFileID);
CString mis_path;
mis_path.Format("Content\\Missions\\%s\\%s.Instance",mis_name,mis_name);
OpenMission(mis_path);
SourceMission="EditorTemplate";
MPGames[GT_SinglePlayer].Supported=true;
}
void SetMissionName(CString old_mission_name,CString new_mission_name)
{
old_mission_name.MakeLower();
new_mission_name.MakeLower();
CString mis_res_name;
mis_res_name.Format("Resource\\UserMissions\\%s.mw4",old_mission_name);
Stuff::MString missionname = (const char *)mis_res_name;
if (MWApplication::TranslateMissionNameIfNecessary(missionname))
{
mis_res_name = (const char *)missionname;
}
ResourceFile *new_mis_file=ResourceManager::Instance->GetResourceFile(MissionResourceFileID);
CString old_name,resource_name;
ResourceID gmid,dlid,rid;
Resource *dlres;
Resource *gmres;
dlres=Mission::GetInstance()->GetDataListResource();
dlres->LoadData();
resource_name=dlres->GetName();
resource_name.MakeLower();
resource_name.Replace(old_mission_name,new_mission_name);
dlres->ChangeName(resource_name);
dlid=dlres->GetResourceID();
gmres=Mission::GetInstance()->GetGameModelResource();
gmres->LoadData();
resource_name=gmres->GetName();
resource_name.MakeLower();
resource_name.Replace(old_mission_name,new_mission_name);
gmres->ChangeName(resource_name);
gmid=gmres->GetResourceID();
Resource mission_resource;
mission_resource.First(new_mis_file);
//Skip the first one since it is the dependancies structure
mission_resource.ReadAndNext();
while(mission_resource.ReadAndNext())
{
rid=mission_resource.GetResourceID();
if((rid!=gmid) && (rid!=dlid))
{
mission_resource.LoadData();
resource_name=mission_resource.GetName();
resource_name.MakeLower();
resource_name.Replace(old_mission_name,new_mission_name);
mission_resource.ChangeName(resource_name);
}
}
MWApplication::GetInstance()->SetMissionName(new_mission_name);
}
void ObjectManager::SaveLightsTextFile()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
// Save Contents File
CString lights_path;
if(IsMissionNight())
lights_path.Format("%s\\%snight.lights",mis_path,mis_name);
else
lights_path.Format("%s\\%s.lights",mis_path,mis_name);
MakeFileWriteable(lights_path);
NotationFile lights_file(lights_path);
lights_file.DeleteAllPages();
ChainIteratorOf<gosFX::Light*> lightiterator(&Mission::GetInstance()->m_staticLights);
int lcntr=0;
CString lname;
gosFX::Light* gamelight;
lightiterator.First();
while((gamelight = lightiterator.ReadAndNext()) != NULL)
{
lname.Format("LookUpLight");
if(gamelight->m_light->GetLightType()==MLRLight::LookUpLight)
{
Page *page=lights_file.SetPage(lname);
Check_Object(page);
gamelight->m_light->Write(page);
}
}
lightiterator.First();
while((gamelight = lightiterator.ReadAndNext()) != NULL)
{
switch (gamelight->m_light->GetLightType())
{
case MLRLight::AmbientLight:
lname.Format("Ambient_Light%04i",lcntr++);
break;
case MLRLight::InfiniteLight:
lname.Format("Infinite_Light%04i",lcntr++);
break;
case MLRLight::PointLight:
lname.Format("Point_Light%04i",lcntr++);
break;
case MLRLight::SpotLight:
lname.Format("Spot_Light%04i",lcntr++);
break;
case MLRLight::LookUpLight:
break;
default:
lname.Format("Generic_Light%04i",lcntr++);
}
if(gamelight->m_light->GetLightType()!=MLRLight::LookUpLight)
{
Page *page=lights_file.SetPage(lname);
Check_Object(page);
gamelight->m_light->Write(page);
}
}
lights_file.Save();
}
int EntityCompare(const void *elem1, const void *elem2 )
{
Entity *obj1,*obj2;
obj1=*((Entity **)elem1);
obj2=*((Entity **)elem2);
Check_Object(obj1);
Check_Object(obj2);
if(obj1->GetClassID()==obj2->GetClassID())
{
if(obj1->IsDerivedFrom(NavPoint::DefaultData)) return 0; //Don't Reorder NavPoints
CString model1,model2;
int val=strcmpi(obj1->GetModelName(),obj2->GetModelName());
if(val==0)
{
if((char *)(obj1->instanceName)==NULL && (char *)(obj2->instanceName)==NULL) return 0;
if((char *)(obj1->instanceName)==NULL ) return -1;
if((char *)(obj2->instanceName)==NULL ) return 1;
return strcmpi(obj1->instanceName,obj2->instanceName);
}
else
return val;
}
else
{
return obj1->GetClassID()<obj2->GetClassID()?-1:1;
}
}
void ObjectManager::SaveContentsTextFile()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
// Save Contents File
CString contents_path;
contents_path.Format("%s\\%s.contents",mis_path,mis_name);
MakeFileWriteable(contents_path);
NotationFile contents_file(contents_path);
contents_file.DeleteAllPages();
Page *inc_page=contents_file.SetPage(NULL);
Check_Object(inc_page);
// inc_page->SetEntry("!Include","Content\\Defines\\MissionLang.defines");
inc_page->SetEntry("!concatenate",false);
inc_page->SetEntry("!preservecase",true);
/*
CString date;
CTime tme=CTime::GetCurrentTime();
inc_page->SetEntry("EditorVersion",VER_PRODUCTVERSION_STR);
inc_page->SetEntry("DateSaved", tme.Format("%A %B %d, %Y %H:%M:%S"));
inc_page->SetEntry("TimeStamp", tme.GetTime());
*/
CString path_path;
path_path.Format("%s\\Paths",mis_path);
gos_CreateDirectory(path_path);
CString dzone_path;
dzone_path.Format("%s\\DropZones",mis_path);
gos_CreateDirectory(dzone_path);
ChainIteratorOf<Entity *> iterator(&Map::GetInstance()->childEntityChain);
Entity *entity;
int list_size,cur_pos=0;
list_size=iterator.GetSize();
Entity **EntityList= new Entity*[list_size];
iterator.First();
while((entity = iterator.ReadAndNext()) != NULL)
{
Check_Object(entity);
EntityList[cur_pos++]=entity;
Verify(cur_pos<=list_size);
}
Verify(cur_pos==list_size);
qsort(EntityList,list_size,sizeof(Entity *),EntityCompare);
for(cur_pos=0;cur_pos<list_size;cur_pos++)
{
entity=EntityList[cur_pos];
Check_Object(entity);
SPEW(("tsteinke","I don't like this, save should really happen in the object"));
if (entity->IsDerivedFrom(Path::DefaultData))
{
CString path_name((char*)entity->instanceName);
Page *entity_page = contents_file.AddPage(path_name);
Check_Object(entity_page);
entity->SaveInstanceText(entity_page);
entity_page->SetEntry("Model","Misc\\Path\\Path.data");
entity_page->SetEntry("ExecutionState","NeverExecuteState");
entity_page->SetEntry("CollisionCallback","false");
entity_page->SetEntry("CollideeType","Zone");
entity_page->SetEntry("CollisionMask",-1);
CString path_filename,path_shortpath;
path_shortpath.Format("Paths\\%s.contents",path_name);
path_filename.Format("%s\\%s.contents",path_path,path_name);
entity_page->SetEntry("PathPoints",path_shortpath);
MakeFileWriteable(path_filename);
NotationFile path_notation_file(path_filename);
path_notation_file.DeleteAllPages();
Page *path_page = path_notation_file.SetPage("Path");
Path* path;
path = Cast_Object(Path*,entity);
CString point_name;
for(int i=0;i<path->pathPoints.size();i++)
{
point_name.Format("Point%i",i+1);
path_page->SetEntry(point_name,path->pathPoints[i]);
}
path_notation_file.Save();
}
else if(entity->IsDerivedFrom(DropZone::DefaultData))
{
CString dzone_name((char*)entity->instanceName);
Page *entity_page = contents_file.AddPage(dzone_name);
Check_Object(entity_page);
entity_page->SetEntry("Model","Misc\\DropZone\\DropZone.data");
entity_page->SetEntry("ExecutionState","NeverExecuteState");
entity_page->SetEntry("TileBound","false");
Point3D local_translation(entity->GetLocalToParent());
entity_page->SetEntry("Translation", local_translation);
YawPitchRoll rotation_value(entity->GetLocalToParent());
entity_page->SetEntry("Rotation", rotation_value);
const char *alignment_text;
alignment_text = Entity::AlignmentAsciiToText(entity->GetAlignment());
entity_page->SetEntry("Alignment", alignment_text);
CString dzone_filename,dzone_shortpath;
dzone_shortpath.Format("DropZones\\%s.contents",dzone_name);
dzone_filename.Format("%s\\%s.contents",dzone_path,dzone_name);
entity_page->SetEntry("DropPoints",dzone_shortpath);
MakeFileWriteable(dzone_filename);
NotationFile drop_notation_file(dzone_filename);
drop_notation_file.DeleteAllPages();
Page *drop_page = drop_notation_file.SetPage("DropPoints");
Page *rot_page = drop_notation_file.SetPage("DropRots");
Point3D point;
YawPitchRoll rot;
LinearMatrix4D mat;
DropZone* drop=Cast_Object(DropZone*,entity);
ChainIteratorOf<DropZone::MatrixPlug *> iterator(&drop->origDropMats);
DropZone::MatrixPlug *drop_point;
CString entry_name;
int count = 1;
while((drop_point = iterator.ReadAndNext()) != NULL)
{
Check_Object(drop_point);
entry_name.Format("Point%i",count);
mat = drop_point->GetItem();
point = (Point3D) mat;
rot = (YawPitchRoll) mat;
drop_page->SetEntry(entry_name, point);
entry_name.Format("Rot%i",count);
rot_page->SetEntry(entry_name, rot);
count++;
}
drop_notation_file.Save();
}
else if (entity->GetPropType() == Entity::MissionPropType &&
!entity->IsDerivedFrom(AI::DefaultData) )
{
Page *entity_page = contents_file.AddPage((char*)entity->instanceName);
Check_Object(entity_page);
entity->SaveInstanceText(entity_page);
}
}
delete EntityList;
// Save AI Drivers And Waypoints
MWMap *mwmap_inst;
AI *ai;
mwmap_inst = Cast_Object (MWMap *,Map::GetInstance());
ChainIteratorOf<AI *> ai_iterator(&mwmap_inst->m_executingAIs);
ai_iterator.First();
while((ai = ai_iterator.ReadAndNext()) != NULL)
{
Check_Object(ai);
if (!ai->IsDerivedFrom (PlayerAI::DefaultData))
{
Page *page = contents_file.AddPage((char*)ai->instanceName);
Check_Object(page);
ai->SaveInstanceText(page);
}
}
contents_file.Save();
}
void ObjectManager::SaveInstanceTextFile()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
{
CString instance_path;
instance_path.Format("%s\\%s.instance",mis_path,mis_name);
MakeFileWriteable(instance_path);
NotationFile instance_file(instance_path);
Page *mission_page = instance_file.SetPage(mis_name);
Mission::GetInstance()->SaveInstanceText(mission_page);
instance_file.Save();
}
CString hint_path;
hint_path.Format("%s\\%s.hint",mis_path,mis_name);
MakeFileWriteable(hint_path);
NotationFile hint_file(hint_path);
CString hint_page_name;
hint_file.DeleteAllPages();
hint_page_name.Format("Resource\\UserMissions\\%s.mw4",mis_name);
Page *hint_page;
// put texture pages here
CString sky_name,str;
CString texture_name;
char c[6]="fblru";
int miplevel,clev;
sky_name=DaySkyName();
bool isnight;
sky_name=sky_name.Mid(sky_name.Find('\\')+1);
str=sky_name.Mid(sky_name.ReverseFind('_')+1);
isnight=(!str.CompareNoCase("night") || !str.CompareNoCase("storm"));
for(clev=0;clev<5;clev++)
for(miplevel=1;miplevel<=5;miplevel++)
{
if(isnight)
texture_name.Format("Skyn%c%c%c%i",sky_name[0],sky_name[sky_name.Find('0')+1],c[clev],miplevel);
else
texture_name.Format("Sky%c%c%c%i",sky_name[0],sky_name[sky_name.Find('0')+1],c[clev],miplevel);
hint_page=hint_file.SetPage(texture_name);
hint_page->SetEntry("mipmap","explicit");
hint_page->SetEntry("nogamma",false);
hint_page->SetEntry("memory","default");
hint_page->SetEntry("blueisalpha",false);
hint_page->SetEntry("format","Solid");
hint_page->SetEntry("pinkisalpha",false);
hint_page->SetEntry("mipfilter","box");
hint_page->SetEntry("reloadfromdisk",true);
hint_page->SetEntry("pageout","default");
hint_page->SetEntry("readonly",true);
hint_page->SetEntry("resourcify",true);
}
if(DaySkyName().CompareNoCase(NightSkyName()))
{
sky_name=NightSkyName();
if(sky_name!="")
{
sky_name=sky_name.Mid(sky_name.Find('\\')+1);
str=sky_name.Mid(sky_name.ReverseFind('_')+1);
isnight=(!str.CompareNoCase("night") || !str.CompareNoCase("storm"));
sky_name=sky_name.Mid(sky_name.Find('\\')+1);
for(clev=0;clev<5;clev++)
for(miplevel=1;miplevel<=5;miplevel++)
{
if(isnight)
texture_name.Format("Skyn%c%c%c%i",sky_name[0],sky_name[sky_name.Find('0')+1],c[clev],miplevel);
else
texture_name.Format("Sky%c%c%c%i",sky_name[0],sky_name[sky_name.Find('0')+1],c[clev],miplevel);
hint_page=hint_file.SetPage(texture_name);
hint_page->SetEntry("mipmap","explicit");
hint_page->SetEntry("nogamma",false);
hint_page->SetEntry("memory","default");
hint_page->SetEntry("blueisalpha",false);
hint_page->SetEntry("format","Solid");
hint_page->SetEntry("pinkisalpha",false);
hint_page->SetEntry("mipfilter","box");
hint_page->SetEntry("reloadfromdisk",true);
hint_page->SetEntry("pageout","default");
hint_page->SetEntry("readonly",true);
hint_page->SetEntry("resourcify",true);
}
}
}
hint_file.Save();
// mission_page->SetEntry("!Include",hint_path);
}
void ObjectManager::SaveBounds()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
int i;
//Save Mission Bounds
FileStream mbound_file;
DynamicArrayOf<Stuff::Vector2DOf<Stuff::Scalar> > mission_bound;
Check_Pointer(MissionBound);
MissionBound->GetBoundData(&mission_bound);
for (i=0;i<mission_bound.GetLength();i++)
{
mission_bound[i].x += MapSize.x*0.5f;
mission_bound[i].y += MapSize.z*0.5f;
mission_bound[i].x *= Map::GetInstance()->GetColumnZoneScale();
mission_bound[i].y *= Map::GetInstance()->GetRowZoneScale();
}
Mission::GetInstance()->SetMissionPolygon(mission_bound);
CString mbound_filename=mis_path+"\\Mission.bounds";
MakeFileWriteable(mbound_filename);
mbound_file.Open((LPCSTR)mbound_filename,FileStream::WriteOnly);
MemoryStreamIO_Write(&mbound_file, &mission_bound);
mbound_file.Close();
//Save Warning Bounds
FileStream wbound_file;
DynamicArrayOf<Stuff::Vector2DOf<Stuff::Scalar> > warning_bound;
Check_Pointer(WarningBound);
WarningBound->GetBoundData(&warning_bound);
for (i=0;i<warning_bound.GetLength();i++)
{
warning_bound[i].x += MapSize.x*0.5f;
warning_bound[i].y += MapSize.z*0.5f;
warning_bound[i].x *= Map::GetInstance()->GetColumnZoneScale();
warning_bound[i].y *= Map::GetInstance()->GetRowZoneScale();
}
Mission::GetInstance()->SetWarningPolygon(warning_bound);
CString wbound_filename=mis_path+"\\Warning.bounds";
MakeFileWriteable(wbound_filename);
wbound_file.Open((LPCSTR)wbound_filename,FileStream::WriteOnly);
MemoryStreamIO_Write(&wbound_file, &warning_bound);
wbound_file.Close();
}
void ObjectManager::SaveNameTable()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
//Save the NameTable
CString table_path;
table_path.Format("%s\\%s.table",mis_path,mis_name);
MakeFileWriteable(table_path);
NotationFile table_file(table_path,NotationFile::Standard,true);
table_file.DeleteAllPages();
Page *page=table_file.SetPage(NULL);
page->SetEntry("!preservecase",true);
NameTable::GetInstance()->IsValid();
NameTable::GetInstance()->SaveTable(&table_file);
table_file.Save();
}
void ObjectManager::SaveRailGraph()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
//Save the RailGraph
CString graph_path,move_grid_path,rect_grid_path,air_move_path;
graph_path.Format("%s\\%sGraph.data",mis_path,mis_name);
move_grid_path.Format("%s\\%sMoveGrid.data",mis_path,mis_name);
rect_grid_path.Format("%s\\%sRectGrid.data",mis_path,mis_name);
air_move_path.Format("%s\\%sAirMoveGrid.data",mis_path,mis_name);
NotationFile railgraph_file(graph_path);
MakeFileWriteable(graph_path);
MakeFileWriteable(move_grid_path);
MakeFileWriteable(rect_grid_path);
MakeFileWriteable(air_move_path);
MW4AI::g_MissionGraph->DumpNotationFile (&railgraph_file,(LPCTSTR) move_grid_path,(LPCTSTR) rect_grid_path,(LPCTSTR) air_move_path);
railgraph_file.Save();
}
void ObjectManager::SaveDataTextFile()
{
CString mis_name=GetName();
CString mis_path;
mis_path.Format("Content\\Missions\\%s",mis_name);
CString data_path;
data_path.Format("%s\\%s.data",mis_path,mis_name);
MakeFileWriteable(data_path);
NotationFile data_file(data_path);
Page *page=data_file.SetPage("GameData");
MisDat.SaveText(&data_file);
data_file.Save();
}
bool ObjectManager::InBuildFile()
{
CString missionName=GetName();
CString missionPath = "Content\\Missions\\";
missionPath += missionName;
CString map_buildpath;
CString map_shortpath;
CString map_longpath;
CString mission_instancepath;
CString mission_buildpath;
map_shortpath.Format("Maps\\%s\\%s.build",MapName,MapName);
mission_buildpath.Format("Missions\\%s\\%s.build",missionName,missionName);
mission_instancepath.Format("Missions\\%s\\%s.instance",missionName,missionName);
map_longpath="Content\\"+map_shortpath;
////////////////////////////////////////////////////////////
// Enter the data in the build file
////////////////////////////////////////////////////////////
// Enter the data in the build file
Verify(gos_DoesFileExist(BUILDFILENAME));
MakeFileWriteable(BUILDFILENAME);
#ifdef USEEXTERNALLY
NotationFile prop_file(BUILDFILENAME);
Page *prop_page = prop_file.FindPage("");
Check_Object(prop_page);
Note *map_note = prop_page->FindNote(map_shortpath);
NotationFile maps_file;
if(!map_note) return false;
map_note->GetEntry(&maps_file);
Page *mission_page = maps_file.FindPage("");
Check_Object(mission_page);
if(mission_page->FindNote(mission_buildpath)) return true;
#else
Stuff::NotationFile build_file(BUILDFILENAME);
Page *texture_page = build_file.FindPage("");
if (!texture_page) return false;
Check_Object(texture_page);
Page::NoteIterator *texture_notes = texture_page->MakeNoteIterator();
Check_Object(texture_notes);
Note *texture_note;
while ((texture_note = texture_notes->ReadAndNext()) != NULL)
{
Check_Object(texture_note);
NotationFile texture_file;
texture_note->GetEntry(&texture_file);
Page *core_page = texture_file.FindPage("");
if (!core_page) return false;
Check_Object(core_page);
Page::NoteIterator *core_notes = core_page->MakeNoteIterator();
Check_Object(core_notes);
Note *core_note;
while ((core_note = core_notes->ReadAndNext()) != NULL)
{
Check_Object(core_note);
NotationFile core_file;
core_note->GetEntry(&core_file);
Page *props_page = core_file.FindPage("");
if(!props_page) return false;
Page::NoteIterator *prop_notes = core_page->MakeNoteIterator();
Check_Object(prop_notes);
Note *prop_note;
while ((prop_note = prop_notes->ReadAndNext()) != NULL)
{
Check_Object(prop_note);
NotationFile prop_file;
prop_note->GetEntry(&prop_file);
Page *props_page = prop_file.FindPage("");
if (props_page)
{
Check_Object(props_page);
Page::NoteIterator *props_notes = props_page->MakeNoteIterator();
Check_Object(props_notes);
Note *props_note;
while ((props_note = props_notes->ReadAndNext()) != NULL)
{
Check_Object(props_note);
NotationFile map_file;
props_note->GetEntry(&map_file);
Page *maps_page = map_file.FindPage("");
Check_Object(maps_page);
Page::NoteIterator *map_notes = maps_page->MakeNoteIterator();
Check_Object(map_notes);
Note *map_note;
NotationFile mission_file;
map_note=maps_page->FindNote(map_shortpath);
if(!map_note) return false;
map_note->GetEntry(&mission_file);
Page *mission_page = mission_file.FindPage("");
if(!mission_page) return false;
if(mission_page->FindNote(mission_buildpath)) return true;
}
}
}
}
}
#endif
return false;
}
void ObjectManager::AddToBuildFile()
{
CString missionName=GetName();
CString missionPath = "Content\\Missions\\";
missionPath += missionName;
CString map_buildpath;
CString map_shortpath;
CString map_longpath;
CString mission_instancepath;
CString mission_buildpath;
map_shortpath.Format("Maps\\%s\\%s.build",MapName,MapName);
mission_buildpath.Format("Missions\\%s\\%s.build",missionName,missionName);
mission_instancepath.Format("Missions\\%s\\%s.instance",missionName,missionName);
map_longpath="Content\\"+map_shortpath;
////////////////////////////////////////////////////////////
// Enter the data in the build file
Verify(gos_DoesFileExist(BUILDFILENAME));
MakeFileWriteable(BUILDFILENAME);
#ifdef USEEXTERNALLY
NotationFile prop_file(BUILDFILENAME);
Page *prop_page = prop_file.FindPage("");
Check_Object(prop_page);
Note *map_note = prop_page->FindNote(map_shortpath);
#else
NotationFile build_file(BUILDFILENAME);
Page *build_page = build_file.FindPage("");
Check_Object(build_page);
Note *texture_note = build_page->FindNote("textures.build");
Check_Object(texture_note);
NotationFile texture_file;
texture_note->GetEntry(&texture_file);
Page *texture_page = texture_file.FindPage("");
Check_Object(texture_page);
Note *core_note = texture_page->FindNote("core.build");
Check_Object(core_note);
NotationFile core_file;
core_note->GetEntry(&core_file);
Page *core_page = core_file.FindPage("");
Check_Object(core_page);
Note *prop_note = core_page->FindNote("props.build");
Check_Object(prop_note);
NotationFile prop_file;
prop_note->GetEntry(&prop_file);
Page *prop_page = prop_file.FindPage("");
Check_Object(prop_page);
Note *map_note = prop_page->FindNote(map_shortpath);
#endif
NotationFile maps_file;
if(!map_note)
{
map_note=prop_page->AddNote(map_shortpath);
Check_Object(map_note);
}
else
{
Check_Object(map_note);
map_note->GetEntry(&maps_file);
}
Page *mission_page;
mission_page = maps_file.FindPage("");
if(!mission_page) mission_page = maps_file.SetPage("");
Check_Object(mission_page);
NotationFile mission_note;
mission_page->SetEntry(mission_buildpath,&mission_note);
map_note->SetEntry(&maps_file);
#ifdef USEEXTERNALLY
prop_file.Save();
#else
prop_note->SetEntry(&prop_file);
core_note->SetEntry(&core_file);
texture_note->SetEntry(&texture_file);
build_file.Save();
#endif
NeedResourceBuild=true;
}
void ObjectManager::SetName( CString &name)
{
if(GetName()!=name)
{
SetMissionName(GetName(),name);
if(SourceMission=="") SourceMission=GetName();
Name=name;
}
}
/// Entity Manipulation
bool HasCollsion(Entity *entity)
{
return (entity->GetSolidVolume()!=NULL || (entity->GetElement() && entity->GetElement()->m_localOBB.sphereRadius>0));
}
void BindEntity(Entity *entity)
{
Check_Object(entity);
entity->SyncMatrices(true);
Entity::CollisionMask oldmask=entity->GetCollisionMask();
if (oldmask == Entity::NeverCollidesMask)
entity->SetCollisionMask(Entity::NeverCollidesMask);
else
entity->SetCollisionMask(Entity::EditorIsMovingFlag);
Map::GetInstance()->UpdateZone(entity);
entity->SetCollisionMask(oldmask);
if(entity->IsDerivedFrom(Cultural::DefaultData) )
{
entity->BindToTile();
}
else
if(!entity->IsMultiTile() )
{
if (entity->IsDerivedFrom(Building::DefaultData) || entity->IsDerivedFrom(Turret::DefaultData) )
{
entity->BindToTile();
}
else if (entity->IsDerivedFrom(Vehicle::DefaultData))
{
Vehicle *vech=Cast_Object(Vehicle *,entity);
if(!vech->GetAI())
{
//
//------------------------------------------
// If we are already tile bound, just return
//------------------------------------------
//
if (!vech->IsTileBound())
{
//
//---------------------------------------------------------------------
// We are tile bound now, so find the tile through our element's parent
//---------------------------------------------------------------------
//
ElementRenderer::Element *element = vech->GetElement();
Check_Object(element);
Zone *zone = Cast_Object(Zone*, element->GetParentElement());
//
//----------------------------------------------------------------
// Unhook the collision, change the flag and hook it back up again
//----------------------------------------------------------------
//
element->DetachFromParent();
vech->replicatorFlags |= Entity::TileBoundFlag;
vech->replicatorFlags &= ~Entity::ColliderFlag;
element->AttachToParent(zone);
element->Sync();
}
}
}
}
}
void UnBindEntity(Entity *entity)
{
Check_Object(entity);
if (entity->IsDerivedFrom(Building::DefaultData) ||
entity->IsDerivedFrom(Turret::DefaultData) ||
entity->IsDerivedFrom(Cultural::DefaultData) ||
entity->IsDerivedFrom(Vehicle::DefaultData)
)
{
entity->BindToZone();
}
}
void RemoveEntityFromNameTable(Entity *entity)
{
Check_Object(entity);
Check_Object(NameTable::GetInstance());
NameTable::GetInstance()->RemoveEntry(entity->objectID);
NameTable::GetInstance()->IsValid();
}
void AddEntityToNameTable(Entity *entity)
{
Check_Object(entity);
Check_Object(NameTable::GetInstance());
if( entity->IsDerivedFrom(Turret::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::TurretArray);
else if( entity->IsDerivedFrom(Cultural::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::CulturalArray);
else if(entity->IsDerivedFrom(Vehicle::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::VehicleArray);
else if(entity->IsDerivedFrom(Building::DefaultData) )
NameTable::GetInstance()->AddEntry(entity, NameTable::BuildingArray);
else if(entity->IsDerivedFrom(NavPoint::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::NavArray);
else if(entity->IsDerivedFrom(DropZone::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::DropZoneArray);
else if(entity->IsDerivedFrom(AI::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::AIArray);
else if(entity->IsDerivedFrom(NonCom::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::BuildingArray);
else if(entity->IsDerivedFrom(Path::DefaultData))
NameTable::GetInstance()->AddEntry(entity, NameTable::PathArray);
else
NameTable::GetInstance()->AddEntry(entity, NameTable::DefaultArray);
NameTable::GetInstance()->IsValid();
}
void MoveEntityTo(Entity *entity,Stuff::LinearMatrix4D &mat)
{
Check_Object(entity);
UnBindEntity(entity);
entity->SetNewLocalToParent(mat);
BindEntity(entity);
}
const char* GetEntityScriptName(Entity *entity)
{
Check_Object(entity);
if ((entity != 0) &&
(entity->IsDerivedFrom(MWObject::DefaultData) == true))
{
MWObject* mwobject = Cast_Object(MWObject*,entity);
if (mwobject->GetAI() != 0)
{
return (mwobject->GetAI()->GetScriptName());
}
}
return (0);
}
void SetEntityScriptName(Entity *entity,char* script_name)
{
Check_Object(entity);
if ((entity != 0) &&
(entity->IsDerivedFrom(MWObject::DefaultData) == true))
{
MWObject* mwobject = Cast_Object(MWObject*,entity);
if (mwobject->GetAI() != 0)
{
mwobject->GetAI()->LoadScript(script_name);
}
}
}
void AddEntityAI(Entity *entity)
{
Check_Object(entity);
Check_Object(EntityManager::GetInstance());
Check_Object(Map::GetInstance());
// Add AIHere
if (entity->IsDerivedFrom(MWObject::DefaultData) == true)
{
MWObject* mwobject = Cast_Object(MWObject*,entity);
if (mwobject->GetAI() != 0)
{
Entity* ai_entity = mwobject->GetAI();
EntityManager::GetInstance()->GetNameSocket()->AddValue(ai_entity,ai_entity->instanceName);
AddEntityToNameTable(ai_entity);
Check_Object(Map::GetInstance());
Map::GetInstance()->AddChild(ai_entity);
ai_entity->SetPropType(Entity::MissionPropType);
ai_entity->SyncMatrices(true);
}
}
}
void RemoveEntityAI(Entity *entity)
{
Check_Object(entity);
Check_Object(EntityManager::GetInstance());
Check_Object(Map::GetInstance());
// Remove AI Here
if (entity->IsDerivedFrom(MWObject::DefaultData) == true)
{
MWObject* mwobject = Cast_Object(MWObject*,entity);
if (mwobject->GetAI() != 0)
{
EntityManager::GetInstance()->GetNameSocket()->Remove(mwobject->GetAI());
Map::GetInstance()->RemoveChild(mwobject->GetAI());
RemoveEntityFromNameTable(mwobject->GetAI());
}
}
}
void UpdateCameraLights()
{
ChainIteratorOf<gosFX::Light*> lights(&Mission::GetInstance()->m_staticLights);
ElementRenderer::StateChange *view_states =
VideoRenderer::Instance->GetSceneCamera()->GetElement()->GetViewingStateChange();
gosFX::Light *light;
int i=0;
while ((light = lights.ReadAndNext()) != NULL)
{
Verify(i < ELEMENTS(view_states->m_lights));
view_states->m_lights[i++] = light->m_light;
}
view_states->m_lights[i] = NULL;
}
void AddLightToMap(gosFX::Light *light)
{
Mission::GetInstance()->m_staticLights.Add(light);
UpdateCameraLights();
}
void RemoveLightFromMap(gosFX::Light *light)
{
Mission::GetInstance()->m_staticLights.Remove(light);
UpdateCameraLights();
}
void AddEntityToMap(Entity *entity,LinearMatrix4D &mat)
{
Check_Object(entity);
Check_Object(Map::GetInstance());
AddEntityToNameTable(entity);
AddEntityAI(entity);
Map::GetInstance()->AddChild(entity);
entity->SetNewLocalToParent(mat);
BindEntity(entity);
}
void RemoveEntityFromMap(Entity *entity)
{
Check_Object(entity);
Check_Object(Mission::GetInstance());
Check_Object(NameTable::GetInstance());
Check_Object(EntityManager::GetInstance());
Check_Object(Map::GetInstance());
UnBindEntity(entity);
RemoveEntityAI(entity);
Map::GetInstance()->RemoveChild(entity);
RemoveEntityFromNameTable(entity);
}
void SetEntityName(Entity *entity,CString newname)
{
Check_Object(entity);
RemoveEntityFromNameTable(entity);
entity->instanceName=(LPCSTR)newname;
AddEntityToNameTable(entity);
}
bool HasSkin(Entity *entity)
{
return entity->IsDerivedFrom(MWMover::DefaultData);
}
char GetEntitySkin(Entity *entity)
{
Check_Object(entity);
if(!HasSkin(entity)) return -1;
MWMover *mwmover = Cast_Object(MWMover*,entity);
return mwmover->GetSkinPrefix();
}
void SetEntitySkin(Entity *entity,char skin)
{
Check_Object(entity);
if(!HasSkin(entity)) return;
MWMover *mwmover = Cast_Object(MWMover*,entity);
mwmover->SetSkinPrefix(skin);
}
void MakeMissionNight(bool night)
{
if(Mission::GetInstance()!=NULL)
{
if(night)
Mission::GetInstance()->SetToNight();
else
Mission::GetInstance()->SetToDay();
}
}
bool IsMissionNight()
{
if(Mission::GetInstance()==NULL) return false;
return Mission::GetInstance()->m_isNightMission;
}
void AdoptFogColors()
{
const Mission::GameModel *model = Mission::GetInstance()->GetGameModel();
Check_Object(model);
ElementRenderer::StateChange *view_states =
VideoRenderer::Instance->GetSceneCamera()->GetElement()->GetViewingStateChange();
if(IsMissionNight())
view_states->SetFogColor(model->m_nightFogColor);
else
view_states->SetFogColor(model->m_fogColor);
}
void MakeFileWriteable(CString str)
{
if(!gos_DoesFileExist(str)) return;
if(gos_FileReadOnly(str))
{
gos_FileSetReadWrite(str);
MessageBox(NULL,str +" has been made writeable and modified","File Modification",MB_OK);
}
}
Scalar GetWaterLevel()
{
return Map::GetInstance()->GetGameModel()->m_waterLevel;
}
void LoadSkys(CComboBox *ctrl)
{
ctrl->ResetContent();
Adept::Resource curres;
curres.First(NULL);
CString res_name,base_name,dir_name;
while(curres.ReadAndNext())
{
res_name=(char *)curres.GetName();
res_name.MakeLower();
int sloc=res_name.Find("skies\\");
if(sloc!=-1)
{ // This is a Data File
base_name=res_name.Mid(sloc+strlen("skies\\"));
base_name=base_name.Left(base_name.ReverseFind('.'));
int itm=ctrl->AddString(base_name);
ctrl->SetItemDataPtr(itm,new CString(res_name));
}
}
}
CString DaySkyName()
{
Resource res(Mission::GetInstance()->skyResourceID);
CString base_name=res.GetName();
base_name=base_name.Mid(base_name.Find("skies\\")+strlen("skies\\"));
base_name=base_name.Left(base_name.ReverseFind('.'));
return base_name;
}
CString NightSkyName()
{
if(Mission::GetInstance()->nightSkyResourceID!=ResourceID::Null)
{
Resource res(Mission::GetInstance()->nightSkyResourceID);
CString base_name=res.GetName();
base_name=base_name.Mid(base_name.Find("skies\\")+strlen("skies\\"));
base_name=base_name.Left(base_name.ReverseFind('.'));
return base_name;
}
else
return "";
}
void SetDaySky(CString str)
{
Resource res(str);
res.LoadData();
ResourceID rid=res.GetResourceID();
Mission::GetInstance()->SetDaySky(rid);
}
void SetNightSky(CString str)
{
Resource res(str);
res.LoadData();
ResourceID rid=res.GetResourceID();
Mission::GetInstance()->SetNightSky(rid);
}
float GetFarClip()
{
return Mission::GetInstance()->GetGameModel()->m_farClip;
}
CZoneReport::BasicTypes CZoneReport::GetType(Entity *entity)
{
if( entity->IsDerivedFrom(Turret::DefaultData)) return MR_TURRET;
else if( entity->IsDerivedFrom(Cultural::DefaultData)) return MR_CULTURAL;
else if( entity->IsDerivedFrom(Mech::DefaultData)) return MR_MECH;
else if(entity->IsDerivedFrom(Vehicle::DefaultData)) return MR_VEHICLE;
else if(entity->IsDerivedFrom(Building::DefaultData) ) return MR_BUILDING;
else if(entity->IsDerivedFrom(NavPoint::DefaultData)) return MR_NAVPOINT;
else if(entity->IsDerivedFrom(DropZone::DefaultData)) return MR_DROPZONE;
else if(entity->IsDerivedFrom(AI::DefaultData)) return MR_AI;
else if(entity->IsDerivedFrom(NonCom::DefaultData)) return MR_NONCOM;
else if(entity->IsDerivedFrom(Path::DefaultData)) return MR_PATH;
else if(entity->IsDerivedFrom(CameraShip::DefaultData)) return MR_CAMERASHIP;
else if(entity->IsDerivedFrom(EffectGenerator::DefaultData)) return MR_EFFECT;
else if(entity->IsDerivedFrom(Objective::DefaultData)) return MR_OBJECTIVE;
// else if(entity->IsDerivedFrom(MechWarrior4::SearchLight::DefaultData)) return MR_SEARCHLIGHT;
else return MR_UNKNOWN;
}
bool CZoneReport::InZone(Adept::Entity *entity)
{
Point3D trans;
trans=entity->GetLocalToWorld();
return (trans.x>=StartX && trans.z>=StartZ && trans.x<(StartX+c_ZoneSize) && trans.z<(StartZ+c_ZoneSize));
}
void CZoneReport::CountTypes(float x,float z)
{
StartX=x;
StartZ=z;
ChainIteratorOf<Entity *> iterator(&Map::GetInstance()->childEntityChain);
Entity *entity;
for(int i=0;i<MR_TYPECOUNT;i++) BasicTypeCount[i]=0;
int list_size,cur_pos=0;
list_size=iterator.GetSize();
Entity **EntityList= new Entity*[list_size];
iterator.First();
while((entity = iterator.ReadAndNext()) != NULL)
{
Check_Object(entity);
if(InZone(entity))
EntityList[cur_pos++]=entity;
Verify(cur_pos<=list_size);
}
EntityCount=cur_pos;
qsort(EntityList,EntityCount,sizeof(Entity *),EntityCompare);
CString LastModel="";
int model_total=0;
int vio_total=0;
model_total=0;
for(cur_pos=0;cur_pos<EntityCount;cur_pos++)
{
entity=EntityList[cur_pos];
Check_Object(entity);
BasicTypeCount[GetType(entity)]++;
if(LastModel.CompareNoCase(entity->GetModelName()))
{
LastModel=entity->GetModelName();
model_total++;
}
if(entity->IsMultiTile()) vio_total++;
}
Models=new ReportModel[model_total];
Violators=new TileViolator[vio_total];
ViolatorCount=0;
UniqueModelCount=0;
if(model_total>0)
Models[UniqueModelCount].Name="";
for(cur_pos=0;cur_pos<EntityCount;cur_pos++)
{
entity=EntityList[cur_pos];
Check_Object(entity);
if(entity->IsMultiTile())
{
if((char *)(entity->instanceName)!=NULL )
{
Violators[ViolatorCount++].Name=entity->instanceName;
}
else
{
Violators[ViolatorCount++].Name="<UnNamed>";
}
}
if(model_total>0)
{
if(UniqueModelCount<1 || (UniqueModelCount<model_total && Models[UniqueModelCount-1].Name.CompareNoCase(entity->GetModelName())))
{
Models[UniqueModelCount].Name=entity->GetModelName();
Models[UniqueModelCount].Count=1;
Models[UniqueModelCount].Type=GetType(entity);
UniqueModelCount++;
Verify(UniqueModelCount<=model_total);
if(UniqueModelCount<model_total)
Models[UniqueModelCount].Name="";
}
else
{
Verify(!Models[UniqueModelCount-1].Name.CompareNoCase(entity->GetModelName()));
Models[UniqueModelCount-1].Count++;
}
}
}
Verify(UniqueModelCount==model_total);
MWMap *mwmap_inst;
AI *ai;
mwmap_inst = Cast_Object (MWMap *,Map::GetInstance());
ChainIteratorOf<AI *> ai_iterator(&mwmap_inst->m_executingAIs);
ai_iterator.First();
while((ai = ai_iterator.ReadAndNext()) != NULL)
{
Check_Object(ai);
if (!ai->IsDerivedFrom (PlayerAI::DefaultData))
{
BasicTypeCount[MR_AI]++;
}
}
//Count Types
delete EntityList;
}
CString GetMissionName()
{
CString MissionName=MWApplication::GetInstance()->GetMissionName();
MissionName=MissionName.Left(MissionName.ReverseFind('.'));
MissionName=MissionName.Mid(MissionName.ReverseFind('\\')+1);
return MissionName;
}
void CMissionReport::CountTypes()
{
MissionName=MWApplication::GetInstance()->GetMissionName();
MissionName=MissionName.Left(MissionName.ReverseFind('.'));
MissionName=MissionName.Mid(MissionName.ReverseFind('\\')+1);
BYTE rows, cols;
Map::GetInstance()->GetElement()->GetSize(&rows, &cols);
ZoneCount=rows*cols;
ZoneRep=new CZoneReport[ZoneCount];
int rinc,cinc;
float rpos,cpos;
UniqueModelCount=0;
ViolatorCount=0;
EntityCount=0;
for(rinc=0,rpos=(-rows*c_ZoneSize*0.5f);rinc<rows;rinc++,rpos+=c_ZoneSize)
for(cinc=0,cpos=(-cols*c_ZoneSize*0.5f);cinc<rows;cinc++,cpos+=c_ZoneSize)
{
ZoneRep[rinc*cols+cinc].RChar='A'+rinc;
ZoneRep[rinc*cols+cinc].CChar='A'+cinc;
ZoneRep[rinc*cols+cinc].CountTypes(rpos,cpos);
ViolatorCount+=ZoneRep[rinc*cols+cinc].GetViolatorCount();
EntityCount+=ZoneRep[rinc*cols+cinc].GetEntityCount();
}
Violators=new TileViolator[ViolatorCount];
int vio_inc=0;
CZoneReport::CountTypes(0.0f,0.0f);
BYTE r,c;
CollisionGrid::Instance->GetSize(&TileRows,&TileCols);
TileEntityCount=new int[TileCols*TileRows];
for(r=0;r<TileRows;r++)
for(c=0;c<TileCols;c++)
{
TileEntityCount[r*TileCols+c]=CollisionGrid::Instance->EntitiesInTile(r,c);
}
}
int EntitiesInTile(int x,int y)
{
BYTE rows, cols;
CollisionGrid::Instance->GetSize(&rows,&cols);
if(x>=cols || x<0 || y>=rows ||y<0) return -1;
return CollisionGrid::Instance->EntitiesInTile(y,x);
}
int GetSkinCount()
{
return MWApplication::GetInstance()->m_skinsTable->GetTableSize();
}
CString GetNthSkinName(int val)
{
MWTable::TableIterator *skin_iterator;
skin_iterator = MWApplication::GetInstance()->m_skinsTable->MakeTableIterator();
MWTableEntry *skin_entry;
skin_entry=(MWTableEntry *)skin_iterator->GetNthItem(val);
Check_Object(skin_entry);
return ((const char *)skin_entry->GetEntryName());
}
char GetNthSkin(int val)
{
MWTable::TableIterator *skin_iterator;
skin_iterator = MWApplication::GetInstance()->m_skinsTable->MakeTableIterator();
MWTableEntry *skin_entry;
skin_entry=(MWTableEntry *)skin_iterator->GetNthItem(val);
Check_Object(skin_entry);
return skin_entry->GetData()[0];
}
CString GetSkinName(char skin)
{
if(skin==-1) return "UnSkinable";
int current_skin;
current_skin = 0;
char skin_string[2];
*skin_string = skin;
skin_string[1] = 0;
current_skin = MWApplication::GetInstance()->m_skinsTable->FindIndexFromDataString(skin_string);
if(current_skin==-1) return "UnSkinable";
return GetNthSkinName(current_skin);
}
void TranslateMissionNameBackIfNecessary(CString &mis_name)
{
Stuff::MString missionname = (const char *)mis_name;
if (MWApplication::TranslateMissionNameBackIfNecessary(missionname))
mis_name=(const char *)missionname;
}
#define GAME_REG_KEY "Software\\Microsoft\\Microsoft Games\\MW4GameED2"
typedef DWORD (*EBUPROC) (LPCTSTR lpRegKeyLocation, LPCTSTR lpEULAFileName, LPCSTR lpWarrantyFileName, BOOL fCheckForFirstRun);
bool FirstRunEula(const char *eula_filename,const char *warranty_filename)
{
EBUPROC pfnEBUEula;
HINSTANCE hMod;
hMod = LoadLibrary("Assets\\binaries\\EBUEula.dll");
if (NULL == hMod)
hMod = LoadLibrary("EBUEula.dll");
if (NULL == hMod) // can�t attach to DLL
{
STOP(("Cannot Load EBUEula.dll"));
}
pfnEBUEula = (EBUPROC) GetProcAddress(hMod, "EBUEula");
if (NULL == pfnEBUEula) // can�t find entry point
{
FreeLibrary(hMod);
STOP(("Cannot Find Entry Point to EBUEula.dll"));
}
//
//This call enables both EULA and warranty accepting/viewing/printing. If your
//game doesn�t ship with a WARRANTY file, specifiy NULL instead of szWarranty�
//The code below, for instance, works with both OEM and retail builds�
//
const char *pszWarrantyParam = 0xFFFFFFFF != GetFileAttributes(warranty_filename) ? warranty_filename : NULL;
BOOL fAllowGameToRun = pfnEBUEula(GAME_REG_KEY, eula_filename, pszWarrantyParam, TRUE);
FreeLibrary(hMod);
return fAllowGameToRun?true:false;
}
void RunEula()
{
CString ename,wname;
ename.LoadString(IDS_ED_EULA_FILENAME);
wname.LoadString(IDS_ED_WARRANTY_FILENAME);
if(!FirstRunEula(ename,wname))
{
/*
CString msg,cap;
msg.LoadString(IDS_ED_EULA_FAIL_MESSAGE);
cap.LoadString(IDS_ED_EULA_FAIL_CAPTION);
if(MessageBox(NULL,msg,cap,MB_YESNO)==IDYES)
{
exit(1);
}
*/
exit(1);
}
}
int __stdcall Mech4ReconnectGame(void) { gosASSERT(FALSE); return 0; }
void __cdecl CDedicatedServerUI::EnterRunningGameState(void) { gosASSERT(FALSE); }
void __cdecl CDedicatedServerUI::EnterStoppingGameState(void) { gosASSERT(FALSE); }
void __cdecl CDedicatedServerUI::EnterRecyclingGameState(void) { gosASSERT(FALSE); }
void __cdecl CDedicatedServerUI::EnterLoadingGameState(void) { gosASSERT(FALSE); }
SCRIPTVAR_INT(ConnectionIndex) = 0;
void RegisterData(void) { gosASSERT(FALSE); }
void UnRegisterData(void) { gosASSERT(FALSE); }
SCRIPTCALLBACK(PreConnect) { gosASSERT(FALSE); return 0; }
SCRIPTCALLBACK(InitConnectionWizard) { gosASSERT(FALSE); return 0; }
SCRIPTCALLBACK(LoadMPConnectionSettings) { gosASSERT(FALSE); return 0; }
SCRIPTCALLBACK(CancelDialup) { gosASSERT(FALSE); return 0; }
Reference in New Issue View Git Blame Copy Permalink