RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
21af36487be2522f676adbcbf4fc5c9cbcdafdba
Client/GameTools/Zallad3D SceneClass/MapStorage.cpp
LGram16 dd97ddec92 Restructure repository to include all source folders 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 20:17:20 +09:00

3692 lines
115 KiB
C++
Raw Blame History

// MapStorage.cpp: implementation of the CMapStorage class.
//
//////////////////////////////////////////////////////////////////////
#include "MapStorage.h"
#include "RenderOption.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/*
List<CSectorDungeonMap*> CMapStorage::m_DundeonMap;
List<CSectorHeightMap*> CMapStorage::m_HeightMap;
List<CSectorMeshMap*> CMapStorage::m_MeshMap;
List<CSectorPlantMap*> CMapStorage::m_PlantMap;
List<CSectorWideMap*> CMapStorage::m_WideMap;
List<CSectorHouseMap*> CMapStorage::m_HouseMap;
List<CSectorWaterMap*> CMapStorage::m_WaterMap;
List<CSectorFallMap*> CMapStorage::m_FallMap;
List<CInHouseObjectMap*> CMapStorage::m_InHouseMap;
List<CSectorMustDivideVertexMap*> CMapStorage::m_MustDivideVertexMap;
List<CSectorEffectMap*> CMapStorage::m_EffectMap;
long CMapStorage::m_TotalHouseSceneCount;
long CMapStorage::m_TotalInHouseLightSceneCount;
long CMapStorage::m_TotalInHouseObjectSceneCount;
long CMapStorage::m_TotalObjectSceneCount;
*/
CMapStorage::CMapStorage()
{
m_TotalHouseSceneCount=0;
m_TotalInHouseLightSceneCount=0;
m_TotalInHouseObjectSceneCount=0;
m_TotalObjectSceneCount=0;
m_TotalLightCount = 0;
m_LoadMode=0;
}
CMapStorage::~CMapStorage()
{
DeleteAllObject();
}
void CMapStorage::Load(char *strFilename)
{
FILE *fp=fopen(strFilename,"rb");
if(fp==NULL)
return;
strcpy(m_strMapFilename,strFilename);
DeleteAllData();
char strRead[MAX_NAMEBUFFER];
fread(strRead,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fread(&m_TotalObjectSceneCount,sizeof(long),1,fp);
// Height-Value Loading
int cSavedHeightData=0;
fread(&cSavedHeightData,sizeof(int),1,fp);
if(m_LoadMode==0)
{
for(int cHeightData=0;cHeightData<cSavedHeightData;cHeightData++)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
AddNode->m_pHeightData=new float[SECTORSX*SECTORSY];
fread(AddNode->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
m_HeightMap.Add(AddNode);
}
}
else
{
float pHeightData[SECTORSX*SECTORSY];
for(int cHeightData=0;cHeightData<cSavedHeightData;cHeightData++)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
AddNode->m_FilePos=ftell(fp);
fread(&pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
m_HeightMap.Add(AddNode);
}
}
//Water loading
int cSavedWaterData=0;
fread(&cSavedWaterData,sizeof(int),1,fp);
for(int cWaterData=0;cWaterData<cSavedWaterData;cWaterData++)
{
CSectorWaterMap *AddNode=new CSectorWaterMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fWaterPosX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterPosY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterHeight,sizeof(float),1,fp);
fread(&AddNode->m_bWaterRelection,sizeof(bool),1,fp);
fread(&AddNode->m_WaterColor,sizeof(color),1,fp);
m_WaterMap.Add(AddNode);
}
//Widemap loading
int cSavedWideData=0;
fread(&cSavedWideData,sizeof(int),1,fp);
for(int cWideData=0;cWideData<cSavedWideData;cWideData++)
{
CSectorWideMap *AddNode=new CSectorWideMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(AddNode->m_strWidemapName[0],sizeof(char)*MAX_NAMEBUFFER,1,fp);
strcpy(AddNode->m_strDetailName[0],"detail.dds");
m_WideMap.Add(AddNode);
}
//Fallmap loading
int cSavedFallData=0;
fread(&cSavedFallData,sizeof(int),1,fp);
for(int cFallData=0;cFallData<cSavedFallData;cFallData++)
{
CSectorFallMap *AddNode=new CSectorFallMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fFallPosX,sizeof(float),1,fp);
fread(&AddNode->m_fFallPosY,sizeof(float),1,fp);
fread(&AddNode->m_fFallRot,sizeof(float),1,fp);
int cSavedFallList;
fread(&cSavedFallList,sizeof(int),1,fp);
for(int cFallList=0;cFallList<cSavedFallList;cFallList++)
{
float ReadFallData;
color ReadFallColor;
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallHeightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallLeftList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallRightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallAddXList.Add(ReadFallData);
fread(&ReadFallColor,sizeof(color),1,fp);
AddNode->m_FallColor.Add(ReadFallColor);
}
m_FallMap.Add(AddNode);
}
// HouseMap loading
int cSavedHouseData=0;
fread(&cSavedHouseData,sizeof(int),1,fp);
for(int cHouseData=0;cHouseData<cSavedHouseData;cHouseData++)
{
CSectorHouseMap *AddNode=new CSectorHouseMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedHouseList=0;
fread(&cSavedHouseList,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<cSavedHouseList;cHouseList++)
{
int ReadHouseID;
char *ReadHouseName;
matrix ReadHouseTM;
fread(&ReadHouseTM,sizeof(matrix),1,fp);
AddNode->m_TM.Add(ReadHouseTM);
fread(&ReadHouseID,sizeof(int),1,fp);
AddNode->m_HouseSceneID.Add(ReadHouseID);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strOutName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strMedName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strInName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
strcpy(ReadHouseName,"");
AddNode->m_strBspName.Add(ReadHouseName);
}
m_HouseMap.Add(AddNode);
}
int cSavedInHouseData=0;
fread(&cSavedInHouseData,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<cSavedInHouseData;cInHouseData++)
{
CInHouseObjectMap *AddNode=new CInHouseObjectMap();
fread(AddNode->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
strcpy(AddNode->m_strOutName,strlwr(AddNode->m_strOutName));
strcpy(AddNode->m_strMedName,strlwr(AddNode->m_strMedName));
strcpy(AddNode->m_strInName,strlwr(AddNode->m_strInName));
strcpy(AddNode->m_strBspName,"");
int cSavedObject,cSavedLight;
fread(&cSavedObject,sizeof(int),1,fp);
for(int cObject=0;cObject<cSavedObject;cObject++)
{
matrix ReadObjectTM;
bool ReadAlpha,ReadLight;
long ReadObjectID;
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strObjectNameList.Add(ReadObjectName);
fread(&ReadObjectID,sizeof(long),1,fp);
AddNode->m_ObjectID.Add(ReadObjectID);
fread(&ReadObjectTM,sizeof(matrix),1,fp);
AddNode->m_matObjectList.Add(ReadObjectTM);
fread(&ReadAlpha,sizeof(bool),1,fp);
AddNode->m_isAlpha.Add(true);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_isLight.Add(true);
}
fread(&cSavedLight,sizeof(int),1,fp);
for(int cLight=0;cLight<cSavedLight;cLight++)
{
matrix ReadLightTM;
float ReadLightRange;
color ReadLightColor;
long ReadLightID;
char *ReadLightName=new char[MAX_NAMEBUFFER];
fread(ReadLightName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strLightNameList.Add(ReadLightName);
fread(&ReadLightID,sizeof(long),1,fp);
AddNode->m_LightID.Add(ReadLightID);
fread(&ReadLightTM,sizeof(matrix),1,fp);
AddNode->m_matLightList.Add(ReadLightTM);
fread(&ReadLightRange,sizeof(float),1,fp);
AddNode->m_fLightRange.Add(ReadLightRange);
fread(&ReadLightColor,sizeof(color),1,fp);
AddNode->m_LightColor.Add(ReadLightColor);
}
m_InHouseMap.Add(AddNode);
}
// PlantMap loading
int cSavedPlantData=0;
fread(&cSavedPlantData,sizeof(int),1,fp);
for(int cPlantData=0;cPlantData<cSavedPlantData;cPlantData++)
{
CSectorPlantMap *AddNode=new CSectorPlantMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedSubPlant;
int ReadKind;
unsigned char ReadPosX,ReadPosZ;
//vector3 ReadPos;
fread(&cSavedSubPlant,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<cSavedSubPlant;cSubPlant++)
{
fread(&ReadKind,sizeof(unsigned char),1,fp);
fread(&ReadPosX,sizeof(unsigned char),1,fp);
fread(&ReadPosZ,sizeof(unsigned char),1,fp);
//fread(&ReadPos,sizeof(vector3),1,fp);
bool isAlready=false;
for(int cNowPlant=0;cNowPlant<AddNode->m_PlantKind.num;cNowPlant++)
{
if( AddNode->m_PlantPosX[cNowPlant]==ReadPosX &&
AddNode->m_PlantPosZ[cNowPlant]==ReadPosZ)
{
AddNode->m_PlantKind[cNowPlant]=ReadKind;
AddNode->m_PlantPosX[cNowPlant]=ReadPosX;
AddNode->m_PlantPosZ[cNowPlant]=ReadPosZ;
isAlready=true;
}
}
if(isAlready==false)
{
AddNode->m_PlantKind.Add(ReadKind);
AddNode->m_PlantPosX.Add(ReadPosX);
AddNode->m_PlantPosZ.Add(ReadPosZ);
}
//AddNode->m_vecPlantPos.Add(ReadPos);
}
m_PlantMap.Add(AddNode);
}
// MeshMap loading
int cSavedMeshData=0;
fread(&cSavedMeshData,sizeof(int),1,fp);
for(int cMeshData=0;cMeshData<cSavedMeshData;cMeshData++)
{
CSectorMeshMap *AddNode=new CSectorMeshMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedObject=0;
fread(&cSavedObject,sizeof(int),1,fp);
int ReadObjectSceneID;
matrix ReadMatrixTM;
bool ReadAlpha,ReadLight;
for(int cObject=0;cObject<cSavedObject;cObject++)
{
fread(&ReadObjectSceneID,sizeof(long),1,fp);
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&ReadMatrixTM,sizeof(matrix),1,fp);
fread(&ReadAlpha,sizeof(bool),1,fp);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_ObjectSceneID.Add(ReadObjectSceneID);
AddNode->m_strObjectName.Add(ReadObjectName);
AddNode->m_TM.Add(ReadMatrixTM);
AddNode->m_isAlpha.Add(true);
AddNode->m_isLight.Add(true);
}
m_MeshMap.Add(AddNode);
}
fclose(fp);
BugFix_Tree();
//BugFix_Hangul2English();
}
void CMapStorage::Save(char *strFilename)
{
FILE *fp=fopen(strFilename,"wb");
if(fp==NULL)
return;
char strWrite[MAX_NAMEBUFFER];
sprintf(strWrite,"ZallA-3D Scene Data File Build#1");
fwrite(strWrite,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalObjectSceneCount,sizeof(long),1,fp);
// Height-Value Saving
fwrite(&m_HeightMap.num,sizeof(int),1,fp);
for(int cHeightData=0;cHeightData<m_HeightMap.num;cHeightData++)
{
fwrite(&m_HeightMap[cHeightData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_HeightMap[cHeightData]->m_IndexY,sizeof(int),1,fp);
fwrite(m_HeightMap[cHeightData]->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
}
//Water Saving
fwrite(&m_WaterMap.num,sizeof(int),1,fp);
for(int cWaterData=0;cWaterData<m_WaterMap.num;cWaterData++)
{
fwrite(&m_WaterMap[cWaterData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterPosX,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterPosY,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterSizeX,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterSizeY,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterHeight,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_bWaterRelection,sizeof(bool),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_WaterColor,sizeof(color),1,fp);
}
//Widemap saving
fwrite(&m_WideMap.num,sizeof(int),1,fp);
for(int cWideData=0;cWideData<m_WideMap.num;cWideData++)
{
fwrite(&m_WideMap[cWideData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_WideMap[cWideData]->m_IndexY,sizeof(int),1,fp);
fwrite(m_WideMap[cWideData]->m_strWidemapName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
}
//Fallmap saving
fwrite(&m_FallMap.num,sizeof(int),1,fp);
for(int cFallData=0;cFallData<m_FallMap.num;cFallData++)
{
fwrite(&m_FallMap[cFallData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_FallMap[cFallData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallPosX,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallPosY,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallRot,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallHeightList.num,sizeof(int),1,fp);
for(int cFallList=0;cFallList<m_FallMap[cFallData]->m_FallHeightList.num;cFallList++)
{
fwrite(&m_FallMap[cFallData]->m_FallHeightList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallLeftList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallRightList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallAddXList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallColor[cFallList],sizeof(color),1,fp);
}
}
//HouseMap saving
fwrite(&m_HouseMap.num,sizeof(int),1,fp);
for(int cHouseData=0;cHouseData<m_HouseMap.num;cHouseData++)
{
fwrite(&m_HouseMap[cHouseData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_TM.num,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<m_HouseMap[cHouseData]->m_TM.num;cHouseList++)
{
fwrite(&m_HouseMap[cHouseData]->m_TM[cHouseList],sizeof(matrix),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_HouseSceneID[cHouseList],sizeof(int),1,fp);
fwrite(m_HouseMap[cHouseData]->m_strOutName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_HouseMap[cHouseData]->m_strMedName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_HouseMap[cHouseData]->m_strInName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
}
}
//InHouseObjectMap saving
fwrite(&m_InHouseMap.num,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<m_InHouseMap.num;cInHouseData++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_strObjectNameList.num,sizeof(int),1,fp);
for(int cObject=0;cObject<m_InHouseMap[cInHouseData]->m_strObjectNameList.num;cObject++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strObjectNameList[cObject],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_ObjectID[cObject],sizeof(long),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_matObjectList[cObject],sizeof(matrix),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_isAlpha[cObject],sizeof(bool),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_isLight[cObject],sizeof(bool),1,fp);
}
fwrite(&m_InHouseMap[cInHouseData]->m_strLightNameList.num,sizeof(int),1,fp);
for(int cLight=0;cLight<m_InHouseMap[cInHouseData]->m_strLightNameList.num;cLight++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strLightNameList[cLight],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_LightID[cLight],sizeof(long),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_matLightList[cLight],sizeof(matrix),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_fLightRange[cLight],sizeof(float),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_LightColor[cLight],sizeof(color),1,fp);
}
}
// PlantMap saving
fwrite(&m_PlantMap.num,sizeof(int),1,fp);
for(int cPlantData=0;cPlantData<m_PlantMap.num;cPlantData++)
{
fwrite(&m_PlantMap[cPlantData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantKind.num,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<m_PlantMap[cPlantData]->m_PlantKind.num;cSubPlant++)
{
fwrite(&m_PlantMap[cPlantData]->m_PlantKind[cSubPlant],sizeof(unsigned char),1,fp);
//fwrite(&m_PlantMap[cPlantData]->m_vecPlantPos[cSubPlant],sizeof(vector3),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosX[cSubPlant],sizeof(unsigned char),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosZ[cSubPlant],sizeof(unsigned char),1,fp);
}
}
// MeshMap saving
fwrite(&m_MeshMap.num,sizeof(int),1,fp);
for(int cMeshData=0;cMeshData<m_MeshMap.num;cMeshData++)
{
fwrite(&m_MeshMap[cMeshData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_ObjectSceneID.num,sizeof(int),1,fp);
for(int cObject=0;cObject<m_MeshMap[cMeshData]->m_ObjectSceneID.num;cObject++)
{
fwrite(&m_MeshMap[cMeshData]->m_ObjectSceneID[cObject],sizeof(long),1,fp);
fwrite(m_MeshMap[cMeshData]->m_strObjectName[cObject],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_MeshMap[cMeshData]->m_TM[cObject],sizeof(matrix),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_isAlpha[cObject],sizeof(bool),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_isLight[cObject],sizeof(bool),1,fp);
}
}
fclose(fp);
}
CSectorDungeonMap* CMapStorage::FindDungeonMap(float fFindx, float fFindy)
{
return NULL;
}
CSectorHeightMap* CMapStorage::FindHeightMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_HeightMap.num;cStorage++)
{
if( m_HeightMap[cStorage]->m_IndexX==indexx &&
m_HeightMap[cStorage]->m_IndexY==indexy)
{
if(m_HeightMap[cStorage]->m_FilePos!=0)
{
FILE *fp=fopen(m_strMapFilename,"rb");
fseek(fp,m_HeightMap[cStorage]->m_FilePos,SEEK_CUR);
m_HeightMap[cStorage]->m_pHeightData=new float[SECTORSX*SECTORSY];
fread(m_HeightMap[cStorage]->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
fclose(fp);
}
return m_HeightMap[cStorage];
}
}
return NULL;
}
CSectorMeshMap* CMapStorage::FindMeshMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_MeshMap.num;cStorage++)
{
if( m_MeshMap[cStorage]->m_IndexX==indexx &&
m_MeshMap[cStorage]->m_IndexY==indexy)
{
return m_MeshMap[cStorage];
}
}
return NULL;
}
CSectorPlantMap* CMapStorage::FindPlantMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_PlantMap.num;cStorage++)
{
if( m_PlantMap[cStorage]->m_IndexX==indexx &&
m_PlantMap[cStorage]->m_IndexY==indexy)
{
return m_PlantMap[cStorage];
}
}
return NULL;
}
CSectorWideMap* CMapStorage::FindWideMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_WideMap.num;cStorage++)
{
if( m_WideMap[cStorage]->m_IndexX==indexx &&
m_WideMap[cStorage]->m_IndexY==indexy)
{
return m_WideMap[cStorage];
}
}
return NULL;
}
CSectorHouseMap* CMapStorage::FindHouseMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_HouseMap.num;cStorage++)
{
if( m_HouseMap[cStorage]->m_IndexX==indexx &&
m_HouseMap[cStorage]->m_IndexY==indexy)
{
return m_HouseMap[cStorage];
}
}
return NULL;
}
void CMapStorage::AddHouseMap(float fAddx, float fAddy, float fAddz,char *strOutName,char *strMedName,char *strInName,char *strBspName)
{
if(strcmp(strOutName,"")==0 && strcmp(strBspName,"")==0 )
return;
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
char *strAddInName=new char[MAX_NAMEBUFFER];
char *strAddMedName=new char[MAX_NAMEBUFFER];
char *strAddOutName=new char[MAX_NAMEBUFFER];
char *strAddBspName=new char[MAX_NAMEBUFFER];
strcpy(strAddInName,strInName);
strcpy(strAddMedName,strMedName);
strcpy(strAddOutName,strOutName);
strcpy(strAddBspName,strBspName);
matrix tm;
tm.Translation(vector3(fAddx,fAddy,fAddz));
for(int i=0;i<m_HouseMap.num;i++)
{
if( m_HouseMap[i]->m_IndexX==indexx &&
m_HouseMap[i]->m_IndexY==indexy)
{
m_HouseMap[i]->m_strInName.Add(strAddInName);
m_HouseMap[i]->m_strMedName.Add(strAddMedName);
m_HouseMap[i]->m_strOutName.Add(strAddOutName);
m_HouseMap[i]->m_strBspName.Add(strAddBspName);
m_HouseMap[i]->m_TM.Add(tm);
m_HouseMap[i]->m_HouseSceneID.Add(m_TotalHouseSceneCount++);
return;
}
}
CSectorHouseMap *AddSectorHouseMap=new CSectorHouseMap;
AddSectorHouseMap->m_IndexX=indexx;
AddSectorHouseMap->m_IndexY=indexy;
AddSectorHouseMap->m_strInName.Add(strAddInName);
AddSectorHouseMap->m_strMedName.Add(strAddMedName);
AddSectorHouseMap->m_strOutName.Add(strAddOutName);
AddSectorHouseMap->m_strBspName.Add(strAddBspName);
AddSectorHouseMap->m_TM.Add(tm);
AddSectorHouseMap->m_HouseSceneID.Add(m_TotalHouseSceneCount++);
m_HouseMap.Add(AddSectorHouseMap);
}
void CMapStorage::DelHouseMap(float fDelx,float fDely,float fDelz,long HouseSceneID)
{
int indexx=(int)(fDelx/SECTORSIZE);
int indexy=(int)(fDelz/SECTORSIZE);
for(int i=0;i<m_HouseMap.num;i++)
{
for(int cObject=0;cObject<m_HouseMap[i]->m_TM.num;cObject++)
{
char *sddfs = m_HouseMap[i]->m_strOutName[cObject];
if(strcmp(m_HouseMap[i]->m_strOutName[cObject],"collision02.r3s") == 0)
{
int a = 10;
}
if(strcmp(m_HouseMap[i]->m_strOutName[cObject],"collision03.r3s") == 0)
{
int a = 10;
}
if(strcmp(m_HouseMap[i]->m_strOutName[cObject],"collision04.r3s") == 0)
{
int a = 10;
}
if(strcmp(m_HouseMap[i]->m_strOutName[cObject],"collision01.r3s") == 0)
{
m_HouseMap[i]->m_TM.DelIndex(cObject);
char *delNode;
delNode=m_HouseMap[i]->m_strOutName[cObject];
m_HouseMap[i]->m_strOutName.DelIndex(cObject);
delete [] delNode;
delNode=m_HouseMap[i]->m_strMedName[cObject];
m_HouseMap[i]->m_strMedName.DelIndex(cObject);
delete [] delNode;
delNode=m_HouseMap[i]->m_strInName[cObject];
m_HouseMap[i]->m_strInName.DelIndex(cObject);
delete [] delNode;
delNode=m_HouseMap[i]->m_strBspName[cObject];
m_HouseMap[i]->m_strBspName.DelIndex(cObject);
delete [] delNode;
}
if(m_HouseMap[i]->m_TM.num==0) // Minotaurs <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
delete m_HouseMap[i];
m_HouseMap.DelIndex(i);
}
}
}
// if( m_HouseMap[i]->m_IndexX==indexx &&
// m_HouseMap[i]->m_IndexY==indexy)
// {
// for(int cObject=0;cObject<m_HouseMap[i]->m_TM.num;cObject++)
// {
//
// if(m_HouseMap[i]->m_HouseSceneID[cObject]==HouseSceneID)
// {
// m_HouseMap[i]->m_TM.DelIndex(cObject);
// char *delNode;
// delNode=m_HouseMap[i]->m_strOutName[cObject];
// m_HouseMap[i]->m_strOutName.DelIndex(cObject);
// delete [] delNode;
// delNode=m_HouseMap[i]->m_strMedName[cObject];
// m_HouseMap[i]->m_strMedName.DelIndex(cObject);
// delete [] delNode;
// delNode=m_HouseMap[i]->m_strInName[cObject];
// m_HouseMap[i]->m_strInName.DelIndex(cObject);
// delete [] delNode;
// delNode=m_HouseMap[i]->m_strBspName[cObject];
// m_HouseMap[i]->m_strBspName.DelIndex(cObject);
// delete [] delNode;
//
// }
// }
// if(m_HouseMap[i]->m_TM.num==0) // Minotaurs <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// {
// delete m_HouseMap[i];
// m_HouseMap.DelIndex(i);
// }
// return;
// }
//}
}
void CMapStorage::AddHeightMap(float fAddx, float fAddy, float fAddz, float *fHeightData)
{
if(fHeightData==NULL)
return;
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i=0;i<m_HeightMap.num;i++)
{
if( m_HeightMap[i]->m_IndexX == indexx &&
m_HeightMap[i]->m_IndexY == indexy)
{
memcpy(m_HeightMap[i]->m_pHeightData,fHeightData,sizeof(float)*SECTORSX*SECTORSY);
return;
}
}
CSectorHeightMap *AddHeightMap=new CSectorHeightMap();
AddHeightMap->m_IndexX=indexx;
AddHeightMap->m_IndexY=indexy;
if(m_LoadMode==0)
{
AddHeightMap->m_pHeightData=new float[SECTORSX*SECTORSY];
}
memcpy(AddHeightMap->m_pHeightData,fHeightData,sizeof(float)*SECTORSX*SECTORSY);
m_HeightMap.Add(AddHeightMap);
}
void CMapStorage::AddWideMap(float fAddx, float fAddy, float fAddz, char *strWideMapName,char *strDetailMapName,char *strWideMapName1,char *strDetailMapName1,char *strWideMapName2,char *strDetailMapName2)
{
if(strcmp(strWideMapName,"")==0)
return;
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i=0;i<m_WideMap.num;i++)
{
if( m_WideMap[i]->m_IndexX == indexx &&
m_WideMap[i]->m_IndexY == indexy)
{
strcpy(m_WideMap[i]->m_strWidemapName[0],strWideMapName);
strcpy(m_WideMap[i]->m_strWidemapName[1],strWideMapName1);
strcpy(m_WideMap[i]->m_strWidemapName[2],strWideMapName2);
strcpy(m_WideMap[i]->m_strDetailName[0],strDetailMapName);
strcpy(m_WideMap[i]->m_strDetailName[1],strDetailMapName1);
strcpy(m_WideMap[i]->m_strDetailName[2],strDetailMapName2);
return;
}
}
CSectorWideMap *AddWideMap=new CSectorWideMap();
AddWideMap->m_IndexX=indexx;
AddWideMap->m_IndexY=indexy;
strcpy(AddWideMap->m_strWidemapName[0],strWideMapName);
strcpy(AddWideMap->m_strWidemapName[1],strWideMapName1);
strcpy(AddWideMap->m_strWidemapName[2],strWideMapName2);
strcpy(AddWideMap->m_strDetailName[0],strDetailMapName);
strcpy(AddWideMap->m_strDetailName[1],strDetailMapName1);
strcpy(AddWideMap->m_strDetailName[2],strDetailMapName2);
m_WideMap.Add(AddWideMap);
}
void CMapStorage::AddWaterMap(float fAddx, float fAddy, float fAddz,float fWaterHeight,float fWaterSizeX,float fWaterSizeY,float fWaterPosX,float fWaterPosY,color WaterColor,bool bWaterRelection)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i=0;i<m_WaterMap.num;i++)
{
if( m_WaterMap[i]->m_IndexX == indexx &&
m_WaterMap[i]->m_IndexY == indexy)
{
m_WaterMap[i]->m_fWaterHeight=fWaterHeight;
m_WaterMap[i]->m_fWaterPosX=fWaterPosX;
m_WaterMap[i]->m_fWaterPosY=fWaterPosY;
m_WaterMap[i]->m_fWaterSizeX=fWaterSizeX;
m_WaterMap[i]->m_fWaterSizeY=fWaterSizeY;
m_WaterMap[i]->m_bWaterRelection=bWaterRelection;
m_WaterMap[i]->m_WaterColor=WaterColor;
return;
}
}
CSectorWaterMap *AddWaterMap=new CSectorWaterMap();
AddWaterMap->m_IndexX=indexx;
AddWaterMap->m_IndexY=indexy;
AddWaterMap->m_fWaterHeight=fWaterHeight;
AddWaterMap->m_fWaterPosX=fWaterPosX;
AddWaterMap->m_fWaterPosY=fWaterPosY;
AddWaterMap->m_fWaterSizeX=fWaterSizeX;
AddWaterMap->m_fWaterSizeY=fWaterSizeY;
AddWaterMap->m_bWaterRelection=bWaterRelection;
AddWaterMap->m_WaterColor=WaterColor;
m_WaterMap.Add(AddWaterMap);
}
CSectorWaterMap* CMapStorage::FindWaterMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_WaterMap.num;cStorage++)
{
if( m_WaterMap[cStorage]->m_IndexX==indexx &&
m_WaterMap[cStorage]->m_IndexY==indexy)
{
return m_WaterMap[cStorage];
}
}
return NULL;
}
void CMapStorage::AddFallMap(float fAddx, float fAddy,float fAddz,float fFallPosX,float fFallPosY,float fFallRot,List<float> &FallHeight,List<float> &FallLeft,List<float> &FallRight,List<float> &FallAddX,List<color> &WaterFallColor)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i=0;i<m_FallMap.num;i++)
{
if( m_FallMap[i]->m_IndexX == indexx &&
m_FallMap[i]->m_IndexY == indexy)
{
m_FallMap[i]->m_fFallPosX=fFallPosX;
m_FallMap[i]->m_fFallPosY=fFallPosY;
m_FallMap[i]->m_fFallRot=fFallRot;
m_FallMap[i]->m_FallHeightList.num=0;
m_FallMap[i]->m_FallLeftList.num=0;
m_FallMap[i]->m_FallRightList.num=0;
m_FallMap[i]->m_FallAddXList.num=0;
for(int cElement=0;cElement<FallHeight.num;cElement++)
{
m_FallMap[i]->m_FallHeightList.Add(FallHeight[cElement]);
m_FallMap[i]->m_FallLeftList.Add(FallLeft[cElement]);
m_FallMap[i]->m_FallRightList.Add(FallRight[cElement]);
m_FallMap[i]->m_FallAddXList.Add(FallAddX[cElement]);
m_FallMap[i]->m_FallColor.Add(WaterFallColor[cElement]);
}
}
}
CSectorFallMap *AddFallMap=new CSectorFallMap();
AddFallMap->m_IndexX=indexx;
AddFallMap->m_IndexY=indexy;
AddFallMap->m_fFallPosX=fFallPosX;
AddFallMap->m_fFallPosY=fFallPosY;
AddFallMap->m_fFallRot=fFallRot;
for(i=0;i<FallHeight.num;i++)
{
AddFallMap->m_FallHeightList.Add(FallHeight[i]);
AddFallMap->m_FallLeftList.Add(FallLeft[i]);
AddFallMap->m_FallRightList.Add(FallRight[i]);
AddFallMap->m_FallAddXList.Add(FallAddX[i]);
AddFallMap->m_FallColor.Add(WaterFallColor[i]);
}
m_FallMap.Add(AddFallMap);
}
CSectorFallMap* CMapStorage::FindFallMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_FallMap.num;cStorage++)
{
if( m_FallMap[cStorage]->m_IndexX==indexx &&
m_FallMap[cStorage]->m_IndexY==indexy)
{
return m_FallMap[cStorage];
}
}
return NULL;
}
void CMapStorage::AddInHouseObject(char *strOutName, char *strMedName, char *strInName,char *strBspName, char *strObjectName, matrix matTM,bool isAlpha,bool isLight)
{
strOutName=strlwr(strOutName);
strMedName=strlwr(strMedName);
strInName=strlwr(strInName);
strBspName=strlwr(strBspName);
for(int cHouse=0;cHouse<m_InHouseMap.num;cHouse++)
{
if( strcmp(m_InHouseMap[cHouse]->m_strOutName,strOutName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strMedName,strMedName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strInName,strInName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strBspName,strBspName)==0 )
{
char *pStrObjectName=new char[MAX_NAMEBUFFER];
strcpy(pStrObjectName,strObjectName);
m_InHouseMap[cHouse]->m_strObjectNameList.Add(pStrObjectName);
m_InHouseMap[cHouse]->m_matObjectList.Add(matTM);
m_InHouseMap[cHouse]->m_isAlpha.Add(isAlpha);
m_InHouseMap[cHouse]->m_isLight.Add(isLight);
m_InHouseMap[cHouse]->m_ObjectID.Add(m_TotalInHouseObjectSceneCount++);
return;
}
}
CInHouseObjectMap *AddInHouseMap=new CInHouseObjectMap();
char *pStrObjectName=new char[MAX_NAMEBUFFER];
strcpy(pStrObjectName,strObjectName);
AddInHouseMap->m_strObjectNameList.Add(pStrObjectName);
AddInHouseMap->m_matObjectList.Add(matTM);
AddInHouseMap->m_isAlpha.Add(isAlpha);
AddInHouseMap->m_isLight.Add(isLight);
strcpy(AddInHouseMap->m_strOutName,strOutName);
strcpy(AddInHouseMap->m_strMedName,strMedName);
strcpy(AddInHouseMap->m_strInName,strInName);
strcpy(AddInHouseMap->m_strBspName,strBspName);
AddInHouseMap->m_ObjectID.Add(m_TotalInHouseObjectSceneCount++);
m_InHouseMap.Add(AddInHouseMap);
}
void CMapStorage::AddInHouseLight(char *strOutName, char *strMedName, char *strInName, char *strBspName, char *strLightName, matrix matTM,float fLightRange,color LightColor)
{
strOutName=strlwr(strOutName);
strMedName=strlwr(strMedName);
strInName=strlwr(strInName);
strBspName=strlwr(strBspName);
for(int cHouse=0;cHouse<m_InHouseMap.num;cHouse++)
{
if( strcmp(m_InHouseMap[cHouse]->m_strOutName,strOutName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strMedName,strMedName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strInName,strInName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strBspName,strBspName)==0 )
{
char *pStrLightName=new char[MAX_NAMEBUFFER];
strcpy(pStrLightName,strLightName);
m_InHouseMap[cHouse]->m_strLightNameList.Add(pStrLightName);
m_InHouseMap[cHouse]->m_matLightList.Add(matTM);
m_InHouseMap[cHouse]->m_fLightRange.Add(fLightRange);
m_InHouseMap[cHouse]->m_LightColor.Add(LightColor);
m_InHouseMap[cHouse]->m_LightID.Add(m_TotalInHouseLightSceneCount++);
return;
}
}
CInHouseObjectMap *AddInHouseMap=new CInHouseObjectMap();
char *pStrObjectName=new char[MAX_NAMEBUFFER];
strcpy(pStrObjectName,strLightName);
AddInHouseMap->m_strLightNameList.Add(pStrObjectName);
AddInHouseMap->m_matLightList.Add(matTM);
AddInHouseMap->m_fLightRange.Add(fLightRange);
AddInHouseMap->m_LightColor.Add(LightColor);
strcpy(AddInHouseMap->m_strOutName,strOutName);
strcpy(AddInHouseMap->m_strMedName,strMedName);
strcpy(AddInHouseMap->m_strInName,strInName);
strcpy(AddInHouseMap->m_strBspName,strBspName);
AddInHouseMap->m_LightID.Add(m_TotalInHouseLightSceneCount++);
m_InHouseMap.Add(AddInHouseMap);
}
CInHouseObjectMap* CMapStorage::FindInHouseMap(char *strOutName, char *strMedName, char *strInName,char *strBspName)
{
strOutName=strlwr(strOutName);
strMedName=strlwr(strMedName);
strInName=strlwr(strInName);
strBspName=strlwr(strBspName);
for(int i=0;i<m_InHouseMap.num;i++)
{
if( strcmp(m_InHouseMap[i]->m_strOutName,strOutName)==0 &&
strcmp(m_InHouseMap[i]->m_strMedName,strMedName)==0 &&
strcmp(m_InHouseMap[i]->m_strInName,strInName)==0 &&
strcmp(m_InHouseMap[i]->m_strBspName,strBspName)==0 )
{
return m_InHouseMap[i];
}
}
return NULL;
}
void CMapStorage::DeleteAllData()
{
int i;
for(i=0;i<m_HouseMap.num;i++)
{
delete m_HouseMap[i];
}
m_HouseMap.num=0;
for(i=0;i<m_HeightMap.num;i++)
{
delete m_HeightMap[i];
}
m_HeightMap.num=0;
for(i=0;i<m_WideMap.num;i++)
{
delete m_WideMap[i];
}
m_WideMap.num=0;
for(i=0;i<m_FallMap.num;i++)
{
delete m_FallMap[i];
}
m_FallMap.num=0;
for(i=0;i<m_InHouseMap.num;i++)
{
delete m_InHouseMap[i];
}
m_InHouseMap.num=0;
for(i=0;i<m_PlantMap.num;i++)
{
delete m_PlantMap[i];
}
m_PlantMap.num=0;
for(i=0;i<m_WaterMap.num;i++)
{
delete m_WaterMap[i];
}
m_WaterMap.num=0;
for(i=0;i<m_MeshMap.num;i++)
{
delete m_MeshMap[i];
}
m_MeshMap.num=0;
for(i=0;i<m_EffectMap.num;i++)
{
delete m_EffectMap[i];
}
m_EffectMap.num = 0;
}
void CMapStorage::DelInHouseObject(char *strOutName, char *strMedName, char *strInName,long ObjectID)
{
for(int cHouse=0;cHouse<m_InHouseMap.num;cHouse++)
{
if( strcmp(m_InHouseMap[cHouse]->m_strOutName,strOutName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strMedName,strMedName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strInName,strInName)==0)
{
for(int cObject=0;cObject<m_InHouseMap[cHouse]->m_strObjectNameList.num;cObject++)
{
if(m_InHouseMap[cHouse]->m_ObjectID[cObject]==ObjectID)
{
delete m_InHouseMap[cHouse]->m_strObjectNameList[cObject];
m_InHouseMap[cHouse]->m_strObjectNameList.DelIndex(cObject);
m_InHouseMap[cHouse]->m_ObjectID.DelIndex(cObject);
m_InHouseMap[cHouse]->m_matObjectList.DelIndex(cObject);
m_InHouseMap[cHouse]->m_isAlpha.DelIndex(cObject);
m_InHouseMap[cHouse]->m_isLight.DelIndex(cObject);
}
}
}
}
}
void CMapStorage::DelInHouseLight(char *strOutName, char *strMedName, char *strInName,long LightID)
{
for(int cHouse=0;cHouse<m_InHouseMap.num;cHouse++)
{
if( strcmp(m_InHouseMap[cHouse]->m_strOutName,strOutName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strMedName,strMedName)==0 &&
strcmp(m_InHouseMap[cHouse]->m_strInName,strInName)==0)
{
for(int cLight=0;cLight<m_InHouseMap[cHouse]->m_strLightNameList.num;cLight++)
{
if(m_InHouseMap[cHouse]->m_LightID[cLight]==LightID)
{
delete m_InHouseMap[cHouse]->m_strLightNameList[cLight];
m_InHouseMap[cHouse]->m_LightID.DelIndex(cLight);
m_InHouseMap[cHouse]->m_strLightNameList.DelIndex(cLight);
m_InHouseMap[cHouse]->m_matLightList.DelIndex(cLight);
m_InHouseMap[cHouse]->m_fLightRange.DelIndex(cLight);
m_InHouseMap[cHouse]->m_LightColor.DelIndex(cLight);
}
}
return;
}
}
}
void CMapStorage::AddPlantMap(float fAddx, float fAddy, float fAddz, unsigned char PlantKind)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int cPlant=0;cPlant<m_PlantMap.num;cPlant++)
{
if( m_PlantMap[cPlant]->m_IndexX == indexx &&
m_PlantMap[cPlant]->m_IndexY == indexy)
{
int ix=(fAddx-(indexx*SECTORSIZE))/LINTERVAL;
int iz=(fAddz-(indexy*SECTORSIZE))/LINTERVAL;
bool isAlready=false;
for(int cSubPlant=0;cSubPlant<m_PlantMap[cPlant]->m_PlantKind.num;cSubPlant++)
{
if( m_PlantMap[cPlant]->m_PlantPosX[cSubPlant]==ix &&
m_PlantMap[cPlant]->m_PlantPosZ[cSubPlant]==iz)
{
m_PlantMap[cPlant]->m_PlantPosX[cSubPlant]=ix;
m_PlantMap[cPlant]->m_PlantPosZ[cSubPlant]=iz;
m_PlantMap[cPlant]->m_PlantKind[cSubPlant]=PlantKind;
isAlready=true;
break;
}
}
if(isAlready==false)
{
m_PlantMap[cPlant]->m_PlantPosX.Add(ix);
m_PlantMap[cPlant]->m_PlantPosZ.Add(iz);
m_PlantMap[cPlant]->m_PlantKind.Add(PlantKind);
}
//m_PlantMap[cPlant]->m_vecPlantPos.Add(vector3(fAddx-(indexx*SECTORSIZE),fAddy,fAddz-(indexy*SECTORSIZE)));
return;
}
}
CSectorPlantMap *AddPlantMap=new CSectorPlantMap();
AddPlantMap->m_IndexX=indexx;
AddPlantMap->m_IndexY=indexy;
int ix=(fAddx-(indexx*SECTORSIZE))/LINTERVAL;
int iz=(fAddz-(indexy*SECTORSIZE))/LINTERVAL;
AddPlantMap->m_PlantKind.Add(PlantKind);
//AddPlantMap->m_vecPlantPos.Add(vector3(fAddx-(indexx*SECTORSIZE),fAddy,fAddz-(indexy*SECTORSIZE)));
AddPlantMap->m_PlantPosX.Add(ix);
AddPlantMap->m_PlantPosZ.Add(iz);
m_PlantMap.Add(AddPlantMap);
}
void CMapStorage::DelPlantMap(float fDelx, float fDelY, float fDelz)
{
int indexx=(int)(fDelx/SECTORSIZE);
int indexy=(int)(fDelz/SECTORSIZE);
int Findx,Findz,Delx,Delz;
for(int cPlant=0;cPlant<m_PlantMap.num;cPlant++)
{
if( m_PlantMap[cPlant]->m_IndexX == indexx &&
m_PlantMap[cPlant]->m_IndexY == indexy)
{
for(int cInPlant=0;cInPlant<m_PlantMap[cPlant]->m_PlantKind.num;cInPlant++)
{
Delx=m_PlantMap[cPlant]->m_PlantPosX[cInPlant];
Delz=m_PlantMap[cPlant]->m_PlantPosZ[cInPlant];
Findx=(int)( (fDelx-(indexx*SECTORSIZE)) /LINTERVAL);
Findz=(int)( (fDelz-(indexy*SECTORSIZE)) /LINTERVAL);
if(Delx==Findx && Delz==Findz)
{
m_PlantMap[cPlant]->m_PlantKind.DelIndex(cInPlant);
m_PlantMap[cPlant]->m_PlantPosX.DelIndex(cInPlant);
m_PlantMap[cPlant]->m_PlantPosZ.DelIndex(cInPlant);
//m_PlantMap[cPlant]->m_vecPlantPos.DelIndex(cInPlant);
}
}
return;
}
}
}
void CMapStorage::AddMeshMap(float fAddx, float fAddy, float fAddz,char *strObjectName,matrix matTM, bool isAlpha, bool isLight)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int cObject=0;cObject<m_MeshMap.num;cObject++)
{
if( m_MeshMap[cObject]->m_IndexX == indexx &&
m_MeshMap[cObject]->m_IndexY == indexy)
{
char *AddObjectName=new char[MAX_NAMEBUFFER];
strcpy(AddObjectName,strObjectName);
m_MeshMap[cObject]->m_strObjectName.Add(AddObjectName);
m_MeshMap[cObject]->m_TM.Add(matTM);
m_MeshMap[cObject]->m_isAlpha.Add(isAlpha);
m_MeshMap[cObject]->m_isLight.Add(isLight);
m_MeshMap[cObject]->m_ObjectSceneID.Add(m_TotalObjectSceneCount++);
return;
}
}
CSectorMeshMap *AddMeshMap=new CSectorMeshMap();
AddMeshMap->m_IndexX=indexx;
AddMeshMap->m_IndexY=indexy;
char *AddObjectName=new char[MAX_NAMEBUFFER];
strcpy(AddObjectName,strObjectName);
AddMeshMap->m_strObjectName.Add(AddObjectName);
AddMeshMap->m_TM.Add(matTM);
AddMeshMap->m_isAlpha.Add(isAlpha);
AddMeshMap->m_isLight.Add(isLight);
AddMeshMap->m_ObjectSceneID.Add(m_TotalObjectSceneCount++);
m_MeshMap.Add(AddMeshMap);
}
void CMapStorage::DelMeshMap(float fDelx, float fDely, float fDelz, long ObjectSceneID)
{
int indexx=(int)(fDelx/SECTORSIZE);
int indexy=(int)(fDelz/SECTORSIZE);
//for(int i=0;i<m_HouseMap.num;i++)
//{
//
// for(int cObject=0;cObject<m_HouseMap[i]->m_TM.num;cObject++)
// {
// char *sddfs = m_MeshMap[i]->m_strObjectName[cObject];
// if(strcmp(m_MeshMap[i]->m_strObjectName[cObject],"collision02.r3s") == 0)
// {
// int a = 10;
// }
// if(strcmp(m_MeshMap[i]->m_strObjectName[cObject],"collision03.r3s") == 0)
// {
// int a = 10;
// }
// if(strcmp(m_MeshMap[i]->m_strObjectName[cObject],"collision04.r3s") == 0)
// {
// int a = 10;
// }
// if(strcmp(m_MeshMap[i]->m_strObjectName[cObject],"collision01.r3s") == 0)
// {
// m_MeshMap[i]->m_TM.DelIndex(cObject);
// m_MeshMap[i]->m_isAlpha.DelIndex(cObject);
// m_MeshMap[i]->m_isLight.DelIndex(cObject);
// m_MeshMap[i]->m_ObjectSceneID.DelIndex(cObject);
// char *delNode;
// delNode=m_MeshMap[i]->m_strObjectName[cObject];
// delete [] delNode;
// m_MeshMap[i]->m_strObjectName.DelIndex(cObject);
//
// }
// if( m_MeshMap[i]->m_TM.num==0)
// {
// delete m_MeshMap[i];
// m_MeshMap.DelIndex(i);
// }
// }
//}
for(int i=0;i<m_MeshMap.num;i++) // Minotaurs <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
if( m_MeshMap[i]->m_IndexX==indexx &&
m_MeshMap[i]->m_IndexY==indexy)
{
for(int cObject=0;cObject<m_MeshMap[i]->m_TM.num;cObject++)
{
if(ObjectSceneID==m_MeshMap[i]->m_ObjectSceneID[cObject])
{
m_MeshMap[i]->m_TM.DelIndex(cObject);
m_MeshMap[i]->m_isAlpha.DelIndex(cObject);
m_MeshMap[i]->m_isLight.DelIndex(cObject);
m_MeshMap[i]->m_ObjectSceneID.DelIndex(cObject);
char *delNode;
delNode=m_MeshMap[i]->m_strObjectName[cObject];
delete [] delNode;
m_MeshMap[i]->m_strObjectName.DelIndex(cObject);
}
}
if( m_MeshMap[i]->m_TM.num==0)
{
delete m_MeshMap[i];
m_MeshMap.DelIndex(i);
}
return;
}
}
}
void CMapStorage::SaveSector(char *strFilename,long SectorX,long SectorY)
{
FILE *fp=fopen(strFilename,"wb");
if(fp==NULL)
return;
char strWrite[MAX_NAMEBUFFER];
sprintf(strWrite,"ZallA-3D Sector Scene Data File Build#1");
fwrite(strWrite,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalObjectSceneCount,sizeof(long),1,fp);
bool HaveHeightMap=false;
for(int cHeightData=0;cHeightData<m_HeightMap.num;cHeightData++)
{
if( m_HeightMap[cHeightData]->m_IndexX==SectorX &&
m_HeightMap[cHeightData]->m_IndexY==SectorY)
{
HaveHeightMap=true;
fwrite(&HaveHeightMap,sizeof(bool),1,fp);
fwrite(m_HeightMap[cHeightData]->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
break;
}
}
if(HaveHeightMap==false)
{
fwrite(&HaveHeightMap,sizeof(bool),1,fp);
}
bool HaveWaterMap=false;
for(int cWaterData=0;cWaterData<m_WaterMap.num;cWaterData++)
{
if( m_WaterMap[cWaterData]->m_IndexX==SectorX &&
m_WaterMap[cWaterData]->m_IndexY==SectorY)
{
HaveWaterMap=true;
fwrite(&HaveWaterMap,sizeof(bool),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterPosX,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterPosY,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterSizeX,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterSizeY,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterHeight,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_bWaterRelection,sizeof(bool),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_WaterColor,sizeof(color),1,fp);
break;
}
}
if(HaveWaterMap==false)
{
fwrite(&HaveWaterMap,sizeof(bool),1,fp);
}
bool HaveWideMap=false;
for(int cWideData=0;cWideData<m_WideMap.num;cWideData++)
{
if( m_WideMap[cWideData]->m_IndexX==SectorX &&
m_WideMap[cWideData]->m_IndexY==SectorY)\
{
HaveWideMap=true;
fwrite(&HaveWideMap,sizeof(bool),1,fp);
fwrite(m_WideMap[cWideData]->m_strWidemapName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
break;
}
}
if(HaveWideMap==false)
{
fwrite(&HaveWideMap,sizeof(bool),1,fp);
}
bool HaveFallMap=false;
for(int cFallData=0;cFallData<m_FallMap.num;cFallData++)
{
if( m_FallMap[cFallData]->m_IndexX==SectorX &&
m_FallMap[cFallData]->m_IndexY==SectorY)
{
HaveFallMap=true;
fwrite(&HaveFallMap,sizeof(bool),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallPosX,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallPosY,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallRot,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallHeightList.num,sizeof(int),1,fp);
for(int cFallList=0;cFallList<m_FallMap[cFallData]->m_FallHeightList.num;cFallList++)
{
fwrite(&m_FallMap[cFallData]->m_FallHeightList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallLeftList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallRightList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallAddXList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallColor[cFallList],sizeof(color),1,fp);
}
break;
}
}
if(HaveFallMap==false)
{
fwrite(&HaveFallMap,sizeof(bool),1,fp);
}
bool HaveHouseMap=false;
for(int cHouseData=0;cHouseData<m_HouseMap.num;cHouseData++)
{
if( m_HouseMap[cHouseData]->m_IndexX==SectorX &&
m_HouseMap[cHouseData]->m_IndexY==SectorY)
{
HaveHouseMap=true;
fwrite(&HaveHouseMap,sizeof(bool),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_TM.num,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<m_HouseMap[cHouseData]->m_TM.num;cHouseList++)
{
matrix matTM=m_HouseMap[cHouseData]->m_TM[cHouseList];
matTM._41-=SectorX*SECTORSIZE;
matTM._43-=SectorY*SECTORSIZE;
//fwrite(&m_HouseMap[cHouseData]->m_TM[cHouseList],sizeof(matrix),1,fp);
fwrite(&matTM,sizeof(matrix),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_HouseSceneID[cHouseList],sizeof(int),1,fp);
fwrite(m_HouseMap[cHouseData]->m_strOutName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_HouseMap[cHouseData]->m_strMedName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_HouseMap[cHouseData]->m_strInName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
}
break;
}
}
if(HaveHouseMap==false)
{
fwrite(&HaveHouseMap,sizeof(bool),1,fp);
}
bool HavePlantMap=false;
for(int cPlantData=0;cPlantData<m_PlantMap.num;cPlantData++)
{
if( m_PlantMap[cPlantData]->m_IndexX==SectorX &&
m_PlantMap[cPlantData]->m_IndexY==SectorY)
{
HavePlantMap=true;
fwrite(&HavePlantMap,sizeof(bool),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantKind.num,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<m_PlantMap[cPlantData]->m_PlantKind.num;cSubPlant++)
{
/*
fwrite(&m_PlantMap[cPlantData]->m_PlantKind[cSubPlant],sizeof(unsigned char),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosX[cSubPlant],sizeof(unsigned char),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosZ[cSubPlant],sizeof(unsigned char),1,fp);
*/
fwrite(&m_PlantMap[cPlantData]->m_PlantKind[cSubPlant],sizeof(unsigned char),1,fp);
//fwrite(&m_PlantMap[cPlantData]->m_vecPlantPos[cSubPlant],sizeof(vector3),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosX[cSubPlant],sizeof(unsigned char),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosZ[cSubPlant],sizeof(unsigned char),1,fp);
//fwrite(&m_PlantMap[cPlantData]->m_vecPlantPos[cSubPlant],sizeof(vector3),1,fp);
}
break;
}
}
if(HavePlantMap==false)
{
fwrite(&HavePlantMap,sizeof(bool),1,fp);
}
bool HaveMeshMap=false;
for(int cMeshData=0;cMeshData<m_MeshMap.num;cMeshData++)
{
if( m_MeshMap[cMeshData]->m_IndexX==SectorX&&
m_MeshMap[cMeshData]->m_IndexY==SectorY)
{
HaveMeshMap=true;
fwrite(&HaveMeshMap,sizeof(bool),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_ObjectSceneID.num,sizeof(int),1,fp);
for(int cObject=0;cObject<m_MeshMap[cMeshData]->m_ObjectSceneID.num;cObject++)
{
fwrite(&m_MeshMap[cMeshData]->m_ObjectSceneID[cObject],sizeof(long),1,fp);
fwrite(m_MeshMap[cMeshData]->m_strObjectName[cObject],sizeof(char)*MAX_NAMEBUFFER,1,fp);
matrix matTM=m_MeshMap[cMeshData]->m_TM[cObject];
matTM._41-=SectorX*SECTORSIZE;
matTM._43-=SectorY*SECTORSIZE;
fwrite(&matTM,sizeof(matrix),1,fp);
//fwrite(&m_MeshMap[cMeshData]->m_TM[cObject],sizeof(matrix),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_isAlpha[cObject],sizeof(bool),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_isLight[cObject],sizeof(bool),1,fp);
}
break;
}
}
if(HaveMeshMap==false)
{
fwrite(&HaveMeshMap,sizeof(bool),1,fp);
}
fclose(fp);
}
void CMapStorage::LoadSector(char *strFilename, long SectorX, long SectorY)
{
FILE *fp=fopen(strFilename,"rb");
if(fp==NULL)
return;
char strRead[MAX_NAMEBUFFER];
fread(strRead,sizeof(char)*MAX_NAMEBUFFER,1,fp);
int ReadJunk;
fread(&ReadJunk,sizeof(long),1,fp);
fread(&ReadJunk,sizeof(long),1,fp);
fread(&ReadJunk,sizeof(long),1,fp);
fread(&ReadJunk,sizeof(long),1,fp);
bool HaveHeightData=false;
fread(&HaveHeightData,sizeof(bool),1,fp);
if(HaveHeightData)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
fread(AddNode->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
AddHeightMap(SectorX*SECTORSIZE,0.0f,SectorY*SECTORSIZE,AddNode->m_pHeightData);
//m_HeightMap.Add(AddNode);
delete AddNode;
}
else
{
for(int cHeight=0;cHeight<m_HeightMap.num;cHeight++)
{
if( m_HeightMap[cHeight]->m_IndexX==SectorX &&
m_HeightMap[cHeight]->m_IndexY==SectorY)
{
m_HeightMap.DelIndex(cHeight);
}
}
}
bool HaveWaterData=false;
fread(&HaveWaterData,sizeof(bool),1,fp);
if(HaveWaterData)
{
CSectorWaterMap *AddNode=new CSectorWaterMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
fread(&AddNode->m_fWaterPosX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterPosY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterHeight,sizeof(float),1,fp);
fread(&AddNode->m_bWaterRelection,sizeof(bool),1,fp);
fread(&AddNode->m_WaterColor,sizeof(color),1,fp);
AddWaterMap(SectorX*SECTORSIZE,0.0f,SectorY*SECTORSIZE,AddNode->m_fWaterHeight,AddNode->m_fWaterSizeX,
AddNode->m_fWaterSizeY,AddNode->m_fWaterPosX,AddNode->m_fWaterPosY,AddNode->m_WaterColor,AddNode->m_bWaterRelection);
delete AddNode;
//m_WaterMap.Add(AddNode);
}
else
{
for(int cWater=0;cWater<m_WaterMap.num;cWater++)
{
if( m_WaterMap[cWater]->m_IndexX==SectorX &&
m_WaterMap[cWater]->m_IndexY==SectorY)
{
m_WaterMap.DelIndex(cWater);
}
}
}
bool HaveWideData=false;
fread(&HaveWideData,sizeof(bool),1,fp);
if(HaveWideData)
{
CSectorWideMap *AddNode=new CSectorWideMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
fread(AddNode->m_strWidemapName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddWideMap(SectorX*SECTORSIZE,0.0f,SectorY*SECTORSIZE,AddNode->m_strWidemapName[0],AddNode->m_strDetailName[0],AddNode->m_strWidemapName[1],AddNode->m_strDetailName[1],AddNode->m_strWidemapName[2],AddNode->m_strDetailName[2]);
delete AddNode;
//m_WideMap.Add(AddNode);
}
else
{
for(int cWide=0;cWide<m_WideMap.num;cWide++)
{
if( m_WideMap[cWide]->m_IndexX==SectorX &&
m_WideMap[cWide]->m_IndexY==SectorY)
{
m_WideMap.DelIndex(cWide);
}
}
}
bool HaveFallData=false;
fread(&HaveFallData,sizeof(bool),1,fp);
if(HaveFallData)
{
CSectorFallMap *AddNode=new CSectorFallMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
fread(&AddNode->m_fFallPosX,sizeof(float),1,fp);
fread(&AddNode->m_fFallPosY,sizeof(float),1,fp);
fread(&AddNode->m_fFallRot,sizeof(float),1,fp);
int cSavedFallList;
fread(&cSavedFallList,sizeof(int),1,fp);
for(int cFallList=0;cFallList<cSavedFallList;cFallList++)
{
float ReadFallData;
color ReadFallColor;
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallHeightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallLeftList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallRightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallAddXList.Add(ReadFallData);
fread(&ReadFallColor,sizeof(color),1,fp);
AddNode->m_FallColor.Add(ReadFallColor);
}
AddFallMap(SectorX*SECTORSIZE,0.0f,SectorY*SECTORSIZE,AddNode->m_fFallPosX,AddNode->m_fFallPosY,
AddNode->m_fFallRot,AddNode->m_FallHeightList,AddNode->m_FallLeftList,AddNode->m_FallRightList,
AddNode->m_FallAddXList,AddNode->m_FallColor);
delete AddNode;
//m_FallMap.Add(AddNode);
}
else
{
for(int cFall=0;cFall<m_FallMap.num;cFall++)
{
if( m_FallMap[cFall]->m_IndexX==SectorX &&
m_FallMap[cFall]->m_IndexY==SectorY)
{
m_FallMap.DelIndex(cFall);
}
}
}
bool HaveHouseData=false;
fread(&HaveHouseData,sizeof(bool),1,fp);
if(HaveHouseData)
{
CSectorHouseMap *AddNode=new CSectorHouseMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
int cSavedHouseList=0;
fread(&cSavedHouseList,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<cSavedHouseList;cHouseList++)
{
int ReadHouseID;
char *ReadHouseName;
matrix ReadHouseTM;
fread(&ReadHouseTM,sizeof(matrix),1,fp);
matrix matTM=ReadHouseTM;
matTM._41+=SectorX*SECTORSIZE;
matTM._43+=SectorY*SECTORSIZE;
//AddNode->m_TM.Add(ReadHouseTM);
AddNode->m_TM.Add(matTM);
fread(&ReadHouseID,sizeof(int),1,fp);
AddNode->m_HouseSceneID.Add(m_TotalHouseSceneCount++);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strOutName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strMedName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strInName.Add(ReadHouseName);
}
for(int cHouseMap=0;cHouseMap<m_HouseMap.num;cHouseMap++)
{
if( m_HouseMap[cHouseMap]->m_IndexX==SectorX &&
m_HouseMap[cHouseMap]->m_IndexY==SectorY)
{
break;
}
}
if(cHouseMap==m_HouseMap.num)
m_HouseMap.Add(AddNode);
else
m_HouseMap[cHouseMap]=AddNode;
}
else
{
for(int cHouse=0;cHouse<m_HouseMap.num;cHouse++)
{
if( m_HouseMap[cHouse]->m_IndexX==SectorX &&
m_HouseMap[cHouse]->m_IndexY==SectorY)
{
m_HouseMap.DelIndex(cHouse);
}
}
}
bool HavePlantData=false;
fread(&HavePlantData,sizeof(bool),1,fp);
if(HavePlantData)
{
CSectorPlantMap *AddNode=new CSectorPlantMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
int cSavedSubPlant;
int ReadKind;
vector3 ReadPos;
unsigned char ReadPosX,ReadPosZ;
fread(&cSavedSubPlant,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<cSavedSubPlant;cSubPlant++)
{
fread(&ReadKind,sizeof(unsigned char),1,fp);
//fread(&ReadPos,sizeof(vector3),1,fp);
fread(&ReadPosX,sizeof(unsigned char),1,fp);
fread(&ReadPosZ,sizeof(unsigned char),1,fp);
///*
AddNode->m_PlantKind.Add(ReadKind);
AddNode->m_PlantPosX.Add(ReadPosX);
AddNode->m_PlantPosZ.Add(ReadPosZ);
//*/
//AddNode->m_vecPlantPos.Add(ReadPos);
/*
fread(&ReadKind,sizeof(unsigned char),1,fp);
fread(&ReadPosX,sizeof(unsigned char),1,fp);
fread(&ReadPosZ,sizeof(unsigned char),1,fp);
//fread(&ReadPos,sizeof(vector3),1,fp);
bool isAlready=false;
for(int cNowPlant=0;cNowPlant<AddNode->m_PlantKind.num;cNowPlant++)
{
if( AddNode->m_PlantPosX[cNowPlant]==ReadPosX &&
AddNode->m_PlantPosZ[cNowPlant]==ReadPosZ)
{
AddNode->m_PlantKind[cNowPlant]=ReadKind;
AddNode->m_PlantPosX[cNowPlant]=ReadPosX;
AddNode->m_PlantPosZ[cNowPlant]=ReadPosZ;
isAlready=true;
}
}
if(isAlready==false)
{
AddNode->m_PlantKind.Add(ReadKind);
AddNode->m_PlantPosX.Add(ReadPosX);
AddNode->m_PlantPosZ.Add(ReadPosZ);
}
*/
}
for(int cPlantMap=0;cPlantMap<m_PlantMap.num;cPlantMap++)
{
if( m_PlantMap[cPlantMap]->m_IndexX==SectorX &&
m_PlantMap[cPlantMap]->m_IndexY==SectorY)
{
break;
}
}
if(cPlantMap==m_PlantMap.num)
m_PlantMap.Add(AddNode);
else
m_PlantMap[cPlantMap]=AddNode;
}
else
{
for(int cPlant=0;cPlant<m_PlantMap.num;cPlant++)
{
if( m_PlantMap[cPlant]->m_IndexX==SectorX &&
m_PlantMap[cPlant]->m_IndexY==SectorY)
{
m_PlantMap.DelIndex(cPlant);
}
}
}
bool HaveMeshData=false;
fread(&HaveMeshData,sizeof(bool),1,fp);
if(HaveMeshData)
{
CSectorMeshMap *AddNode=new CSectorMeshMap();
AddNode->m_IndexX=SectorX;
AddNode->m_IndexY=SectorY;
int cSavedObject=0;
fread(&cSavedObject,sizeof(int),1,fp);
int ReadObjectSceneID;
matrix ReadMatrixTM;
bool ReadAlpha,ReadLight;
for(int cObject=0;cObject<cSavedObject;cObject++)
{
fread(&ReadObjectSceneID,sizeof(long),1,fp);
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&ReadMatrixTM,sizeof(matrix),1,fp);
fread(&ReadAlpha,sizeof(bool),1,fp);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_ObjectSceneID.Add(m_TotalObjectSceneCount++);
AddNode->m_strObjectName.Add(ReadObjectName);
matrix matTM=ReadMatrixTM;
matTM._41+=SectorX*SECTORSIZE;
matTM._43+=SectorY*SECTORSIZE;
AddNode->m_TM.Add(matTM);
//AddNode->m_TM.Add(ReadMatrixTM);
AddNode->m_isAlpha.Add(ReadAlpha);
AddNode->m_isLight.Add(ReadLight);
}
for(int cMeshMap=0;cMeshMap<m_MeshMap.num;cMeshMap++)
{
if( m_MeshMap[cMeshMap]->m_IndexX==SectorX &&
m_MeshMap[cMeshMap]->m_IndexY==SectorY)
{
break;
//m_MeshMap.DelIndex(cMeshMap);
}
}
if(cMeshMap==m_MeshMap.num)
m_MeshMap.Add(AddNode);
else
m_MeshMap[cMeshMap]=AddNode;
}
else
{
for(int cMesh=0;cMesh<m_MeshMap.num;cMesh++)
{
if( m_MeshMap[cMesh]->m_IndexX==SectorX &&
m_MeshMap[cMesh]->m_IndexY==SectorY)
{
m_MeshMap.DelIndex(cMesh);
}
}
}
fclose(fp);
}
void CMapStorage::OldLoad(char *strFilename)
{
FILE *fp=fopen(strFilename,"rb");
if(fp==NULL)
return;
DeleteAllData();
char strRead[MAX_NAMEBUFFER];
fread(strRead,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fread(&m_TotalObjectSceneCount,sizeof(long),1,fp);
// Height-Value Loading
int cSavedHeightData=0;
fread(&cSavedHeightData,sizeof(int),1,fp);
for(int cHeightData=0;cHeightData<cSavedHeightData;cHeightData++)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(AddNode->m_pHeightData,sizeof(float)*(SECTORSX-1)*(SECTORSY-1),1,fp);
//m_HeightMap.Add(AddNode);
}
//Water loading
int cSavedWaterData=0;
fread(&cSavedWaterData,sizeof(int),1,fp);
for(int cWaterData=0;cWaterData<cSavedWaterData;cWaterData++)
{
CSectorWaterMap *AddNode=new CSectorWaterMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fWaterPosX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterPosY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterHeight,sizeof(float),1,fp);
fread(&AddNode->m_bWaterRelection,sizeof(bool),1,fp);
fread(&AddNode->m_WaterColor,sizeof(color),1,fp);
m_WaterMap.Add(AddNode);
}
//Widemap loading
int cSavedWideData=0;
fread(&cSavedWideData,sizeof(int),1,fp);
for(int cWideData=0;cWideData<cSavedWideData;cWideData++)
{
CSectorWideMap *AddNode=new CSectorWideMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(AddNode->m_strWidemapName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
m_WideMap.Add(AddNode);
}
//Fallmap loading
int cSavedFallData=0;
fread(&cSavedFallData,sizeof(int),1,fp);
for(int cFallData=0;cFallData<cSavedFallData;cFallData++)
{
CSectorFallMap *AddNode=new CSectorFallMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fFallPosX,sizeof(float),1,fp);
fread(&AddNode->m_fFallPosY,sizeof(float),1,fp);
fread(&AddNode->m_fFallRot,sizeof(float),1,fp);
int cSavedFallList;
fread(&cSavedFallList,sizeof(int),1,fp);
for(int cFallList=0;cFallList<cSavedFallList;cFallList++)
{
float ReadFallData;
color ReadFallColor;
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallHeightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallLeftList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallRightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallAddXList.Add(ReadFallData);
fread(&ReadFallColor,sizeof(color),1,fp);
AddNode->m_FallColor.Add(ReadFallColor);
}
m_FallMap.Add(AddNode);
}
// HouseMap loading
int cSavedHouseData=0;
fread(&cSavedHouseData,sizeof(int),1,fp);
for(int cHouseData=0;cHouseData<cSavedHouseData;cHouseData++)
{
CSectorHouseMap *AddNode=new CSectorHouseMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedHouseList=0;
fread(&cSavedHouseList,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<cSavedHouseList;cHouseList++)
{
int ReadHouseID;
char *ReadHouseName;
matrix ReadHouseTM;
fread(&ReadHouseTM,sizeof(matrix),1,fp);
AddNode->m_TM.Add(ReadHouseTM);
fread(&ReadHouseID,sizeof(int),1,fp);
AddNode->m_HouseSceneID.Add(ReadHouseID);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strOutName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strMedName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strInName.Add(ReadHouseName);
}
m_HouseMap.Add(AddNode);
}
int cSavedInHouseData=0;
fread(&cSavedInHouseData,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<cSavedInHouseData;cInHouseData++)
{
CInHouseObjectMap *AddNode=new CInHouseObjectMap();
fread(AddNode->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
int cSavedObject,cSavedLight;
fread(&cSavedObject,sizeof(int),1,fp);
for(int cObject=0;cObject<cSavedObject;cObject++)
{
matrix ReadObjectTM;
bool ReadAlpha,ReadLight;
long ReadObjectID;
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strObjectNameList.Add(ReadObjectName);
fread(&ReadObjectID,sizeof(long),1,fp);
AddNode->m_ObjectID.Add(ReadObjectID);
fread(&ReadObjectTM,sizeof(matrix),1,fp);
AddNode->m_matObjectList.Add(ReadObjectTM);
fread(&ReadAlpha,sizeof(bool),1,fp);
AddNode->m_isAlpha.Add(ReadAlpha);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_isLight.Add(ReadLight);
}
fread(&cSavedLight,sizeof(int),1,fp);
for(int cLight=0;cLight<cSavedLight;cLight++)
{
matrix ReadLightTM;
float ReadLightRange;
color ReadLightColor;
long ReadLightID;
char *ReadLightName=new char[MAX_NAMEBUFFER];
fread(ReadLightName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strLightNameList.Add(ReadLightName);
fread(&ReadLightID,sizeof(long),1,fp);
AddNode->m_LightID.Add(ReadLightID);
fread(&ReadLightTM,sizeof(matrix),1,fp);
AddNode->m_matLightList.Add(ReadLightTM);
fread(&ReadLightRange,sizeof(float),1,fp);
AddNode->m_fLightRange.Add(ReadLightRange);
fread(&ReadLightColor,sizeof(color),1,fp);
AddNode->m_LightColor.Add(ReadLightColor);
}
/*
AddNode->m_strLightNameList.num=0;
AddNode->m_LightID.num=0;
AddNode->m_matLightList.num=0;
AddNode->m_fLightRange.num=0;
AddNode->m_LightColor.num=0;
m_TotalInHouseLightSceneCount=0;
*/
m_InHouseMap.Add(AddNode);
}
// PlantMap loading
int cSavedPlantData=0;
fread(&cSavedPlantData,sizeof(int),1,fp);
for(int cPlantData=0;cPlantData<cSavedPlantData;cPlantData++)
{
CSectorPlantMap *AddNode=new CSectorPlantMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedSubPlant;
int ReadKind;
vector3 ReadPos;
fread(&cSavedSubPlant,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<cSavedSubPlant;cSubPlant++)
{
fread(&ReadKind,sizeof(unsigned char),1,fp);
fread(&ReadPos,sizeof(vector3),1,fp);
AddNode->m_PlantKind.Add(ReadKind);
//AddNode->m_vecPlantPos.Add(ReadPos);
}
//m_PlantMap.Add(AddNode);
}
// MeshMap loading
int cSavedMeshData=0;
fread(&cSavedMeshData,sizeof(int),1,fp);
for(int cMeshData=0;cMeshData<cSavedMeshData;cMeshData++)
{
CSectorMeshMap *AddNode=new CSectorMeshMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedObject=0;
fread(&cSavedObject,sizeof(int),1,fp);
int ReadObjectSceneID;
matrix ReadMatrixTM;
bool ReadAlpha,ReadLight;
for(int cObject=0;cObject<cSavedObject;cObject++)
{
fread(&ReadObjectSceneID,sizeof(long),1,fp);
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&ReadMatrixTM,sizeof(matrix),1,fp);
fread(&ReadAlpha,sizeof(bool),1,fp);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_ObjectSceneID.Add(ReadObjectSceneID);
AddNode->m_strObjectName.Add(ReadObjectName);
AddNode->m_TM.Add(ReadMatrixTM);
AddNode->m_isAlpha.Add(ReadAlpha);
AddNode->m_isLight.Add(ReadLight);
}
m_MeshMap.Add(AddNode);
}
fclose(fp);
}
void CMapStorage::SaveInHouseMap(char *strFilename)
{
FILE *fp=fopen(strFilename,"wb");
if(fp==NULL)
return;
fwrite(&m_InHouseMap.num,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<m_InHouseMap.num;cInHouseData++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_strObjectNameList.num,sizeof(int),1,fp);
for(int cObject=0;cObject<m_InHouseMap[cInHouseData]->m_strObjectNameList.num;cObject++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strObjectNameList[cObject],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_ObjectID[cObject],sizeof(long),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_matObjectList[cObject],sizeof(matrix),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_isAlpha[cObject],sizeof(bool),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_isLight[cObject],sizeof(bool),1,fp);
}
fwrite(&m_InHouseMap[cInHouseData]->m_strLightNameList.num,sizeof(int),1,fp);
for(int cLight=0;cLight<m_InHouseMap[cInHouseData]->m_strLightNameList.num;cLight++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strLightNameList[cLight],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_LightID[cLight],sizeof(long),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_matLightList[cLight],sizeof(matrix),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_fLightRange[cLight],sizeof(float),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_LightColor[cLight],sizeof(color),1,fp);
}
}
fclose(fp);
}
void CMapStorage::LoadInHouseMap(char *strFilename)
{
int cSavedInHouseData=0;
FILE *fp=fopen(strFilename,"rb");
fread(&cSavedInHouseData,sizeof(int),1,fp);
if(cSavedInHouseData==0)
return;
m_InHouseMap.num=0;
for(int cInHouseData=0;cInHouseData<cSavedInHouseData;cInHouseData++)
{
CInHouseObjectMap *AddNode=new CInHouseObjectMap();
fread(AddNode->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
strcpy(AddNode->m_strOutName,strlwr(AddNode->m_strOutName));
strcpy(AddNode->m_strMedName,strlwr(AddNode->m_strMedName));
strcpy(AddNode->m_strInName,strlwr(AddNode->m_strInName));
int cSavedObject,cSavedLight;
fread(&cSavedObject,sizeof(int),1,fp);
for(int cObject=0;cObject<cSavedObject;cObject++)
{
matrix ReadObjectTM;
bool ReadAlpha,ReadLight;
long ReadObjectID;
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strObjectNameList.Add(ReadObjectName);
fread(&ReadObjectID,sizeof(long),1,fp);
AddNode->m_ObjectID.Add(ReadObjectID);
fread(&ReadObjectTM,sizeof(matrix),1,fp);
AddNode->m_matObjectList.Add(ReadObjectTM);
fread(&ReadAlpha,sizeof(bool),1,fp);
AddNode->m_isAlpha.Add(true);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_isLight.Add(true);
}
fread(&cSavedLight,sizeof(int),1,fp);
for(int cLight=0;cLight<cSavedLight;cLight++)
{
matrix ReadLightTM;
float ReadLightRange;
color ReadLightColor;
long ReadLightID;
char *ReadLightName=new char[MAX_NAMEBUFFER];
fread(ReadLightName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strLightNameList.Add(ReadLightName);
fread(&ReadLightID,sizeof(long),1,fp);
AddNode->m_LightID.Add(ReadLightID);
fread(&ReadLightTM,sizeof(matrix),1,fp);
AddNode->m_matLightList.Add(ReadLightTM);
fread(&ReadLightRange,sizeof(float),1,fp);
AddNode->m_fLightRange.Add(ReadLightRange);
fread(&ReadLightColor,sizeof(color),1,fp);
AddNode->m_LightColor.Add(ReadLightColor);
}
/*
AddNode->m_strLightNameList.num=0;
AddNode->m_LightID.num=0;
AddNode->m_matLightList.num=0;
AddNode->m_fLightRange.num=0;
AddNode->m_LightColor.num=0;
m_TotalInHouseLightSceneCount=0;
*/
m_InHouseMap.Add(AddNode);
}
fclose(fp);
}
void CMapStorage::BugFix_Tree()
{
for(int cPlantMap=0;cPlantMap<m_PlantMap.num;cPlantMap++)
{
CSectorPlantMap *PlantMap=m_PlantMap[cPlantMap];
List<int> DelTreeList;
for(int cPlant=0;cPlant<PlantMap->m_PlantKind.num;cPlant++)
{
//ix=PlantMap->m_vecPlantPos[cPlant].x/LINTERVAL;
//iy=PlantMap->m_vecPlantPos[cPlant].z/LINTERVAL;
//if( ix < 0 || ix>= SECTORSX || iy < 0 || iy>=SECTORSY)
//DelTreeList.Add(cPlant);
}
for(cPlant=DelTreeList.num-1;cPlant>=0;cPlant--)
{
PlantMap->m_PlantKind.DelIndex(DelTreeList[cPlant]);
//PlantMap->m_vecPlantPos.DelIndex(DelTreeList[cPlant]);
}
}
}
List<char *> strHangulList;
List<char *> strEnglishList;
void ConvertH2E(char *strHangle)
{
strHangle=strlwr(strHangle);
for(int cHangul=0;cHangul<strHangulList.num;cHangul++)
{
if(strcmp(strHangulList[cHangul],strHangle)==0)
{
strcpy(strHangle,strEnglishList[cHangul]);
break;
}
}
}
void CMapStorage::BugFix_Hangul2English()
{
FILE *fp=fopen("c:\\convert2.txt","rt");
int ErrorCheck=0;
do
{
char *strHangul=new char[256];
char *strEnglish=new char[256];
char dummy[256];
ErrorCheck=fscanf(fp,"%s %s %s",dummy,strHangul,strEnglish);
if(ErrorCheck!=-1)
{
strHangul=strlwr(strHangul);
strHangulList.Add(strHangul);
strEnglish=strlwr(strEnglish);
strEnglishList.Add(strEnglish);
}
}
while(ErrorCheck!=-1);
for(int cWideData=0;cWideData<m_WideMap.num;cWideData++)
{
ConvertH2E(m_WideMap[cWideData]->m_strWidemapName[0]);
}
for(int cHouseData=0;cHouseData<m_HouseMap.num;cHouseData++)
{
for(int cHouseList=0;cHouseList<m_HouseMap[cHouseData]->m_HouseSceneID.num;cHouseList++)
{
ConvertH2E(m_HouseMap[cHouseData]->m_strOutName[cHouseList]);
ConvertH2E(m_HouseMap[cHouseData]->m_strMedName[cHouseList]);
ConvertH2E(m_HouseMap[cHouseData]->m_strInName[cHouseList]);
}
}
for(int cInHouseData=0;cInHouseData<m_InHouseMap.num;cInHouseData++)
{
ConvertH2E(m_InHouseMap[cInHouseData]->m_strOutName);
ConvertH2E(m_InHouseMap[cInHouseData]->m_strMedName);
ConvertH2E(m_InHouseMap[cInHouseData]->m_strInName);
for(int cObject=0;cObject<m_InHouseMap[cInHouseData]->m_strObjectNameList.num;cObject++)
{
ConvertH2E(m_InHouseMap[cInHouseData]->m_strObjectNameList[cObject]);
}
for(int cLight=0;cLight<m_InHouseMap[cInHouseData]->m_strLightNameList.num;cLight++)
{
ConvertH2E(m_InHouseMap[cInHouseData]->m_strLightNameList[cLight]);
}
}
for(int cMeshData=0;cMeshData<m_MeshMap.num;cMeshData++)
{
for(int cObject=0;cObject<m_MeshMap[cMeshData]->m_ObjectSceneID.num;cObject++)
{
ConvertH2E(m_MeshMap[cMeshData]->m_strObjectName[cObject]);
}
}
}
void CMapStorage::BugFix_Tree2(char *strFilename)
{
FILE *fp=fopen(strFilename,"rb");
if(fp==NULL)
return;
DeleteAllData();
char strRead[MAX_NAMEBUFFER];
fread(strRead,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fread(&m_TotalObjectSceneCount,sizeof(long),1,fp);
// Height-Value Loading
int cSavedHeightData=0;
fread(&cSavedHeightData,sizeof(int),1,fp);
for(int cHeightData=0;cHeightData<cSavedHeightData;cHeightData++)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(AddNode->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
m_HeightMap.Add(AddNode);
}
//Water loading
int cSavedWaterData=0;
fread(&cSavedWaterData,sizeof(int),1,fp);
for(int cWaterData=0;cWaterData<cSavedWaterData;cWaterData++)
{
CSectorWaterMap *AddNode=new CSectorWaterMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fWaterPosX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterPosY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterHeight,sizeof(float),1,fp);
fread(&AddNode->m_bWaterRelection,sizeof(bool),1,fp);
fread(&AddNode->m_WaterColor,sizeof(color),1,fp);
m_WaterMap.Add(AddNode);
}
//Widemap loading
int cSavedWideData=0;
fread(&cSavedWideData,sizeof(int),1,fp);
for(int cWideData=0;cWideData<cSavedWideData;cWideData++)
{
CSectorWideMap *AddNode=new CSectorWideMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(AddNode->m_strWidemapName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
m_WideMap.Add(AddNode);
}
//Fallmap loading
int cSavedFallData=0;
fread(&cSavedFallData,sizeof(int),1,fp);
for(int cFallData=0;cFallData<cSavedFallData;cFallData++)
{
CSectorFallMap *AddNode=new CSectorFallMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fFallPosX,sizeof(float),1,fp);
fread(&AddNode->m_fFallPosY,sizeof(float),1,fp);
fread(&AddNode->m_fFallRot,sizeof(float),1,fp);
int cSavedFallList;
fread(&cSavedFallList,sizeof(int),1,fp);
for(int cFallList=0;cFallList<cSavedFallList;cFallList++)
{
float ReadFallData;
color ReadFallColor;
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallHeightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallLeftList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallRightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallAddXList.Add(ReadFallData);
fread(&ReadFallColor,sizeof(color),1,fp);
AddNode->m_FallColor.Add(ReadFallColor);
}
m_FallMap.Add(AddNode);
}
// HouseMap loading
int cSavedHouseData=0;
fread(&cSavedHouseData,sizeof(int),1,fp);
for(int cHouseData=0;cHouseData<cSavedHouseData;cHouseData++)
{
CSectorHouseMap *AddNode=new CSectorHouseMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedHouseList=0;
fread(&cSavedHouseList,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<cSavedHouseList;cHouseList++)
{
int ReadHouseID;
char *ReadHouseName;
matrix ReadHouseTM;
fread(&ReadHouseTM,sizeof(matrix),1,fp);
AddNode->m_TM.Add(ReadHouseTM);
fread(&ReadHouseID,sizeof(int),1,fp);
AddNode->m_HouseSceneID.Add(ReadHouseID);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strOutName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strMedName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strInName.Add(ReadHouseName);
}
m_HouseMap.Add(AddNode);
}
int cSavedInHouseData=0;
fread(&cSavedInHouseData,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<cSavedInHouseData;cInHouseData++)
{
CInHouseObjectMap *AddNode=new CInHouseObjectMap();
fread(AddNode->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
strcpy(AddNode->m_strOutName,strlwr(AddNode->m_strOutName));
strcpy(AddNode->m_strMedName,strlwr(AddNode->m_strMedName));
strcpy(AddNode->m_strInName,strlwr(AddNode->m_strInName));
int cSavedObject,cSavedLight;
fread(&cSavedObject,sizeof(int),1,fp);
for(int cObject=0;cObject<cSavedObject;cObject++)
{
matrix ReadObjectTM;
bool ReadAlpha,ReadLight;
long ReadObjectID;
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strObjectNameList.Add(ReadObjectName);
fread(&ReadObjectID,sizeof(long),1,fp);
AddNode->m_ObjectID.Add(ReadObjectID);
fread(&ReadObjectTM,sizeof(matrix),1,fp);
AddNode->m_matObjectList.Add(ReadObjectTM);
fread(&ReadAlpha,sizeof(bool),1,fp);
AddNode->m_isAlpha.Add(true);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_isLight.Add(true);
}
fread(&cSavedLight,sizeof(int),1,fp);
for(int cLight=0;cLight<cSavedLight;cLight++)
{
matrix ReadLightTM;
float ReadLightRange;
color ReadLightColor;
long ReadLightID;
char *ReadLightName=new char[MAX_NAMEBUFFER];
fread(ReadLightName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strLightNameList.Add(ReadLightName);
fread(&ReadLightID,sizeof(long),1,fp);
AddNode->m_LightID.Add(ReadLightID);
fread(&ReadLightTM,sizeof(matrix),1,fp);
AddNode->m_matLightList.Add(ReadLightTM);
fread(&ReadLightRange,sizeof(float),1,fp);
AddNode->m_fLightRange.Add(ReadLightRange);
fread(&ReadLightColor,sizeof(color),1,fp);
AddNode->m_LightColor.Add(ReadLightColor);
}
/*
AddNode->m_strLightNameList.num=0;
AddNode->m_LightID.num=0;
AddNode->m_matLightList.num=0;
AddNode->m_fLightRange.num=0;
AddNode->m_LightColor.num=0;
m_TotalInHouseLightSceneCount=0;
*/
m_InHouseMap.Add(AddNode);
}
// PlantMap loading
int cSavedPlantData=0;
fread(&cSavedPlantData,sizeof(int),1,fp);
for(int cPlantData=0;cPlantData<cSavedPlantData;cPlantData++)
{
CSectorPlantMap *AddNode=new CSectorPlantMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedSubPlant;
int ReadKind;
vector3 ReadPos;
fread(&cSavedSubPlant,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<cSavedSubPlant;cSubPlant++)
{
fread(&ReadKind,sizeof(unsigned char),1,fp);
fread(&ReadPos,sizeof(vector3),1,fp);
int ix=ReadPos.x/LINTERVAL;
int iy=ReadPos.z/LINTERVAL;
AddNode->m_PlantKind.Add(ReadKind);
AddNode->m_PlantPosX.Add(ix);
AddNode->m_PlantPosZ.Add(iy);
}
m_PlantMap.Add(AddNode);
}
// MeshMap loading
int cSavedMeshData=0;
fread(&cSavedMeshData,sizeof(int),1,fp);
for(int cMeshData=0;cMeshData<cSavedMeshData;cMeshData++)
{
CSectorMeshMap *AddNode=new CSectorMeshMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedObject=0;
fread(&cSavedObject,sizeof(int),1,fp);
int ReadObjectSceneID;
matrix ReadMatrixTM;
bool ReadAlpha,ReadLight;
for(int cObject=0;cObject<cSavedObject;cObject++)
{
fread(&ReadObjectSceneID,sizeof(long),1,fp);
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&ReadMatrixTM,sizeof(matrix),1,fp);
fread(&ReadAlpha,sizeof(bool),1,fp);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_ObjectSceneID.Add(ReadObjectSceneID);
AddNode->m_strObjectName.Add(ReadObjectName);
AddNode->m_TM.Add(ReadMatrixTM);
AddNode->m_isAlpha.Add(true);
AddNode->m_isLight.Add(true);
}
m_MeshMap.Add(AddNode);
}
fclose(fp);
}
CSectorMustDivideVertexMap* CMapStorage::FindMustDivideVertexMap(float fFindX, float fFindY)
{
int indexx=(int)(fFindX/SECTORSIZE);
int indexy=(int)(fFindY/SECTORSIZE);
for(int cStorage=0;cStorage<m_MustDivideVertexMap.num;cStorage++)
{
if( m_MustDivideVertexMap[cStorage]->m_IndexX==indexx &&
m_MustDivideVertexMap[cStorage]->m_IndexY==indexy)
{
return m_MustDivideVertexMap[cStorage];
}
}
return NULL;
}
void CMapStorage::AddMustDivideVertex(CSectorMustDivideVertexMap *pMustDivideVertex)
{
m_MustDivideVertexMap.Add(pMustDivideVertex);
}
void CMapStorage::AddSectorLight(float fAddx,float fAddy,float fAddz,float fR,float fG,float fB,float fRad,int iLightSam,int iShadowSam,float fShadowFactor,int iAmb,char *strEffect,float fExpose)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i = 0; i < m_LightMap.num; i++ )
{
if((m_LightMap[i]->m_IndexX == indexx) &&
(m_LightMap[i]->m_IndexY == indexy))
{
CSectorLight pNode;
pNode.m_fRange = fRad;
pNode.m_vecColor.x = fR;
pNode.m_vecColor.y = fG;
pNode.m_vecColor.z = fB;
pNode.m_vecPos.x = fAddx;
pNode.m_vecPos.y = fAddy;
pNode.m_vecPos.z = fAddz;
pNode.m_iLightSamples = iLightSam;
pNode.m_iShadowSamples = iShadowSam;
pNode.m_fShadowFactors = fShadowFactor;
pNode.m_iAmbient = iAmb;
pNode.m_fExpose = fExpose;
strcpy(pNode.m_strEffect,strEffect);
m_LightMap[i]->m_lstLights.push_back(pNode);
return;
}
}
CSectorLightMap *pMap = new CSectorLightMap;
pMap->m_IndexX = indexx;
pMap->m_IndexY = indexy;
CSectorLight pNode;
pNode.m_fRange = fRad;
pNode.m_vecColor.x = fR;
pNode.m_vecColor.y = fG;
pNode.m_vecColor.z = fB;
pNode.m_vecPos.x = fAddx;
pNode.m_vecPos.y = fAddy;
pNode.m_vecPos.z = fAddz;
pNode.m_iLightSamples = iLightSam;
pNode.m_iShadowSamples = iShadowSam;
pNode.m_fShadowFactors = fShadowFactor;
pNode.m_iAmbient = iAmb;
pNode.m_fExpose = fExpose;
strcpy(pNode.m_strEffect,strEffect);
pMap->m_lstLights.push_back(pNode);
m_LightMap.Add(pMap);
}
void CMapStorage::DeleteSectorLight(float fAddx,float fAddy,float fAddz)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i = 0; i < m_LightMap.num; i++ )
{
if((m_LightMap[i]->m_IndexX == indexx) &&
(m_LightMap[i]->m_IndexY == indexy))
{
for(int k = 0; k < m_LightMap[i]->m_lstLights.size(); i++)
{
if((m_LightMap[i]->m_lstLights[k].m_vecPos.x == fAddx) &&
(m_LightMap[i]->m_lstLights[k].m_vecPos.y == fAddy) &&
(m_LightMap[i]->m_lstLights[k].m_vecPos.z == fAddz))
{
m_LightMap[i]->m_lstLights.erase(&(m_LightMap[i]->m_lstLights[k]));
return;
}
}
}
}
}
CSectorLightMap *CMapStorage::FindLightMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int i = 0; i < m_LightMap.num; i++)
{
if((m_LightMap[i]->m_IndexX == indexx) &&
(m_LightMap[i]->m_IndexY == indexy))
{
return m_LightMap[i];
}
}
return (CSectorLightMap *)NULL;
}
void CMapStorage::AddEffectMap(float fAddx,float fAddy, float fAddz,char *strFilename,float xrot,float yrot,float zrot)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
// List<vector3> m_vecEffectPos;
// List<char*> m_vecEffectName;
for(int i=0;i<m_EffectMap.num;i++)
{
if( m_EffectMap[i]->m_IndexX==indexx &&
m_EffectMap[i]->m_IndexY==indexy )
{
m_EffectMap[i]->m_vecEffectPos.Add(vector3(fAddx,fAddy,fAddz));
m_EffectMap[i]->m_vecEffectRot.Add(vector3(xrot,yrot,zrot));
char *pAddName = new char[256];
strcpy(pAddName,strFilename);
m_EffectMap[i]->m_strEffectName.Add(pAddName);
m_EffectMap[i]->Sector_EffectNum++;
return;
}
}
CSectorEffectMap *AddEffectMap=new CSectorEffectMap();
AddEffectMap->m_IndexX=indexx;
AddEffectMap->m_IndexY=indexy;
AddEffectMap->m_vecEffectPos.Add(vector3(fAddx,fAddy,fAddz));
AddEffectMap->m_vecEffectRot.Add(vector3(xrot,yrot,zrot));
char *pAddName = new char[256];
strcpy(pAddName,strFilename);
AddEffectMap->m_strEffectName.Add(pAddName);
m_EffectMap.Add(AddEffectMap);
m_EffectMap[i]->Sector_EffectNum++;
}
void CMapStorage::DelEffectMap(float fAddx,float fAddy,float fAddz,char *filename)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
int j;
for(int cStorage=0;cStorage<m_EffectMap.num;cStorage++)
{
if( m_EffectMap[cStorage]->m_IndexX==indexx &&
m_EffectMap[cStorage]->m_IndexY==indexy)
{
for(j=0;j<m_EffectMap[cStorage]->Sector_EffectNum;j++) {
if(m_EffectMap[cStorage]->m_vecEffectPos[j].x == fAddx &&
m_EffectMap[cStorage]->m_vecEffectPos[j].y == fAddy &&
m_EffectMap[cStorage]->m_vecEffectPos[j].z == fAddz) {
m_EffectMap[cStorage]->m_vecEffectPos.DelIndex(j);
m_EffectMap[cStorage]->m_strEffectName.DelIndex(j);
m_EffectMap[cStorage]->Sector_EffectNum--;
return;
}
}
}
}
return;
}
CSectorEffectMap *CMapStorage::FindEffectMap(int indexX,int indexY) {
for(int cStorage=0;cStorage<m_EffectMap.num;cStorage++) {
if( m_EffectMap[cStorage]->m_IndexX==indexX &&
m_EffectMap[cStorage]->m_IndexY==indexY) {
return m_EffectMap[cStorage];
//return &m_EffectMap.m_Effect[cStorage];
}
}
return NULL;
}
CSectorEffectMap *CMapStorage::FindEffectMap(int &index) {
if(index >= m_EffectMap.num)
index = 0;
return m_EffectMap[index];
}
CSectorEffectMap *CMapStorage::FindEffectMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_EffectMap.num;cStorage++)
{
if( m_EffectMap[cStorage]->m_IndexX==indexx &&
m_EffectMap[cStorage]->m_IndexY==indexy)
{
return m_EffectMap[cStorage];
//return &m_EffectMap.m_Effect[cStorage];
}
}
return NULL;
}
void CMapStorage::DeleteAllObject()
{
int i;
for(i=0;i<m_HouseMap.num;i++)
{
delete m_HouseMap[i];
}
for(i=0;i<m_HeightMap.num;i++)
{
delete m_HeightMap[i];
}
for(i=0;i<m_WideMap.num;i++)
{
delete m_WideMap[i];
}
for(i=0;i<m_FallMap.num;i++)
{
delete m_FallMap[i];
}
for(i=0;i<m_InHouseMap.num;i++)
{
delete m_InHouseMap[i];
}
for(i=0;i<m_PlantMap.num;i++)
{
delete m_PlantMap[i];
}
for(i=0;i<m_MeshMap.num;i++)
{
delete m_MeshMap[i];
}
for(i=0;i<m_WaterMap.num;i++)
{
delete m_WaterMap[i];
}
for(i=0;i<m_EffectMap.num;i++)
{
delete m_EffectMap[i];
}
for(i=0;i<m_LandscapeEffectMap.num;i++) {
delete m_LandscapeEffectMap[i];
}
for(i = 0; i < m_LightMap.num; i++ )
{
delete m_LightMap[i];
}
m_LightMap.num = 0;
m_HouseMap.num=0;
m_HeightMap.num=0;
m_WideMap.num=0;
m_FallMap.num=0;
m_InHouseMap.num=0;
m_PlantMap.num=0;
m_MeshMap.num=0;
m_WaterMap.num=0;
m_EffectMap.num= 0;
m_LandscapeEffectMap.num = 0;
}
/*
void CMapStorage::AddSoundMap(float fAddx, float fAddy, float fAddz, char *strFilename, float fMinRange,float fMaxRange)
{
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i=0;i<m_SoundMap.num;i++)
{
if( m_SoundMap[i]->m_IndexX == indexx &&
m_SoundMap[i]->m_IndexY == indexy)
{
char *pFilename=new char[256];
strcpy(pFilename,strFilename);
m_SoundMap[i]->m_strSoundFilenameList.Add(pFilename);
m_SoundMap[i]->m_SoundPosList.Add(vector3(fAddx,fAddy,fAddz));
m_SoundMap[i]->m_SoundMinRangeList.Add(fMinRange);
m_SoundMap[i]->m_SoundMaxRangeList.Add(fMaxRange);
return;
}
}
CSectorSoundMap *AddNode=new CSectorSoundMap();
AddNode->m_IndexX=indexx;
AddNode->m_IndexY=indexy;
AddNode->m_SoundPosList.Add(vector3(fAddx,fAddy,fAddz));
AddNode->m_SoundMinRangeList.Add(fMinRange);
AddNode->m_SoundMaxRangeList.Add(fMaxRange);
char *pFilename=new char[256];
strcpy(pFilename,strFilename);
AddNode->m_strSoundFilenameList.Add(pFilename);
m_SoundMap.Add(AddNode);
/*
if(fHeightData==NULL)
return;
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
for(int i=0;i<m_HeightMap.num;i++)
{
if( m_HeightMap[i]->m_IndexX == indexx &&
m_HeightMap[i]->m_IndexY == indexy)
{
memcpy(m_HeightMap[i]->m_pHeightData,fHeightData,sizeof(float)*SECTORSX*SECTORSY);
return;
}
}
CSectorHeightMap *AddHeightMap=new CSectorHeightMap();
AddHeightMap->m_IndexX=indexx;
AddHeightMap->m_IndexY=indexy;
if(m_LoadMode==0)
{
AddHeightMap->m_pHeightData=new float[SECTORSX*SECTORSY];
}
memcpy(AddHeightMap->m_pHeightData,fHeightData,sizeof(float)*SECTORSX*SECTORSY);
m_HeightMap.Add(AddHeightMap);
*/
/*
}
CSectorSoundMap* CMapStorage::FindSoundMap(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_SoundMap.num;cStorage++)
{
if( m_SoundMap[cStorage]->m_IndexX==indexx &&
m_SoundMap[cStorage]->m_IndexY==indexy)
{
return m_SoundMap[cStorage];
}
}
return NULL;
}
void CMapStorage::SaveSoundMap(char *strSoundMapFilename)
{
FILE *fp=fopen(strSoundMapFilename,"wb");
fwrite(&m_SoundMap.num,sizeof(int),1,fp);
for(int cStorage=0;cStorage<m_SoundMap.num;cStorage++)
{
fwrite(&m_SoundMap[cStorage]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_SoundMap[cStorage]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_SoundMap[cStorage]->m_SoundMaxRangeList.num,sizeof(int),1,fp);
for(int i=0;i<m_SoundMap[cStorage]->m_SoundMaxRangeList.num;i++)
{
fwrite(m_SoundMap[cStorage]->m_strSoundFilenameList[i],sizeof(char)*256,1,fp);
fwrite(&m_SoundMap[cStorage]->m_SoundPosList[i],sizeof(vector3),1,fp);
fwrite(&m_SoundMap[cStorage]->m_SoundMaxRangeList[i],sizeof(float),1,fp);
fwrite(&m_SoundMap[cStorage]->m_SoundMinRangeList[i],sizeof(float),1,fp);
}
}
}
void CMapStorage::LoadSoundMap(char *strSoundMapFilename)
{
FILE *fp=fopen(strSoundMapFilename,"rb");
if(fp==NULL)
return;
int nStorage=0;
fread(&nStorage,sizeof(int),1,fp);
for(int cStorage=0;cStorage<nStorage;cStorage++)
{
CSectorSoundMap *AddNode=new CSectorSoundMap();
AddNode->m_IndexY;
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int c;
fread(&c,sizeof(int),1,fp);
for(int i=0;i<c;i++)
{
char *strName=new char[256];
fread(strName,sizeof(char)*256,1,fp);
AddNode->m_strSoundFilenameList.Add(strName);
vector3 vecPos;
fread(&vecPos,sizeof(vector3),1,fp);
AddNode->m_SoundPosList.Add(vecPos);
float fRange;
fread(&fRange,sizeof(float),1,fp);
AddNode->m_SoundMaxRangeList.Add(fRange);
fread(&fRange,sizeof(float),1,fp);
AddNode->m_SoundMinRangeList.Add(fRange);
}
m_SoundMap.Add(AddNode);
}
}
*/
void CMapStorage::SaveGF3(char *strFilename)
{
FILE *fp=fopen(strFilename,"wb");
if(fp==NULL)
return;
char strWrite[MAX_NAMEBUFFER];
sprintf(strWrite,"ZallA-3D Scene Data File Build#2");
fwrite(strWrite,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fwrite(&m_TotalObjectSceneCount,sizeof(long),1,fp);
// Height-Value Saving
fwrite(&m_HeightMap.num,sizeof(int),1,fp);
for(int cHeightData=0;cHeightData<m_HeightMap.num;cHeightData++)
{
fwrite(&m_HeightMap[cHeightData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_HeightMap[cHeightData]->m_IndexY,sizeof(int),1,fp);
fwrite(m_HeightMap[cHeightData]->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
}
//Water Saving
fwrite(&m_WaterMap.num,sizeof(int),1,fp);
for(int cWaterData=0;cWaterData<m_WaterMap.num;cWaterData++)
{
fwrite(&m_WaterMap[cWaterData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterPosX,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterPosY,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterSizeX,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterSizeY,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_fWaterHeight,sizeof(float),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_bWaterRelection,sizeof(bool),1,fp);
fwrite(&m_WaterMap[cWaterData]->m_WaterColor,sizeof(color),1,fp);
}
//Widemap saving
fwrite(&m_WideMap.num,sizeof(int),1,fp);
for(int cWideData=0;cWideData<m_WideMap.num;cWideData++)
{
fwrite(&m_WideMap[cWideData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_WideMap[cWideData]->m_IndexY,sizeof(int),1,fp);
fwrite(m_WideMap[cWideData]->m_strWidemapName[0],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_WideMap[cWideData]->m_strDetailName[0],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_WideMap[cWideData]->m_strWidemapName[1],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_WideMap[cWideData]->m_strDetailName[1],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_WideMap[cWideData]->m_strWidemapName[2],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_WideMap[cWideData]->m_strDetailName[2],sizeof(char)*MAX_NAMEBUFFER,1,fp);
}
//Fallmap saving
fwrite(&m_FallMap.num,sizeof(int),1,fp);
for(int cFallData=0;cFallData<m_FallMap.num;cFallData++)
{
fwrite(&m_FallMap[cFallData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_FallMap[cFallData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallPosX,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallPosY,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_fFallRot,sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallHeightList.num,sizeof(int),1,fp);
for(int cFallList=0;cFallList<m_FallMap[cFallData]->m_FallHeightList.num;cFallList++)
{
fwrite(&m_FallMap[cFallData]->m_FallHeightList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallLeftList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallRightList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallAddXList[cFallList],sizeof(float),1,fp);
fwrite(&m_FallMap[cFallData]->m_FallColor[cFallList],sizeof(color),1,fp);
}
}
//HouseMap saving
fwrite(&m_HouseMap.num,sizeof(int),1,fp);
for(int cHouseData=0;cHouseData<m_HouseMap.num;cHouseData++)
{
fwrite(&m_HouseMap[cHouseData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_TM.num,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<m_HouseMap[cHouseData]->m_TM.num;cHouseList++)
{
fwrite(&m_HouseMap[cHouseData]->m_TM[cHouseList],sizeof(matrix),1,fp);
fwrite(&m_HouseMap[cHouseData]->m_HouseSceneID[cHouseList],sizeof(int),1,fp);
fwrite(m_HouseMap[cHouseData]->m_strOutName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
/* if(strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood01(a)_gg_6000o.r3s")||
strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood01(b)_gg_6000o.r3s")||
strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood01(c)_gg_6000o.r3s")||
strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood02(a)_gg_6000o.r3s")||
strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood02(b)_gg_6000o.r3s")||
strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood02(c)_gg_6000o.r3s")||
strstr(m_HouseMap[cHouseData]->m_strMedName[cHouseList],"snowwood02(d)_gg_6000o.r3s")
)
{
char strName[256] = {0};
sprintf(strName,"_QWE_%s",m_HouseMap[cHouseData]->m_strMedName[cHouseList]);
fwrite(strName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
}
else*/
fwrite(m_HouseMap[cHouseData]->m_strMedName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_HouseMap[cHouseData]->m_strInName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_HouseMap[cHouseData]->m_strBspName[cHouseList],sizeof(char)*MAX_NAMEBUFFER,1,fp);
}
}
//InHouseObjectMap saving
fwrite(&m_InHouseMap.num,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<m_InHouseMap.num;cInHouseData++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(m_InHouseMap[cInHouseData]->m_strBspName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_strObjectNameList.num,sizeof(int),1,fp);
for(int cObject=0;cObject<m_InHouseMap[cInHouseData]->m_strObjectNameList.num;cObject++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strObjectNameList[cObject],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_ObjectID[cObject],sizeof(long),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_matObjectList[cObject],sizeof(matrix),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_isAlpha[cObject],sizeof(bool),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_isLight[cObject],sizeof(bool),1,fp);
}
fwrite(&m_InHouseMap[cInHouseData]->m_strLightNameList.num,sizeof(int),1,fp);
for(int cLight=0;cLight<m_InHouseMap[cInHouseData]->m_strLightNameList.num;cLight++)
{
fwrite(m_InHouseMap[cInHouseData]->m_strLightNameList[cLight],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_LightID[cLight],sizeof(long),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_matLightList[cLight],sizeof(matrix),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_fLightRange[cLight],sizeof(float),1,fp);
fwrite(&m_InHouseMap[cInHouseData]->m_LightColor[cLight],sizeof(color),1,fp);
}
}
// PlantMap saving
fwrite(&m_PlantMap.num,sizeof(int),1,fp);
for(int cPlantData=0;cPlantData<m_PlantMap.num;cPlantData++)
{
fwrite(&m_PlantMap[cPlantData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantKind.num,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<m_PlantMap[cPlantData]->m_PlantKind.num;cSubPlant++)
{
fwrite(&m_PlantMap[cPlantData]->m_PlantKind[cSubPlant],sizeof(unsigned char),1,fp);
//fwrite(&m_PlantMap[cPlantData]->m_vecPlantPos[cSubPlant],sizeof(vector3),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosX[cSubPlant],sizeof(unsigned char),1,fp);
fwrite(&m_PlantMap[cPlantData]->m_PlantPosZ[cSubPlant],sizeof(unsigned char),1,fp);
}
}
// MeshMap saving
fwrite(&m_MeshMap.num,sizeof(int),1,fp);
for(int cMeshData=0;cMeshData<m_MeshMap.num;cMeshData++)
{
fwrite(&m_MeshMap[cMeshData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_ObjectSceneID.num,sizeof(int),1,fp);
for(int cObject=0;cObject<m_MeshMap[cMeshData]->m_ObjectSceneID.num;cObject++)
{
fwrite(&m_MeshMap[cMeshData]->m_ObjectSceneID[cObject],sizeof(long),1,fp);
fwrite(m_MeshMap[cMeshData]->m_strObjectName[cObject],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fwrite(&m_MeshMap[cMeshData]->m_TM[cObject],sizeof(matrix),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_isAlpha[cObject],sizeof(bool),1,fp);
fwrite(&m_MeshMap[cMeshData]->m_isLight[cObject],sizeof(bool),1,fp);
}
}
fwrite(&m_EffectMap.num,sizeof(int),1,fp);
for(int cEffectData=0;cEffectData<m_EffectMap.num;cEffectData++)
{
fwrite(&m_EffectMap[cEffectData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_EffectMap[cEffectData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_EffectMap[cEffectData]->m_vecEffectPos.num,sizeof(int),1,fp);
for(int cEffect=0;cEffect<m_EffectMap[cEffectData]->m_vecEffectPos.num;cEffect++)
{
fwrite(&m_EffectMap[cEffectData]->m_vecEffectPos[cEffect],sizeof(vector3),1,fp);
fwrite(&m_EffectMap[cEffectData]->m_vecEffectRot[cEffect],sizeof(vector3),1,fp);
fwrite(m_EffectMap[cEffectData]->m_strEffectName[cEffect],sizeof(char)*256,1,fp);
}
}
// landscapeeffect save
fwrite(&m_LandscapeEffectMap.num,sizeof(int),1,fp);
for(int cLandscapeEffectData = 0;cLandscapeEffectData<m_LandscapeEffectMap.num;cLandscapeEffectData++) {
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_IndexX,sizeof(int),1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_IndexY,sizeof(int),1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect.num,sizeof(int),1,fp);
for(int cLand = 0;cLand <m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect.num;cLand++) {
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect[cLand].m_nEffectMethod,sizeof(int),1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect[cLand].m_vecCenterPos,sizeof(vector3),1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect[cLand].m_Name,sizeof(char)* 50,1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect[cLand].m_Param,sizeof(float) * 50,1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect[cLand].m_IntParam,sizeof(int) * 20,1,fp);
fwrite(&m_LandscapeEffectMap[cLandscapeEffectData]->m_LandscapeEffect[cLand].m_dwBlend,sizeof(DWORD) * 2,1,fp);
}
}
// Sector Light Save
fwrite(&m_LightMap.num,sizeof(int),1,fp);
for(int iLightMap = 0; iLightMap < m_LightMap.num; iLightMap++)
{
int iNum = m_LightMap[iLightMap]->m_lstLights.size();
fwrite((int *)&(m_LightMap[iLightMap]->m_IndexX),sizeof(int),1,fp);
fwrite((int *)&(m_LightMap[iLightMap]->m_IndexY),sizeof(int),1,fp);
fwrite((int *)&(iNum),sizeof(int),1,fp);
for(int iLight = 0; iLight < m_LightMap[iLightMap]->m_lstLights.size(); iLight++)
{
fwrite((CSectorLight *)&(m_LightMap[iLightMap]->m_lstLights[iLight]),sizeof(CSectorLight),1,fp);
}
}
fclose(fp);
}
void CMapStorage::LoadGF3(char *strFilename)
{
FILE *fp=fopen(strFilename,"rb");
if(fp==NULL)
return;
/// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
float ft = 3000.0f;
ft = 0.0f;
strcpy(m_strMapFilename,strFilename);
DeleteAllData();
char strRead[MAX_NAMEBUFFER];
fread(strRead,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&m_TotalHouseSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseLightSceneCount,sizeof(long),1,fp);
fread(&m_TotalInHouseObjectSceneCount,sizeof(long),1,fp);
fread(&m_TotalObjectSceneCount,sizeof(long),1,fp);
// Height-Value Loading
int cSavedHeightData=0;
fread(&cSavedHeightData,sizeof(int),1,fp);
if(m_LoadMode==0)
{
for(int cHeightData=0;cHeightData<cSavedHeightData;cHeightData++)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
AddNode->m_pHeightData=new float[SECTORSX*SECTORSY];
fread(AddNode->m_pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
if(ft != 0.0f)
{
for(int i = 0; i < SECTORSX*SECTORSY; ++i)
{
AddNode->m_pHeightData[i] += ft;
}
}
m_HeightMap.Add(AddNode);
}
}
else
{
float pHeightData[SECTORSX*SECTORSY];
for(int cHeightData=0;cHeightData<cSavedHeightData;cHeightData++)
{
CSectorHeightMap *AddNode=new CSectorHeightMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
AddNode->m_FilePos=ftell(fp);
fread(&pHeightData,sizeof(float)*SECTORSX*SECTORSY,1,fp);
if(ft != 0.0f)
{
for(int i = 0; i < SECTORSX*SECTORSY; ++i)
{
AddNode->m_pHeightData[i] += ft;
}
}
m_HeightMap.Add(AddNode);
}
}
//Water loading
int cSavedWaterData=0;
fread(&cSavedWaterData,sizeof(int),1,fp);
for(int cWaterData=0;cWaterData<cSavedWaterData;cWaterData++)
{
CSectorWaterMap *AddNode=new CSectorWaterMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fWaterPosX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterPosY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeX,sizeof(float),1,fp);
fread(&AddNode->m_fWaterSizeY,sizeof(float),1,fp);
fread(&AddNode->m_fWaterHeight,sizeof(float),1,fp); /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(ft != 0.0f)
AddNode->m_fWaterHeight += ft;
fread(&AddNode->m_bWaterRelection,sizeof(bool),1,fp);
fread(&AddNode->m_WaterColor,sizeof(color),1,fp);
m_WaterMap.Add(AddNode);
}
//Widemap loading
int cSavedWideData=0;
fread(&cSavedWideData,sizeof(int),1,fp);
for(int cWideData=0;cWideData<cSavedWideData;cWideData++)
{
CSectorWideMap *AddNode=new CSectorWideMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(AddNode->m_strWidemapName[0],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strDetailName[0],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strWidemapName[1],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strDetailName[1],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strWidemapName[2],sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strDetailName[2],sizeof(char)*MAX_NAMEBUFFER,1,fp);
if(CRenderOption::m_TerrainMultiDetalTexture)
{
}
else
{
strcpy(AddNode->m_strDetailName[0],"detail.dds");
strcpy(AddNode->m_strWidemapName[1],"");
strcpy(AddNode->m_strDetailName[1],"");
strcpy(AddNode->m_strWidemapName[2],"");
strcpy(AddNode->m_strDetailName[2],"");
}
m_WideMap.Add(AddNode);
}
//Fallmap loading
int cSavedFallData=0;
fread(&cSavedFallData,sizeof(int),1,fp);
for(int cFallData=0;cFallData<cSavedFallData;cFallData++)
{
CSectorFallMap *AddNode=new CSectorFallMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
fread(&AddNode->m_fFallPosX,sizeof(float),1,fp);
fread(&AddNode->m_fFallPosY,sizeof(float),1,fp);
fread(&AddNode->m_fFallRot,sizeof(float),1,fp);
int cSavedFallList;
fread(&cSavedFallList,sizeof(int),1,fp);
for(int cFallList=0;cFallList<cSavedFallList;cFallList++)
{
float ReadFallData;
color ReadFallColor;
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallHeightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallLeftList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallRightList.Add(ReadFallData);
fread(&ReadFallData,sizeof(float),1,fp);
AddNode->m_FallAddXList.Add(ReadFallData);
fread(&ReadFallColor,sizeof(color),1,fp);
AddNode->m_FallColor.Add(ReadFallColor);
}
m_FallMap.Add(AddNode);
}
// HouseMap loading
int cSavedHouseData=0;
fread(&cSavedHouseData,sizeof(int),1,fp);
for(int cHouseData=0;cHouseData<cSavedHouseData;cHouseData++)
{
CSectorHouseMap *AddNode=new CSectorHouseMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedHouseList=0;
fread(&cSavedHouseList,sizeof(int),1,fp);
for(int cHouseList=0;cHouseList<cSavedHouseList;cHouseList++)
{
int ReadHouseID;
char *ReadHouseName;
matrix ReadHouseTM;
fread(&ReadHouseTM,sizeof(matrix),1,fp);
if(ft != 0.0f)
ReadHouseTM._42 += ft;
AddNode->m_TM.Add(ReadHouseTM);
fread(&ReadHouseID,sizeof(int),1,fp);
AddNode->m_HouseSceneID.Add(ReadHouseID);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strOutName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strMedName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strInName.Add(ReadHouseName);
ReadHouseName=new char[MAX_NAMEBUFFER];
fread(ReadHouseName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strBspName.Add(ReadHouseName);
}
m_HouseMap.Add(AddNode);
}
int cSavedInHouseData=0;
fread(&cSavedInHouseData,sizeof(int),1,fp);
for(int cInHouseData=0;cInHouseData<cSavedInHouseData;cInHouseData++)
{
CInHouseObjectMap *AddNode=new CInHouseObjectMap();
fread(AddNode->m_strOutName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strMedName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strInName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(AddNode->m_strBspName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
strcpy(AddNode->m_strOutName,strlwr(AddNode->m_strOutName));
strcpy(AddNode->m_strMedName,strlwr(AddNode->m_strMedName));
strcpy(AddNode->m_strInName,strlwr(AddNode->m_strInName));
strcpy(AddNode->m_strBspName,strlwr(AddNode->m_strBspName));
int cSavedObject,cSavedLight;
fread(&cSavedObject,sizeof(int),1,fp);
for(int cObject=0;cObject<cSavedObject;cObject++)
{
matrix ReadObjectTM;
bool ReadAlpha,ReadLight;
long ReadObjectID;
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strObjectNameList.Add(ReadObjectName);
fread(&ReadObjectID,sizeof(long),1,fp);
AddNode->m_ObjectID.Add(ReadObjectID);
fread(&ReadObjectTM,sizeof(matrix),1,fp);
AddNode->m_matObjectList.Add(ReadObjectTM);
fread(&ReadAlpha,sizeof(bool),1,fp);
AddNode->m_isAlpha.Add(true);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_isLight.Add(true);
}
fread(&cSavedLight,sizeof(int),1,fp);
for(int cLight=0;cLight<cSavedLight;cLight++)
{
matrix ReadLightTM;
float ReadLightRange;
color ReadLightColor;
long ReadLightID;
char *ReadLightName=new char[MAX_NAMEBUFFER];
fread(ReadLightName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
AddNode->m_strLightNameList.Add(ReadLightName);
fread(&ReadLightID,sizeof(long),1,fp);
AddNode->m_LightID.Add(ReadLightID);
fread(&ReadLightTM,sizeof(matrix),1,fp);
AddNode->m_matLightList.Add(ReadLightTM);
fread(&ReadLightRange,sizeof(float),1,fp);
AddNode->m_fLightRange.Add(ReadLightRange);
fread(&ReadLightColor,sizeof(color),1,fp);
AddNode->m_LightColor.Add(ReadLightColor);
}
m_InHouseMap.Add(AddNode);
}
// PlantMap loading
int cSavedPlantData=0;
fread(&cSavedPlantData,sizeof(int),1,fp);
for(int cPlantData=0;cPlantData<cSavedPlantData;cPlantData++)
{
CSectorPlantMap *AddNode=new CSectorPlantMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedSubPlant;
int ReadKind;
unsigned char ReadPosX,ReadPosZ;
//vector3 ReadPos;
fread(&cSavedSubPlant,sizeof(int),1,fp);
for(int cSubPlant=0;cSubPlant<cSavedSubPlant;cSubPlant++)
{
fread(&ReadKind,sizeof(unsigned char),1,fp);
fread(&ReadPosX,sizeof(unsigned char),1,fp);
fread(&ReadPosZ,sizeof(unsigned char),1,fp);
//fread(&ReadPos,sizeof(vector3),1,fp);
bool isAlready=false;
for(int cNowPlant=0;cNowPlant<AddNode->m_PlantKind.num;cNowPlant++)
{
if( AddNode->m_PlantPosX[cNowPlant]==ReadPosX &&
AddNode->m_PlantPosZ[cNowPlant]==ReadPosZ)
{
AddNode->m_PlantKind[cNowPlant]=ReadKind;
AddNode->m_PlantPosX[cNowPlant]=ReadPosX;
AddNode->m_PlantPosZ[cNowPlant]=ReadPosZ;
isAlready=true;
}
}
if(isAlready==false)
{
AddNode->m_PlantKind.Add(ReadKind);
AddNode->m_PlantPosX.Add(ReadPosX);
AddNode->m_PlantPosZ.Add(ReadPosZ);
}
//AddNode->m_vecPlantPos.Add(ReadPos);
}
m_PlantMap.Add(AddNode);
}
// MeshMap loading
int cSavedMeshData=0;
fread(&cSavedMeshData,sizeof(int),1,fp);
for(int cMeshData=0;cMeshData<cSavedMeshData;cMeshData++)
{
CSectorMeshMap *AddNode=new CSectorMeshMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int cSavedObject=0;
fread(&cSavedObject,sizeof(int),1,fp);
int ReadObjectSceneID;
matrix ReadMatrixTM;
bool ReadAlpha,ReadLight;
for(int cObject=0;cObject<cSavedObject;cObject++)
{
fread(&ReadObjectSceneID,sizeof(long),1,fp);
char *ReadObjectName=new char[MAX_NAMEBUFFER];
fread(ReadObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
fread(&ReadMatrixTM,sizeof(matrix),1,fp);
if(ft != 0.0f)
ReadMatrixTM._42 += ft;
fread(&ReadAlpha,sizeof(bool),1,fp);
fread(&ReadLight,sizeof(bool),1,fp);
AddNode->m_ObjectSceneID.Add(ReadObjectSceneID);
AddNode->m_strObjectName.Add(ReadObjectName);
AddNode->m_TM.Add(ReadMatrixTM);
AddNode->m_isAlpha.Add(true);
AddNode->m_isLight.Add(true);
}
m_MeshMap.Add(AddNode);
}
int cSavedEffectData=0;
fread(&cSavedEffectData,sizeof(int),1,fp);
for(int cEffectData=0;cEffectData<cSavedEffectData;cEffectData++)
{
CSectorEffectMap *AddNode=new CSectorEffectMap();
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int nEffect;
fread(&nEffect,sizeof(int),1,fp);
vector3 vecEffectPos;
vector3 vecEffectRot;
char* strEffectName;
for(int cEffect=0;cEffect<nEffect;cEffect++)
{
fread(&vecEffectPos,sizeof(vector3),1,fp);
if(ft != 0.0f)
vecEffectPos.y += ft;
fread(&vecEffectRot,sizeof(vector3),1,fp);
strEffectName=new char[256];
fread(strEffectName,sizeof(char)*256,1,fp);
AddNode->m_vecEffectPos.Add(vecEffectPos);
AddNode->m_strEffectName.Add(strEffectName);
AddNode->m_vecEffectRot.Add(vecEffectRot);
}
m_EffectMap.Add(AddNode);
}
//landscape effect
int cSaveLandscapeEffectData = 0;
fread((int *)&cSaveLandscapeEffectData,sizeof(int),1,fp);
for(int cLandscape = 0;cLandscape<cSaveLandscapeEffectData;cLandscape++) {
CSectorLandscapeEffectMap *AddNode = new CSectorLandscapeEffectMap();
CSectorLandscapeEffectMap ::LandscapeEffect *tmpLandscape;
fread(&AddNode->m_IndexX,sizeof(int),1,fp);
fread(&AddNode->m_IndexY,sizeof(int),1,fp);
int nLandscapeEffect;
fread(&nLandscapeEffect,sizeof(int),1,fp);
for(int cLEffect =0;cLEffect<nLandscapeEffect;cLEffect++) {
tmpLandscape = new CSectorLandscapeEffectMap::LandscapeEffect();
fread(&(tmpLandscape->m_nEffectMethod),sizeof(int),1,fp);
fread(&(tmpLandscape->m_vecCenterPos),sizeof(vector3),1,fp);
if(ft != 0.0f)
tmpLandscape->m_vecCenterPos.y += ft;
fread(tmpLandscape->m_Name,sizeof(char)* 50,1,fp);
fread(tmpLandscape->m_Param,sizeof(float)* 50,1,fp);
fread(tmpLandscape->m_IntParam,sizeof(int)* 20,1,fp);
fread(tmpLandscape->m_dwBlend,sizeof(DWORD)*2,1,fp);
AddNode->m_LandscapeEffect.Add(*tmpLandscape);
delete tmpLandscape;
//AddNode->m_LandscapeEffect.Add
}
m_LandscapeEffectMap.Add(AddNode);
}
// Sector Light Load
if(feof(fp) == 0)
{
int iLightMapNum;
fread((int *)&iLightMapNum,sizeof(int),1,fp);
if(iLightMapNum >0 && iLightMapNum < 100)
{
for(int iLightMap = 0; iLightMap < iLightMapNum; iLightMap++)
{
CSectorLightMap *pAddNode = new CSectorLightMap;
fread((int *)&(pAddNode->m_IndexX),sizeof(int),1,fp);
fread((int *)&(pAddNode->m_IndexY),sizeof(int),1,fp);
int iLightNum;
fread((int *)&iLightNum,sizeof(int),1,fp);
for(int iLight = 0; iLight < iLightNum; iLight++)
{
CSectorLight Node;
fread((CSectorLight *)&(Node),sizeof(CSectorLight),1,fp);
if(ft != 0.0f)
Node.m_vecPos.y += ft;
pAddNode->m_lstLights.push_back(Node);
}
m_LightMap.Add(pAddNode);
}
}
}
fclose(fp);
BugFix_Tree();
//BugFix_Hangul2English();
}
void CMapStorage::DeleteLandscapeEffect(CSectorLandscapeEffectMap* pmap){
int del_map = 0;
for(del_map = 0;del_map < m_LandscapeEffectMap.num;del_map++) {
if(m_LandscapeEffectMap[del_map] == pmap) {
m_LandscapeEffectMap.DelIndex(del_map);
}
}
}
void CMapStorage::AddLandscapeEffect(float fAddx, float fAddy, float fAddz,int nEffectMethod,DWORD dwBlend[2],float Param[50],int IntParam[20],char *strTextureName,char *eff)
{
/*
*/
int indexx=(int)(fAddx/SECTORSIZE);
int indexy=(int)(fAddz/SECTORSIZE);
bool new_sector = false;
fAddy+=100.0f;
for(int i=0;i<m_LandscapeEffectMap.num;i++)
{
if( m_LandscapeEffectMap[i]->m_IndexX == indexx &&
m_LandscapeEffectMap[i]->m_IndexY == indexy )
{
CSectorLandscapeEffectMap::LandscapeEffect AddEffectNode;
AddEffectNode.m_vecCenterPos=vector3(fAddx,fAddy,fAddz);
AddEffectNode.m_nEffectMethod=nEffectMethod;
AddEffectNode.m_dwBlend[0]=dwBlend[0];
AddEffectNode.m_dwBlend[1]=dwBlend[1];
memcpy(AddEffectNode.m_Param,Param,sizeof(float)*50);
memcpy(AddEffectNode.m_IntParam,IntParam,sizeof(int)*20);
if(strTextureName != NULL)
strncpy(AddEffectNode.m_Name,strTextureName,49);
// strcpy(AddEffectNode.m_EffName,eff);
m_LandscapeEffectMap[i]->m_LandscapeEffect.Add(AddEffectNode);
new_sector = true;
}
}
if(!new_sector) {
CSectorLandscapeEffectMap *AddLandscapeEffect=new CSectorLandscapeEffectMap();
AddLandscapeEffect->m_IndexX=indexx;
AddLandscapeEffect->m_IndexY=indexy;
CSectorLandscapeEffectMap::LandscapeEffect AddEffectNode;
AddEffectNode.m_vecCenterPos=vector3(fAddx,fAddy,fAddz);
AddEffectNode.m_nEffectMethod=nEffectMethod;
AddEffectNode.m_dwBlend[0]=dwBlend[0];
AddEffectNode.m_dwBlend[1]=dwBlend[1];
memcpy(AddEffectNode.m_Param,Param,sizeof(float)*50);
memcpy(AddEffectNode.m_IntParam,IntParam,sizeof(int)*20);
if(strTextureName != NULL)
strncpy(AddEffectNode.m_Name,strTextureName,49);
// strcpy(AddEffectNode.m_EffName,eff);
AddLandscapeEffect->m_LandscapeEffect.Add(AddEffectNode);
m_LandscapeEffectMap.Add(AddLandscapeEffect);
}
}
CSectorLandscapeEffectMap* CMapStorage::FindLandscapeEffect(float fFindx, float fFindy)
{
int indexx=(int)(fFindx/SECTORSIZE);
int indexy=(int)(fFindy/SECTORSIZE);
for(int cStorage=0;cStorage<m_LandscapeEffectMap.num;cStorage++)
{
if( m_LandscapeEffectMap[cStorage]->m_IndexX==indexx &&
m_LandscapeEffectMap[cStorage]->m_IndexY==indexy)
{
return m_LandscapeEffectMap[cStorage];
}
}
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink