id
/
quake3
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
quake3/q3radiant/MAP.CPP

1062 lines
24 KiB
C++
Executable File
Raw Permalink Blame History

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// map.c
#include "stdafx.h"
#include "qe3.h"
#include "PrefsDlg.h"
qboolean modified; // for quit confirmation (0 = clean, 1 = unsaved,
// 2 = autosaved, but not regular saved)
char currentmap[1024];
brush_t active_brushes; // brushes currently being displayed
brush_t selected_brushes; // highlighted
face_t *selected_face;
brush_t *selected_face_brush;
brush_t filtered_brushes; // brushes that have been filtered or regioned
entity_t entities; // head/tail of doubly linked list
entity_t *world_entity = NULL; // "classname" "worldspawn" !
void AddRegionBrushes (void);
void RemoveRegionBrushes (void);
void DupLists()
{
DWORD dw = GetTickCount();
}
/*
=============================================================
Cross map selection saving
this could fuck up if you have only part of a complex entity selected...
=============================================================
*/
brush_t between_brushes;
entity_t between_entities;
bool g_bRestoreBetween = false;
void Map_SaveBetween (void)
{
if (g_pParentWnd->ActiveXY())
{
g_bRestoreBetween = true;
g_pParentWnd->ActiveXY()->Copy();
}
return;
#if 0
brush_t *b;
entity_t *e, *e2;
between_brushes.next = selected_brushes.next;
between_brushes.prev = selected_brushes.prev;
between_brushes.next->prev = &between_brushes;
between_brushes.prev->next = &between_brushes;
between_entities.next = between_entities.prev = &between_entities;
selected_brushes.next = selected_brushes.prev = &selected_brushes;
for (b=between_brushes.next ; b != &between_brushes ; b=b->next)
{
e = b->owner;
if (e == world_entity)
b->owner = NULL;
else
{
for (e2=between_entities.next ; e2 != &between_entities ; e2=e2->next)
if (e2 == e)
goto next; // allready got the entity
// move the entity over
e->prev->next = e->next;
e->next->prev = e->prev;
e->next = between_entities.next;
e->prev = &between_entities;
e->next->prev = e;
e->prev->next = e;
}
next: ;
}
#endif
}
void Map_RestoreBetween (void)
{
if (g_pParentWnd->ActiveXY() && g_bRestoreBetween)
g_pParentWnd->ActiveXY()->Paste();
return;
#if 0
entity_t *head, *tail;
brush_t *b;
if (!between_brushes.next)
return;
for (b=between_brushes.next ; b != &between_brushes ; b=b->next)
{
if (!b->owner)
{
b->owner = world_entity;
b->onext = world_entity->brushes.onext;
b->oprev = &world_entity->brushes;
b->onext->oprev = b;
b->oprev->onext = b;
}
}
selected_brushes.next = between_brushes.next;
selected_brushes.prev = between_brushes.prev;
selected_brushes.next->prev = &selected_brushes;
selected_brushes.prev->next = &selected_brushes;
head = between_entities.next;
tail = between_entities.prev;
if (head != tail)
{
entities.prev->next = head;
head->prev = entities.prev;
tail->next = &entities;
entities.prev = tail;
}
between_brushes.next = NULL;
between_entities.next = NULL;
#endif
}
//============================================================================
bool CheckForTinyBrush(brush_t* b, int n, float fSize)
{
bool bTiny = false;
for (int i=0 ; i<3 ; i++)
{
if (b->maxs[i] - b->mins[i] < fSize)
bTiny = true;
}
if (bTiny)
Sys_Printf("Possible problem brush (too small) #%i ", n);
return bTiny;
}
void Map_BuildBrushData(void)
{
brush_t *b, *next;
if (active_brushes.next == NULL)
return;
Sys_BeginWait (); // this could take a while
int n = 0;
for (b=active_brushes.next ; b != NULL && b != &active_brushes ; b=next)
{
next = b->next;
Brush_Build( b, true, false, false );
if (!b->brush_faces || (g_PrefsDlg.m_bCleanTiny && CheckForTinyBrush(b, n++, g_PrefsDlg.m_fTinySize)))
{
Brush_Free (b);
Sys_Printf ("Removed degenerate brush\n");
}
}
Sys_EndWait();
}
entity_t *Map_FindClass (char *cname)
{
entity_t *ent;
for (ent = entities.next ; ent != &entities ; ent=ent->next)
{
if (!strcmp(cname, ValueForKey (ent, "classname")))
return ent;
}
return NULL;
}
/*
================
Map_Free
================
*/
void Map_Free (void)
{
g_bRestoreBetween = false;
if (selected_brushes.next &&
(selected_brushes.next != &selected_brushes) )
{
if (MessageBox(g_qeglobals.d_hwndMain, "Copy selection?", "", MB_YESNO) == IDYES)
Map_SaveBetween ();
}
Texture_ClearInuse ();
Pointfile_Clear ();
strcpy (currentmap, "unnamed.map");
Sys_SetTitle (currentmap);
g_qeglobals.d_num_entities = 0;
g_qeglobals.d_numterrapoints = 0;
if (!active_brushes.next)
{ // first map
active_brushes.prev = active_brushes.next = &active_brushes;
selected_brushes.prev = selected_brushes.next = &selected_brushes;
filtered_brushes.prev = filtered_brushes.next = &filtered_brushes;
entities.prev = entities.next = &entities;
}
else
{
while (active_brushes.next != &active_brushes)
Brush_Free (active_brushes.next);
while (selected_brushes.next != &selected_brushes)
Brush_Free (selected_brushes.next);
while (filtered_brushes.next != &filtered_brushes)
Brush_Free (filtered_brushes.next);
while (entities.next != &entities)
Entity_Free (entities.next);
}
if (world_entity)
Entity_Free(world_entity);
world_entity = NULL;
}
entity_t *AngledEntity()
{
entity_t *ent = Map_FindClass ("info_player_start");
if (!ent)
{
ent = Map_FindClass ("info_player_deathmatch");
}
if (!ent)
{
ent = Map_FindClass ("info_player_deathmatch");
}
if (!ent)
{
ent = Map_FindClass ("team_CTF_redplayer");
}
if (!ent)
{
ent = Map_FindClass ("team_CTF_blueplayer");
}
if (!ent)
{
ent = Map_FindClass ("team_CTF_redspawn");
}
if (!ent)
{
ent = Map_FindClass ("team_CTF_bluespawn");
}
return ent;
}
/*
================
Map_LoadFile
================
*/
void Map_LoadFile (char *filename)
{
char *buf;
entity_t *ent;
char temp[1024];
Sys_BeginWait ();
Select_Deselect();
//SetInspectorMode(W_CONSOLE);
QE_ConvertDOSToUnixName( temp, filename );
Sys_Printf ("Map_LoadFile: %s\n", temp );
Map_Free ();
//++timo FIXME: maybe even easier to have Group_Init called from Map_Free?
Group_Init();
g_qeglobals.d_parsed_brushes = 0;
strcpy (currentmap, filename);
if (LoadFile (filename, (void **)&buf) != -1)
{
StartTokenParsing (buf);
g_qeglobals.d_num_entities = 0;
// Timo
// will be used in Entity_Parse to detect if a conversion between brush formats is needed
g_qeglobals.bNeedConvert = false;
g_qeglobals.bOldBrushes = false;
g_qeglobals.bPrimitBrushes = false;
while (1)
{
ent = Entity_Parse (false, &active_brushes);
if (!ent)
break;
if (!strcmp(ValueForKey (ent, "classname"), "worldspawn"))
{
if (world_entity)
Sys_Printf ("WARNING: multiple worldspawn\n");
world_entity = ent;
}
else if (!strcmp(ValueForKey (ent, "classname"), "group_info"))
{
// it's a group thing!
Group_Add(ent);
Entity_Free(ent);
}
else
{
// add the entity to the end of the entity list
ent->next = &entities;
ent->prev = entities.prev;
entities.prev->next = ent;
entities.prev = ent;
g_qeglobals.d_num_entities++;
}
}
}
free (buf);
if (!world_entity)
{
Sys_Printf ("No worldspawn in map.\n");
Map_New ();
return;
}
Sys_Printf ("--- LoadMapFile ---\n");
Sys_Printf ("%s\n", temp );
Sys_Printf ("%5i brushes\n", g_qeglobals.d_parsed_brushes );
Sys_Printf ("%5i entities\n", g_qeglobals.d_num_entities);
Map_RestoreBetween ();
Sys_Printf ("Map_BuildAllDisplayLists\n");
Map_BuildBrushData();
// reset the "need conversion" flag
// conversion to the good format done in Map_BuildBrushData
g_qeglobals.bNeedConvert=false;
//
// move the view to a start position
//
ent = AngledEntity();
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
if (ent)
{
GetVectorForKey (ent, "origin", g_pParentWnd->GetCamera()->Camera().origin);
GetVectorForKey (ent, "origin", g_pParentWnd->GetXYWnd()->GetOrigin());
g_pParentWnd->GetCamera()->Camera().angles[YAW] = FloatForKey (ent, "angle");
}
else
{
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
VectorCopy (vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
VectorCopy (vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
}
Map_RegionOff ();
modified = false;
Sys_SetTitle (temp);
Texture_ShowInuse ();
Sys_EndWait();
Sys_UpdateWindows (W_ALL);
}
/*
===========
Map_SaveFile
===========
*/
void Map_SaveFile (char *filename, qboolean use_region )
{
entity_t *e, *next;
FILE *f;
char temp[1024];
int count;
if (filename == NULL || strlen(filename) == 0)
{
CFileDialog dlgSave(FALSE, "map", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "Map Files (*.map)|*.map||", AfxGetMainWnd());
if (dlgSave.DoModal() == IDOK)
filename = strdup(dlgSave.m_ofn.lpstrFile);
else
return;
}
Pointfile_Clear ();
QE_ConvertDOSToUnixName( temp, filename );
if (!use_region)
{
char backup[1024];
// rename current to .bak
strcpy (backup, filename);
StripExtension (backup);
strcat (backup, ".bak");
_unlink (backup);
rename (filename, backup);
}
Sys_Printf ("Map_SaveFile: %s\n", filename);
f = fopen(filename, "w");
if (!f)
{
Sys_Printf ("ERROR!!!! Couldn't open %s\n", filename);
return;
}
if (use_region)
{
AddRegionBrushes ();
}
// write world entity first
Entity_Write (world_entity, f, use_region);
// then write all other ents
count = 1;
for (e=entities.next ; e != &entities ; e=next)
{
next = e->next;
if (e->brushes.onext == &e->brushes)
{
Entity_Free (e); // no brushes left, so remove it
}
else
{
fprintf (f, "// entity %i\n", count);
count++;
Entity_Write (e, f, use_region);
}
}
// save the group info stuff
Group_Save(f);
fclose (f);
if (use_region)
RemoveRegionBrushes ();
Sys_Printf ("Saved.\n");
modified = false;
if ( !strstr( temp, "autosave" ) )
Sys_SetTitle (temp);
if (!use_region)
{
time_t timer;
FILE *f;
time (&timer);
MessageBeep (MB_ICONEXCLAMATION);
f = fopen ("c:/tstamps.log", "a");
if (f)
{
fprintf (f, "%s", filename);
//fprintf (f, "%4i : %35s : %s", g_qeglobals.d_workcount, filename, ctime(&timer));
fclose (f);
g_qeglobals.d_workcount = 0;
}
fclose (f);
Sys_Status ("Saved.\n", 0);
}
//Curve_WriteFile (filename); //.trinity
//Patch_WriteFile (filename);
}
/*
===========
Map_New
===========
*/
void Map_New (void)
{
Sys_Printf ("Map_New\n");
Map_Free ();
Patch_Cleanup();
world_entity = (entity_s*)qmalloc(sizeof(*world_entity));
world_entity->brushes.onext =
world_entity->brushes.oprev = &world_entity->brushes;
SetKeyValue (world_entity, "classname", "worldspawn");
world_entity->eclass = Eclass_ForName ("worldspawn", true);
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
VectorCopy (vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
g_pParentWnd->GetCamera()->Camera().origin[2] = 48;
VectorCopy (vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
Map_RestoreBetween ();
Group_Init();
Sys_UpdateWindows (W_ALL);
modified = false;
}
/*
===========================================================
REGION
===========================================================
*/
qboolean region_active;
vec3_t region_mins = {MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD};
vec3_t region_maxs = {MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD};
brush_t *region_sides[4];
/*
===========
AddRegionBrushes
a regioned map will have temp walls put up at the region boundary
===========
*/
void AddRegionBrushes (void)
{
vec3_t mins, maxs;
int i;
texdef_t td;
if (!region_active)
return;
memset (&td, 0, sizeof(td));
//strcpy (td.name, "REGION");
td.SetName("REGION");
mins[0] = region_mins[0] - 16;
maxs[0] = region_mins[0] + 1;
mins[1] = region_mins[1] - 16;
maxs[1] = region_maxs[1] + 16;
mins[2] = MIN_WORLD_COORD;
maxs[2] = MAX_WORLD_COORD;
region_sides[0] = Brush_Create (mins, maxs, &td);
mins[0] = region_maxs[0] - 1;
maxs[0] = region_maxs[0] + 16;
region_sides[1] = Brush_Create (mins, maxs, &td);
mins[0] = region_mins[0] - 16;
maxs[0] = region_maxs[0] + 16;
mins[1] = region_mins[1] - 16;
maxs[1] = region_mins[1] + 1;
region_sides[2] = Brush_Create (mins, maxs, &td);
mins[1] = region_maxs[1] - 1;
maxs[1] = region_maxs[1] + 16;
region_sides[3] = Brush_Create (mins, maxs, &td);
for (i=0 ; i<4 ; i++)
{
Brush_AddToList (region_sides[i], &selected_brushes);
Entity_LinkBrush (world_entity, region_sides[i]);
Brush_Build( region_sides[i] );
}
}
void RemoveRegionBrushes (void)
{
int i;
if (!region_active)
return;
for (i=0 ; i<4 ; i++)
Brush_Free (region_sides[i]);
}
qboolean Map_IsBrushFiltered (brush_t *b)
{
int i;
for (i=0 ; i<3 ; i++)
{
if (b->mins[i] > region_maxs[i])
return true;
if (b->maxs[i] < region_mins[i])
return true;
}
return false;
}
/*
===========
Map_RegionOff
Other filtering options may still be on
===========
*/
void Map_RegionOff (void)
{
brush_t *b, *next;
int i;
region_active = false;
for (i=0 ; i<3 ; i++)
{
region_maxs[i] = MAX_WORLD_COORD;//4096;
region_mins[i] = MIN_WORLD_COORD;//-4096;
}
for (b=filtered_brushes.next ; b != &filtered_brushes ; b=next)
{
next = b->next;
if (Map_IsBrushFiltered (b))
continue; // still filtered
Brush_RemoveFromList (b);
if (active_brushes.next == NULL || active_brushes.prev == NULL)
{
active_brushes.next = &active_brushes;
active_brushes.prev = &active_brushes;
}
Brush_AddToList (b, &active_brushes);
}
Sys_UpdateWindows (W_ALL);
}
void Map_ApplyRegion (void)
{
brush_t *b, *next;
region_active = true;
for (b=active_brushes.next ; b != &active_brushes ; b=next)
{
next = b->next;
if (!Map_IsBrushFiltered (b))
continue; // still filtered
Brush_RemoveFromList (b);
Brush_AddToList (b, &filtered_brushes);
}
Sys_UpdateWindows (W_ALL);
}
/*
========================
Map_RegionSelectedBrushes
========================
*/
void Map_RegionSelectedBrushes (void)
{
Map_RegionOff ();
if (selected_brushes.next == &selected_brushes) // nothing selected
{
Sys_Printf("Tried to region with no selection...\n");
return;
}
region_active = true;
Select_GetBounds (region_mins, region_maxs);
// move the entire active_brushes list to filtered_brushes
filtered_brushes.next = active_brushes.next;
filtered_brushes.prev = active_brushes.prev;
filtered_brushes.next->prev = &filtered_brushes;
filtered_brushes.prev->next = &filtered_brushes;
// move the entire selected_brushes list to active_brushes
active_brushes.next = selected_brushes.next;
active_brushes.prev = selected_brushes.prev;
active_brushes.next->prev = &active_brushes;
active_brushes.prev->next = &active_brushes;
// clear selected_brushes
selected_brushes.next = selected_brushes.prev = &selected_brushes;
Sys_UpdateWindows (W_ALL);
}
/*
===========
Map_RegionXY
===========
*/
void Map_RegionXY (void)
{
Map_RegionOff ();
region_mins[0] = g_pParentWnd->GetXYWnd()->GetOrigin()[0] - 0.5 * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale();
region_maxs[0] = g_pParentWnd->GetXYWnd()->GetOrigin()[0] + 0.5 * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale();
region_mins[1] = g_pParentWnd->GetXYWnd()->GetOrigin()[1] - 0.5 * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale();
region_maxs[1] = g_pParentWnd->GetXYWnd()->GetOrigin()[1] + 0.5 * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale();
region_mins[2] = -MIN_WORLD_COORD;
region_maxs[2] = MAX_WORLD_COORD;
Map_ApplyRegion ();
}
/*
===========
Map_RegionTallBrush
===========
*/
void Map_RegionTallBrush (void)
{
brush_t *b;
if (!QE_SingleBrush ())
return;
b = selected_brushes.next;
Map_RegionOff ();
VectorCopy (b->mins, region_mins);
VectorCopy (b->maxs, region_maxs);
region_mins[2] = MIN_WORLD_COORD;
region_maxs[2] = MAX_WORLD_COORD;
Select_Delete ();
Map_ApplyRegion ();
}
/*
===========
Map_RegionBrush
===========
*/
void Map_RegionBrush (void)
{
brush_t *b;
if (!QE_SingleBrush ())
return;
b = selected_brushes.next;
Map_RegionOff ();
VectorCopy (b->mins, region_mins);
VectorCopy (b->maxs, region_maxs);
Select_Delete ();
Map_ApplyRegion ();
}
void UniqueTargetName(CString& rStr)
{
// make a unique target value
int maxtarg = 0;
for (entity_t* e=entities.next ; e != &entities ; e=e->next)
{
char* tn = ValueForKey (e, "targetname");
if (tn && tn[0])
{
int targetnum = atoi(tn+1);
if (targetnum > maxtarg)
maxtarg = targetnum;
}
else
{
tn = ValueForKey (e, "target");
if (tn && tn[0])
{
int targetnum = atoi(tn+1);
if (targetnum > maxtarg)
maxtarg = targetnum;
}
}
}
rStr.Format("t%i", maxtarg+1);
}
//
//================
//Map_ImportFile
// Timo 09/01/99 : called by CXYWnd::Paste & Map_ImportFile
// if Map_ImportFile ( prefab ), the buffer may contain brushes in old format ( conversion needed )
//================
//
void Map_ImportBuffer (char* buf)
{
entity_t* ent;
brush_t* b = NULL;
CPtrArray ptrs;
Select_Deselect();
Undo_Start("import buffer");
g_qeglobals.d_parsed_brushes = 0;
if (buf)
{
CMapStringToString mapStr;
StartTokenParsing (buf);
g_qeglobals.d_num_entities = 0;
// Timo
// will be used in Entity_Parse to detect if a conversion between brush formats is needed
g_qeglobals.bNeedConvert = false;
g_qeglobals.bOldBrushes = false;
g_qeglobals.bPrimitBrushes = false;
while (1)
{
// use the selected brushes list as it's handy
//ent = Entity_Parse (false, &selected_brushes);
ent = Entity_Parse (false, &active_brushes);
if (!ent)
break;
//end entity for undo
Undo_EndEntity(ent);
//end brushes for undo
for(b = ent->brushes.onext; b && b != &ent->brushes; b = b->onext)
{
Undo_EndBrush(b);
}
if (!strcmp(ValueForKey (ent, "classname"), "worldspawn"))
{
// world brushes need to be added to the current world entity
b=ent->brushes.onext;
while (b && b != &ent->brushes)
{
brush_t* bNext = b->onext;
Entity_UnlinkBrush(b);
Entity_LinkBrush(world_entity, b);
ptrs.Add(b);
b = bNext;
}
}
else
{
// the following bit remaps conflicting target/targetname key/value pairs
CString str = ValueForKey(ent, "target");
CString strKey;
CString strTarget("");
if (str.GetLength() > 0)
{
if (FindEntity("target", str.GetBuffer(0)))
{
if (!mapStr.Lookup(str, strKey))
{
UniqueTargetName(strKey);
mapStr.SetAt(str, strKey);
}
strTarget = strKey;
SetKeyValue(ent, "target", strTarget.GetBuffer(0));
}
}
str = ValueForKey(ent, "targetname");
if (str.GetLength() > 0)
{
if (FindEntity("targetname", str.GetBuffer(0)))
{
if (!mapStr.Lookup(str, strKey))
{
UniqueTargetName(strKey);
mapStr.SetAt(str, strKey);
}
SetKeyValue(ent, "targetname", strKey.GetBuffer(0));
}
}
//if (strTarget.GetLength() > 0)
// SetKeyValue(ent, "target", strTarget.GetBuffer(0));
// add the entity to the end of the entity list
ent->next = &entities;
ent->prev = entities.prev;
entities.prev->next = ent;
entities.prev = ent;
g_qeglobals.d_num_entities++;
for (b=ent->brushes.onext ; b != &ent->brushes ; b=b->onext)
{
ptrs.Add(b);
}
}
}
}
//::ShowWindow(g_qeglobals.d_hwndEntity, FALSE);
//::LockWindowUpdate(g_qeglobals.d_hwndEntity);
g_bScreenUpdates = false;
for (int i = 0; i < ptrs.GetSize(); i++)
{
Brush_Build(reinterpret_cast<brush_t*>(ptrs[i]), true, false);
Select_Brush(reinterpret_cast<brush_t*>(ptrs[i]), true, false);
}
//::LockWindowUpdate(NULL);
g_bScreenUpdates = true;
ptrs.RemoveAll();
// reset the "need conversion" flag
// conversion to the good format done in Map_BuildBrushData
g_qeglobals.bNeedConvert=false;
Sys_UpdateWindows (W_ALL);
//Sys_MarkMapModified();
modified = true;
Undo_End();
}
//
//================
//Map_ImportFile
//================
//
void Map_ImportFile (char *filename)
{
char* buf;
char temp[1024];
Sys_BeginWait ();
QE_ConvertDOSToUnixName( temp, filename );
if (LoadFile (filename, (void **)&buf) != -1)
{
Map_ImportBuffer(buf);
free(buf);
Map_BuildBrushData();
}
Sys_UpdateWindows (W_ALL);
modified = true;
Sys_EndWait();
}
//
//===========
//Map_SaveSelected
//===========
//
// Saves selected world brushes and whole entities with partial/full selections
//
void Map_SaveSelected(char* pFilename)
{
entity_t *e, *next;
FILE *f;
char temp[1024];
int count;
QE_ConvertDOSToUnixName(temp, pFilename);
f = fopen(pFilename, "w");
if (!f)
{
Sys_Printf ("ERROR!!!! Couldn't open %s\n", pFilename);
return;
}
// write world entity first
Entity_WriteSelected(world_entity, f);
// then write all other ents
count = 1;
for (e=entities.next ; e != &entities ; e=next)
{
fprintf (f, "// entity %i\n", count);
count++;
Entity_WriteSelected(e, f);
next = e->next;
}
fclose (f);
}
//
//===========
//Map_SaveSelected
//===========
//
// Saves selected world brushes and whole entities with partial/full selections
//
void Map_SaveSelected(CMemFile* pMemFile, CMemFile* pPatchFile)
{
entity_t *e, *next;
int count;
CString strTemp;
// write world entity first
Entity_WriteSelected(world_entity, pMemFile);
// then write all other ents
count = 1;
for (e=entities.next ; e != &entities ; e=next)
{
MemFile_fprintf(pMemFile, "// entity %i\n", count);
count++;
Entity_WriteSelected(e, pMemFile);
next = e->next;
}
//if (pPatchFile)
// Patch_WriteFile(pPatchFile);
}
void MemFile_fprintf(CMemFile* pMemFile, const char* pText, ...)
{
char Buffer[4096];
va_list args;
va_start (args,pText);
vsprintf(Buffer, pText, args);
pMemFile->Write(Buffer, strlen(Buffer));
}
Reference in New Issue View Git Blame Copy Permalink