unsigned char NC_IsIn(char * strin, char * str)
{
char * tmp;
char t1[4096];
char t2[4096];
strcpy(t1, strin);
strcpy(t2, str);
MakeUpcase(t1);
MakeUpcase(t2);
tmp = strstr(t1, t2);
if (tmp == NULL) return 0;
return 1;
}
void EERIE_MESH_TWEAK_Skin(EERIE_3DOBJ * obj, char * s1, char * s2)
{
if (obj == NULL) return;
if (s1 == NULL) return;
if (s2 == NULL) return;
char skintochange[512];
char skinname[512];
sprintf(skintochange, "Graph\\Obj3D\\Textures\\%s.bmp", s1);
MakeUpcase(skintochange);
TextureContainer * tex = D3DTextr_CreateTextureFromFile(skintochange);
if (obj->originaltextures == NULL)
{
obj->originaltextures = (char *)malloc(256 * obj->nbmaps);
memset(obj->originaltextures, 0, 256 * obj->nbmaps);
for (long i = 0; i < obj->nbmaps; i++)
{
if (obj->texturecontainer[i])
strcpy(obj->originaltextures + 256 * i, obj->texturecontainer[i]->m_texName);
}
}
if ((tex != NULL) && (obj->originaltextures != NULL))
{
for (long i = 0; i < obj->nbmaps; i++)
{
if ((strstr(obj->originaltextures + 256 * i, skintochange)))
{
strcpy(skintochange, obj->texturecontainer[i]->m_texName);
break;
}
}
tex->Restore(GDevice);
TextureContainer * tex2 = FindTexture(skintochange);
if (tex2)
for (long i = 0; i < obj->nbmaps; i++)
{
if (obj->texturecontainer[i] == tex2) obj->texturecontainer[i] = tex;
}
}
}
//***********************************************************************************************
// Saves an FTL File
// Must pass the original name of the theo file
//-----------------------------------------------------------------------------------------------
// VERIFIED (Cyril 2001/10/15)
//***********************************************************************************************
BOOL ARX_FTL_Save(char * incomplete_fic, char * complete_fic, EERIE_3DOBJ * obj)
{
// Need an object to be saved !
if (obj == NULL) return FALSE;
// Generate File name/path and create it
char path[256];
char gamefic[256];
sprintf(gamefic, "%sGame%s", Project.workingdir, incomplete_fic);
SetExt(gamefic, ".FTL");
strcpy(path, gamefic);
RemoveName(path);
if (!CreateFullPath(path)) return NULL;
// create some usefull vars
ARX_FTL_PRIMARY_HEADER * afph;
ARX_FTL_SECONDARY_HEADER * afsh;
ARX_FTL_CLOTHES_DATA_HEADER * afcdh;
ARX_FTL_3D_DATA_HEADER * af3Ddh;
ARX_FTL_COLLISION_SPHERES_DATA_HEADER * afcsdh;
unsigned char * dat = NULL;
long pos = 0;
long allocsize = 8000000; // need to compute it more precisely
// Compute allocsize...
allocsize = sizeof(ARX_FTL_PRIMARY_HEADER)
+ 512 //checksum
+ sizeof(ARX_FTL_SECONDARY_HEADER)
+ sizeof(ARX_FTL_3D_DATA_HEADER)
+ sizeof(EERIE_OLD_VERTEX) * obj->nbvertex
+ sizeof(EERIE_FACE_FTL) * obj->nbfaces
+ obj->nbmaps * 256 // texturecontainernames
+ sizeof(EERIE_ACTIONLIST) * obj->nbaction
+ 128000; // just in case...
if (obj->nbgroups > 0)
{
allocsize += sizeof(EERIE_GROUPLIST) * obj->nbgroups;
for (long i = 0; i < obj->nbgroups; i++)
{
if (obj->grouplist[i].nb_index > 0)
{
allocsize += sizeof(long) * obj->grouplist[i].nb_index;
}
}
}
if (obj->nbselections > 0)
{
allocsize += sizeof(EERIE_SELECTIONS) * obj->nbselections;
for (long i = 0; i < obj->nbselections; i++)
{
allocsize += sizeof(long) * obj->selections[i].nb_selected;
}
}
if (obj->sdata && obj->sdata->nb_spheres) // Collision Spheres Data
{
allocsize += sizeof(ARX_FTL_COLLISION_SPHERES_DATA_HEADER);
allocsize += sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres;
}
if (obj->cdata) // Clothes DATA
{
allocsize += sizeof(ARX_FTL_CLOTHES_DATA_HEADER);
allocsize += sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert;
allocsize += sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs;
}
// Finished computing allocsize Now allocate it...
dat = (unsigned char *)malloc(allocsize);
if (!dat)
HERMES_Memory_Emergency_Out();
memset(dat, 0, allocsize);
// Primary Header
afph = (ARX_FTL_PRIMARY_HEADER *)dat;
pos += sizeof(ARX_FTL_PRIMARY_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
afph->ident[0] = 'F';
afph->ident[1] = 'T';
afph->ident[2] = 'L';
afph->version = CURRENT_FTL_VERSION;
// Identification
char check[512];
MakeUpcase(complete_fic);
HERMES_CreateFileCheck(complete_fic, check, 512, CURRENT_FTL_VERSION);
memcpy(dat + pos, check, 512);
pos += 512;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// Secondary Header
afsh = (ARX_FTL_SECONDARY_HEADER *)(dat + pos);
pos += sizeof(ARX_FTL_SECONDARY_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// 3D Data
afsh->offset_3Ddata = pos; //-1;
af3Ddh = (ARX_FTL_3D_DATA_HEADER *)(dat + afsh->offset_3Ddata);
pos += sizeof(ARX_FTL_3D_DATA_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
af3Ddh->nb_vertex = obj->nbvertex;
af3Ddh->nb_faces = obj->nbfaces;
af3Ddh->nb_maps = obj->nbmaps;
af3Ddh->nb_groups = obj->nbgroups;
af3Ddh->nb_action = obj->nbaction;
af3Ddh->nb_selections = obj->nbselections;
af3Ddh->origin = obj->origin;
// vertexes
if (af3Ddh->nb_vertex > 0)
{
for (long ii = 0; ii < af3Ddh->nb_vertex; ii++)
{
memcpy(dat + pos, &obj->vertexlist[ii], sizeof(EERIE_OLD_VERTEX));
pos += sizeof(EERIE_OLD_VERTEX);
}
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
// faces
if (af3Ddh->nb_faces > 0)
{
for (long ii = 0; ii < af3Ddh->nb_faces; ii++)
{
EERIE_FACE_FTL * eff = (EERIE_FACE_FTL *)(dat + pos);
eff->facetype = obj->facelist[ii].facetype;
eff->texid = obj->facelist[ii].texid;
eff->transval = obj->facelist[ii].transval;
eff->temp = obj->facelist[ii].temp;
memcpy(&eff->norm, &obj->facelist[ii].norm, sizeof(EERIE_3D));
for (long kk = 0; kk < IOPOLYVERT; kk++)
{
memcpy(&eff->nrmls[kk], &obj->facelist[ii].nrmls[kk], sizeof(EERIE_3D));
eff->vid[kk] = obj->facelist[ii].vid[kk];
eff->u[kk] = obj->facelist[ii].u[kk];
eff->v[kk] = obj->facelist[ii].v[kk];
eff->ou[kk] = obj->facelist[ii].ou[kk];
eff->ov[kk] = obj->facelist[ii].ov[kk];
eff->rgb[kk] = 0;
}
pos += sizeof(EERIE_FACE_FTL);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
}
// textures
for (long i = 0; i < af3Ddh->nb_maps; i++)
{
char ficc[256];
memset(ficc, 0, 256);
if (obj->texturecontainer[i])
strcpy(ficc, obj->texturecontainer[i]->m_texName);
memcpy(dat + pos, ficc, 256);
pos += 256;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
// groups
if (af3Ddh->nb_groups > 0)
{
memcpy(dat + pos, obj->grouplist, sizeof(EERIE_GROUPLIST)*af3Ddh->nb_groups);
pos += sizeof(EERIE_GROUPLIST) * af3Ddh->nb_groups;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
for (int i = 0; i < af3Ddh->nb_groups; i++)
{
if (obj->grouplist[i].nb_index > 0)
{
memcpy(dat + pos, obj->grouplist[i].indexes, sizeof(long)*obj->grouplist[i].nb_index);
pos += sizeof(long) * obj->grouplist[i].nb_index;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
}
}
// actionpoints
if (af3Ddh->nb_action > 0)
{
memcpy(dat + pos, obj->actionlist, sizeof(EERIE_ACTIONLIST)*af3Ddh->nb_action);
pos += sizeof(EERIE_ACTIONLIST) * af3Ddh->nb_action;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
// selections
if (af3Ddh->nb_selections > 0)
{
memcpy(dat + pos, obj->selections, sizeof(EERIE_SELECTIONS)*af3Ddh->nb_selections);
pos += sizeof(EERIE_SELECTIONS) * af3Ddh->nb_selections;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
for (int i = 0; i < af3Ddh->nb_selections; i++)
{
memcpy(dat + pos, obj->selections[i].selected, sizeof(long)*obj->selections[i].nb_selected);
pos += sizeof(long) * obj->selections[i].nb_selected;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
strcpy(af3Ddh->name, obj->file);
}
// Progressive DATA
afsh->offset_progressive_data = -1;
// Collision Spheres Data
if (obj->sdata && obj->sdata->nb_spheres)
{
afsh->offset_collision_spheres = pos; //-1;
afcsdh = (ARX_FTL_COLLISION_SPHERES_DATA_HEADER *)(dat + afsh->offset_collision_spheres);
pos += sizeof(ARX_FTL_COLLISION_SPHERES_DATA_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
afcsdh->nb_spheres = obj->sdata->nb_spheres;
memcpy(dat + pos, obj->sdata->spheres, sizeof(COLLISION_SPHERE)*obj->sdata->nb_spheres);
pos += sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
else afsh->offset_collision_spheres = -1;
// Clothes DATA
if (obj->cdata == NULL)
{
afsh->offset_clothes_data = -1;
}
else
{
afsh->offset_clothes_data = pos;
afcdh = (ARX_FTL_CLOTHES_DATA_HEADER *)(dat + afsh->offset_clothes_data);
afcdh->nb_cvert = obj->cdata->nb_cvert;
afcdh->nb_springs = obj->cdata->nb_springs;
pos += sizeof(ARX_FTL_CLOTHES_DATA_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// now save cvert
memcpy(dat + pos, obj->cdata->cvert, sizeof(CLOTHESVERTEX)*obj->cdata->nb_cvert);
pos += sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// now saves springs
memcpy(dat + pos, obj->cdata->springs, sizeof(EERIE_SPRINGS)*obj->cdata->nb_springs);
pos += sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
afsh->offset_physics_box = -1;
afsh->offset_cylinder = -1;
// Now we can flush our cool FTL file to the hard drive
unsigned long handle;
char _error[512];
if (pos > allocsize)
{
sprintf(_error, "Badly Allocated SaveBuffer...%s", gamefic);
goto error;
}
char * compressed;
compressed = NULL;
long cpr_pos;
cpr_pos = 0;
compressed = STD_Implode((char *)dat, pos, &cpr_pos);
// Now Saving Whole Buffer
if (!(handle = FileOpenWrite(gamefic)))
{
sprintf(_error, "Unable to Open %s for Write...", gamefic);
goto error;
}
if (FileWrite(handle, compressed, cpr_pos) != cpr_pos)
{
sprintf(_error, "Unable to Write to %s", gamefic);
goto error;
}
FileCloseWrite(handle);
free(compressed);
free(dat);
return TRUE;
error:
;
ShowPopup(_error);
free(dat);
return FALSE;
}
//***********************************************************************************************
// Uses Fast Object Load if FTL file exists
//-----------------------------------------------------------------------------------------------
// VERIFIED (Cyril 2001/10/15)
//***********************************************************************************************
EERIE_3DOBJ * ARX_FTL_Load(char * incomplete_fic, char * complete_fic, EERIE_3DOBJ * obj)
{
// Creates FTL file name
char gamefic[256];
sprintf(gamefic, "%sGame%s", Project.workingdir, incomplete_fic);
SetExt(gamefic, ".FTL");
// Checks for FTL file existence
if (!PAK_FileExist(gamefic)) return NULL;
// Our file exist we can use it
unsigned char * dat;
long pos = 0;
long allocsize;
ARX_FTL_PRIMARY_HEADER * afph;
ARX_FTL_SECONDARY_HEADER * afsh;
ARX_FTL_PROGRESSIVE_DATA_HEADER * afpdh;
ARX_FTL_CLOTHES_DATA_HEADER * afcdh;
ARX_FTL_COLLISION_SPHERES_DATA_HEADER * afcsdh;
ARX_FTL_3D_DATA_HEADER * af3Ddh;
char * compressed = NULL;
long cpr_pos = 0;
long NOrelease = 1;
long NoCheck = 0;
compressed = MCache_Pop(gamefic, &cpr_pos);
if (!compressed)
{
compressed = (char *)PAK_FileLoadMalloc(gamefic, &cpr_pos);
NOrelease = MCache_Push(gamefic, compressed, cpr_pos) ? 1 : 0;
}
else NoCheck = 1;
if (!compressed) return NULL;
long DontCheck = 0;
if (CURRENT_LOADMODE != LOAD_TRUEFILE) DontCheck = 1;
dat = (unsigned char *)STD_Explode(compressed, cpr_pos, &allocsize);//pos,&cpr_pos);
if (!dat) return NULL;
if (!NOrelease) free(compressed);
// Pointer to Primary Header
afph = (ARX_FTL_PRIMARY_HEADER *)dat;
pos += sizeof(ARX_FTL_PRIMARY_HEADER);
// Verify FTL file Signature
if ((afph->ident[0] != 'F') && (afph->ident[1] != 'T') && (afph->ident[2] != 'L'))
{
free(dat);
return NULL;
}
// Verify FTL file version
if (afph->version != CURRENT_FTL_VERSION)
{
free(dat);
return NULL;
}
// Verify Checksum
if ((!NOCHECKSUM || NoCheck) && !DontCheck)
{
char check[512];
MakeUpcase(complete_fic);
HERMES_CreateFileCheck(complete_fic, check, 512, CURRENT_FTL_VERSION);
char * pouet = (char *)(dat + pos);
for (long i = 0; i < 512; i++)
if (check[i] != pouet[i])
{
free(dat);
return NULL;
}
}
// Increases offset by checksum size
pos += 512;
// Pointer to Secondary Header
afsh = (ARX_FTL_SECONDARY_HEADER *)(dat + pos);
pos += sizeof(ARX_FTL_SECONDARY_HEADER);
// Check For & Load 3D Data
if (afsh->offset_3Ddata != -1)
{
if (obj) ReleaseEERIE3DObj(obj), obj = NULL;
//todo free
obj = (EERIE_3DOBJ *)malloc(sizeof(EERIE_3DOBJ));
memset(obj, 0, sizeof(EERIE_3DOBJ));
af3Ddh = (ARX_FTL_3D_DATA_HEADER *)(dat + afsh->offset_3Ddata);
pos = afsh->offset_3Ddata;
pos += sizeof(ARX_FTL_3D_DATA_HEADER);
obj->nbvertex = af3Ddh->nb_vertex;
obj->nbfaces = af3Ddh->nb_faces;
obj->nbmaps = af3Ddh->nb_maps;
obj->nbgroups = af3Ddh->nb_groups;
obj->nbaction = af3Ddh->nb_action;
obj->nbselections = af3Ddh->nb_selections;
obj->origin = af3Ddh->origin;
strcpy(obj->file, af3Ddh->name);
// Alloc'n'Copy vertices
if (obj->nbvertex > 0)
{
//todo free
obj->vertexlist = (EERIE_VERTEX *)malloc(sizeof(EERIE_VERTEX) * obj->nbvertex);
obj->vertexlist3 = (EERIE_VERTEX *)malloc(sizeof(EERIE_VERTEX) * obj->nbvertex);
for (long ii = 0; ii < obj->nbvertex; ii++)
{
memcpy(&obj->vertexlist[ii], dat + pos, sizeof(EERIE_OLD_VERTEX));
memcpy(&obj->vertexlist3[ii], dat + pos, sizeof(EERIE_OLD_VERTEX));
pos += sizeof(EERIE_OLD_VERTEX);
}
obj->point0.x = obj->vertexlist[obj->origin].v.x;
obj->point0.y = obj->vertexlist[obj->origin].v.y;
obj->point0.z = obj->vertexlist[obj->origin].v.z;
for (long i = 0; i < obj->nbvertex; i++)
{
obj->vertexlist[i].vert.color = 0xFF000000;
obj->vertexlist3[i].vert.color = 0xFF000000;
}
}
// Alloc'n'Copy faces
if (obj->nbfaces > 0)
{
//todo free
obj->facelist = (EERIE_FACE *)malloc(sizeof(EERIE_FACE) * obj->nbfaces);
for (long ii = 0; ii < af3Ddh->nb_faces; ii++)
{
EERIE_FACE_FTL * eff = (EERIE_FACE_FTL *)(dat + pos);
obj->facelist[ii].facetype = eff->facetype;
obj->facelist[ii].texid = eff->texid;
obj->facelist[ii].transval = eff->transval;
obj->facelist[ii].temp = eff->temp;
memcpy(&obj->facelist[ii].norm, &eff->norm, sizeof(EERIE_3D));
for (long kk = 0; kk < IOPOLYVERT; kk++)
{
memcpy(&obj->facelist[ii].nrmls[kk], &eff->nrmls[kk], sizeof(EERIE_3D));
obj->facelist[ii].vid[kk] = eff->vid[kk];
obj->facelist[ii].u[kk] = eff->u[kk];
obj->facelist[ii].v[kk] = eff->v[kk];
obj->facelist[ii].ou[kk] = eff->ou[kk];
obj->facelist[ii].ov[kk] = eff->ov[kk];
}
pos += sizeof(EERIE_FACE_FTL);
}
}
// Alloc'n'Copy textures
if (af3Ddh->nb_maps > 0)
{
char ficc[256];
char ficc2[256];
char ficc3[256];
//todo free
obj->texturecontainer = (TextureContainer **)malloc(sizeof(TextureContainer *) * af3Ddh->nb_maps);
for (long i = 0; i < af3Ddh->nb_maps; i++)
{
memcpy(ficc2, dat + pos, 256);
strcpy(ficc3, Project.workingdir);
strcat(ficc3, ficc2);
File_Standardize(ficc3, ficc);
obj->texturecontainer[i] = D3DTextr_CreateTextureFromFile(ficc, Project.workingdir, 0, 0, EERIETEXTUREFLAG_LOADSCENE_RELEASE);
if (GDevice && obj->texturecontainer[i] && !obj->texturecontainer[i]->m_pddsSurface)
obj->texturecontainer[i]->Restore(GDevice);
MakeUserFlag(obj->texturecontainer[i]);
pos += 256;
}
}
// Alloc'n'Copy groups
if (obj->nbgroups > 0)
{
//todo free
obj->grouplist = (EERIE_GROUPLIST *)malloc(sizeof(EERIE_GROUPLIST) * obj->nbgroups);
memcpy(obj->grouplist, dat + pos, sizeof(EERIE_GROUPLIST) * obj->nbgroups);
pos += sizeof(EERIE_GROUPLIST) * obj->nbgroups;
for (long i = 0; i < obj->nbgroups; i++)
if (obj->grouplist[i].nb_index > 0)
{
//TO DO: FREE+++++++++++++++++++++++
obj->grouplist[i].indexes = (long *)malloc(sizeof(long) * obj->grouplist[i].nb_index);
memcpy(obj->grouplist[i].indexes, dat + pos, sizeof(long)*obj->grouplist[i].nb_index);
pos += sizeof(long) * obj->grouplist[i].nb_index;
}
}
// Alloc'n'Copy action points
if (obj->nbaction > 0)
{
//todo free
obj->actionlist = (EERIE_ACTIONLIST *)malloc(sizeof(EERIE_ACTIONLIST) * obj->nbaction);
memcpy(obj->actionlist, dat + pos, sizeof(EERIE_ACTIONLIST)*obj->nbaction);
pos += sizeof(EERIE_ACTIONLIST) * obj->nbaction;
}
// Alloc'n'Copy selections
if (obj->nbselections > 0)
{
//todo free++
obj->selections = (EERIE_SELECTIONS *)malloc(sizeof(EERIE_SELECTIONS) * obj->nbselections);
memcpy(obj->selections, dat + pos, sizeof(EERIE_SELECTIONS)*obj->nbselections);
pos += sizeof(EERIE_SELECTIONS) * obj->nbselections;
for (long i = 0; i < af3Ddh->nb_selections; i++)
{
//todo free+++
obj->selections[i].selected = (long *)malloc(sizeof(long) * obj->selections[i].nb_selected);
memcpy(obj->selections[i].selected, dat + pos, sizeof(long)*obj->selections[i].nb_selected);
pos += sizeof(long) * obj->selections[i].nb_selected;
}
}
obj->pbox = NULL;
}
if (!obj)
{
free(dat);
return NULL;
}
// Alloc'n'Copy Collision Spheres Data
if (afsh->offset_collision_spheres != -1)
{
afcsdh = (ARX_FTL_COLLISION_SPHERES_DATA_HEADER *)(dat + afsh->offset_collision_spheres);
pos = afsh->offset_collision_spheres;
pos += sizeof(ARX_FTL_COLLISION_SPHERES_DATA_HEADER);
obj->sdata = (COLLISION_SPHERES_DATA *)malloc(sizeof(COLLISION_SPHERES_DATA));
obj->sdata->nb_spheres = afcsdh->nb_spheres;
obj->sdata->spheres = (COLLISION_SPHERE *)malloc(sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres);
memcpy(obj->sdata->spheres, dat + pos, sizeof(COLLISION_SPHERE)*obj->sdata->nb_spheres);
pos += sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres;
}
// Alloc'n'Copy Progressive DATA
if (afsh->offset_progressive_data != -1)
{
afpdh = (ARX_FTL_PROGRESSIVE_DATA_HEADER *)(dat + afsh->offset_progressive_data);
pos = afsh->offset_progressive_data;
pos += sizeof(ARX_FTL_PROGRESSIVE_DATA_HEADER);
pos += sizeof(PROGRESSIVE_DATA) * afpdh->nb_vertex;
}
// Alloc'n'Copy Clothes DATA
if (afsh->offset_clothes_data != -1)
{
obj->cdata = (CLOTHES_DATA *)malloc(sizeof(CLOTHES_DATA));
memset(obj->cdata, 0, sizeof(CLOTHES_DATA));
afcdh = (ARX_FTL_CLOTHES_DATA_HEADER *)(dat + afsh->offset_clothes_data);
obj->cdata->nb_cvert = (short)afcdh->nb_cvert;
obj->cdata->nb_springs = (short)afcdh->nb_springs;
pos = afsh->offset_clothes_data;
pos += sizeof(ARX_FTL_CLOTHES_DATA_HEADER);
// now load cvert
obj->cdata->cvert = (CLOTHESVERTEX *)malloc(sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert);
obj->cdata->backup = (CLOTHESVERTEX *)malloc(sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert);
memcpy(obj->cdata->cvert, dat + pos, sizeof(CLOTHESVERTEX)*obj->cdata->nb_cvert);
memcpy(obj->cdata->backup, dat + pos, sizeof(CLOTHESVERTEX)*obj->cdata->nb_cvert);
pos += sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert;
// now load springs
obj->cdata->springs = (EERIE_SPRINGS *)malloc(sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs);
memcpy(obj->cdata->springs, dat + pos, sizeof(EERIE_SPRINGS)*obj->cdata->nb_springs);
pos += sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs;
}
free(dat);
if (BH_MODE)
EERIE_OBJECT_MakeBH(obj);
EERIE_OBJECT_CenterObjectCoordinates(obj);
EERIE_CreateCedricData(obj);
EERIEOBJECT_CreatePFaces(obj);
// Now we can release our cool FTL file
EERIE_Object_Precompute_Fast_Access(obj);
return obj;
}
long GetLevelNumByName(char * name)
{
if (name)
{
char temp[256];
strcpy(temp, name);
MakeUpcase(temp);
if (IsIn(temp, "LEVEL10")) return 10;
if (IsIn(temp, "LEVEL11")) return 11;
if (IsIn(temp, "LEVEL12")) return 12;
if (IsIn(temp, "LEVEL13")) return 13;
if (IsIn(temp, "LEVEL14")) return 14;
if (IsIn(temp, "LEVEL15")) return 15;
if (IsIn(temp, "LEVEL16")) return 16;
if (IsIn(temp, "LEVEL17")) return 17;
if (IsIn(temp, "LEVEL18")) return 18;
if (IsIn(temp, "LEVEL19")) return 19;
if (IsIn(temp, "LEVEL20")) return 20;
if (IsIn(temp, "LEVEL21")) return 21;
if (IsIn(temp, "LEVEL22")) return 22;
if (IsIn(temp, "LEVEL23")) return 23;
if (IsIn(temp, "LEVEL24")) return 24;
if (IsIn(temp, "LEVEL25")) return 25;
if (IsIn(temp, "LEVEL26")) return 26;
if (IsIn(temp, "LEVEL27")) return 27;
if (IsIn(temp, "LEVELDEMO2")) return 29;
if (IsIn(temp, "LEVELDEMO3")) return 30;
if (IsIn(temp, "LEVELDEMO4")) return 31;
if (IsIn(temp, "LEVELDEMO")) return 28;
if (IsIn(temp, "LEVEL0")) return 0;
if (IsIn(temp, "LEVEL1")) return 1;
if (IsIn(temp, "LEVEL2")) return 2;
if (IsIn(temp, "LEVEL3")) return 3;
if (IsIn(temp, "LEVEL4")) return 4;
if (IsIn(temp, "LEVEL5")) return 5;
if (IsIn(temp, "LEVEL6")) return 6;
if (IsIn(temp, "LEVEL7")) return 7;
if (IsIn(temp, "LEVEL8")) return 8;
if (IsIn(temp, "LEVEL9")) return 9;
}
return -1;
}
