Utils/MapEdit/Core.cpp

@@ -24,8 +24,6 @@
 /*****************************************************************************/
 CCore::CCore()
 {
-	for (int i=0; i<LAYER_TYPE_MAX; i++) Layers[i]=0;
-
 	TileViewFlag=FALSE;
 	GridFlag=TRUE;
 	CurrentMousePos=CPoint(0,0);
@@ -39,7 +37,8 @@ CCore::CCore()
 /*****************************************************************************/
 CCore::~CCore()
 {
-	for (int i=0; i<LAYER_TYPE_MAX; i++) if (Layers[i]) delete Layers[i];
+int	ListSize=Layer.size();
+	for (int i=0; i<ListSize; i++) delete Layer[i];
 }
 
 /*****************************************************************************/
@@ -53,29 +52,96 @@ CMultiBar	*ParamBar=Frm->GetParamBar();
 			ParamBar->Add(Frm->GetLayerList(),IDD_LAYER_LIST_DIALOG,TRUE,TRUE);
 			ParamBar->Add(Frm->GetTileSetDlg(),IDD_TILESET_DIALOG,TRUE,TRUE);
 			UpdateParamBar();
-//			Layers[ActiveLayer]->InitGUI(this);
+//			Layer[ActiveLayer]->InitGUI(this);
 //			ParamBar->Update();
+			UpdateAll(NULL);
 }
 
 /*****************************************************************************/
-void	CCore::NewMap()
+void	CCore::New()
 {
 // Create Gfx Layers
 //									Name	Width					Height					SizeDiv	ViewDiv	3d?		Resizable?
-	Layers[LAYER_TYPE_BACK]=	new CLayerTile(	"Back",	32,						32,						1.0f,	4.0f,	FALSE,	FALSE);
+	Layer.push_back(new CLayerTile(	"Back",	32,						32,						1.0f,	4.0f,	FALSE,	FALSE));
-	Layers[LAYER_TYPE_MID]=		new CLayerTile(	"Mid",	TileLayerDefaultWidth,	TileLayerDefaultHeight,	2.0f,	2.0f,	FALSE,	TRUE);
+	Layer.push_back(new CLayerTile(	"Mid",	TileLayerDefaultWidth,	TileLayerDefaultHeight,	2.0f,	2.0f,	FALSE,	TRUE));
-	Layers[LAYER_TYPE_ACTION]=	new CLayerTile(	"Action",TileLayerDefaultWidth,	TileLayerDefaultHeight,	1.0f,	1.0f,	TRUE,	TRUE);
+	Layer.push_back(new CLayerTile(	"Action",TileLayerDefaultWidth,	TileLayerDefaultHeight,	1.0f,	1.0f,	TRUE,	TRUE));
-	Layers[LAYER_TYPE_FORE]=	new CLayerTile(	"Fore",	TileLayerDefaultWidth,	TileLayerDefaultHeight,	0.5f,	0.5f,	FALSE,	TRUE);
+	Layer.push_back(new CLayerTile(	"Fore",	TileLayerDefaultWidth,	TileLayerDefaultHeight,	0.5f,	0.5f,	FALSE,	TRUE));
 
-	ActiveLayer=LAYER_TYPE_ACTION;
+	ActiveLayer=LAYER_ACTION;
 	MapCam=Vec(0,0,0);
 	TileCam=Vec(0,0,0);
 	Init();
 }
 
 /*****************************************************************************/
-void	CCore::OpenMap()
+void	CCore::Load(CFile *File)
 {
+float	Version;
+
+		File->Read(&Version,sizeof(float));
+
+		File->Read(&MapCam,sizeof(Vec));
+		File->Read(&TileCam,sizeof(Vec));
+
+		File->Read(&TileCam,sizeof(Vec));
+
+		File->Read(&TileViewFlag,sizeof(BOOL));
+		File->Read(&GridFlag,sizeof(BOOL));
+		File->Read(&Is3dFlag,sizeof(BOOL));
+
+
+// Layers
+int		LayerCount;
+		File->Read(&LayerCount,sizeof(int));
+		File->Read(&ActiveLayer,sizeof(int));
+
+		for (int i=0;i<LayerCount;i++)
+		{
+			int	Type;
+
+			File->Read(&Type,sizeof(int));
+			switch (Type)
+			{
+			case LAYER_TYPE_TILE:
+				Layer.push_back(new CLayerTile(File,Version));
+				break;
+
+			}
+		}
+	TileBank.Load(File,Version);
+	Init();
+
+}
+
+/*****************************************************************************/
+void	CCore::Save(CFile *File)
+{
+
+		File->Write(&FileVersion,sizeof(float));
+
+		File->Write(&MapCam,sizeof(Vec));
+		File->Write(&TileCam,sizeof(Vec));
+
+		File->Write(&TileCam,sizeof(Vec));
+
+		File->Write(&TileViewFlag,sizeof(BOOL));
+		File->Write(&GridFlag,sizeof(BOOL));
+		File->Write(&Is3dFlag,sizeof(BOOL));
+
+
+// Layers
+int		LayerCount=Layer.size();
+		File->Write(&LayerCount,sizeof(int));
+		File->Write(&ActiveLayer,sizeof(int));
+
+		for (int i=0;i<LayerCount;i++)
+		{
+			int	Type=Layer[i]->GetType();
+			File->Write(&Type,sizeof(int));
+			Layer[i]->Save(File);
+		}
+	TileBank.Save(File);
+
 }
 
 /*****************************************************************************/
@@ -101,18 +167,19 @@ void	CCore::Render(CMapEditView *View,BOOL ForceRender)
 void	CCore::RenderLayers(CMapEditView *View)
 {
 Vec		&ThisCam=GetCam();
+int		ListSize=Layer.size();
 		
-		for (int i=0;i<LAYER_TYPE_MAX;i++)
+		for (int i=0;i<ListSize;i++)
 		{
-			Layers[i]->Render(this,ThisCam,Is3dFlag);
+			Layer[i]->Render(this,ThisCam,Is3dFlag);
 		}
 		
-		Layers[ActiveLayer]->RenderCursor(this,ThisCam,Is3dFlag);
+		Layer[ActiveLayer]->RenderCursor(this,ThisCam,Is3dFlag);
-		if (GridFlag) Layers[ActiveLayer]->RenderGrid(this,ThisCam);
+		if (GridFlag) Layer[ActiveLayer]->RenderGrid(this,ThisCam);
 		
 // Get Cursor Pos
 		LastCursorPos=CursorPos;
-		Layers[ActiveLayer]->FindCursorPos(this,View,GetCam(),CurrentMousePos);
+		Layer[ActiveLayer]->FindCursorPos(this,View,GetCam(),CurrentMousePos);
 }
 
 /*****************************************************************************/
@@ -134,7 +201,7 @@ void	CCore::SetMode(int NewMode)
 {
 BOOL	RedrawFlag=FALSE;
 
-		RedrawFlag=Layers[ActiveLayer]->SetMode(NewMode);
+		RedrawFlag=Layer[ActiveLayer]->SetMode(NewMode);
 		//if (RedrawFlag) View->Invalidate();
 }
 
@@ -152,7 +219,7 @@ BOOL	RedrawFlag=FALSE;
 		}
 		else
 		{
-			RedrawFlag=Layers[ActiveLayer]->LButtonControl(this,View,nFlags,CursorPos,DownFlag);
+			RedrawFlag=Layer[ActiveLayer]->LButtonControl(this,View,nFlags,CursorPos,DownFlag);
 		}
 		TileBank.SetActiveBrushL();
 
@@ -179,7 +246,7 @@ BOOL	RedrawFlag=FALSE;
 		}
 		else
 		{
-			RedrawFlag=Layers[ActiveLayer]->RButtonControl(this,View,nFlags,CursorPos,DownFlag);
+			RedrawFlag=Layer[ActiveLayer]->RButtonControl(this,View,nFlags,CursorPos,DownFlag);
 		}
 		TileBank.SetActiveBrushR();
 
@@ -213,8 +280,8 @@ Vec		&ThisCam=GetCam();
 			RECT	ThisRect;
 
 			View->GetWindowRect(&ThisRect);
-			XS=ThisCam.z*4;//*Layers[ActiveLayer]->GetLayerZPos();
+			XS=ThisCam.z*4;//*Layer[ActiveLayer]->GetLayerZPos();
-			YS=ThisCam.z*4;//*Layers[ActiveLayer]->GetLayerZPos();
+			YS=ThisCam.z*4;//*Layer[ActiveLayer]->GetLayerZPos();
 			XS/=((ThisRect.right-ThisRect.left));
 			YS/=((ThisRect.bottom-ThisRect.top));
 	
@@ -235,7 +302,7 @@ Vec		&ThisCam=GetCam();
 			}
 			else
 			{
-			Layers[ActiveLayer]->MouseMove(this,View,nFlags,CursorPos);
+			Layer[ActiveLayer]->MouseMove(this,View,nFlags,CursorPos);
 			}
 		}
 
@@ -259,7 +326,7 @@ CMultiBar	*ParamBar=Frm->GetParamBar();
 			}
 			else
 			{
-				Layers[ActiveLayer]->InitGUI(this);
+				Layer[ActiveLayer]->InitGUI(this);
 			}
 			
 			ParamBar->Update();
@@ -267,11 +334,12 @@ CMultiBar	*ParamBar=Frm->GetParamBar();
 }
 
 /*****************************************************************************/
+/*
 void	CCore::SetActiveLayer(int i)
 {
 //	UpdateParamBar(NULL,ParamViewFlag);
 }
-
+*/
 /*****************************************************************************/
 /*** Grid ********************************************************************/
 /*****************************************************************************/
@@ -332,7 +400,7 @@ void	CCore::MirrorX(CMapEditView *View)
 {
 		if (!TileViewFlag) 
 		{
-			Layers[ActiveLayer]->MirrorX(this);
+			Layer[ActiveLayer]->MirrorX(this);
 			UpdateView(View);
 		}
 }
@@ -342,7 +410,7 @@ void	CCore::MirrorY(CMapEditView *View)
 {
 		if (!TileViewFlag) 
 		{
-			Layers[ActiveLayer]->MirrorY(this);
+			Layer[ActiveLayer]->MirrorY(this);
 			UpdateView(View);
 		}
 }
@@ -380,7 +448,7 @@ void	CCore::UpdateAll(CMapEditView *View)
 		UpdateGrid(View);
 
 		TileBank.UpdateGUI(this,TileViewFlag);
-		Layers[ActiveLayer]->UpdateGUI(this);
+		Layer[ActiveLayer]->UpdateGUI(this);
 
 }
 
@@ -400,11 +468,12 @@ void	CCore::SetMapSize(CMapEditView *View,int Width,int Height)
 {
 	if (Width==GetMapWidth() && Height==GetMapHeight()) return;
 
-	for (int i=0; i<LAYER_TYPE_MAX; i++) 
+int		ListSize=Layer.size();
+
+	for (int i=0; i<ListSize; i++) 
 	{
-//		Layers[i]->Resize(Width,Height);
+		Layer[i]->Resize(Width,Height);
 	}
-		Layers[LAYER_TYPE_ACTION]->Resize(Width,Height);
 
 	UpdateView(View);
 }

Utils/MapEdit/Core.h

@@ -13,18 +13,27 @@
 #include	"TexCache.h"
 #include	"TileSet.h"
 
+const	float	FileVersion=1.0f;
 
 /*****************************************************************************/
 class	CMapEditView;
 class	CCore
 {
 public:
+	enum
+	{
+		LAYER_BACK=0,
+		LAYER_MID,
+		LAYER_ACTION,
+		LAYER_FORE,
+	};
 		CCore();
 		~CCore();
 
 		void					Init();
-		void					NewMap();
+		void					New();
-		void					OpenMap();
+		void					Load(CFile *File);
+		void					Save(CFile *File);
 		void					Render(CMapEditView *View,BOOL ForceRender=FALSE);
 		void					RenderLayers(CMapEditView *View);
 		void					RenderTileView(CMapEditView *View);
@@ -53,9 +62,9 @@ public:
 		void					UpdateParamBar();
 
 // Layers
-		void					SetActiveLayer(int Layer);
+//		void					SetActiveLayer(int Layer);
-		int						GetActiveLayer()				{return(ActiveLayer);}
+//		int						GetActiveLayer()				{return(ActiveLayer);}
-		CLayer					*GetLayer(int i)				{return(Layers[i]);}
+//		CLayer					*GetLayer(int i)				{return(Layer[i]);}
 
 // Grid
 		void					UpdateGrid(CMapEditView *View,BOOL Toggle=FALSE);
@@ -73,15 +82,15 @@ public:
 		CPoint					&GetCursorPos()					{return(CursorPos);}
 
 		void					SetMapSize(CMapEditView *View,int Width,int Height);
-		int						GetMapWidth()					{return(Layers[LAYER_TYPE_ACTION]->GetWidth());}
+		int						GetMapWidth()					{return(Layer[LAYER_ACTION]->GetWidth());}
-		int						GetMapHeight()					{return(Layers[LAYER_TYPE_ACTION]->GetHeight());}
+		int						GetMapHeight()					{return(Layer[LAYER_ACTION]->GetHeight());}
 
 private:
 		CPoint					CurrentMousePos,LastMousePos;
 		CPoint					CursorPos,LastCursorPos;
 		Vec						MapCam,TileCam;
 
-		CLayer					*Layers[LAYER_TYPE_MAX];
+		std::vector<CLayer*>	Layer;
 		int						ActiveLayer;
 
 		CTileBank				TileBank;

Utils/MapEdit/Layer.h

@@ -18,11 +18,7 @@ SELECT_BUFFER_SIZE=16,
 /*****************************************************************************/
 enum LAYER_TYPE
 {
-	LAYER_TYPE_BACK=0,
+	LAYER_TYPE_TILE=0,
-	LAYER_TYPE_MID,
-	LAYER_TYPE_ACTION,
-	LAYER_TYPE_FORE,
-
 	LAYER_TYPE_MAX
 };
 
@@ -38,6 +34,7 @@ virtual	~CLayer(){};
 
 virtual	char			*GetName();
 virtual	void			SetName(char *_Name);
+virtual	int				GetType()=0;
 
 virtual	float			GetLayerZPosDiv()		{return(ZPosDiv);}
 
@@ -54,6 +51,9 @@ virtual	int				GetWidth()=0;
 virtual	int				GetHeight()=0;
 virtual	void			Resize(int Width,int Height)=0;
 
+virtual	void			Load(CFile *File,float Version)=0;
+virtual	void			Save(CFile *File)=0;
+
 // Functions
 virtual	BOOL			SetMode(int NewMode)=0;
 virtual	BOOL			InitMode()=0;

Utils/MapEdit/LayerTile.cpp

@@ -39,9 +39,9 @@ CLayerTile::CLayerTile(char *_Name,int Width,int Height,float MapDiv,float ZDiv,
 
 /*****************************************************************************/
 // Load Layer
-CLayerTile::CLayerTile(char *_Name)
+CLayerTile::CLayerTile(CFile *File,int Version)
 {
-	ASSERT(1);
+	Load(File,Version);
 }
 
 /*****************************************************************************/
@@ -49,6 +49,34 @@ CLayerTile::~CLayerTile()
 {
 }
 
+/*****************************************************************************/
+void	CLayerTile::Load(CFile *File,float Version)
+{
+// Version 1
+		File->Read(Name,256);
+		File->Read(&Render3dFlag,sizeof(BOOL));
+		File->Read(&ZPosDiv,sizeof(float));
+		File->Read(&MapSizeDiv,sizeof(float));
+		File->Read(&ResizeFlag,sizeof(BOOL));
+		File->Read(&Mode,sizeof(MouseMode));
+		Map.Load(File,Version);
+}
+
+/*****************************************************************************/
+void	CLayerTile::Save(CFile *File)
+{
+// Always Save current version
+
+		File->Write(Name,256);
+		File->Write(&Render3dFlag,sizeof(BOOL));
+		File->Write(&ZPosDiv,sizeof(float));
+		File->Write(&MapSizeDiv,sizeof(float));
+		File->Write(&ResizeFlag,sizeof(BOOL));
+		File->Write(&Mode,sizeof(MouseMode));
+		Map.Save(File);
+
+}
+
 /*****************************************************************************/
 void	CLayerTile::Resize(int Width,int Height)
 {

Utils/MapEdit/LayerTile.h

@@ -12,8 +12,8 @@
 /*****************************************************************************/
 enum	TileLayerEnum
 {
-	TileLayerDefaultWidth=3,
+	TileLayerDefaultWidth=30,
-	TileLayerDefaultHeight=2,
+	TileLayerDefaultHeight=20,
 };
 
 /*****************************************************************************/
@@ -36,9 +36,11 @@ public:
 		};
 
 		CLayerTile(char *_Name,int Width,int Height,float MapDiv,float ZDiv,BOOL Is3d,BOOL Resizable);		// New Layer
-		CLayerTile(char *_Name);																			// Load Layer
+		CLayerTile(CFile *File,int Version);																// Load Layer
 		~CLayerTile();
 
+		int				GetType()			{return(LAYER_TYPE_TILE);}
+
 		void			Render(CCore *Core,Vec &CamPos,BOOL Is3d);
 		void			RenderGrid(CCore *Core,Vec &CamPos);
 
@@ -52,6 +54,8 @@ public:
 		int				GetHeight()			{return(Map.GetHeight());}
 		void			Resize(int Width,int Height);
 
+		void			Load(CFile *File,float Version);
+		void			Save(CFile *File);
 
 // Functions
 		BOOL			SetMode(int NewMode);

Utils/MapEdit/Map.cpp

@@ -12,6 +12,49 @@
 #include	"Map.h"
 
 
+/*****************************************************************************/
+void	CMap::Load(CFile *File,float Version)
+{
+// Version 1
+int	Width;
+int	Height;
+
+		File->Read(&Width,sizeof(int));
+		File->Read(&Height,sizeof(int));
+
+		Delete();
+		SetSize(Width,Height);
+		for (int Y=0;Y<Height;Y++)
+		{
+			for (int X=0;X<Width;X++)
+			{
+				sMapElem	ThisElem;
+				File->Read(&ThisElem,sizeof(sMapElem));
+				Set(X,Y,ThisElem);
+			}
+		}
+
+}
+
+/*****************************************************************************/
+void	CMap::Save(CFile *File)
+{
+int	Width=GetWidth();
+int	Height=GetHeight();
+
+		File->Write(&Width,sizeof(int));
+		File->Write(&Height,sizeof(int));
+
+		for (int Y=0;Y<Height;Y++)
+		{
+			for (int X=0;X<Width;X++)
+			{
+				sMapElem	&ThisElem=Get(X,Y);
+				File->Write(&ThisElem,sizeof(sMapElem));
+			}
+		}
+}
+
 /*****************************************************************************/
 void	CMap::SetSize(int Width,int Height,BOOL ClearFlag)
 {

Utils/MapEdit/Map.h

@@ -48,6 +48,10 @@ public:
 
 		BOOL		DoesContainTile(sMapElem &Tile);
 
+		void		Load(CFile *File,float Version);
+		void		Save(CFile *File);
+
+
 inline	void	operator=(CMap &Src)	
 {
 int		Width=Src.GetWidth();

Utils/MapEdit/MapEdit.clw

@@ -18,19 +18,19 @@ Class6=CMapEditDoc
 Class7=CMapEditView
 
 ResourceCount=10
-Resource1=IDR_MAINFRAME (English (U.S.))
+Resource1=IDD_LAYER_LIST_DIALOG
-Resource2=IDD_TILESET_DIALOG
+Resource2=IDR_MAINFRAME (English (U.S.))
-Resource3=IDD_LAYER_LIST_DIALOG
+Resource3=IDR_TOOLBAR (English (U.S.))
 Resource4=IDD_DIALOGBAR (English (U.S.))
 Resource5=IDR_MAPEDITYPE (English (U.S.))
 Class8=CMultiBar
-Resource6=IDD_ABOUTBOX (English (U.S.))
+Resource6=IDD_TILESET_DIALOG
-Resource7=IDR_TOOLBAR (English (U.S.))
+Resource7=IDD_MULTIBAR (English (U.S.))
 Class9=CLayerList
 Class10=CTileSetDlg
-Resource8=IDD_MULTIBAR (English (U.S.))
+Resource8=IDD_GFXTOOLBAR
 Class11=CGfxToolBar
-Resource9=IDD_GFXTOOLBAR
+Resource9=IDD_ABOUTBOX (English (U.S.))
 Class12=CMapSizeDlg
 Resource10=IDD_MAPSIZE
 

Utils/MapEdit/MapEdit.cpp

@@ -71,7 +71,7 @@ BOOL CMapEditApp::InitInstance()
 	// Change the registry key under which our settings are stored.
 	// TODO: You should modify this string to be something appropriate
 	// such as the name of your company or organization.
-	SetRegistryKey(_T("Local AppWizard-Generated Applications"));
+	SetRegistryKey(_T("Climax"));
 
 	LoadStdProfileSettings();  // Load standard INI file options (including MRU)
 

Utils/MapEdit/MapEdit.dsp

@@ -316,6 +316,14 @@ SOURCE=.\LayerList.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\MapSizeDlg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MapSizeDlg.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\MultiBar.cpp
 # End Source File
 # Begin Source File

Utils/MapEdit/MapEdit.rc

@@ -277,8 +277,8 @@ END
 
 STRINGTABLE PRELOAD DISCARDABLE 
 BEGIN
-    IDR_MAINFRAME           "MapEdit"
+    IDR_MAINFRAME           "Map Editor"
-    IDR_MAPEDITYPE          "\nMapEdi\nMapEdi\n\n\nMapEdit.Document\nMapEdi Document"
+    IDR_MAPEDITYPE          "Map Edit Doc\n\n\nMapEdit Project (*.MEP)\n.Mep\n"
 END
 
 STRINGTABLE PRELOAD DISCARDABLE 

Utils/MapEdit/MapEditDoc.cpp

@@ -39,7 +39,7 @@ BOOL CMapEditDoc::OnNewDocument()
 {
 	if (!CDocument::OnNewDocument()) return FALSE;
 	TRACE0("New Doc\n");
-	Core.NewMap();
+	Core.New();
 
 	return TRUE;
 }
@@ -61,12 +61,11 @@ void CMapEditDoc::Serialize(CArchive& ar)
 {
 	if (ar.IsStoring())
 	{
-		// TODO: add storing code here
+		Core.Save(ar.GetFile());
-   
 	}
 	else
 	{
-		// TODO: add loading code here
+		Core.Load(ar.GetFile());
 	}
 }
 
@@ -100,6 +99,12 @@ void	CMapEditDoc::Render(CMapEditView *View)
 		Core.Render(View);
 }
 
+/*********************************************************************************/
+void	CMapEditDoc::UpdateAll(CMapEditView *View)
+{
+		Core.UpdateAll(View);
+}
+
 /*********************************************************************************/
 void	CMapEditDoc::OnStatusCursorXY(CCmdUI *pCmdUI)
 {

Utils/MapEdit/MapEditView.cpp

@@ -143,8 +143,8 @@ void CMapEditView::OnSetFocus(CWnd* pOldWnd)
 CMapEditDoc	*CurDoc=GetDocument();
 	CGLEnabledView::OnSetFocus(pOldWnd);
 	theApp.SetCurrent(CurDoc);
-//	CurDoc->UpdateAll(this);
+	CurDoc->UpdateAll(this);
-	CurDoc->UpdateAllViews(this);
+//	CurDoc->UpdateAllViews(this);
 }
 
 /*********************************************************************************/

Utils/MapEdit/TileSet.cpp

@@ -44,7 +44,7 @@ CTileBank::CTileBank()
 		SelStart=-1;
 		SelEnd=1;
 
-#ifdef _DEBUG
+#ifdef _DEBUGx
 	AddTileSet("c:/temp/rockp/rockp.gin");
 
 int	W=3;
@@ -72,6 +72,49 @@ CTileBank::~CTileBank()
 {
 }
 
+/*****************************************************************************/
+void	CTileBank::Load(CFile *File,float Version)
+{
+int		ListSize;
+	
+	File->Read(&ListSize,sizeof(int));
+	File->Read(&CurrentSet,sizeof(int));
+	File->Read(&ActiveBrush,sizeof(int));
+	Brush[0].Load(File,Version);
+	Brush[1].Load(File,Version);
+
+	for (int i=0;i<ListSize;i++)
+	{
+		char	Filename[256+64];
+
+		File->Read(Filename,256+64);
+		AddTileSet(Filename);
+	}
+
+
+}
+
+/*****************************************************************************/
+void	CTileBank::Save(CFile *File)
+{
+int		ListSize=TileSet.size();
+
+	File->Write(&ListSize,sizeof(int));
+	File->Write(&CurrentSet,sizeof(int));
+	File->Write(&ActiveBrush,sizeof(int));
+	Brush[0].Save(File);
+	Brush[1].Save(File);
+
+	for (int i=0;i<ListSize;i++)
+	{
+		CTileSet	&ThisSet=TileSet[i];
+		char	Filename[256+64];
+
+		sprintf(Filename,"%s%s.%s",ThisSet.GetPath(),ThisSet.GetName(),"Gin");
+		File->Write(Filename,256+64);		
+	}
+}
+
 /*****************************************************************************/
 void	CTileBank::AddTileSet(char *Filename)
 {
@@ -456,54 +499,6 @@ int			TileID=0;
 		glEnable(GL_TEXTURE_2D);
 }
 
-/*
-void	CTileSet::RenderMisc(BOOL LTileFlag,BOOL RTileFlag,BOOL CursorFlag,BOOL GridFlag)
-{
-		glDisable(GL_TEXTURE_2D);
-
-		if (LTileFlag || RTileFlag || CursorFlag)
-		{
-			glBegin(GL_QUADS); 
-			glNormal3f( 1,1,1);
-
-			glColor3ub(255,255,0);
-
-			if (LTileFlag)
-			{
-				glColor3ub(255,0,0);
-			}
-			if (RTileFlag)
-			{
-				glColor3ub(0,0,255);
-			}
-			BuildGLQuad(TileBrowserX0,TileBrowserX1,TileBrowserY0,TileBrowserY1,0);
-			glEnd();
-		}
-
-		if (GridFlag)
-		{
-			glBegin(GL_LINES); 
-				glNormal3f( 1,1,1);
-				glColor3ub(255,255,255);
-			
-				glVertex3f( TileBrowserX0,TileBrowserY0,0);
-				glVertex3f( TileBrowserX1,TileBrowserY0,0);
-
-				glVertex3f( TileBrowserX0,TileBrowserY1,0);
-				glVertex3f( TileBrowserX1,TileBrowserY1,0);
-
-				glVertex3f( TileBrowserX0,TileBrowserY0,0);
-				glVertex3f( TileBrowserX0,TileBrowserY1,0);
-
-				glVertex3f( TileBrowserX1,TileBrowserY0,0);
-				glVertex3f( TileBrowserX1,TileBrowserY1,0);
-
-			glEnd();
-		}
-
-		glEnable(GL_TEXTURE_2D);
-}
-*/
 /*****************************************************************************/
 int		CTileSet::FindCursorPos(CCore *Core,CMapEditView *View,Vec &CamPos,CPoint &MousePos)
 {

Utils/MapEdit/TileSet.h

@@ -66,6 +66,10 @@ public:
 		void		SetActiveBrushL()					{ActiveBrush=LBrush;}
 		void		SetActiveBrushR()					{ActiveBrush=RBrush;}
 
+		void		Load(CFile *File,float Version);
+		void		Save(CFile *File);
+
+
 private:
 		BOOL		Select(int BrushID,BOOL DownFlag);
 		void		SetBrush(CMap &ThisBrush);