Utils/MapEdit/CmdMsg.h

@@ -44,6 +44,12 @@ enum	CmdMsg
 		CmdMsg_ThingPosUp,			// 28
 		CmdMsg_ThingPosDown,		// 29
 		CmdMsg_ThingPosDelete,		// 30
+// Shade
+		CmdMsg_ShadeGfxNew,			// 31
+		CmdMsg_ShadeGfxSelect,		// 32
+		CmdMsg_ShadeGfxGoto,		// 33
+		CmdMsg_ShadeGfxDelete,		// 34
+
 };
 #endif
 /*****************************************************************************/

Utils/MapEdit/Core.cpp

@@ -82,12 +82,15 @@ int		Width,Height;
 // Create Tile Layers
 		AddLayer(LAYER_TYPE_TILE,LAYER_SUBTYPE_ACTION, Width, Height);
 #ifdef _DEBUG
+//		AddLayer(LAYER_TYPE_SHADE,LAYER_SUBTYPE_NONE, Width, Height);
 		AddLayer(LAYER_TYPE_TRIGGER,LAYER_SUBTYPE_NONE, Width, Height);
-		AddLayer(LAYER_TYPE_PLATFORM,LAYER_SUBTYPE_NONE, Width, Height);
+//		AddLayer(LAYER_TYPE_PLATFORM,LAYER_SUBTYPE_NONE, Width, Height);
+//		AddLayer(LAYER_TYPE_HAZARD,LAYER_SUBTYPE_NONE, Width, Height);
 //		AddLayer(LAYER_TYPE_FX,LAYER_SUBTYPE_NONE, Width, Height);
 //		AddLayer(LAYER_TYPE_ACTOR,LAYER_SUBTYPE_NONE, Width, Height);
 //		AddLayer(LAYER_TYPE_ITEM,LAYER_SUBTYPE_NONE, Width, Height);
 #endif
+
 		for (int i=0; i<Layer.size(); i++)
 		{
 			Layer[i]->InitSubView(this);
@@ -95,7 +98,7 @@ int		Width,Height;
 
 		ActiveLayer=FindLayer(LAYER_TYPE_TILE,LAYER_SUBTYPE_ACTION);
 #ifdef _DEBUG
-		ActiveLayer=FindLayer(LAYER_TYPE_PLATFORM,LAYER_SUBTYPE_NONE);
+		ActiveLayer=FindLayer(LAYER_TYPE_TRIGGER,LAYER_SUBTYPE_NONE);
 		if (ActiveLayer<0) ActiveLayer=0;
 #endif
 		CurrentLayer=Layer[ActiveLayer];

Utils/MapEdit/Core.h

@@ -19,7 +19,7 @@
 #include	"Layer.h"
 #include	"LayerTile.h"
 
-const	s32		FileVersion=8;
+const	s32		FileVersion=9;
 
 #define	SCREEN_MAP_WIDTH	30
 #define	SCREEN_MAP_HEIGHT	20

Utils/MapEdit/Elem.cpp

@@ -350,6 +350,7 @@ float	v1=1.0f;//Tex.ScaleU;
 			List=glGenLists(1);
 			glNewList(List,GL_COMPILE);
 
+			TexID=Tex.TexID;
 			glBindTexture(GL_TEXTURE_2D, Tex.TexID);
 			glBegin (GL_QUADS);
 				glTexCoord2f(u0,v0);

Utils/MapEdit/Elem.h

@@ -81,6 +81,8 @@ static	bool	DefTexFlag;
 
 		void	SetBlank();
 		void	SetInvalid();
+		GLint	GetTexID()	{return(TexID);}
+
 protected:
 		void	Build3dElem(CTexCache &TexCache,CScene &ThisScene,int Node);
 		void	Build2dElem(CCore *Core,const char *Filename,int TexId);
@@ -106,6 +108,7 @@ protected:
 		float					UnitWidth,UnitHeight;
 		int						ElemID;
 		u8						*ElemRGB;
+		GLint					TexID;
 };
 
 /*****************************************************************************/

Utils/MapEdit/ExportHdr.h

@@ -9,6 +9,17 @@
 
 #include	<List.h>
 
+/*****************************************************************************/
+struct	sRGBCol
+{
+		u8	R,G,B,P;
+};
+
+struct	sXY
+{
+		int	x,y;
+};
+
 /*****************************************************************************/
 #define	EXPORT_LAYER_COUNT	16
 struct	sExpFileHdr
@@ -87,36 +98,98 @@ bool	operator ==(sExpLayerTile const &v1)	{return(Tile==v1.Tile && Flags==v1.Fla
 
 };
 
-
 /*****************************************************************************/
-/*
+/*****************************************************************************/
-struct	sExpTex
+/*****************************************************************************/
+struct	sLayerShadeGfx
 {
-	char			*Filename;
+	sRGBCol		RGB[4];
-
+	int			Gfx;
-	BOOL			operator==(sExpTex const &v1)		{return (!strcmp(Filename,v1.Filename));}
+	sXY			Pos;
+	sXY			Ofs[4];
+	int			TransMode;
 };
-*/
-/*
-struct	sExpMapElem
-{
-	u16		Set;
-	u16		Tile;
-	u16		Flags;
 
-BOOL	operator==(sExpMapElem const &v1)
-		{
-		return(Set==v1.Set && Tile==v1.Tile);
-		}
-};
-*/
 /*****************************************************************************/
 /*** Things ******************************************************************/
 /*****************************************************************************/
+struct	sLayerThingDef
+{
+	int		Store[32];
+};
+
+struct	sLayerThingActor
+{
+	int						ActorSpeed;
+	int						ActorTurnRate;
+	int						ActorHealth;
+	int						ActorAttackStrength;
+	bool					ActorCollisionFlag;
+};
+
+struct	sLayerThingItem
+{
+};
+
+struct	sLayerThingPlatform
+{
+	int						PlatformSpeed;
+	int						PlatformTurnRate;
+	int						PlatformCollisionFlag;
+	int						PlatformType;
+	int						PlatformMoveType;
+	int						PlatformTriStart;
+	int						PlatformTriCount;
+};
+
+struct	sLayerThingTrigger
+{
+	int						TriggerWidth;
+	int						TriggerHeight;
+	int						TriggerTargetX;
+	int						TriggerTargetY;
+};
+
+struct	sLayerThingFX
+{
+	int						FXSpeed;
+	int						FXWidth;
+	int						FXHeight;
+};
+
+struct	sLayerThingHazard
+{
+	int						HazardSpeed;
+	int						HazardTurnRate;
+	int						HazardHealth;
+	int						HazardAttackStrength;
+	int						HazardRespawn;
+	bool					HazardCollisionFlag;
+	int						HazardTriStart;
+	int						HazardTriCount;
+
+};
+
 struct	sLayerThingData
 {
 	int						WaypointCount;
 
+	union
+	{
+		sLayerThingDef		RESERVE;
+		sLayerThingActor	Actor;
+		sLayerThingItem		Item;
+		sLayerThingPlatform	Platform;
+		sLayerThingTrigger	Trigger;
+		sLayerThingFX		FX;
+		sLayerThingHazard	Hazard;
+	};
+};
+
+struct	sLayerThingDataOLD
+{
+	int						WaypointCount;
+
 	int						Speed;
 	int						TurnRate;
 	int						Health;
@@ -129,11 +202,11 @@ struct	sLayerThingData
 	int						PlatformType;
 // Boxes
 	int						Width,Height;
-// Spare
 	int						TriStart,TriCount;
-	int						Spare[2];
+	int						TargetX,TargetY;
-
+// NO SPARE!!
 };
 
+
 #endif
 

Utils/MapEdit/GUILayerHazard.cpp

@@ -1,9 +1,9 @@
-// GUILayerActor.cpp : implementation file
+// GUILayerHazard.cpp : implementation file
 //
 
 #include "stdafx.h"
 #include "mapedit.h"
-#include "GUILayerActor.h"
+#include "GUILayerHazard.h"
 
 #include "MapEditDoc.h"
 #include "MainFrm.h"
@@ -15,49 +15,51 @@ static char THIS_FILE[] = __FILE__;
 #endif
 
 /////////////////////////////////////////////////////////////////////////////
-// CGUILayerActor dialog
+// CGUILayerHazard dialog
 
 
-CGUILayerActor::CGUILayerActor(CWnd* pParent /*=NULL*/)
+CGUILayerHazard::CGUILayerHazard(CWnd* pParent /*=NULL*/)
-	: CDialog(CGUILayerActor::IDD, pParent)
+	: CDialog(CGUILayerHazard::IDD, pParent)
 {
 	DisableCallback(true);
-	//{{AFX_DATA_INIT(CGUILayerActor)
+	//{{AFX_DATA_INIT(CGUILayerHazard)
 	//}}AFX_DATA_INIT
 	DisableCallback(false);
 }
 
 
-void CGUILayerActor::DoDataExchange(CDataExchange* pDX)
+void CGUILayerHazard::DoDataExchange(CDataExchange* pDX)
 {
 	CDialog::DoDataExchange(pDX);
-	//{{AFX_DATA_MAP(CGUILayerActor)
+	//{{AFX_DATA_MAP(CGUILayerHazard)
-	DDX_Control(pDX, IDC_ACTOR_TURNRATE_SPIN, m_TurnRateSpin);
+	DDX_Control(pDX, IDC_HAZARD_TURNRATE_SPIN, m_TurnRateSpin);
-	DDX_Control(pDX, IDC_ACTOR_SPEED_SPIN, m_SpeedSpin);
+	DDX_Control(pDX, IDC_HAZARD_SPEED_SPIN, m_SpeedSpin);
-	DDX_Control(pDX, IDC_ACTOR_HEALTH_SPIN, m_HealthSpin);
+	DDX_Control(pDX, IDC_HAZARD_HEALTH_SPIN, m_HealthSpin);
-	DDX_Control(pDX, IDC_ACTOR_ATTACK_SPIN, m_AttackSpin);
+	DDX_Control(pDX, IDC_HAZARD_ATTACK_SPIN, m_AttackSpin);
-	DDX_Control(pDX, IDC_ACTOR_COLLISION, m_Collision);
+	DDX_Control(pDX, IDC_HAZARD_RESPAWN_SPIN, m_RespawnSpin);
-	DDX_Control(pDX, IDC_ACTOR_PLAYER, m_Player);
+	DDX_Control(pDX, IDC_HAZARD_COLLISION, m_Collision);
-	DDX_Control(pDX, IDC_ACTOR_TURNRATE, m_TurnRate);
+	DDX_Control(pDX, IDC_HAZARD_TURNRATE, m_TurnRate);
-	DDX_Control(pDX, IDC_ACTOR_SPEED, m_Speed);
+	DDX_Control(pDX, IDC_HAZARD_SPEED, m_Speed);
-	DDX_Control(pDX, IDC_ACTOR_ATTACK, m_Attack);
+	DDX_Control(pDX, IDC_HAZARD_ATTACK, m_Attack);
-	DDX_Control(pDX, IDC_ACTOR_HEALTH, m_Health);
+	DDX_Control(pDX, IDC_HAZARD_HEALTH, m_Health);
+	DDX_Control(pDX, IDC_HAZARD_RESPAWN, m_Respawn);
 	//}}AFX_DATA_MAP
 }
 
 
-BEGIN_MESSAGE_MAP(CGUILayerActor, CDialog)
+BEGIN_MESSAGE_MAP(CGUILayerHazard, CDialog)
-	//{{AFX_MSG_MAP(CGUILayerActor)
+	//{{AFX_MSG_MAP(CGUILayerHazard)
-	ON_EN_CHANGE(IDC_ACTOR_HEALTH, OnChangeParam)
+	ON_EN_CHANGE(IDC_HAZARD_HEALTH, OnChangeParam)
-	ON_EN_CHANGE(IDC_ACTOR_ATTACK, OnChangeParam)
+	ON_EN_CHANGE(IDC_HAZARD_ATTACK, OnChangeParam)
-	ON_BN_CLICKED(IDC_ACTOR_COLLISION, OnChangeParam)
+	ON_BN_CLICKED(IDC_HAZARD_COLLISION, OnChangeParam)
-	ON_EN_CHANGE(IDC_ACTOR_SPEED, OnChangeParam)
+	ON_EN_CHANGE(IDC_HAZARD_SPEED, OnChangeParam)
-	ON_EN_CHANGE(IDC_ACTOR_TURNRATE, OnChangeParam)
+	ON_EN_CHANGE(IDC_HAZARD_TURNRATE, OnChangeParam)
+	ON_EN_CHANGE(IDC_HAZARD_RESPAWN, OnChangeParam)
 	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerActor::SetVal(CEdit &Dlg,int Val)
+void	CGUILayerHazard::SetVal(CEdit &Dlg,int Val)
 {
 CString	Str;
 		if (!Dlg) return;
@@ -68,7 +70,7 @@ CString	Str;
 }
 
 /////////////////////////////////////////////////////////////////////////////
-int		CGUILayerActor::GetVal(CEdit &Dlg)
+int		CGUILayerHazard::GetVal(CEdit &Dlg)
 {
 CString	Str;
 int		Val=0;
@@ -80,6 +82,6 @@ int		Val=0;
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// CGUILayerActor message handlers
+// CGUILayerHazard message handlers
 
-void CGUILayerActor::OnChangeParam()					{if (!CallbackFlag) theApp.GetCurrent()->GUIChanged();}
+void CGUILayerHazard::OnChangeParam()					{if (!CallbackFlag) theApp.GetCurrent()->GUIChanged();}

Utils/MapEdit/GUILayerHazard.h

@@ -1,40 +1,41 @@
-#if !defined(AFX_GUILAYERACTOR_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_)
+#if !defined(AFX_GUILAYERHAZARD_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_)
-#define AFX_GUILAYERACTOR_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_
+#define AFX_GUILAYERHAZARD_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_
 
 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000
-// GUILayerActor.h : header file
+// GUILayerHazard.h : header file
 //
 
 /////////////////////////////////////////////////////////////////////////////
-// CGUILayerActor dialog
+// CGUILayerHazard dialog
 
-class CGUILayerActor : public CDialog 
+class CGUILayerHazard : public CDialog 
 {
 // Construction
 public:
-	CGUILayerActor(CWnd* pParent = NULL);   // standard constructor
+	CGUILayerHazard(CWnd* pParent = NULL);   // standard constructor
 
 // Dialog Data
-	//{{AFX_DATA(CGUILayerActor)
+	//{{AFX_DATA(CGUILayerHazard)
-	enum { IDD = IDD_LAYER_ACTOR };
+	enum { IDD = IDD_LAYER_HAZARD };
 	CSpinButtonCtrl	m_TurnRateSpin;
 	CSpinButtonCtrl	m_SpeedSpin;
 	CSpinButtonCtrl	m_HealthSpin;
 	CSpinButtonCtrl	m_AttackSpin;
+	CSpinButtonCtrl	m_RespawnSpin;
 	CButton	m_Collision;
-	CButton	m_Player;
 	CEdit	m_TurnRate;
 	CEdit	m_Speed;
 	CEdit	m_Attack;
 	CEdit	m_Health;
+	CEdit	m_Respawn;
 	//}}AFX_DATA
 
 
 // Overrides
 	// ClassWizard generated virtual function overrides
-	//{{AFX_VIRTUAL(CGUILayerActor)
+	//{{AFX_VIRTUAL(CGUILayerHazard)
 	protected:
 	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
 	//}}AFX_VIRTUAL
@@ -49,7 +50,7 @@ protected:
 	bool	CallbackFlag;
 
 	// Generated message map functions
-	//{{AFX_MSG(CGUILayerActor)
+	//{{AFX_MSG(CGUILayerHazard)
 	afx_msg void OnChangeParam();
 	//}}AFX_MSG
 	DECLARE_MESSAGE_MAP()
@@ -58,4 +59,4 @@ protected:
 //{{AFX_INSERT_LOCATION}}
 // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
 
-#endif // !defined(AFX_GUILAYERACTOR_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_)
+#endif // !defined(AFX_GUILAYERHAZARD_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_)

Utils/MapEdit/GUILayerShade.cpp

@@ -23,12 +23,6 @@ CGUILayerShade::CGUILayerShade(CWnd* pParent /*=NULL*/)
 {
 	//{{AFX_DATA_INIT(CGUILayerShade)
 	//}}AFX_DATA_INIT
-	SetFlag=true;
-	Map[0][0]=&m_R0; Map[0][1]=&m_G0;	Map[0][2]=&m_B0;
-	Map[1][0]=&m_R1; Map[1][1]=&m_G1;	Map[1][2]=&m_B1;
-	Map[2][0]=&m_R2; Map[2][1]=&m_G2;	Map[2][2]=&m_B2;
-	Map[3][0]=&m_R3; Map[3][1]=&m_G3;	Map[3][2]=&m_B3;
-
 }
 
 
@@ -36,63 +30,105 @@ void CGUILayerShade::DoDataExchange(CDataExchange* pDX)
 {
 	CDialog::DoDataExchange(pDX);
 	//{{AFX_DATA_MAP(CGUILayerShade)
-	DDX_Control(pDX, IDC_SPIN2, m_CountSpin);
+	DDX_Control(pDX, IDC_LAYERSHADE_DEF_LIST, m_DefList);
-	DDX_Control(pDX, IDC_LAYERSHADE_SPIN1, m_Spin1);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADECOUNT_SPIN, m_ShadeCountSpin);
-	DDX_Control(pDX, IDC_LAYERSHADE_SPIN0, m_Spin0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADECOUNT, m_ShadeCount);
-	DDX_Control(pDX, IDC_LAYERSHADE_SCALE1, m_Scale1);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADER0, m_ShadeR0);
-	DDX_Control(pDX, IDC_LAYERSHADE_SCALE0, m_Scale0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEG0, m_ShadeG0);
-	DDX_Control(pDX, IDC_LAYERSHADE_MOVE1, m_Move1);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEB0, m_ShadeB0);
-	DDX_Control(pDX, IDC_LAYERSHADE_MOVE0, m_Move0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADER1, m_ShadeR1);
-	DDX_Control(pDX, IDC_LAYERSHADE_COLOR1, m_Color1);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEG1, m_ShadeG1);
-	DDX_Control(pDX, IDC_LAYERSHADE_COLOR0, m_Color0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEB1, m_ShadeB1);
-	DDX_Control(pDX, IDC_LAYERSHADE_TRANS1, m_Trans1);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADER2, m_ShadeR2);
-	DDX_Control(pDX, IDC_LAYERSHADE_TRANS0, m_Trans0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEG2, m_ShadeG2);
-	DDX_Control(pDX, IDC_LAYERSHADE_BACKGFX1, m_Gfx1);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEB2, m_ShadeB2);
-	DDX_Control(pDX, IDC_LAYERSHADE_BACKGFX0, m_Gfx0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADER3, m_ShadeR3);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITR0, m_R0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEG3, m_ShadeG3);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITG0, m_G0);
+	DDX_Control(pDX, IDC_LAYERSHADE_SHADEB3, m_ShadeB3);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITB0, m_B0);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_CURRENT_SPIN, m_GfxCurrentSpin);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITR1, m_R1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_CURRENT, m_GfxCurrent);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITG1, m_G1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_LIST, m_GfxBankList);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITB1, m_B1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_XSPIN, m_GfxPosXSpin);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITR2, m_R2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_X, m_GfxPosX);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITG2, m_G2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_YSPIN, m_GfxPosYSpin);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITB2, m_B2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_Y, m_GfxPosY);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITR3, m_R3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_X0, m_GfxSpinx0);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITG3, m_G3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_Y0, m_GfxSpiny0);
-	DDX_Control(pDX, IDC_LAYERSHADE_EDITB3, m_B3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_X0, m_Gfxx0);
-	DDX_Control(pDX, IDC_LAYERSHADE_COUNTEDIT, m_Count);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_Y0, m_Gfxy0);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXR0, m_GfxR0);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXG0, m_GfxG0);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXB0, m_GfxB0);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_X1, m_GfxSpinx1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_Y1, m_GfxSpiny1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_X1, m_Gfxx1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_Y1, m_Gfxy1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXR1, m_GfxR1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXG1, m_GfxG1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXB1, m_GfxB1);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_X2, m_GfxSpinx2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_Y2, m_GfxSpiny2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_X2, m_Gfxx2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_Y2, m_Gfxy2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXR2, m_GfxR2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXG2, m_GfxG2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXB2, m_GfxB2);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_X3, m_GfxSpinx3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_Y3, m_GfxSpiny3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_X3, m_Gfxx3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_Y3, m_Gfxy3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXR3, m_GfxR3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXG3, m_GfxG3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFXB3, m_GfxB3);
+	DDX_Control(pDX, IDC_LAYERSHADE_GFX_TRANSLIST, m_GfxTransList);
 	//}}AFX_DATA_MAP
 }
 
-
 BEGIN_MESSAGE_MAP(CGUILayerShade, CDialog)
 	//{{AFX_MSG_MAP(CGUILayerShade)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITB0, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADECOUNT, OnChangeParam)
-	ON_CBN_SELCHANGE(IDC_LAYERSHADE_BACKGFX0, OnChangeParam)
+	ON_BN_CLICKED(IDC_LAYERSHADE_GFX_GOTO, OnGoto)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITB1, OnChangeLayershadeEdit)
+	ON_BN_CLICKED(IDC_LAYERSHADE_GFX_DELETE, OnDelete)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITG0, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_CURRENT, OnChangeCurrent)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITG1, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADER0, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITR0, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG0, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITR1, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB0, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITB2, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADER1, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITB3, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG1, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITG2, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB1, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITG3, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADER2, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITR2, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG2, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_EDITR3, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB2, OnChangeParam)
-	ON_EN_CHANGE(IDC_LAYERSHADE_COUNTEDIT, OnChangeLayershadeEdit)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADER3, OnChangeParam)
-	ON_CBN_SELCHANGE(IDC_LAYERSHADE_BACKGFX1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG3, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_COLOR0, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB3, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_COLOR1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_XSPIN, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_MOVE0, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_MOVE1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_YSPIN, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_SCALE0, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_SCALE1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X0, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_SPIN0, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y0, OnChangeParam)
-	ON_BN_CLICKED(IDC_LAYERSHADE_SPIN1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXR0, OnChangeParam)
-	ON_CBN_SELCHANGE(IDC_LAYERSHADE_TRANS0, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXG0, OnChangeParam)
-	ON_CBN_SELCHANGE(IDC_LAYERSHADE_TRANS1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXB0, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXR1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXG1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXB1, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X2, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y2, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXR2, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXG2, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXB2, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X3, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y3, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXR3, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXG3, OnChangeParam)
+	ON_EN_CHANGE(IDC_LAYERSHADE_GFXB3, OnChangeParam)
+	ON_CBN_SELCHANGE(IDC_LAYERSHADE_GFX_LIST, OnChangeParam)
+	ON_CBN_SELCHANGE(IDC_LAYERSHADE_GFX_TRANSLIST, OnChangeParam)
+	ON_CBN_SELCHANGE(IDC_LAYERSHADE_DEF_LIST, OnNew)
 	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()
 
@@ -104,110 +140,123 @@ void	CGUILayerShade::OnOK()
 }	
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::SetVal(CEdit &Dlg,int &Val)
+void	CGUILayerShade::SetVal(CEdit &Dlg,int &Val,int Min,int Max)
 {
 CString	Str;
+bool	CF=CallbackFlag;
 		if (!Dlg) return;
-		SetFlag=true;
+		if (Min!=-1 && Val<Min) Val=Min;
+		if (Max!=-1 && Val>Max) Val=Max;
+		CallbackFlag=false;
 		Str.Format("%i",Val); 
 		Dlg.SetWindowText(Str); 
-		SetFlag=false;
+		CallbackFlag=CF;
 }
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::GetVal(CEdit &Dlg,int &Val)
+void	CGUILayerShade::GetVal(CEdit &Dlg,int &Val,int Min,int Max)
 {
 CString	Str;
+		Val=0;
 		if (!Dlg) return;
-		
 		Dlg.GetWindowText(Str); 
 		if (Str.GetLength()) 
+		{
 			Val=atoi(Str);
-		else
+			if (Min!=-1 && Val<Min) {Val=Min;SetVal(Dlg,Val,Min,Max);}
-			Val=0;
+			if (Max!=-1 && Val>Max) {Val=Max;SetVal(Dlg,Val,Min,Max);}
+		}
 }
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::LimitVal(int Min,int Max,CEdit &Dlg)
+void	CGUILayerShade::SetRGB(CEdit &DlgR,CEdit &DlgG,CEdit &DlgB,u8 &R,u8 &G,u8 &B)
 {
-int		Val;
+int		iR,iG,iB;
-		if (!Dlg) return;
-DWORD	Sel=Dlg.GetSel();	// Retain cursor pos :o), Im getting good at this!
 		
-		GetVal(Dlg,Val);
+		iR=R;
-		if (Val<Min) Val=Min;
+		iG=G;
-		if (Val>Max) Val=Max;
+		iB=B;
 
-		SetVal(Dlg,Val);
+		SetVal(DlgR,iR,0,255);
+		SetVal(DlgG,iG,0,255);
+		SetVal(DlgB,iB,0,255);
 
-		Dlg.SetSel(Sel);
+		R=iR;
+		G=iG;
+		B=iB;
 
 }
-/////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::SetRGB(RGBQUAD &RGB,int Set)
-{
-int		Val;
-
-		Val=RGB.rgbRed;		SetVal(*Map[Set][0],Val); 
-		Val=RGB.rgbGreen;	SetVal(*Map[Set][1],Val);
-		Val=RGB.rgbBlue;	SetVal(*Map[Set][2],Val);
-}
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::GetRGB(RGBQUAD &RGB,int Set)
+void	CGUILayerShade::GetRGB(CEdit &DlgR,CEdit &DlgG,CEdit &DlgB,u8 &R,u8 &G,u8 &B)
 {
-int		Val;
+int		iR,iG,iB;
-		GetVal(*Map[Set][0],Val);	RGB.rgbRed=Val;		
+		
-		GetVal(*Map[Set][1],Val);	RGB.rgbGreen=Val;	
+		iR=R;
-		GetVal(*Map[Set][2],Val);	RGB.rgbBlue=Val;	
+		iG=G;
+		iB=B;
+	
+		GetVal(DlgR,iR,0,255);
+		GetVal(DlgG,iG,0,255);
+		GetVal(DlgB,iB,0,255);
+	
+		R=iR;
+		G=iG;
+		B=iB;
+
 }
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::CheckRGB(int Set)
+void	CGUILayerShade::SetShadeRGB(int idx,u8 &R,u8 &G,u8 &B)
 {
-		LimitVal(0,255,*Map[Set][0]);
+		switch(idx)
-		LimitVal(0,255,*Map[Set][1]);
+		{
-		LimitVal(0,255,*Map[Set][2]);
+		case 0: SetRGB(m_ShadeR0,m_ShadeG0,m_ShadeB0,R,G,B); break;
+		case 1: SetRGB(m_ShadeR1,m_ShadeG1,m_ShadeB1,R,G,B); break;
+		case 2: SetRGB(m_ShadeR2,m_ShadeG2,m_ShadeB2,R,G,B); break;
+		case 3: SetRGB(m_ShadeR3,m_ShadeG3,m_ShadeB3,R,G,B); break;
+		}
 }
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::SetStatus(int Set,bool f)
+void	CGUILayerShade::GetShadeRGB(int idx,u8 &R,u8 &G,u8 &B)
 {
-		Map[Set][0]->SetReadOnly(f);
+		switch(idx)
-		Map[Set][1]->SetReadOnly(f);
+		{
-		Map[Set][2]->SetReadOnly(f);
+		case 0: GetRGB(m_ShadeR0,m_ShadeG0,m_ShadeB0,R,G,B); break;
+		case 1: GetRGB(m_ShadeR1,m_ShadeG1,m_ShadeB1,R,G,B); break;
+		case 2: GetRGB(m_ShadeR2,m_ShadeG2,m_ShadeB2,R,G,B); break;
+		case 3: GetRGB(m_ShadeR3,m_ShadeG3,m_ShadeB3,R,G,B); break;
+		}
 }
 
 /////////////////////////////////////////////////////////////////////////////
-void	CGUILayerShade::CheckData()
+void	CGUILayerShade::SetGfxRGB(int idx,u8 &R,u8 &G,u8 &B)
 {
-int		i;
+		switch(idx)
-int		Count;
-
-		SetFlag=true;
-		LimitVal(2,4,m_Count);
-		GetCount(Count);
-		for (i=0; i<4; i++) 
 		{
-			CheckRGB(i);
+		case 0: SetRGB(m_GfxR0,m_GfxG0,m_GfxB0,R,G,B); break;
-			SetStatus(i,i>=Count);
+		case 1: SetRGB(m_GfxR1,m_GfxG1,m_GfxB1,R,G,B); break;
+		case 2: SetRGB(m_GfxR2,m_GfxG2,m_GfxB2,R,G,B); break;
+		case 3: SetRGB(m_GfxR3,m_GfxG3,m_GfxB3,R,G,B); break;
 		}
-
-		SetFlag=false;
 }
 
 /////////////////////////////////////////////////////////////////////////////
-
+void	CGUILayerShade::GetGfxRGB(int idx,u8 &R,u8 &G,u8 &B)
-void CGUILayerShade::OnChangeLayershadeEdit() 
 {
-	if (SetFlag) return;
+		switch(idx)
-
-	if (theApp.GetCurrent() && m_R0)
 		{
-		CheckData();
+		case 0: GetRGB(m_GfxR0,m_GfxG0,m_GfxB0,R,G,B); break;
-		theApp.GetCurrent()->GUIChanged();
+		case 1: GetRGB(m_GfxR1,m_GfxG1,m_GfxB1,R,G,B); break;
+		case 2: GetRGB(m_GfxR2,m_GfxG2,m_GfxB2,R,G,B); break;
+		case 3: GetRGB(m_GfxR3,m_GfxG3,m_GfxB3,R,G,B); break;
 		}
 }
 
-void CGUILayerShade::OnChangeParam()					{if (!SetFlag) theApp.GetCurrent()->GUIChanged();}
+/////////////////////////////////////////////////////////////////////////////
-
+void CGUILayerShade::OnChangeParam()				{if (CallbackFlag) theApp.GetCurrent()->GUIChanged();}
+void CGUILayerShade::OnGoto()						{theApp.GetCurrent()->Command(CmdMsg_ShadeGfxGoto);}
+void CGUILayerShade::OnDelete()						{theApp.GetCurrent()->Command(CmdMsg_ShadeGfxDelete);}
+void CGUILayerShade::OnChangeCurrent()				{if (CallbackFlag) theApp.GetCurrent()->Command(CmdMsg_ShadeGfxSelect);}
+void CGUILayerShade::OnNew()						{theApp.GetCurrent()->Command(CmdMsg_ShadeGfxNew,m_DefList.GetCurSel());}

Utils/MapEdit/GUILayerShade.h

@@ -7,6 +7,9 @@
 // LayerShadeGUI.h : header file
 //
 
+#ifndef	u8
+typedef	unsigned char	u8;
+#endif
 /////////////////////////////////////////////////////////////////////////////
 // CGUILayerShade dialog
 
@@ -16,50 +19,60 @@ class CGUILayerShade : public CDialog
 public:
 	CGUILayerShade(CWnd* pParent = NULL);   // standard constructor
 
-	void	SetVal(CEdit &Dlg,int &Val);
-	void	GetVal(CEdit &Dlg,int &Val);
-	void	LimitVal(int Min,int Max,CEdit &Dlg);
-
-	void	SetRGB(RGBQUAD &RGB,int Set);
-	void	GetRGB(RGBQUAD &RGB,int Set);
-
-	void	SetCount(int &Count)	{SetVal(m_Count,Count);}
-	void	GetCount(int &Count)	{GetVal(m_Count,Count);}
-
-	void	CheckData();
-	void	CheckRGB(int Set);
-
-	void	SetStatus(int Set,bool f);
-
 // Dialog Data
 	//{{AFX_DATA(CGUILayerShade)
 	enum { IDD = IDD_LAYER_SHADE };
-	CSpinButtonCtrl	m_CountSpin;
+	CComboBox	m_DefList;
-	CButton	m_Spin1;
+	CSpinButtonCtrl	m_ShadeCountSpin;
-	CButton	m_Spin0;
+	CEdit			m_ShadeCount;
-	CButton	m_Scale1;
+	CEdit			m_ShadeR0;
-	CButton	m_Scale0;
+	CEdit			m_ShadeG0;
-	CButton	m_Move1;
+	CEdit			m_ShadeB0;
-	CButton	m_Move0;
+	CEdit			m_ShadeR1;
-	CButton	m_Color1;
+	CEdit			m_ShadeG1;
-	CButton	m_Color0;
+	CEdit			m_ShadeB1;
-	CComboBox	m_Trans1;
+	CEdit			m_ShadeR2;
-	CComboBox	m_Trans0;
+	CEdit			m_ShadeG2;
-	CComboBox	m_Gfx1;
+	CEdit			m_ShadeB2;
-	CComboBox	m_Gfx0;
+	CEdit			m_ShadeR3;
-	CEdit	m_R0;
+	CEdit			m_ShadeG3;
-	CEdit	m_G0;
+	CEdit			m_ShadeB3;
-	CEdit	m_B0;
+	CSpinButtonCtrl	m_GfxCurrentSpin;
-	CEdit	m_R1;
+	CEdit			m_GfxCurrent;
-	CEdit	m_G1;
+	CComboBox		m_GfxBankList;
-	CEdit	m_B1;
+	CEdit			m_GfxPosXSpin;
-	CEdit	m_R2;
+	CEdit			m_GfxPosX;
-	CEdit	m_G2;
+	CEdit			m_GfxPosYSpin;
-	CEdit	m_B2;
+	CEdit			m_GfxPosY;
-	CEdit	m_R3;
+	CSpinButtonCtrl	m_GfxSpinx0;
-	CEdit	m_G3;
+	CSpinButtonCtrl	m_GfxSpiny0;
-	CEdit	m_B3;
+	CEdit			m_Gfxx0;
-	CEdit	m_Count;
+	CEdit			m_Gfxy0;
+	CEdit			m_GfxR0;
+	CEdit			m_GfxG0;
+	CEdit			m_GfxB0;
+	CSpinButtonCtrl	m_GfxSpinx1;
+	CSpinButtonCtrl	m_GfxSpiny1;
+	CEdit			m_Gfxx1;
+	CEdit			m_Gfxy1;
+	CEdit			m_GfxR1;
+	CEdit			m_GfxG1;
+	CEdit			m_GfxB1;
+	CSpinButtonCtrl	m_GfxSpinx2;
+	CSpinButtonCtrl	m_GfxSpiny2;
+	CEdit			m_Gfxx2;
+	CEdit			m_Gfxy2;
+	CEdit			m_GfxR2;
+	CEdit			m_GfxG2;
+	CEdit			m_GfxB2;
+	CSpinButtonCtrl	m_GfxSpinx3;
+	CSpinButtonCtrl	m_GfxSpiny3;
+	CEdit			m_Gfxx3;
+	CEdit			m_Gfxy3;
+	CEdit			m_GfxR3;
+	CEdit			m_GfxG3;
+	CEdit			m_GfxB3;
+	CComboBox		m_GfxTransList;
 	//}}AFX_DATA
 
 	void OnOK();
@@ -72,17 +85,32 @@ public:
 	//}}AFX_VIRTUAL
 
 // Implementation
+public:
+	void	EnableCallback()		{CallbackFlag=true;}
+	void	DisableCallback()		{CallbackFlag=false;}
+	void	SetVal(CEdit &Dlg,int &Val,int Min=-1,int Max=-1);
+	void	GetVal(CEdit &Dlg,int &Val,int Min=-1,int Max=-1);
+	void	SetRGB(CEdit &RDlg,CEdit &GDlg,CEdit &BDlg,u8 &R,u8 &G,u8 &B);
+	void	GetRGB(CEdit &RDlg,CEdit &GDlg,CEdit &BDlg,u8 &R,u8 &G,u8 &B);
+
+	void	SetShadeRGB(int idx,u8 &R,u8 &G,u8 &B);
+	void	GetShadeRGB(int idx,u8 &R,u8 &G,u8 &B);
+	void	SetGfxRGB(int idx,u8 &R,u8 &G,u8 &B);
+	void	GetGfxRGB(int idx,u8 &R,u8 &G,u8 &B);
+
 protected:
+	bool	CallbackFlag;
 
 	// Generated message map functions
 	//{{AFX_MSG(CGUILayerShade)
-	afx_msg void OnChangeLayershadeEdit();
 	afx_msg void OnChangeParam();
+	afx_msg void OnGoto();
+	afx_msg void OnDelete();
+	afx_msg void OnChangeCurrent();
+	afx_msg void OnNew();
 	//}}AFX_MSG
 	DECLARE_MESSAGE_MAP()
-	bool	SetFlag;
 
-	CEdit	*Map[4][4];
 };
 
 //{{AFX_INSERT_LOCATION}}

Utils/MapEdit/GUILayerTrigger.cpp

@@ -32,6 +32,11 @@ void CGUILayerTrigger::DoDataExchange(CDataExchange* pDX)
 {
 	CDialog::DoDataExchange(pDX);
 	//{{AFX_DATA_MAP(CGUILayerTrigger)
+	DDX_Control(pDX, IDC_TRIGGER_TARGET, m_TargetTxt);
+	DDX_Control(pDX, IDC_TRIGGER_TARGETY_SPIN, m_TargetYSpin);
+	DDX_Control(pDX, IDC_TRIGGER_TARGETX_SPIN, m_TargetXSpin);
+	DDX_Control(pDX, IDC_TRIGGER_TARGETY, m_TargetY);
+	DDX_Control(pDX, IDC_TRIGGER_TARGETX, m_TargetX);
 	DDX_Control(pDX, IDC_TRIGGER_WIDTH_SPIN, m_WidthSpin);
 	DDX_Control(pDX, IDC_TRIGGER_HEIGHT_SPIN, m_HeightSpin);
 	DDX_Control(pDX, IDC_TRIGGER_WIDTH, m_Width);
@@ -44,6 +49,8 @@ BEGIN_MESSAGE_MAP(CGUILayerTrigger, CDialog)
 	//{{AFX_MSG_MAP(CGUILayerTrigger)
 	ON_EN_CHANGE(IDC_TRIGGER_HEIGHT, OnParamChange)
 	ON_EN_CHANGE(IDC_TRIGGER_WIDTH, OnParamChange)
+	ON_EN_CHANGE(IDC_TRIGGER_TARGETX, OnParamChange)
+	ON_EN_CHANGE(IDC_TRIGGER_TARGETY, OnParamChange)
 	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()
 

Utils/MapEdit/GUILayerTrigger.h

@@ -19,6 +19,11 @@ public:
 // Dialog Data
 	//{{AFX_DATA(CGUILayerTrigger)
 	enum { IDD = IDD_LAYER_TRIGGER };
+	CStatic	m_TargetTxt;
+	CSpinButtonCtrl	m_TargetYSpin;
+	CSpinButtonCtrl	m_TargetXSpin;
+	CEdit	m_TargetY;
+	CEdit	m_TargetX;
 	CSpinButtonCtrl	m_WidthSpin;
 	CSpinButtonCtrl	m_HeightSpin;
 	CEdit	m_Width;

Utils/MapEdit/GUINewMap.cpp

@@ -30,9 +30,9 @@ void CGUINewMap::DoDataExchange(CDataExchange* pDX)
 	CDialog::DoDataExchange(pDX);
 	//{{AFX_DATA_MAP(CGUINewMap)
 	DDX_Text(pDX, IDC_MAPSIZE_HEIGHT, m_Height);
-	DDV_MinMaxUInt(pDX, m_Height, 24, 1024);
+	DDV_MinMaxUInt(pDX, m_Height, 24, 32000);
 	DDX_Text(pDX, IDC_MAPSIZE_WIDTH, m_Width);
-	DDV_MinMaxUInt(pDX, m_Width, 34, 1024);
+	DDV_MinMaxUInt(pDX, m_Width, 34, 32000);
 	//}}AFX_DATA_MAP
 }
 

Utils/MapEdit/Layer.cpp

@@ -26,6 +26,7 @@
 #include	"LayerPlatform.h"
 #include	"LayerTrigger.h"
 #include	"LayerFX.h"
+#include	"LayerHazard.h"
 
 #include	"LayerDef.h"
 #include	"Utils.h"
@@ -45,6 +46,7 @@ sLayerInfoTable	CLayer::InfoTable[]=
 	{LAYER_TYPE_PLATFORM,	LAYER_SUBTYPE_NONE,		"Platform",		true,	1.0f,	false,	true,		true,	LAYER_SUBVIEW_NONE,},
 	{LAYER_TYPE_TRIGGER,	LAYER_SUBTYPE_NONE,		"Trigger",		true,	1.0f,	false,	true,		true,	LAYER_SUBVIEW_NONE,},
 	{LAYER_TYPE_FX,			LAYER_SUBTYPE_NONE,		"FX",			true,	1.0f,	false,	true,		true,	LAYER_SUBVIEW_NONE,},
+	{LAYER_TYPE_HAZARD,		LAYER_SUBTYPE_NONE,		"Hazard",		true,	1.0f,	false,	true,		true,	LAYER_SUBVIEW_NONE,},
 };
 
 int		CLayer::InfoTableSize=sizeof(InfoTable)/sizeof(sLayerInfoTable);
@@ -100,6 +102,9 @@ CLayer	*New;
 		case LAYER_TYPE_FX:
 			New=new CLayerFX(Def);
 			break;
+		case LAYER_TYPE_HAZARD:
+			New=new CLayerHazard(Def);
+			break;
 		default:
 			ASSERT(!"Unknown Layer");
 		}
@@ -140,6 +145,9 @@ CLayer	*New;
 			case LAYER_TYPE_FX:
 				New=new CLayerFX(File,Version);
 				break;
+			case LAYER_TYPE_HAZARD:
+				New=new CLayerHazard(File,Version);
+				break;
 			default:
 				ASSERT(!"Unknown Layer");
 			}
@@ -195,6 +203,7 @@ Vector3		&Scale=Core->GetScaleVector();
 float		Col;
 const float	OverVal=0.1f;
 
+		if (GetType()>LAYER_TYPE_COLLISION) return;
 		glMatrixMode(GL_MODELVIEW);
 		glPushMatrix();
 		glLoadIdentity();

Utils/MapEdit/LayerActor.cpp

@@ -40,6 +40,31 @@ void	CLayerActor::InitSubView(CCore *Core)
 {
 }
 
+/*****************************************************************************/
+void	CLayerActor::LoadDefThing(const char *Name,sLayerThing &ThisDef)
+{
+		ThisDef.Data.Actor.ActorSpeed=ThingScript.GetInt(Name,"Speed");
+		ThisDef.Data.Actor.ActorTurnRate=ThingScript.GetInt(Name,"TurnRate");
+		ThisDef.Data.Actor.ActorHealth=ThingScript.GetInt(Name,"Health");
+		ThisDef.Data.Actor.ActorAttackStrength=ThingScript.GetInt(Name,"AttackStrength");
+		ThisDef.Data.Actor.ActorCollisionFlag=ThingScript.GetInt(Name,"Collision")==1;
+}
+
+/*****************************************************************************/
+void	CLayerActor::LoadOldThing(CFile *File,sLayerThing &ThisThing)
+{
+sLayerThingDataOLD	OldThing;
+
+		File->Read(&OldThing,sizeof(sLayerThingDataOLD));
+
+		ThisThing.Data.Actor.ActorSpeed=OldThing.Speed;
+		ThisThing.Data.Actor.ActorTurnRate=OldThing.TurnRate;
+		ThisThing.Data.Actor.ActorHealth=OldThing.Health;
+		ThisThing.Data.Actor.ActorAttackStrength=OldThing.AttackStrength;
+		ThisThing.Data.Actor.ActorCollisionFlag=OldThing.CollisionFlag;
+
+}
+
 /*****************************************************************************/
 /*** Gui *********************************************************************/
 /*****************************************************************************/
@@ -101,12 +126,13 @@ void	CLayerActor::GUIThingUpdate(bool OnlySel)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			GUIActor.SetVal(GUIActor.m_Speed,ThisThing.Data.Speed);
+			GUIActor.SetVal(GUIActor.m_Speed,ThisThing.Data.Actor.ActorSpeed);
-			GUIActor.SetVal(GUIActor.m_TurnRate,ThisThing.Data.TurnRate);
+			GUIActor.SetVal(GUIActor.m_TurnRate,ThisThing.Data.Actor.ActorTurnRate);
-			GUIActor.SetVal(GUIActor.m_Health,ThisThing.Data.Health);
+			GUIActor.SetVal(GUIActor.m_Health,ThisThing.Data.Actor.ActorHealth);
-			GUIActor.SetVal(GUIActor.m_Attack,ThisThing.Data.AttackStrength);
+			GUIActor.SetVal(GUIActor.m_Attack,ThisThing.Data.Actor.ActorAttackStrength);
-			GUIActor.m_Collision.SetCheck(ThisThing.Data.CollisionFlag);
+			GUIActor.m_Collision.SetCheck(ThisThing.Data.Actor.ActorCollisionFlag);
-			GUIActor.m_Player.SetCheck(ThisThing.Data.PlayerFlag);
+			bool	IsPlayer=ThingScript.GetInt(ThisThing.Name,"Player")==1;
+			GUIActor.m_Player.SetCheck(IsPlayer);
 		}
 		else
 		{
@@ -132,12 +158,11 @@ void	CLayerActor::GUIChanged(CCore *Core)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			ThisThing.Data.Speed=GUIActor.GetVal(GUIActor.m_Speed);
+			ThisThing.Data.Actor.ActorSpeed=GUIActor.GetVal(GUIActor.m_Speed);
-			ThisThing.Data.TurnRate=GUIActor.GetVal(GUIActor.m_TurnRate);
+			ThisThing.Data.Actor.ActorTurnRate=GUIActor.GetVal(GUIActor.m_TurnRate);
-			ThisThing.Data.Health=GUIActor.GetVal(GUIActor.m_Health);
+			ThisThing.Data.Actor.ActorHealth=GUIActor.GetVal(GUIActor.m_Health);
-			ThisThing.Data.AttackStrength=GUIActor.GetVal(GUIActor.m_Attack);
+			ThisThing.Data.Actor.ActorAttackStrength=GUIActor.GetVal(GUIActor.m_Attack);
-			ThisThing.Data.CollisionFlag=GUIActor.m_Collision.GetCheck()!=0;
+			ThisThing.Data.Actor.ActorCollisionFlag=GUIActor.m_Collision.GetCheck()!=0;
-			ThisThing.Data.PlayerFlag=GUIActor.m_Player.GetCheck()!=0;
 		}
 
 }

Utils/MapEdit/LayerActor.h

@@ -21,6 +21,9 @@ public:
 		void			InitLayer(sLayerDef &Def);
 		void			InitSubView(CCore *Core);
 
+		void			LoadDefThing(const char *Name,sLayerThing &ThisDef);
+		void			LoadOldThing(CFile *File,sLayerThing &ThisThing);
+
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);

Utils/MapEdit/LayerDef.h

@@ -19,6 +19,7 @@ enum LAYER_TYPE
 	LAYER_TYPE_PLATFORM,
 	LAYER_TYPE_TRIGGER,
 	LAYER_TYPE_FX,
+	LAYER_TYPE_HAZARD,
 	LAYER_TYPE_MAX
 };
 

Utils/MapEdit/LayerFX.cpp

@@ -40,6 +40,22 @@ void	CLayerFX::InitSubView(CCore *Core)
 {
 }
 
+/*****************************************************************************/
+void	CLayerFX::LoadDefThing(const char *Name,sLayerThing &ThisDef)
+{
+}
+
+/*****************************************************************************/
+void	CLayerFX::LoadOldThing(CFile *File,sLayerThing &ThisThing)
+{
+sLayerThingDataOLD	OldThing;
+
+		File->Read(&OldThing,sizeof(sLayerThingDataOLD));
+		ThisThing.Data.FX.FXSpeed=OldThing.Speed;
+		ThisThing.Data.FX.FXWidth=OldThing.Width;
+		ThisThing.Data.FX.FXHeight=OldThing.Height;
+}
+
 /*****************************************************************************/
 void	CLayerFX::RenderThing(CCore *Core,Vector3 &ThisCam,sLayerThing &ThisThing,bool Render3d,bool Selected)
 {
@@ -71,8 +87,8 @@ float		Col=0.8f,A=0.8f;
 			Core->RenderNumber(0);
 			glEnable(GL_DEPTH_TEST);
 
-float	W=(ThisThing.Data.Width);
+float	W=(ThisThing.Data.FX.FXWidth);
-float	H=-(ThisThing.Data.Height);
+float	H=-(ThisThing.Data.FX.FXHeight);
 // Draw Box
 			glBegin (GL_QUADS);
 				glColor4f(0,0,Col-0.25f,A);
@@ -162,9 +178,9 @@ void	CLayerFX::GUIThingUpdate(bool OnlySel)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			GUIFX.SetVal(GUIFX.m_Speed,ThisThing.Data.Speed);
+			GUIFX.SetVal(GUIFX.m_Speed,ThisThing.Data.FX.FXSpeed);
-			GUIFX.SetVal(GUIFX.m_Width,ThisThing.Data.Width);
+			GUIFX.SetVal(GUIFX.m_Width,ThisThing.Data.FX.FXWidth);
-			GUIFX.SetVal(GUIFX.m_Height,ThisThing.Data.Height);
+			GUIFX.SetVal(GUIFX.m_Height,ThisThing.Data.FX.FXHeight);
 		}
 		else
 		{
@@ -186,9 +202,9 @@ void	CLayerFX::GUIChanged(CCore *Core)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			ThisThing.Data.Speed=GUIFX.GetVal(GUIFX.m_Speed);
+			ThisThing.Data.FX.FXSpeed=GUIFX.GetVal(GUIFX.m_Speed);
-			ThisThing.Data.Width=GUIFX.GetVal(GUIFX.m_Width);
+			ThisThing.Data.FX.FXWidth=GUIFX.GetVal(GUIFX.m_Width);
-			ThisThing.Data.Height=GUIFX.GetVal(GUIFX.m_Height);
+			ThisThing.Data.FX.FXHeight=GUIFX.GetVal(GUIFX.m_Height);
 		}
 }
 
@@ -196,6 +212,6 @@ void	CLayerFX::GUIChanged(CCore *Core)
 void	CLayerFX::SetThingParams(sLayerThing &Thing)
 {
 		Thing.Data.WaypointCount=1;
-		if (Thing.Data.Width<1) Thing.Data.Width=1;
+		if (Thing.Data.FX.FXWidth<1) Thing.Data.FX.FXWidth=1;
-		if (Thing.Data.Height<1) Thing.Data.Height=1;
+		if (Thing.Data.FX.FXHeight<1) Thing.Data.FX.FXHeight=1;
 }

Utils/MapEdit/LayerFX.h

@@ -22,6 +22,9 @@ public:
 		void			InitLayer(sLayerDef &Def);
 		void			InitSubView(CCore *Core);
 
+		void			LoadDefThing(const char *Name,sLayerThing &ThisDef);
+		void			LoadOldThing(CFile *File,sLayerThing &ThisThing);
+
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);

Utils/MapEdit/LayerHazard.cpp

@@ -1,6 +1,6 @@
-/*******************/
+/********************/
-/*** Layer Actor ***/
+/*** Layer Hazard ***/
-/*******************/
+/********************/
 
 #include	"stdafx.h"
 #include	<Vector3.h>
@@ -15,64 +15,92 @@
 
 #include	"Core.h"
 #include	"LayerThing.h"
-#include	"LayerActor.h"
+#include	"LayerHazard.h"
 #include	"Utils.h"
 #include	"Export.h"
 
 /*****************************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
-CLayerActor::CLayerActor(sLayerDef &Def)
+CLayerHazard::CLayerHazard(sLayerDef &Def)
 {
 		InitLayer(Def);
 }
 
 /*****************************************************************************/
-void	CLayerActor::InitLayer(sLayerDef &Def)
+void	CLayerHazard::InitLayer(sLayerDef &Def)
 {
 		ThingBank=new CElemBank(-1,-1,false,CElem::CentreModeLR | CElem::CentreModeB);
 		CLayerThing::InitLayer(Def);
-		LoadThingScript(theApp.GetConfigStr("LayerScript","ActorScript"));
+		LoadThingScript(theApp.GetConfigStr("LayerScript","HazardScript"));
 }
 
 /*****************************************************************************/
-void	CLayerActor::InitSubView(CCore *Core)
+void	CLayerHazard::InitSubView(CCore *Core)
 {
 }
 
+/*****************************************************************************/
+void	CLayerHazard::LoadDefThing(const char *Name,sLayerThing &ThisDef)
+{
+		ThisDef.Data.Hazard.HazardSpeed=ThingScript.GetInt(Name,"Speed");
+		ThisDef.Data.Hazard.HazardTurnRate=ThingScript.GetInt(Name,"TurnRate");
+		ThisDef.Data.Hazard.HazardHealth=ThingScript.GetInt(Name,"Health");
+		ThisDef.Data.Hazard.HazardAttackStrength=ThingScript.GetInt(Name,"AttackStrength");
+		ThisDef.Data.Hazard.HazardRespawn=ThingScript.GetInt(Name,"Respawn");
+		ThisDef.Data.Hazard.HazardCollisionFlag=ThingScript.GetInt(Name,"Collision")==1;
+
+}
+
+/*****************************************************************************/
+void	CLayerHazard::LoadOldThing(CFile *File,sLayerThing &ThisThing)
+{
+sLayerThingDataOLD	OldThing;
+
+		File->Read(&OldThing,sizeof(sLayerThingDataOLD));
+		ThisThing.Data.Hazard.HazardSpeed=OldThing.Speed;
+		ThisThing.Data.Hazard.HazardTurnRate=OldThing.TurnRate;
+		ThisThing.Data.Hazard.HazardHealth=OldThing.Health;
+		ThisThing.Data.Hazard.HazardAttackStrength=OldThing.AttackStrength;
+		ThisThing.Data.Hazard.HazardRespawn=OldThing.Speed;
+		ThisThing.Data.Hazard.HazardCollisionFlag=OldThing.CollisionFlag;
+}
+
+
 /*****************************************************************************/
 /*** Gui *********************************************************************/
 /*****************************************************************************/
-void	CLayerActor::GUIInit(CCore *Core)
+void	CLayerHazard::GUIInit(CCore *Core)
 {
-		GUIActor.DisableCallback(true);
+		GUIHazard.DisableCallback(true);
 		Core->GUIAdd(GUIThing,IDD_LAYER_THING);
 		Core->GUIAdd(GUIThingPos,IDD_LAYER_THING_POS);
-		Core->GUIAdd(GUIActor,IDD_LAYER_ACTOR);
+		Core->GUIAdd(GUIHazard,IDD_LAYER_HAZARD);
-		GUIActor.DisableCallback(false);
+		GUIHazard.DisableCallback(false);
 
-		GUIActor.m_HealthSpin.SetRange(0,255);
+		GUIHazard.m_HealthSpin.SetRange(0,255);
-		GUIActor.m_AttackSpin.SetRange(0,255);
+		GUIHazard.m_AttackSpin.SetRange(0,255);
-		GUIActor.m_SpeedSpin.SetRange(0,255);
+		GUIHazard.m_SpeedSpin.SetRange(0,255);
-		GUIActor.m_TurnRateSpin.SetRange(0,255);
+		GUIHazard.m_TurnRateSpin.SetRange(0,255);
+		GUIHazard.m_RespawnSpin.SetRange(0,255);
 
 }
 
 /*****************************************************************************/
-void	CLayerActor::GUIKill(CCore *Core)
+void	CLayerHazard::GUIKill(CCore *Core)
 {
 		Core->GUIRemove(GUIThing,IDD_LAYER_THING);
 		Core->GUIRemove(GUIThingPos,IDD_LAYER_THING_POS);
-		Core->GUIRemove(GUIActor,IDD_LAYER_ACTOR);
+		Core->GUIRemove(GUIHazard,IDD_LAYER_HAZARD);
 }
 
 /*****************************************************************************/
-void	CLayerActor::GUIUpdate(CCore *Core)
+void	CLayerHazard::GUIUpdate(CCore *Core)
 {
 int			i,ListSize;
 CComboBox	&List=GUIThing.m_DefList;
 
-// Setup Def Actor List
+// Setup Def Hazard List
 		ListSize=DefList.size();
 		List.ResetContent();
 		for (i=0; i<ListSize; i++)
@@ -85,7 +113,7 @@ CComboBox	&List=GUIThing.m_DefList;
 }
 
 /*****************************************************************************/
-void	CLayerActor::GUIThingDefClear()
+void	CLayerHazard::GUIThingDefClear()
 {
 CComboBox	&List=GUIThing.m_DefList;
 		CurrentDefThing=-1;
@@ -93,51 +121,48 @@ CComboBox	&List=GUIThing.m_DefList;
 }
 
 /*****************************************************************************/
-void	CLayerActor::GUIThingUpdate(bool OnlySel)
+void	CLayerHazard::GUIThingUpdate(bool OnlySel)
 {
 		GUIThingUpdateList(GUIThing.m_List,false);
 // Params
-		GUIActor.DisableCallback(true);
+		GUIHazard.DisableCallback(true);
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			GUIActor.SetVal(GUIActor.m_Speed,ThisThing.Data.Speed);
+			GUIHazard.SetVal(GUIHazard.m_Speed,ThisThing.Data.Hazard.HazardSpeed);
-			GUIActor.SetVal(GUIActor.m_TurnRate,ThisThing.Data.TurnRate);
+			GUIHazard.SetVal(GUIHazard.m_TurnRate,ThisThing.Data.Hazard.HazardTurnRate);
-			GUIActor.SetVal(GUIActor.m_Health,ThisThing.Data.Health);
+			GUIHazard.SetVal(GUIHazard.m_Health,ThisThing.Data.Hazard.HazardHealth);
-			GUIActor.SetVal(GUIActor.m_Attack,ThisThing.Data.AttackStrength);
+			GUIHazard.SetVal(GUIHazard.m_Attack,ThisThing.Data.Hazard.HazardAttackStrength);
-			GUIActor.m_Collision.SetCheck(ThisThing.Data.CollisionFlag);
+			GUIHazard.m_Collision.SetCheck(ThisThing.Data.Hazard.HazardCollisionFlag);
-			GUIActor.m_Player.SetCheck(ThisThing.Data.PlayerFlag);
 		}
 		else
 		{
-			GUIActor.m_Speed.SetWindowText("");
+			GUIHazard.m_Speed.SetWindowText("");
-			GUIActor.m_TurnRate.SetWindowText("");
+			GUIHazard.m_TurnRate.SetWindowText("");
-			GUIActor.m_Health.SetWindowText("");
+			GUIHazard.m_Health.SetWindowText("");
-			GUIActor.m_Attack.SetWindowText("");
+			GUIHazard.m_Attack.SetWindowText("");
-			GUIActor.m_Collision.SetCheck(false);
+			GUIHazard.m_Collision.SetCheck(false);
-			GUIActor.m_Player.SetCheck(false);
 		}
-		GUIActor.DisableCallback(false);
+		GUIHazard.DisableCallback(false);
 }
 
 /*****************************************************************************/
-void	CLayerActor::GUIThingPointUpdate(bool OnlySel)
+void	CLayerHazard::GUIThingPointUpdate(bool OnlySel)
 {
 		GUIThingPointUpdateList(GUIThingPos.m_List,OnlySel);
 }
 
 /*****************************************************************************/
-void	CLayerActor::GUIChanged(CCore *Core)
+void	CLayerHazard::GUIChanged(CCore *Core)
 {
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			ThisThing.Data.Speed=GUIActor.GetVal(GUIActor.m_Speed);
+			ThisThing.Data.Hazard.HazardSpeed=GUIHazard.GetVal(GUIHazard.m_Speed);
-			ThisThing.Data.TurnRate=GUIActor.GetVal(GUIActor.m_TurnRate);
+			ThisThing.Data.Hazard.HazardTurnRate=GUIHazard.GetVal(GUIHazard.m_TurnRate);
-			ThisThing.Data.Health=GUIActor.GetVal(GUIActor.m_Health);
+			ThisThing.Data.Hazard.HazardHealth=GUIHazard.GetVal(GUIHazard.m_Health);
-			ThisThing.Data.AttackStrength=GUIActor.GetVal(GUIActor.m_Attack);
+			ThisThing.Data.Hazard.HazardAttackStrength=GUIHazard.GetVal(GUIHazard.m_Attack);
-			ThisThing.Data.CollisionFlag=GUIActor.m_Collision.GetCheck()!=0;
+			ThisThing.Data.Hazard.HazardCollisionFlag=GUIHazard.m_Collision.GetCheck()!=0;
-			ThisThing.Data.PlayerFlag=GUIActor.m_Player.GetCheck()!=0;
 		}
 
 }

Utils/MapEdit/LayerHazard.h

@@ -1,26 +1,29 @@
-/*******************/
+/********************/
-/*** Layer Actor ***/
+/*** Layer Hazard ***/
-/*******************/
+/********************/
 
-#ifndef	__LAYER_ACTOR_HEADER__
+#ifndef	__LAYER_HAZARD_HEADER__
-#define	__LAYER_ACTOR_HEADER__
+#define	__LAYER_HAZARD_HEADER__
 
 #include	"LayerThing.h"
 #include	"Layer.h"
 #include	"MapEdit.h"
-#include	"GUILayerActor.h"
+#include	"GUILayerHazard.h"
 #include	"Elem.h"
 
 /*****************************************************************************/
-class	CLayerActor : public CLayerThing
+class	CLayerHazard : public CLayerThing
 {
 public:
-		CLayerActor(sLayerDef &Def);
+		CLayerHazard(sLayerDef &Def);
-		CLayerActor(CFile *File,int Version)	{Load(File,Version);}
+		CLayerHazard(CFile *File,int Version)	{Load(File,Version);}
 
 		void			InitLayer(sLayerDef &Def);
 		void			InitSubView(CCore *Core);
 
+		void			LoadDefThing(const char *Name,sLayerThing &ThisDef);
+		void			LoadOldThing(CFile *File,sLayerThing &ThisThing);
+
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);
@@ -32,7 +35,7 @@ public:
 		void			GUIThingPointUpdate(bool OnlySel=false);
 
 protected:
-		CGUILayerActor		GUIActor;
+		CGUILayerHazard		GUIHazard;
 
 };
 

Utils/MapEdit/LayerItem.cpp

@@ -42,6 +42,20 @@ void	CLayerItem::InitSubView(CCore *Core)
 {
 }
 
+/*****************************************************************************/
+void	CLayerItem::LoadDefThing(const char *Name,sLayerThing &ThisDef)
+{
+}
+
+/*****************************************************************************/
+void	CLayerItem::LoadOldThing(CFile *File,sLayerThing &ThisThing)
+{
+sLayerThingDataOLD	OldThing;
+
+		File->Read(&OldThing,sizeof(sLayerThingDataOLD));
+}
+
+
 /*****************************************************************************/
 /*** Gui *********************************************************************/
 /*****************************************************************************/

Utils/MapEdit/LayerItem.h

@@ -20,6 +20,9 @@ public:
 		void			InitLayer(sLayerDef &Def);
 		void			InitSubView(CCore *Core);
 
+		void			LoadDefThing(const char *Name,sLayerThing &ThisDef);
+		void			LoadOldThing(CFile *File,sLayerThing &ThisThing);
+
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);

Utils/MapEdit/LayerPlatform.cpp

@@ -40,6 +40,28 @@ void	CLayerPlatform::InitSubView(CCore *Core)
 {
 }
 
+/*****************************************************************************/
+void	CLayerPlatform::LoadDefThing(const char *Name,sLayerThing &ThisDef)
+{
+}
+
+/*****************************************************************************/
+void	CLayerPlatform::LoadOldThing(CFile *File,sLayerThing &ThisThing)
+{
+sLayerThingDataOLD	OldThing;
+
+		File->Read(&OldThing,sizeof(sLayerThingDataOLD));
+		ThisThing.Data.Platform.PlatformSpeed=OldThing.Speed;
+		ThisThing.Data.Platform.PlatformTurnRate=OldThing.TurnRate;
+		ThisThing.Data.Platform.PlatformType=OldThing.PlatformType;
+		ThisThing.Data.Platform.PlatformMoveType=OldThing.MoveType;
+		ThisThing.Data.Platform.PlatformCollisionFlag=OldThing.CollisionFlag;
+		ThisThing.Data.Platform.PlatformTriCount=OldThing.TriCount;	// Not needed but what the hell!!
+		ThisThing.Data.Platform.PlatformTriStart=OldThing.TriStart;	// Not needed but what the hell!!
+
+}
+
+
 /*****************************************************************************/
 /*** Gui *********************************************************************/
 /*****************************************************************************/
@@ -112,11 +134,11 @@ void	CLayerPlatform::GUIThingUpdate(bool OnlySel)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			GUIPlatform.SetVal(GUIPlatform.m_Speed,ThisThing.Data.Speed);
+			GUIPlatform.SetVal(GUIPlatform.m_Speed,ThisThing.Data.Platform.PlatformSpeed);
-			GUIPlatform.SetVal(GUIPlatform.m_TurnRate,ThisThing.Data.TurnRate);
+			GUIPlatform.SetVal(GUIPlatform.m_TurnRate,ThisThing.Data.Platform.PlatformTurnRate);
-			GUIPlatform.m_Collision.SetCheck(ThisThing.Data.CollisionFlag);
+			GUIPlatform.m_Collision.SetCheck(ThisThing.Data.Platform.PlatformCollisionFlag);
-			GUIPlatform.m_MoveList.SetCurSel(ThisThing.Data.MoveType);
+			GUIPlatform.m_MoveList.SetCurSel(ThisThing.Data.Platform.PlatformMoveType);
-			GUIPlatform.m_Type.SetCurSel(ThisThing.Data.PlatformType);
+			GUIPlatform.m_Type.SetCurSel(ThisThing.Data.Platform.PlatformType);
 		}
 		else
 		{
@@ -141,11 +163,11 @@ void	CLayerPlatform::GUIChanged(CCore *Core)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			ThisThing.Data.Speed=GUIPlatform.GetVal(GUIPlatform.m_Speed);
+			ThisThing.Data.Platform.PlatformSpeed=GUIPlatform.GetVal(GUIPlatform.m_Speed);
-			ThisThing.Data.TurnRate=GUIPlatform.GetVal(GUIPlatform.m_TurnRate);
+			ThisThing.Data.Platform.PlatformTurnRate=GUIPlatform.GetVal(GUIPlatform.m_TurnRate);
-			ThisThing.Data.CollisionFlag=GUIPlatform.m_Collision.GetCheck()!=0;
+			ThisThing.Data.Platform.PlatformCollisionFlag=GUIPlatform.m_Collision.GetCheck()!=0;
-			ThisThing.Data.MoveType=GUIPlatform.m_MoveList.GetCurSel();
+			ThisThing.Data.Platform.PlatformMoveType=GUIPlatform.m_MoveList.GetCurSel();
-			ThisThing.Data.PlatformType=GUIPlatform.m_Type.GetCurSel();
+			ThisThing.Data.Platform.PlatformType=GUIPlatform.m_Type.GetCurSel();
 			SetThingParams(ThisThing);
 		}
 }
@@ -153,7 +175,7 @@ void	CLayerPlatform::GUIChanged(CCore *Core)
 /*****************************************************************************/
 void	CLayerPlatform::SetThingParams(sLayerThing &Thing)
 {
-		switch(Thing.Data.MoveType)
+		switch(Thing.Data.Platform.PlatformMoveType)
 		{
 			case MoveTypeLinear:
 				Thing.Data.WaypointCount=16;
@@ -181,6 +203,6 @@ void	CLayerPlatform::ExportThingData(CCore *Core,CExport &Exp,sLayerThing &ThisT
 {
 CElem	&ThisElem=ThingBank->GetElem(ThisThing.ElemID,0);
 
-		Exp.ExportElem3d(Core,ThisElem,OutThing.TriStart,OutThing.TriCount);
+		Exp.ExportElem3d(Core,ThisElem,OutThing.Platform.PlatformTriStart,OutThing.Platform.PlatformTriCount);
 		
 }

Utils/MapEdit/LayerPlatform.h

@@ -28,6 +28,9 @@ public:
 		void			InitLayer(sLayerDef &Def);
 		void			InitSubView(CCore *Core);
 
+		void			LoadDefThing(const char *Name,sLayerThing &ThisDef);
+		void			LoadOldThing(CFile *File,sLayerThing &ThisThing);
+
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);

Utils/MapEdit/LayerShade.cpp

@@ -21,6 +21,7 @@
 #include	"Select.h"
 #include	"Export.h"
 #include	"GUILayerShade.h"
+#include	"Elem.h"
 
 
 /*****************************************************************************/
@@ -30,101 +31,146 @@
 CLayerShade::CLayerShade(sLayerDef &Def)
 {
 		InitLayer(Def);
-// Load script (messy)
 GString	ExecPath;
 GString	ScriptName;
 
-		GetExecPath(ExecPath);
+		GfxBank=new CElemBank(-1,-1,false,CElem::CentreModeLR | CElem::CentreModeTB);
-		ScriptName=ExecPath+theApp.GetConfigStr("LayerScript","BackGfxScript");
+		LoadGfx();
-		Script.LoadAndImport(ScriptName);
+		Cursor.Gfx=-1;
+		Cursor.Ofs[0].x=-2;	Cursor.Ofs[0].y=-2;
+		Cursor.Ofs[1].x=+2;	Cursor.Ofs[1].y=-2;
+		Cursor.Ofs[2].x=-2;	Cursor.Ofs[2].y=+2;
+		Cursor.Ofs[3].x=+2;	Cursor.Ofs[3].y=+2;
+		Cursor.TransMode=0;
 
-int		i,ListSize=Script.GetGroupCount();
+		for(int i=0; i<4; i++)
-		BackGfx.resize(ListSize);
-
-		for (i=0; i<ListSize; i++)
 		{
-			BackGfx[i]=Script.GetGroupName(i);
+			Cursor.RGB[i].R=Cursor.RGB[i].G=Cursor.RGB[i].B=255;
-			TRACE1("%s\n",BackGfx[i]);
 		}
-		Back0=Back1=-1;
+		CurrentGfx=-1;
-		TransMode0=TransMode1=0;
-		Flags0=Flags1=-1;
 }
 
 
 /*****************************************************************************/
 CLayerShade::~CLayerShade()
 {
+		GfxBank->CleanUp();
+		delete GfxBank;
+}
+
+/*****************************************************************************/
+void	CLayerShade::LoadGfx()
+{
+GString	ExecPath;
+GString	ScriptName;
+		GetExecPath(ExecPath);
+		ScriptName=ExecPath+theApp.GetConfigStr("LayerScript","BackGfxScript");
+		Script.LoadAndImport(ScriptName);
+
+int		i,ListSize=Script.GetGroupCount();
+		BankList.resize(ListSize);
+
+		for (i=0; i<ListSize; i++)
+		{
+			sBackList	&ThisGfx=BankList[i];
+
+			char	*Name=Script.GetGroupName(i);
+			char	*Gfx=Script.GetStr(Name,"gfx");
+
+			ThisGfx.Name=Name;
+			if (Gfx) 
+			{
+				char	Filename[512];
+				GFName::makeabsolute(ExecPath,Gfx,Filename);
+				ThisGfx.ElemID=GfxBank->AddSet(Filename);
+			}
+		}
 }
 
 /*****************************************************************************/
 void	CLayerShade::InitLayer(sLayerDef &Def)
 {
 		CLayer::InitLayer(Def);
-		LayerDef.Width=TileLayerMinWidth+(Def.Width-TileLayerMinWidth)/GetScaleFactor();
+//		LayerDef.Width=TileLayerMinWidth+(Def.Width-TileLayerMinWidth)/GetScaleFactor();
-		LayerDef.Height=TileLayerMinHeight+(Def.Height-TileLayerMinHeight)/GetScaleFactor();
+//		LayerDef.Height=TileLayerMinHeight+(Def.Height-TileLayerMinHeight)/GetScaleFactor();
 
-		RGB[0].rgbRed=255;	RGB[0].rgbGreen=255;	RGB[0].rgbBlue=255;
+		ShadeRGB[0].R=255;	ShadeRGB[0].G=255;	ShadeRGB[0].B=255;
-		RGB[1].rgbRed=255;	RGB[1].rgbGreen=0;		RGB[1].rgbBlue=0;
+		ShadeRGB[1].R=255;	ShadeRGB[1].G=0;		ShadeRGB[1].B=0;
-		RGB[2].rgbRed=0;	RGB[2].rgbGreen=255;	RGB[2].rgbBlue=0;
+		ShadeRGB[2].R=0;	ShadeRGB[2].G=255;	ShadeRGB[2].B=0;
-		RGB[3].rgbRed=0;	RGB[3].rgbGreen=0;		RGB[3].rgbBlue=255;
+		ShadeRGB[3].R=0;	ShadeRGB[3].G=0;		ShadeRGB[3].B=255;
-		Count=2;
+
+		ShadeCount=2;
 
 }
 /*****************************************************************************/
 void	CLayerShade::Load(CFile *File,int Version)
 {
-		if (Version<=5)
+int		i;
-		{
-			BOOL	DB;
-			float	DF;
-			LayerDef.Type=LAYER_TYPE_SHADE;
-			File->Read(&DB,sizeof(BOOL));
-			File->Read(&DF,sizeof(float));
-			File->Read(&DB,sizeof(BOOL));
-			File->Read(&LayerDef.VisibleFlag,sizeof(BOOL));
-			File->Read(&LayerDef.SubType,sizeof(int));
-			File->Read(&LayerDef.Width,sizeof(int));
-			File->Read(&LayerDef.Height,sizeof(int));
-		}
 		InitLayer(LayerDef);
-		File->Read(&Count,sizeof(int));
+
-		for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
+		File->Read(&ShadeCount,sizeof(int));
+		
+		if (Version<9)
+		{ // GOD I HATE FILE VERSIONS NOW!!
+			int		DummyInt;
+
+			for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
 			{
-			File->Read(&Pos[i],sizeof(int));
+				RGBQUAD	RGB;
-			File->Read(&RGB[i],sizeof(RGBQUAD));
+				File->Read(&DummyInt,sizeof(int));
+				File->Read(&RGB,sizeof(RGBQUAD));
+				ShadeRGB[i].R=RGB.rgbRed;
+				ShadeRGB[i].G=RGB.rgbGreen;
+				ShadeRGB[i].B=RGB.rgbBlue;
 			}
-		if (Version>=7)
+			File->Read(&DummyInt,sizeof(int));
+			File->Read(&DummyInt,sizeof(int));
+			if (Version==8)
 			{
-			File->Read(&Back0,sizeof(int));
+			File->Read(&DummyInt,sizeof(int));
-			File->Read(&Back1,sizeof(int));
+			File->Read(&DummyInt,sizeof(int));
+			File->Read(&DummyInt,sizeof(int));
+			File->Read(&DummyInt,sizeof(int));
 			}
-		if (Version>=8)
+		}
+		else
 		{
-			File->Read(&TransMode0,sizeof(int));
+			int	GfxCount;
-			File->Read(&Flags0,sizeof(int));
+			for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
-			File->Read(&TransMode1,sizeof(int));
+			{
-			File->Read(&Flags1,sizeof(int));
+				File->Read(&ShadeRGB[i],sizeof(sRGBCol));
+			}
+// Load GfxList
+			File->Read(&GfxCount,sizeof(int));
+			GfxList.resize(GfxCount);
+
+			for (i=0; i<GfxCount; i++)
+			{
+				sLayerShadeGfx	&ThisGfx=GfxList[i];
+				File->Read(&ThisGfx,sizeof(sLayerShadeGfx));
 			}
 
 		}
+}
 
 /*****************************************************************************/
 void	CLayerShade::Save(CFile *File)
 {
 // Always Save current version
-		File->Write(&Count,sizeof(int));
+		File->Write(&ShadeCount,sizeof(int));
 		for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
 		{
-			File->Write(&Pos[i],sizeof(int));
+			File->Write(&ShadeRGB[i],sizeof(sRGBCol));
-			File->Write(&RGB[i],sizeof(RGBQUAD));
 		}
-		File->Write(&Back0,sizeof(int));
+		int	GfxCount=GfxList.size();
-		File->Write(&Back1,sizeof(int));
+		File->Write(&GfxCount,sizeof(int));
-		File->Write(&TransMode0,sizeof(int));
+		
-		File->Write(&Flags0,sizeof(int));
+		for (i=0; i<GfxCount; i++)
-		File->Write(&TransMode1,sizeof(int));
+		{
-		File->Write(&Flags1,sizeof(int));
+			sLayerShadeGfx	&ThisGfx=GfxList[i];
+			File->Write(&ThisGfx,sizeof(sLayerShadeGfx));
+		}
+
 }
 
 /*****************************************************************************/
@@ -138,12 +184,12 @@ float		ZoomH=Core->GetZoomH();
 float		ScrOfsX=(ZoomW/2);
 float		ScrOfsY=(ZoomH/2);
 Vector3		&Scale=Core->GetScaleVector();
-int			ThisCount=Count-1;
+int			ThisCount=ShadeCount-1;
 float		X0=0;
 float		X1=LayerDef.Width;
 float		Y=(0+1);
-
 float		YInc=(float)LayerDef.Height/(float)ThisCount;
+int			i,ListSize;
 
 			glMatrixMode(GL_MODELVIEW);
 			glPushMatrix();
@@ -153,159 +199,342 @@ float		YInc=(float)LayerDef.Height/(float)ThisCount;
 			glTranslatef(-ScrOfsX,ScrOfsY,0);	// Bring to top left corner
 
 			glBegin (GL_QUADS);
-			for (int i=0; i<ThisCount; i++)
+			for (i=0; i<ThisCount; i++)
 			{
-					glColor3ub(RGB[i+0].rgbRed,RGB[i+0].rgbGreen,RGB[i+0].rgbBlue);
+					glColor3ub(ShadeRGB[i+0].R,ShadeRGB[i+0].G,ShadeRGB[i+0].B);
 					glVertex3f( X0,Y,0.0f);
 					glVertex3f( X1,Y,0.0f);
 					Y-=YInc;
-					glColor3ub(RGB[i+1].rgbRed,RGB[i+1].rgbGreen,RGB[i+1].rgbBlue);
+					glColor3ub(ShadeRGB[i+1].R,ShadeRGB[i+1].G,ShadeRGB[i+1].B);
 					glVertex3f( X1,Y,0.0f);
 					glVertex3f( X0,Y,0.0f);
 			}
 			glEnd();
 			glPopMatrix();
+// Render Gfx
+		ListSize=GfxList.size();
+		for (i=0; i<ListSize; i++)
+		{
+			sLayerShadeGfx	&ThisGfx=GfxList[i];
+			RenderBackGfx(Core,ThisCam,ThisGfx);
+		}
+
 }
 
 
+/*****************************************************************************/
+void	CLayerShade::RenderCursor(CCore *Core,Vector3 &CamPos,bool Is3d)
+{
+Vector3		ThisCam=Core->OffsetCam(CamPos,GetScaleFactor());
+CPoint		&CursPos=Core->GetCursorPos();
+
+		Cursor.Pos.x=CursPos.x;
+		Cursor.Pos.y=CursPos.y;
+		if (CursPos.x<0 || CursPos.y<0) return;
+		if (Cursor.Gfx==-1) return;
+		RenderBackGfx(Core,ThisCam,Cursor);
+}
+
+/*****************************************************************************/
+void	CLayerShade::RenderBackGfx(CCore *Core,Vector3 &ThisCam,sLayerShadeGfx &ThisGfx)
+{
+float		ZoomW=Core->GetZoomW();
+float		ZoomH=Core->GetZoomH();
+Vector3		&Scale=Core->GetScaleVector();
+Vector3		ScrOfs(ZoomW/2,ZoomH/2,0);
+int			i;
+			if (GfxBank->NeedLoad()) GfxBank->LoadAllSets(Core);
+
+CElem		Elem=GfxBank->GetElem(ThisGfx.Gfx,0);
+
+			glMatrixMode(GL_MODELVIEW);
+			glPushMatrix();
+			glLoadIdentity();
+
+			glScalef(Scale.x,Scale.y,Scale.z);
+			glTranslatef(-ThisCam.x,ThisCam.y,0);					// Set scroll offset
+			glTranslatef(-ScrOfs.x,ScrOfs.y,0);						// Bring to top left corner
+
+			glTranslatef(ThisGfx.Pos.x,-ThisGfx.Pos.y,0);		// Set Pos
+			glColor3ub(255,255,255);
+
+			glEnable(GL_TEXTURE_2D);
+			glBindTexture(GL_TEXTURE_2D, Elem.GetTexID());
+			glBegin (GL_QUADS);
+				i=0; glColor3ub(ThisGfx.RGB[i].R,ThisGfx.RGB[i].G,ThisGfx.RGB[i].B); glTexCoord2f(0.0f,1.0f); glVertex3f(ThisGfx.Ofs[i].x ,-ThisGfx.Ofs[i].y,0.0f);
+				i=1; glColor3ub(ThisGfx.RGB[i].R,ThisGfx.RGB[i].G,ThisGfx.RGB[i].B); glTexCoord2f(1.0f,1.0f); glVertex3f(ThisGfx.Ofs[i].x ,-ThisGfx.Ofs[i].y,0.0f);
+				i=3; glColor3ub(ThisGfx.RGB[i].R,ThisGfx.RGB[i].G,ThisGfx.RGB[i].B); glTexCoord2f(1.0f,0.0f); glVertex3f(ThisGfx.Ofs[i].x ,-ThisGfx.Ofs[i].y,0.0f);
+				i=2; glColor3ub(ThisGfx.RGB[i].R,ThisGfx.RGB[i].G,ThisGfx.RGB[i].B); glTexCoord2f(0.0f,0.0f); glVertex3f(ThisGfx.Ofs[i].x ,-ThisGfx.Ofs[i].y,0.0f);
+			glEnd();
+			glDisable(GL_TEXTURE_2D);
+			glPopMatrix();
+}
+
+/*****************************************************************************/
+void	CLayerShade::CheckLayerSize(int Width,int Height)
+{
+		if (Resize(Width,Height))
+		{
+			CString mexstr;
+			mexstr.Format("%s Layer Resized to Correct Size\nPlease re-save\n", GetName());
+			AfxMessageBox(mexstr,MB_OK | MB_ICONEXCLAMATION);
+		}
+}
+
 /*****************************************************************************/
 bool	CLayerShade::Resize(int Width,int Height)
 {
-		LayerDef.Width=TileLayerMinWidth+(Width-TileLayerMinWidth)/GetScaleFactor();
-		LayerDef.Height=TileLayerMinHeight+(Height-TileLayerMinHeight)/GetScaleFactor();
 
+		Width=TileLayerMinWidth+(Width-TileLayerMinWidth)/GetScaleFactor();
+		Height=TileLayerMinHeight+(Height-TileLayerMinHeight)/GetScaleFactor();
+		if (LayerDef.Width!=Width || LayerDef.Height!=Height)
+		{
+			LayerDef.Width=Width;
+			LayerDef.Height=Height;
 			return(true);
 		}
 
+		return(false);
+}
+
 /*****************************************************************************/
 /*** Gui *********************************************************************/
 /*****************************************************************************/
 void	CLayerShade::GUIInit(CCore *Core)
 {
-		Core->GUIAdd(GUI,IDD_LAYER_SHADE);
+int		i,ListSize;
-		for (int i=0; i<LAYER_SHADE_MAX; i++) 
-		{
-			GUI.SetRGB(RGB[i],i);
-		}
-		GUI.SetCount(Count);
-		InitGfxList();
 
-		if (Flags0 & SpinFlag)	GUI.m_Spin0.SetCheck(true);
+		GUIShade.DisableCallback();
-		if (Flags0 & ScaleFlag)	GUI.m_Scale0.SetCheck(true);
+		Core->GUIAdd(GUIShade,IDD_LAYER_SHADE);
-		if (Flags0 & MoveFlag)	GUI.m_Move0.SetCheck(true);
-		if (Flags0 & ColorFlag)	GUI.m_Color0.SetCheck(true);
 
-		if (Flags1 & SpinFlag)	GUI.m_Spin1.SetCheck(true);
+// Init BankList
-		if (Flags1 & ScaleFlag)	GUI.m_Scale1.SetCheck(true);
+		ListSize=BankList.size();
-		if (Flags1 & MoveFlag)	GUI.m_Move1.SetCheck(true);
+		GUIShade.m_GfxBankList.ResetContent();
-		if (Flags1 & ColorFlag)	GUI.m_Color1.SetCheck(true);
+		GUIShade.m_DefList.ResetContent();
-
-		GUI.m_Trans0.ResetContent();
-		GUI.m_Trans0.AddString("Normal");
-		GUI.m_Trans0.AddString("50%");
-		GUI.m_Trans0.AddString("Subtractive");
-		GUI.m_Trans0.AddString("Another one");
-		GUI.m_Trans0.SetCurSel(TransMode0);
-
-		GUI.m_Trans1.ResetContent();
-		GUI.m_Trans1.AddString("Normal");
-		GUI.m_Trans1.AddString("50%");
-		GUI.m_Trans1.AddString("Subtractive");
-		GUI.m_Trans1.AddString("Another one");
-		GUI.m_Trans1.SetCurSel(TransMode1);
-
-		GUI.m_CountSpin.SetRange(1,4);
-
-
-}
-
-/*****************************************************************************/
-void	CLayerShade::InitGfxList()
-{
-int		i,ListSize=BackGfx.size();
-CComboBox	&List0=GUI.m_Gfx0;
-CComboBox	&List1=GUI.m_Gfx1;
-
-		List0.ResetContent();
-		List1.ResetContent();
 		for (i=0; i<ListSize; i++)
 		{
-			List0.AddString(BackGfx[i]);
+			GUIShade.m_GfxBankList.AddString(BankList[i].Name);
-			List1.AddString(BackGfx[i]);
+			GUIShade.m_DefList.AddString(BankList[i].Name);
 		}
-		List0.SetCurSel(Back0);
+
-		List1.SetCurSel(Back1);
+		GUIShade.m_GfxTransList.ResetContent();
+		GUIShade.m_GfxTransList.AddString("Normal");
+		GUIShade.m_GfxTransList.AddString("50%");
+		GUIShade.m_GfxTransList.AddString("Subtractive");
+		GUIShade.m_GfxTransList.AddString("Another one");
+
+		GUIShade.m_GfxSpinx0.SetRange(-32,+32);	GUIShade.m_GfxSpiny0.SetRange(-32,+32);
+		GUIShade.m_GfxSpinx1.SetRange(-32,+32);	GUIShade.m_GfxSpiny1.SetRange(-32,+32);
+		GUIShade.m_GfxSpinx2.SetRange(-32,+32);	GUIShade.m_GfxSpiny2.SetRange(-32,+32);
+		GUIShade.m_GfxSpinx3.SetRange(-32,+32);	GUIShade.m_GfxSpiny3.SetRange(-32,+32);
+		GUIShade.EnableCallback();
+		Core->RedrawView();
 }
 
 /*****************************************************************************/
 void	CLayerShade::GUIKill(CCore *Core)
 {
-		Core->GUIRemove(GUI,IDD_LAYER_SHADE);
+		GUIChanged(Core);
+		Core->GUIRemove(GUIShade,IDD_LAYER_SHADE);
 }
 
 /*****************************************************************************/
 void	CLayerShade::GUIUpdate(CCore *Core)
 {
-		GUI.CheckData();
+int		i,ListSize;
+
+// Shades
+		GUIShade.DisableCallback();
+
+		for (i=0; i<LAYER_SHADE_MAX; i++)
+		{
+			GUIShade.SetShadeRGB(i,ShadeRGB[i].R,ShadeRGB[i].G,ShadeRGB[i].B);
+		}
+		GUIShade.m_ShadeCountSpin.SetRange(2,4);
+		GUIShade.SetVal(GUIShade.m_ShadeCount,ShadeCount,2,4);
+
+// Gfx
+		ListSize=GfxList.size();
+		if (!ListSize)
+		{
+			GUIShade.m_GfxCurrent.SetWindowText("");
+			GUIShade.m_GfxCurrentSpin.SetRange(0,0);
+			return;
+		}
+
+sLayerShadeGfx	&ThisGfx=GfxList[CurrentGfx];
+
+		GUIShade.m_GfxCurrentSpin.SetRange(0,ListSize);
+		GUIShade.SetVal(GUIShade.m_GfxCurrent,CurrentGfx,0,ListSize-1);
+		GUIShade.SetVal(GUIShade.m_GfxPosX,ThisGfx.Pos.x);
+		GUIShade.SetVal(GUIShade.m_GfxPosY,ThisGfx.Pos.y);
+		GUIShade.m_GfxBankList.SetCurSel(ThisGfx.Gfx);
+		
+		for ( i=0;i<4; i++)
+		{
+			GUIShade.SetGfxRGB(i,ThisGfx.RGB[i].R,ThisGfx.RGB[i].G,ThisGfx.RGB[i].B);
+		}
+
+		GUIShade.SetVal(GUIShade.m_Gfxx0,ThisGfx.Ofs[0].x); GUIShade.SetVal(GUIShade.m_Gfxy0,ThisGfx.Ofs[0].y);
+		GUIShade.SetVal(GUIShade.m_Gfxx1,ThisGfx.Ofs[1].x); GUIShade.SetVal(GUIShade.m_Gfxy1,ThisGfx.Ofs[1].y);
+		GUIShade.SetVal(GUIShade.m_Gfxx2,ThisGfx.Ofs[2].x); GUIShade.SetVal(GUIShade.m_Gfxy2,ThisGfx.Ofs[2].y);
+		GUIShade.SetVal(GUIShade.m_Gfxx3,ThisGfx.Ofs[3].x); GUIShade.SetVal(GUIShade.m_Gfxy3,ThisGfx.Ofs[3].y);
+
+		GUIShade.m_GfxTransList.SetCurSel(ThisGfx.TransMode);
+		GUIShade.EnableCallback();
 }
 
 /*****************************************************************************/
 void	CLayerShade::GUIChanged(CCore *Core)
 {
-		for (int i=0; i<LAYER_SHADE_MAX; i++) 
+int		i,ListSize;
+
+// Shade
+		for (i=0; i<LAYER_SHADE_MAX; i++) 
 		{
-			GUI.GetRGB(RGB[i],i);
+			GUIShade.GetShadeRGB(i,ShadeRGB[i].R,ShadeRGB[i].G,ShadeRGB[i].B);
 		}
-		GUI.GetCount(Count);
+		GUIShade.GetVal(GUIShade.m_ShadeCount,ShadeCount,2,4);
-		Back0=GUI.m_Gfx0.GetCurSel();
+// Gfx
-		Back1=GUI.m_Gfx1.GetCurSel();
+		GUIShade.GetVal(GUIShade.m_GfxCurrent,CurrentGfx); 
+		ListSize=GfxList.size();
+		if (!ListSize || CurrentGfx==-1) return;
 
-		Flags0=0;
+sLayerShadeGfx	&ThisGfx=GfxList[CurrentGfx];
-		if (GUI.m_Spin0.GetCheck())		Flags0|=SpinFlag;
-		if (GUI.m_Scale0.GetCheck())	Flags0|=ScaleFlag;
-		if (GUI.m_Move0.GetCheck())		Flags0|=MoveFlag;
-		if (GUI.m_Color0.GetCheck())	Flags0|=ColorFlag;
-		TransMode0=GUI.m_Trans0.GetCurSel();
 		
-		Flags1=0;
+		GUIShade.GetVal(GUIShade.m_GfxCurrent,ListSize,0,ListSize);
-		if (GUI.m_Spin1.GetCheck())		Flags1|=SpinFlag;
+		GUIShade.GetVal(GUIShade.m_GfxPosX,ThisGfx.Pos.x);
-		if (GUI.m_Scale1.GetCheck())	Flags1|=ScaleFlag;
+		GUIShade.GetVal(GUIShade.m_GfxPosY,ThisGfx.Pos.y);
-		if (GUI.m_Move1.GetCheck())		Flags1|=MoveFlag;
+		ThisGfx.Gfx=GUIShade.m_GfxBankList.GetCurSel();
-		if (GUI.m_Color1.GetCheck())	Flags1|=ColorFlag;
-		TransMode1=GUI.m_Trans1.GetCurSel();
 		
+		for ( i=0;i<4; i++)
+		{
+			GUIShade.GetGfxRGB(i,ThisGfx.RGB[i].R,ThisGfx.RGB[i].G,ThisGfx.RGB[i].B);
+		}
+		GUIShade.GetVal(GUIShade.m_Gfxx0,ThisGfx.Ofs[0].x); GUIShade.GetVal(GUIShade.m_Gfxy0,ThisGfx.Ofs[0].y);
+		GUIShade.GetVal(GUIShade.m_Gfxx1,ThisGfx.Ofs[1].x); GUIShade.GetVal(GUIShade.m_Gfxy1,ThisGfx.Ofs[1].y);
+		GUIShade.GetVal(GUIShade.m_Gfxx2,ThisGfx.Ofs[2].x); GUIShade.GetVal(GUIShade.m_Gfxy2,ThisGfx.Ofs[2].y);
+		GUIShade.GetVal(GUIShade.m_Gfxx3,ThisGfx.Ofs[3].x); GUIShade.GetVal(GUIShade.m_Gfxy3,ThisGfx.Ofs[3].y);
+		ThisGfx.TransMode=GUIShade.m_GfxTransList.GetCurSel();
+
+		GUIUpdate(Core);
 }
 
 /*****************************************************************************/
 /*** Functions ***************************************************************/
+/*****************************************************************************/
+
+bool	CLayerShade::LButtonControl(CCore *Core,UINT nFlags, CPoint &CursorPos,bool DownFlag)
+{
+		if (DownFlag) AddGfx(Core);
+		return(true);
+}
+
+/*****************************************************************************/
+bool	CLayerShade::RButtonControl(CCore *Core,UINT nFlags, CPoint &CursorPos,bool DownFlag)
+{
+		if (DownFlag) Cursor.Gfx=-1;
+		return(true);
+}
+
+/*****************************************************************************/
+bool	CLayerShade::MouseMove(CCore *Core,UINT nFlags, CPoint &CursorPos)
+{
+		return(true);
+}
+
+/*****************************************************************************/
+bool	CLayerShade::Command(int CmdMsg,CCore *Core,int Param0,int Param1)
+{
+bool	Ret=false;
+
+		switch(CmdMsg)
+		{
+		case CmdMsg_ShadeGfxNew:
+			Cursor.Gfx=Param0;
+			GUIShade.m_DefList.SetCurSel(-1);
+			break;
+		case CmdMsg_ShadeGfxSelect:
+			GUIShade.GetVal(GUIShade.m_GfxCurrent,CurrentGfx);
+			if (CurrentGfx>GfxList.size()-1) CurrentGfx=GfxList.size()-1;
+			GUIUpdate(Core);
+			break;
+		case CmdMsg_ShadeGfxGoto:
+			GotoGfx(Core);
+			break;
+		case CmdMsg_ShadeGfxDelete:
+			DeleteGfx(Core);
+			break;
+		default:
+			break;
+		}
+
+		return(Ret);
+
+}
+
+/*****************************************************************************/
+void	CLayerShade::AddGfx(CCore *Core)
+{
+	if (Cursor.Gfx==-1) return;
+
+	CurrentGfx=GfxList.size();
+	GfxList.push_back(Cursor);
+
+	Cursor.Gfx=-1;
+	GUIUpdate(Core);
+}
+
+/*****************************************************************************/
+void	CLayerShade::GotoGfx(CCore *Core)
+{
+		if (CurrentGfx==-1) return;
+sLayerShadeGfx	&ThisGfx=GfxList[CurrentGfx];
+CPoint		Pos;
+			Pos.x=ThisGfx.Pos.x;
+			Pos.y=ThisGfx.Pos.y;
+			Core->SetCamPos(Pos);
+}
+
+/*****************************************************************************/
+void	CLayerShade::DeleteGfx(CCore *Core)
+{
+		if (!GfxList.size()) return;
+
+		GfxList.erase(CurrentGfx);
+		if (CurrentGfx) CurrentGfx--;
+		GUIUpdate(Core);
+
+}
+
 /*****************************************************************************/
 void	CLayerShade::Export(CCore *Core,CExport &Exp)
 {
+int		i,ListSize;
+
 		Exp.ExportLayerHeader(LayerDef);//LAYER_TYPE_SHADE,LayerDef.SubType,LayerDef.Width,LayerDef.Height);
-		Exp.Write(&Count,sizeof(int));
+		Exp.Write(&ShadeCount,sizeof(int));
-		for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
+		for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
 		{
-			Exp.Write(&Pos[i],sizeof(int));
+			Exp.Write(&ShadeRGB[i],sizeof(sRGBCol));
-			Exp.Write(&RGB[i].rgbRed,sizeof(u8));
-			Exp.Write(&RGB[i].rgbGreen,sizeof(u8));
-			Exp.Write(&RGB[i].rgbBlue,sizeof(u8));
-			Exp.Write(&RGB[i].rgbRed,sizeof(u8));	// Pad
 		}
 
-		Exp.Write(&TransMode0,sizeof(int));
+// Write Gfx List
-		Exp.Write(&Flags0,sizeof(int));
+		ListSize=GfxList.size();
-		Exp.Write(&TransMode1,sizeof(int));
+		Exp.Write(&ListSize,sizeof(int));
-		Exp.Write(&Flags1,sizeof(int));
 
-// Back Gfx
+		for (i=0; i<ListSize; i++)
+		{
+			sLayerShadeGfx	&ThisGfx=GfxList[i];
+			Exp.Write(&ThisGfx,sizeof(sLayerShadeGfx));
+		}
+// Write Gfx Names
+		ListSize=BankList.size();
+		Exp.Write(&ListSize,sizeof(int));
+		for (i=0; i<ListSize; i++)
+		{
 			char	Txt[256];
-
+			sprintf(Txt,BankList[i].Name);
-		Txt[0]=0; 
-		if (Back0!=-1) sprintf(Txt,BackGfx[Back0]);
 			Exp.Write(Txt,strlen(Txt)+1);
-		
+		}
-		Txt[0]=0; 
-		if (Back1!=-1) sprintf(Txt,BackGfx[Back1]);
-		Exp.Write(Txt,strlen(Txt)+1);		
-
 }

Utils/MapEdit/LayerShade.h

@@ -8,6 +8,17 @@
 #include	"Layer.h"
 #include	"MapEdit.h"
 #include	"GUILayerShade.h"
+#include	"Elem.h"
+#include	"ExportHdr.h"
+
+
+/*****************************************************************************/
+struct	sBackList
+{
+		GString	Name;
+		int		ElemID;
+};
+
 
 /*****************************************************************************/
 class	CCore;
@@ -18,11 +29,6 @@ public:
 		enum
 		{
 			LAYER_SHADE_RGB_MAX=4,
-
-			SpinFlag=1<<0,
-			ScaleFlag=1<<1,
-			MoveFlag=1<<2,
-			ColorFlag=1<<3,
 		};
 
 		CLayerShade(sLayerDef &Def);
@@ -35,13 +41,16 @@ public:
 		void			RenderGrid(CCore *Core,Vector3 &CamPos,bool Active){};
 		void			RenderSelection(CCore *Core,Vector3 &ThisCam){};
 
-		void			RenderCursor(CCore *Core,Vector3 &CamPos,bool Is3d){};
+		void			RenderCursor(CCore *Core,Vector3 &CamPos,bool Is3d);
 
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);
 		void			GUIChanged(CCore *Core);
 
+//		int				GetWidth()						{return(LayerDef.Width);}
+//		int				GetHeight()						{return(LayerDef.Height);}
+		void			CheckLayerSize(int Width,int Height);
 		bool			Resize(int Width,int Height);
 
 		void			Load(CFile *File,int Version);
@@ -50,21 +59,30 @@ public:
 		void			Export(CCore *Core,CExport &Exp);
 
 // Functions
+		bool			LButtonControl(CCore *Core,UINT nFlags, CPoint &CursorPos,bool DownFlag);
+		bool			RButtonControl(CCore *Core,UINT nFlags, CPoint &CursorPos,bool DownFlag);
+		bool			MouseMove(CCore *Core,UINT nFlags, CPoint &CursorPos);
+		bool			Command(int CmdMsg,CCore *Core,int Param0=0,int Param1=0);
 
 protected:
+		void			LoadGfx();
 		void			Render(CCore *Core,Vector3 &CamPos,CMap &ThisMap,bool Render3d,float Alpha=1.0f,Vector3 *Ofs=0);
-		void			InitGfxList();
+		void			RenderBackGfx(CCore *Core,Vector3 &ThisCam,sLayerShadeGfx &ThisGfx);
+		void			AddGfx(CCore *Core);
+		void			GotoGfx(CCore *Core);
+		void			DeleteGfx(CCore *Core);
 
-		CGUILayerShade	GUI;
+		CGUILayerShade		GUIShade;
 		CIni				Script;
-		CList<GString>	BackGfx;
+		CList<sBackList>	BankList;
-		int				Back0,Back1;
+		CElemBank			*GfxBank;
-		int				TransMode0,TransMode1;
+		sLayerShadeGfx			Cursor;
-		int				Flags0,Flags1;
 
-		int				Count;
+		int					ShadeCount;
-		int				Pos[LAYER_SHADE_RGB_MAX];
+		sRGBCol				ShadeRGB[LAYER_SHADE_RGB_MAX];
-		RGBQUAD			RGB[LAYER_SHADE_RGB_MAX];
+
+		CList<sLayerShadeGfx>		GfxList;
+		int					CurrentGfx;
 
 };
 

Utils/MapEdit/LayerThing.cpp

@@ -66,8 +66,15 @@ int		i,ListSize;
 		{
 			sLayerThing	&ThisThing=ThingList[i];
 			LoadThing(File,Version,ThisThing);
+			if (Version<9)
+			{
+				LoadOldThing(File,ThisThing);
+			}
+			else
+			{
 				File->Read(&ThisThing.Data,sizeof(sLayerThingData));
 			}
+		}
 		LoadThingNames(File,Version);
 
 }
@@ -179,13 +186,8 @@ int		i,ListSize=ThingScript.GetGroupCount();
 			memset(&ThisDef.Data,0,sizeof(sLayerThingData));
 			ThisDef.Name=Name;
 			ThisDef.Data.WaypointCount=ThingScript.GetInt(Name,"WayPoints");
-			ThisDef.Data.Speed=ThingScript.GetInt(Name,"Speed");
-			ThisDef.Data.TurnRate=ThingScript.GetInt(Name,"TurnRate");
-			ThisDef.Data.Health=ThingScript.GetInt(Name,"Health");
-			ThisDef.Data.AttackStrength=ThingScript.GetInt(Name,"AttackStrength");
-			ThisDef.Data.PlayerFlag=ThingScript.GetInt(Name,"Player")==1;
-			ThisDef.Data.CollisionFlag=ThingScript.GetInt(Name,"Collision")==1;
 
+			LoadDefThing(Name,ThisDef);
 			ThisDef.XY.resize(1);
 			TRACE2("%s\t\t%s\n",Name,Gfx);
 			if (Gfx) 

Utils/MapEdit/LayerThing.h

@@ -64,11 +64,13 @@ virtual	void			GUIThingPointUpdateList(CListBox &List,bool OnlySel=false);
 
 virtual	void			Load(CFile *File,int Version);
 virtual	void			LoadThing(CFile *File,int Version,sLayerThing &ThisThing);
+virtual	void			LoadOldThing(CFile *File,sLayerThing &ThisThing)=0;
 virtual	void			LoadThingNames(CFile *File,int Version);
 virtual	void			Save(CFile *File);
 virtual	void			SaveThing(CFile *File,sLayerThing &ThisThing);
 virtual	void			SaveThingNames(CFile *File);
 virtual	void			LoadThingScript(const char *Filename);
+virtual	void			LoadDefThing(const char *Name,sLayerThing &ThisDef)=0;
 
 virtual	void			Export(CCore *Core,CExport &Exp);
 virtual	void			ExportThing(CCore *Core,CExport &Exp,sLayerThing &ThisThing);

Utils/MapEdit/LayerTrigger.cpp

@@ -40,6 +40,24 @@ void	CLayerTrigger::InitSubView(CCore *Core)
 {
 }
 
+/*****************************************************************************/
+void	CLayerTrigger::LoadDefThing(const char *Name,sLayerThing &ThisDef)
+{
+}
+
+/*****************************************************************************/
+void	CLayerTrigger::LoadOldThing(CFile *File,sLayerThing &ThisThing)
+{
+sLayerThingDataOLD	OldThing;
+
+		File->Read(&OldThing,sizeof(sLayerThingDataOLD));
+		ThisThing.Data.Trigger.TriggerWidth=OldThing.Width;
+		ThisThing.Data.Trigger.TriggerHeight=OldThing.Height;
+		ThisThing.Data.Trigger.TriggerTargetX=OldThing.TargetX;
+		ThisThing.Data.Trigger.TriggerTargetY=OldThing.TargetY;
+}
+
+
 /*****************************************************************************/
 void	CLayerTrigger::RenderThing(CCore *Core,Vector3 &ThisCam,sLayerThing &ThisThing,bool Render3d,bool Selected)
 {
@@ -71,8 +89,8 @@ float		Col=0.8f,A=0.8f;
 			Core->RenderNumber(0);
 			glEnable(GL_DEPTH_TEST);
 
-float	W=(ThisThing.Data.Width);
+float	W=(ThisThing.Data.Trigger.TriggerWidth);
-float	H=-(ThisThing.Data.Height);
+float	H=-(ThisThing.Data.Trigger.TriggerHeight);
 // Draw Box
 			glBegin (GL_QUADS);
 				glColor4f(0,Col-0.25f,0,A);
@@ -96,9 +114,34 @@ float	H=-(ThisThing.Data.Height);
 
 				glVertex3f( 0,H+1,0);
 				glVertex3f( 0,0+1,0);
-
 			glEnd();
 
+			if (Selected && ThingScript.GetInt(ThisThing.Name,"HasTarget"))
+			{ // Draw Target
+				float	ox,oy;
+				float	tx,ty;
+
+				ox=W/2.0f;
+				oy=H/2.0f;
+				tx=ThisThing.Data.Trigger.TriggerTargetX-ThisThing.XY[0].x;
+				ty=ThisThing.XY[0].y-ThisThing.Data.Trigger.TriggerTargetY;
+				glBegin(GL_LINES); 
+					glColor4f(Col,Col,Col,A);
+					glVertex3f( ox,oy+1.0f,0);
+					glVertex3f( tx+0.5f,ty+0.5f,0);
+				glEnd();
+				glBegin (GL_QUADS);
+					glColor4f(Col,0,Col,A);
+					glVertex3f(tx+0,ty+0,0);
+					glVertex3f(tx+1,ty+0,0);
+					glVertex3f(tx+1,ty+1,0);
+					glVertex3f(tx+0,ty+1,0);
+				glEnd();
+
+				
+			}
+
+
 			glDisable(GL_DEPTH_TEST);
 
 			glPopMatrix();
@@ -109,13 +152,15 @@ float	H=-(ThisThing.Data.Height);
 /*****************************************************************************/
 void	CLayerTrigger::GUIInit(CCore *Core)
 {
+		
 		GUITrigger.DisableCallback(true);
 		Core->GUIAdd(GUIThing,IDD_LAYER_THING);
 		Core->GUIAdd(GUITrigger,IDD_LAYER_TRIGGER);
 		GUITrigger.DisableCallback(false);
 		GUITrigger.m_WidthSpin.SetRange(1,255);
 		GUITrigger.m_HeightSpin.SetRange(1,255);
-
+		GUITrigger.m_TargetXSpin.SetRange(0,32000);
+		GUITrigger.m_TargetYSpin.SetRange(0,32000);
 }
 
 /*****************************************************************************/
@@ -154,20 +199,36 @@ CComboBox	&List=GUIThing.m_DefList;
 /*****************************************************************************/
 void	CLayerTrigger::GUIThingUpdate(bool OnlySel)
 {
+int		TargetMode=SW_SHOW;
+
 		GUIThingUpdateList(GUIThing.m_List,false);
 // Params
 		GUITrigger.DisableCallback(true);
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			GUITrigger.SetVal(GUITrigger.m_Width,ThisThing.Data.Width);
+			GUITrigger.SetVal(GUITrigger.m_Width,ThisThing.Data.Trigger.TriggerWidth);
-			GUITrigger.SetVal(GUITrigger.m_Height,ThisThing.Data.Height);
+			GUITrigger.SetVal(GUITrigger.m_Height,ThisThing.Data.Trigger.TriggerHeight);
+			GUITrigger.SetVal(GUITrigger.m_TargetX,ThisThing.Data.Trigger.TriggerTargetX);
+			GUITrigger.SetVal(GUITrigger.m_TargetY,ThisThing.Data.Trigger.TriggerTargetY);
+			if (ThingScript.GetInt(ThisThing.Name,"HasTarget")==0)
+			{
+				TargetMode=SW_HIDE;
+			}
 		}
 		else
 		{
 			GUITrigger.m_Width.SetWindowText("");
 			GUITrigger.m_Height.SetWindowText("");
+			TargetMode=SW_HIDE;
 		}
+
+		GUITrigger.m_TargetTxt.ShowWindow(TargetMode);
+		GUITrigger.m_TargetX.ShowWindow(TargetMode);
+		GUITrigger.m_TargetY.ShowWindow(TargetMode);
+		GUITrigger.m_TargetXSpin.ShowWindow(TargetMode);
+		GUITrigger.m_TargetYSpin.ShowWindow(TargetMode);
+
 		GUITrigger.DisableCallback(false);
 }
 
@@ -183,8 +244,10 @@ void	CLayerTrigger::GUIChanged(CCore *Core)
 		if (CurrentThing!=-1)
 		{
 			sLayerThing	&ThisThing=ThingList[CurrentThing];
-			ThisThing.Data.Width=GUITrigger.GetVal(GUITrigger.m_Width);
+			ThisThing.Data.Trigger.TriggerWidth=GUITrigger.GetVal(GUITrigger.m_Width);
-			ThisThing.Data.Height=GUITrigger.GetVal(GUITrigger.m_Height);
+			ThisThing.Data.Trigger.TriggerHeight=GUITrigger.GetVal(GUITrigger.m_Height);
+			ThisThing.Data.Trigger.TriggerTargetX=GUITrigger.GetVal(GUITrigger.m_TargetX);
+			ThisThing.Data.Trigger.TriggerTargetY=GUITrigger.GetVal(GUITrigger.m_TargetY);
 		}
 }
 
@@ -192,7 +255,6 @@ void	CLayerTrigger::GUIChanged(CCore *Core)
 void	CLayerTrigger::SetThingParams(sLayerThing &Thing)
 {
 		Thing.Data.WaypointCount=1;
-		if (Thing.Data.Width<1) Thing.Data.Width=1;
+		if (Thing.Data.Trigger.TriggerWidth<1) Thing.Data.Trigger.TriggerWidth=1;
-		if (Thing.Data.Height<1) Thing.Data.Height=1;
+		if (Thing.Data.Trigger.TriggerHeight<1) Thing.Data.Trigger.TriggerHeight=1;
-//		Thing.XY.resize(1);
 }

Utils/MapEdit/LayerTrigger.h

@@ -22,6 +22,9 @@ public:
 		void			InitLayer(sLayerDef &Def);
 		void			InitSubView(CCore *Core);
 
+		void			LoadDefThing(const char *Name,sLayerThing &ThisDef);
+		void			LoadOldThing(CFile *File,sLayerThing &ThisThing);
+
 		void			GUIInit(CCore *Core);
 		void			GUIKill(CCore *Core);
 		void			GUIUpdate(CCore *Core);

Utils/MapEdit/MapEdit.clw

@@ -2,59 +2,62 @@
 
 [General Info]
 Version=1
-LastClass=CGUILayerTrigger
+LastClass=CGUINewMap
 LastTemplate=CDialog
 NewFileInclude1=#include "stdafx.h"
 NewFileInclude2=#include "mapedit.h"
 LastPage=0
 
-ClassCount=24
+ClassCount=26
 Class1=CChildFrame
 Class2=CGLEnabledView
 Class3=CGUIAddLayer
 Class4=CGUIElemList
 Class5=CGUILayerActor
 Class6=GUILayerCollision
-Class7=CGUILayerList
+Class7=CGUILayerFX
-Class8=CGUILayerPlatform
+Class8=CGUILayerHazard
-Class9=CGUILayerShade
+Class9=CGUILayerItem
-Class10=CGUILayerThing
+Class10=CGUILayerList
-Class11=CGuiLayerThingPos
+Class11=CGUILayerPlatform
-Class12=CGUIMultiBar
+Class12=CGUILayerShade
-Class13=CGUINewMap
+Class13=CGUILayerThing
-Class14=CGUIResize
+Class14=CGuiLayerThingPos
-Class15=CGUITileBank
+Class15=CGUILayerTrigger
-Class16=GUIToolBar
+Class16=CGUIMultiBar
-Class17=CLayerTileCollision
+Class17=CGUINewMap
-Class18=CMainFrame
+Class18=CGUIResize
-Class19=CMapEditApp
+Class19=CGUITileBank
-Class20=CAboutDlg
+Class20=GUIToolBar
-Class21=CMapEditDoc
+Class21=CLayerTileCollision
-Class22=CMapEditView
+Class22=CMainFrame
+Class23=CMapEditApp
+Class24=CAboutDlg
+Class25=CMapEditDoc
+Class26=CMapEditView
 
-ResourceCount=20
+ResourceCount=21
-Resource1=IDD_LAYER_THING_POS
+Resource1=IDD_LAYER_COLLISION
-Resource2=IDD_NEWMAP
+Resource2=IDR_MAPEDITYPE (English (U.S.))
-Resource3=IDD_TILEBANK
+Resource3=IDD_ELEMLIST
-Resource4=IDR_MAPEDITYPE (English (U.S.))
+Resource4=IDD_MULTIBAR (English (U.S.))
 Resource5=IDD_LAYER_THING
-Resource6=IDD_LAYER_TRIGGER
+Resource6=IDD_NEWMAP
-Resource7=IDD_ELEMLIST
+Resource7=IDD_LAYER_PLATFORM
-Resource8=IDD_MULTIBAR (English (U.S.))
+Resource8=IDD_LAYER_TRIGGER
-Resource9=IDD_ABOUTBOX (English (U.S.))
+Resource9=IDD_TILEBANK
-Resource10=IDD_LAYER_ACTOR
+Resource10=IDR_TOOLBAR (English (U.S.))
-Resource11=IDD_LAYER_PLATFORM
+Resource11=IDR_MAINFRAME (English (U.S.))
-Resource12=IDD_RESIZE
+Resource12=IDD_ABOUTBOX (English (U.S.))
-Resource13=IDD_ADDLAYER
+Resource13=IDD_LAYER_ACTOR
-Resource14=IDD_LAYER_FX
+Resource14=IDD_LAYER_LIST
-Resource15=IDR_MAINFRAME (English (U.S.))
+Resource15=IDD_RESIZE
-Resource16=IDD_LAYER_SHADE
+Resource16=IDD_LAYER_THING_POS
-Resource17=IDD_LAYER_COLLISION
+Resource17=IDD_ADDLAYER
-Resource18=IDD_TOOLBAR
+Resource18=IDD_LAYER_FX
-Class23=CGUILayerTrigger
+Resource19=IDD_TOOLBAR
-Resource19=IDD_LAYER_LIST
+Resource20=IDD_LAYER_SHADE
-Class24=CGUILayerFX
+Resource21=IDD_LAYER_HAZARD
-Resource20=IDR_TOOLBAR (English (U.S.))
 
 [CLS:CChildFrame]
 Type=0
@@ -85,9 +88,6 @@ Type=0
 BaseClass=CDialog
 HeaderFile=GUILayerActor.h
 ImplementationFile=GUILayerActor.cpp
-Filter=D
-VirtualFilter=dWC
-LastObject=IDC_ACTOR_SPEED_SPIN
 
 [CLS:GUILayerCollision]
 Type=0
@@ -95,6 +95,25 @@ BaseClass=CDialog
 HeaderFile=GUILayerCollision.h
 ImplementationFile=GUILayerCollision.cpp
 
+[CLS:CGUILayerFX]
+Type=0
+BaseClass=CDialog
+HeaderFile=GUILayerFX.h
+ImplementationFile=GUILayerFX.cpp
+
+[CLS:CGUILayerHazard]
+Type=0
+BaseClass=CDialog
+HeaderFile=GUILayerHazard.h
+ImplementationFile=GUILayerHazard.cpp
+LastObject=CGUILayerHazard
+
+[CLS:CGUILayerItem]
+Type=0
+BaseClass=CDialog
+HeaderFile=GUILayerItem.h
+ImplementationFile=GUILayerItem.cpp
+
 [CLS:CGUILayerList]
 Type=0
 BaseClass=CDialog
@@ -106,9 +125,6 @@ Type=0
 BaseClass=CDialog
 HeaderFile=GUILayerPlatform.h
 ImplementationFile=GUILayerPlatform.cpp
-Filter=D
-VirtualFilter=dWC
-LastObject=CGUILayerPlatform
 
 [CLS:CGUILayerShade]
 Type=0
@@ -117,7 +133,7 @@ HeaderFile=GUILayerShade.h
 ImplementationFile=GUILayerShade.cpp
 Filter=D
 VirtualFilter=dWC
-LastObject=IDC_LAYERSHADE_TRANS1
+LastObject=CGUILayerShade
 
 [CLS:CGUILayerThing]
 Type=0
@@ -131,6 +147,12 @@ BaseClass=CDialog
 HeaderFile=GuiLayerThingPos.h
 ImplementationFile=GuiLayerThingPos.cpp
 
+[CLS:CGUILayerTrigger]
+Type=0
+BaseClass=CDialog
+HeaderFile=GUILayerTrigger.h
+ImplementationFile=GUILayerTrigger.cpp
+
 [CLS:CGUIMultiBar]
 Type=0
 BaseClass=CDialogBar
@@ -142,6 +164,9 @@ Type=0
 BaseClass=CDialog
 HeaderFile=GUINewMap.h
 ImplementationFile=GUINewMap.cpp
+Filter=D
+VirtualFilter=dWC
+LastObject=CGUINewMap
 
 [CLS:CGUIResize]
 Type=0
@@ -183,6 +208,7 @@ Type=0
 BaseClass=CDialog
 HeaderFile=MapEdit.cpp
 ImplementationFile=MapEdit.cpp
+LastObject=CAboutDlg
 
 [CLS:CMapEditDoc]
 Type=0
@@ -242,6 +268,44 @@ Control6=IDC_LAYERCOLLISION_WATER,button,1342242816
 Control7=IDC_LAYERCOLLISION_SOLID,button,1342242816
 Control8=IDC_LAYERCOLLISION_DEATH,button,1342242816
 
+[DLG:IDD_LAYER_FX]
+Type=1
+Class=CGUILayerFX
+ControlCount=8
+Control1=IDC_FX_SPEED_TEXT,static,1342308354
+Control2=IDC_FX_SIZE_TEXT,static,1342308354
+Control3=IDC_FX_WIDTH,edit,1350633600
+Control4=IDC_FX_WIDTH_SPIN,msctls_updown32,1342177334
+Control5=IDC_FX_HEIGHT,edit,1350633600
+Control6=IDC_FX_HEIGHT_SPIN,msctls_updown32,1342177334
+Control7=IDC_FX_SPEED,edit,1350633600
+Control8=IDC_FX_SPEED_SPIN,msctls_updown32,1342177462
+
+[DLG:IDD_LAYER_HAZARD]
+Type=1
+Class=CGUILayerHazard
+ControlCount=16
+Control1=IDC_HAZARD_SPEED_TEXT,static,1342308354
+Control2=IDC_HAZARD_SPEED,edit,1350633600
+Control3=IDC_HAZARD_SPEED_SPIN,msctls_updown32,1342177334
+Control4=IDC_HAZARD_TURNRATE_TEXT,static,1342308354
+Control5=IDC_HAZARD_TURNRATE,edit,1350633600
+Control6=IDC_HAZARD_TURNRATE_SPIN,msctls_updown32,1342177334
+Control7=IDC_HAZARD_HEALTH_TEXT,static,1342308354
+Control8=IDC_HAZARD_HEALTH,edit,1350633600
+Control9=IDC_HAZARD_HEALTH_SPIN,msctls_updown32,1342177334
+Control10=IDC_HAZARD_ATTACK_TEXT,static,1342308354
+Control11=IDC_HAZARD_ATTACK,edit,1350633600
+Control12=IDC_HAZARD_ATTACK_SPIN,msctls_updown32,1342177334
+Control13=IDC_HAZARD_COLLISION,button,1342243363
+Control14=IDC_HAZARD_RESPAWN_TEXT,static,1342308354
+Control15=IDC_HAZARD_RESPAWN,edit,1350633600
+Control16=IDC_HAZARD_RESPAWN_SPIN,msctls_updown32,1342177334
+
+[DLG:IDD_LAYER_ITEM]
+Type=1
+Class=CGUILayerItem
+
 [DLG:IDD_LAYER_LIST]
 Type=1
 Class=CGUILayerList
@@ -267,35 +331,69 @@ Control9=IDC_PLATFORM_TYPE,combobox,1344339971
 [DLG:IDD_LAYER_SHADE]
 Type=1
 Class=CGUILayerShade
-ControlCount=28
+ControlCount=62
-Control1=IDC_LAYERSHADE_EDITR0,edit,1350770688
+Control1=IDC_LAYERSHADE_SHADER0,edit,1350770688
-Control2=IDC_LAYERSHADE_EDITG0,edit,1350770816
+Control2=IDC_LAYERSHADE_SHADEG0,edit,1350770816
-Control3=IDC_LAYERSHADE_EDITB0,edit,1350770816
+Control3=IDC_LAYERSHADE_SHADEB0,edit,1350770816
 Control4=IDC_LAYERSHADE_COUNTTEXT,static,1342312449
-Control5=IDC_LAYERSHADE_EDITR1,edit,1350770688
+Control5=IDC_LAYERSHADE_SHADER1,edit,1350770688
-Control6=IDC_LAYERSHADE_EDITG1,edit,1350770816
+Control6=IDC_LAYERSHADE_SHADEG1,edit,1350770816
-Control7=IDC_LAYERSHADE_EDITB1,edit,1350770816
+Control7=IDC_LAYERSHADE_SHADEB1,edit,1350770816
-Control8=IDC_LAYERSHADE_EDITR2,edit,1350770688
+Control8=IDC_LAYERSHADE_SHADER2,edit,1350770688
-Control9=IDC_LAYERSHADE_EDITG2,edit,1350770816
+Control9=IDC_LAYERSHADE_SHADEG2,edit,1350770816
-Control10=IDC_LAYERSHADE_EDITB2,edit,1350770816
+Control10=IDC_LAYERSHADE_SHADEB2,edit,1350770816
 Control11=IDC_LAYERSHADE_TEXT7,static,1342312449
-Control12=IDC_LAYERSHADE_EDITR3,edit,1350770688
+Control12=IDC_LAYERSHADE_SHADER3,edit,1350770688
-Control13=IDC_LAYERSHADE_EDITG3,edit,1350770816
+Control13=IDC_LAYERSHADE_SHADEG3,edit,1350770816
-Control14=IDC_LAYERSHADE_EDITB3,edit,1350770816
+Control14=IDC_LAYERSHADE_SHADEB3,edit,1350770816
-Control15=IDC_LAYERSHADE_COUNTEDIT,edit,1350576256
+Control15=IDC_LAYERSHADE_SHADECOUNT,edit,1350576256
-Control16=IDC_SPIN2,msctls_updown32,1342177302
+Control16=IDC_LAYERSHADE_SHADECOUNT_SPIN,msctls_updown32,1342177302
-Control17=IDC_LAYERSHADE_BACKGFX0,combobox,1344339971
+Control17=IDC_LAYERSHADE_GFX_CURRENT,edit,1350576256
-Control18=IDC_LAYERSHADE_BACKGFX1,combobox,1344339971
+Control18=IDC_LAYERSHADE_GFX_CURRENT_SPIN,msctls_updown32,1342177466
-Control19=IDC_LAYERSHADE_SPIN0,button,1342242851
+Control19=IDC_LAYERSHADE_COUNTTEXT2,static,1342312449
-Control20=IDC_LAYERSHADE_MOVE0,button,1342242851
+Control20=IDC_LAYERSHADE_GFX_LIST,combobox,1344274435
-Control21=IDC_LAYERSHADE_SCALE0,button,1342242851
+Control21=IDC_LAYERSHADE_GFX_GOTO,button,1342177280
-Control22=IDC_LAYERSHADE_COLOR0,button,1342242851
+Control22=IDC_LAYERSHADE_GFX_DELETE,button,1342177280
-Control23=IDC_LAYERSHADE_TRANS0,combobox,1344339971
+Control23=IDC_LAYERSHADE_POSTEXT,static,1342312449
-Control24=IDC_LAYERSHADE_SPIN1,button,1342242851
+Control24=IDC_LAYERSHADE_XYTEXT0,static,1342312449
-Control25=IDC_LAYERSHADE_MOVE1,button,1342242851
+Control25=IDC_LAYERSHADE_GFX_X0,edit,1350576256
-Control26=IDC_LAYERSHADE_SCALE1,button,1342242851
+Control26=IDC_LAYERSHADE_GFX_SPIN_X0,msctls_updown32,1342177334
-Control27=IDC_LAYERSHADE_COLOR1,button,1342242851
+Control27=IDC_LAYERSHADE_GFX_Y0,edit,1350576256
-Control28=IDC_LAYERSHADE_TRANS1,combobox,1344339971
+Control28=IDC_LAYERSHADE_GFX_SPIN_Y0,msctls_updown32,1342177334
+Control29=IDC_LAYERSHADE_XYTEXT1,static,1342312449
+Control30=IDC_LAYERSHADE_GFX_X1,edit,1350576256
+Control31=IDC_LAYERSHADE_GFX_SPIN_X1,msctls_updown32,1342177334
+Control32=IDC_LAYERSHADE_GFX_Y1,edit,1350576256
+Control33=IDC_LAYERSHADE_GFX_SPIN_Y1,msctls_updown32,1342177334
+Control34=IDC_LAYERSHADE_XYTEXT2,static,1342312449
+Control35=IDC_LAYERSHADE_GFX_X2,edit,1350576256
+Control36=IDC_LAYERSHADE_GFX_SPIN_X2,msctls_updown32,1342177334
+Control37=IDC_LAYERSHADE_GFX_Y2,edit,1350576256
+Control38=IDC_LAYERSHADE_GFX_SPIN_Y2,msctls_updown32,1342177334
+Control39=IDC_LAYERSHADE_XYTEXT3,static,1342312449
+Control40=IDC_LAYERSHADE_GFX_X3,edit,1350576256
+Control41=IDC_LAYERSHADE_GFX_SPIN_X3,msctls_updown32,1342177334
+Control42=IDC_LAYERSHADE_GFX_Y3,edit,1350576256
+Control43=IDC_LAYERSHADE_GFX_SPIN_Y3,msctls_updown32,1342177334
+Control44=IDC_LAYERSHADE_GFX_TRANSLIST,combobox,1342177283
+Control45=IDC_LAYERSHADE_TRANSTEXT,static,1342312449
+Control46=IDC_LAYERSHADE_GFXR0,edit,1350770688
+Control47=IDC_LAYERSHADE_GFXG0,edit,1350770816
+Control48=IDC_LAYERSHADE_GFXB0,edit,1350770816
+Control49=IDC_LAYERSHADE_GFXR1,edit,1350770688
+Control50=IDC_LAYERSHADE_GFXG1,edit,1350770816
+Control51=IDC_LAYERSHADE_GFXB1,edit,1350770816
+Control52=IDC_LAYERSHADE_GFXR2,edit,1350770688
+Control53=IDC_LAYERSHADE_GFXG2,edit,1350770816
+Control54=IDC_LAYERSHADE_GFXB2,edit,1350770816
+Control55=IDC_LAYERSHADE_GFXR3,edit,1350770688
+Control56=IDC_LAYERSHADE_GFXG3,edit,1350770816
+Control57=IDC_LAYERSHADE_GFXB3,edit,1350770816
+Control58=IDC_LAYERSHADE_GFX_X,edit,1350568064
+Control59=IDC_LAYERSHADE_GFX_XSPIN,msctls_updown32,1342177334
+Control60=IDC_LAYERSHADE_GFX_Y,edit,1350568064
+Control61=IDC_LAYERSHADE_GFX_YSPIN,msctls_updown32,1342177334
+Control62=IDC_LAYERSHADE_DEF_LIST,combobox,1342177283
 
 [DLG:IDD_LAYER_THING]
 Type=1
@@ -315,6 +413,21 @@ Control2=IDC_THING_POS_UP,button,1342242816
 Control3=IDC_THING_POS_DOWN,button,1342242816
 Control4=IDC_THING_POS_DELETE,button,1342242816
 
+[DLG:IDD_LAYER_TRIGGER]
+Type=1
+Class=CGUILayerTrigger
+ControlCount=10
+Control1=IDC_TRIGGER_SIZE,static,1342308354
+Control2=IDC_TRIGGER_WIDTH,edit,1350633600
+Control3=IDC_TRIGGER_WIDTH_SPIN,msctls_updown32,1342177334
+Control4=IDC_TRIGGER_HEIGHT,edit,1350633600
+Control5=IDC_TRIGGER_HEIGHT_SPIN,msctls_updown32,1342177334
+Control6=IDC_TRIGGER_TARGET,static,1342308354
+Control7=IDC_TRIGGER_TARGETX,edit,1350633600
+Control8=IDC_TRIGGER_TARGETX_SPIN,msctls_updown32,1342177334
+Control9=IDC_TRIGGER_TARGETY,edit,1350633600
+Control10=IDC_TRIGGER_TARGETY_SPIN,msctls_updown32,1342177334
+
 [DLG:IDD_MULTIBAR]
 Type=1
 Class=CGUIMultiBar
@@ -467,44 +580,3 @@ Type=1
 Class=?
 ControlCount=0
 
-[DLG:IDD_LAYER_TRIGGER]
-Type=1
-Class=CGUILayerTrigger
-ControlCount=5
-Control1=IDC_TRIGGER_SIZE,static,1342308354
-Control2=IDC_TRIGGER_WIDTH,edit,1350633600
-Control3=IDC_TRIGGER_WIDTH_SPIN,msctls_updown32,1342177334
-Control4=IDC_TRIGGER_HEIGHT,edit,1350633600
-Control5=IDC_TRIGGER_HEIGHT_SPIN,msctls_updown32,1342177334
-
-[CLS:CGUILayerTrigger]
-Type=0
-HeaderFile=GUILayerTrigger.h
-ImplementationFile=GUILayerTrigger.cpp
-BaseClass=CDialog
-Filter=D
-VirtualFilter=dWC
-LastObject=CGUILayerTrigger
-
-[DLG:IDD_LAYER_FX]
-Type=1
-Class=CGUILayerFX
-ControlCount=8
-Control1=IDC_FX_SPEED_TEXT,static,1342308354
-Control2=IDC_FX_SIZE_TEXT,static,1342308354
-Control3=IDC_FX_WIDTH,edit,1350633600
-Control4=IDC_FX_WIDTH_SPIN,msctls_updown32,1342177334
-Control5=IDC_FX_HEIGHT,edit,1350633600
-Control6=IDC_FX_HEIGHT_SPIN,msctls_updown32,1342177334
-Control7=IDC_FX_SPEED,edit,1350633600
-Control8=IDC_FX_SPEED_SPIN,msctls_updown32,1342177462
-
-[CLS:CGUILayerFX]
-Type=0
-HeaderFile=GUILayerFX.h
-ImplementationFile=GUILayerFX.cpp
-BaseClass=CDialog
-Filter=D
-VirtualFilter=dWC
-LastObject=IDC_FX_WIDTH
-

Utils/MapEdit/MapEdit.cpp

@@ -133,12 +133,12 @@ void	CMapEditApp::CloseDoc(CMapEditDoc *Cur)
 	}
 }
 
-char	*CMapEditApp::GetConfigStr(char *Grp,char *Key)
+char	*CMapEditApp::GetConfigStr(const char *Grp,const char *Key)
 {
 		return(MainIni.GetStr(Grp,Key));
 }
 
-int		CMapEditApp::GetConfigInt(char *Grp,char *Key)
+int		CMapEditApp::GetConfigInt(const char *Grp,const char *Key)
 {
 		return(MainIni.GetInt(Grp,Key));
 }

Utils/MapEdit/MapEdit.dsp

@@ -131,6 +131,14 @@ SOURCE=.\LayerFX.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\LayerHazard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LayerHazard.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\LayerItem.cpp
 # End Source File
 # Begin Source File
@@ -425,6 +433,14 @@ SOURCE=.\GUILayerFX.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\GUILayerHazard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\GUILayerHazard.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\GUILayerList.cpp
 # End Source File
 # Begin Source File
@@ -518,10 +534,18 @@ SOURCE=..\..\tools\MapEdit\actor.ini
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\tools\MapEdit\BackGfx.ini
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\tools\MapEdit\fx.ini
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\tools\MapEdit\Hazard.ini
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\tools\MapEdit\Item.ini
 # End Source File
 # Begin Source File

Utils/MapEdit/MapEdit.h

@@ -33,8 +33,8 @@ public:
 	{
 		return(CurrentDoc);
 	}
-	char	*GetConfigStr(char *Grp,char *Key);
+	char	*GetConfigStr(const char *Grp,const char *Key);
-	int		GetConfigInt(char *Grp,char *Key);
+	int		GetConfigInt(const char *Grp,const char *Key);
 
 // Overrides
 	// ClassWizard generated virtual function overrides

Utils/MapEdit/MapEdit.rc

@@ -532,60 +532,129 @@ BEGIN
                     WS_TABSTOP
 END
 
-IDD_LAYER_SHADE DIALOG DISCARDABLE  0, 0, 156, 166
+IDD_LAYER_SHADE DIALOG DISCARDABLE  0, 0, 156, 296
 STYLE WS_CHILD
 FONT 8, "MS Sans Serif"
 BEGIN
-    EDITTEXT        IDC_LAYERSHADE_EDITR0,45,15,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_SHADER0,45,15,20,12,ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITG0,65,15,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEG0,65,15,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITB0,85,15,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEB0,85,15,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
     CTEXT           "Count",IDC_LAYERSHADE_COUNTTEXT,5,5,25,10,SS_SUNKEN
-    EDITTEXT        IDC_LAYERSHADE_EDITR1,45,30,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_SHADER1,45,30,20,12,ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITG1,65,30,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEG1,65,30,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITB1,85,30,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEB1,85,30,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITR2,45,45,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_SHADER2,45,45,20,12,ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITG2,65,45,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEG2,65,45,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITB2,85,45,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEB2,85,45,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
     CTEXT           "RGB",IDC_LAYERSHADE_TEXT7,45,5,60,8,SS_SUNKEN
-    EDITTEXT        IDC_LAYERSHADE_EDITR3,45,60,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_SHADER3,45,60,20,12,ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITG3,65,60,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEG3,65,60,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_EDITB3,85,60,20,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADEB3,85,60,20,12,ES_AUTOHSCROLL | 
                     ES_NUMBER | WS_GROUP
-    EDITTEXT        IDC_LAYERSHADE_COUNTEDIT,5,15,25,12,ES_AUTOHSCROLL | 
+    EDITTEXT        IDC_LAYERSHADE_SHADECOUNT,5,15,25,12,ES_AUTOHSCROLL | 
                     ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
-    CONTROL         "Spin2",IDC_SPIN2,"msctls_updown32",UDS_SETBUDDYINT | 
+    CONTROL         "Spin2",IDC_LAYERSHADE_SHADECOUNT_SPIN,"msctls_updown32",
-                    UDS_ALIGNRIGHT | UDS_AUTOBUDDY,31,10,11,20
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY,31,10,
-    COMBOBOX        IDC_LAYERSHADE_BACKGFX0,5,75,140,220,CBS_DROPDOWNLIST | 
+                    11,20
-                    WS_VSCROLL | WS_TABSTOP
+    EDITTEXT        IDC_LAYERSHADE_GFX_CURRENT,5,100,30,12,ES_AUTOHSCROLL | 
-    COMBOBOX        IDC_LAYERSHADE_BACKGFX1,5,120,140,220,CBS_DROPDOWNLIST | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
-                    WS_VSCROLL | WS_TABSTOP
+    CONTROL         "Spin1",IDC_LAYERSHADE_GFX_CURRENT_SPIN,"msctls_updown32",
-    CONTROL         "Spin",IDC_LAYERSHADE_SPIN0,"Button",BS_AUTOCHECKBOX | 
+                    UDS_SETBUDDYINT | UDS_ALIGNLEFT | UDS_AUTOBUDDY | 
-                    BS_LEFTTEXT | WS_TABSTOP,5,90,30,10
+                    UDS_ARROWKEYS | UDS_NOTHOUSANDS,125,100,11,15
-    CONTROL         "Move",IDC_LAYERSHADE_MOVE0,"Button",BS_AUTOCHECKBOX | 
+    CTEXT           "Gfx",IDC_LAYERSHADE_COUNTTEXT2,5,75,145,10,SS_SUNKEN
-                    BS_LEFTTEXT | WS_TABSTOP,65,90,30,10
+    COMBOBOX        IDC_LAYERSHADE_GFX_LIST,5,116,145,190,CBS_DROPDOWNLIST | 
-    CONTROL         "Scale",IDC_LAYERSHADE_SCALE0,"Button",BS_AUTOCHECKBOX | 
+                    WS_VSCROLL
-                    BS_LEFTTEXT | WS_TABSTOP,35,90,30,10
+    PUSHBUTTON      "Goto",IDC_LAYERSHADE_GFX_GOTO,5,130,70,15,NOT 
-    CONTROL         "Color",IDC_LAYERSHADE_COLOR0,"Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP
-                    BS_LEFTTEXT | WS_TABSTOP,95,90,30,10
+    PUSHBUTTON      "Delete",IDC_LAYERSHADE_GFX_DELETE,80,130,70,15,NOT 
-    COMBOBOX        IDC_LAYERSHADE_TRANS0,5,100,140,81,CBS_DROPDOWNLIST | 
+                    WS_TABSTOP
-                    WS_VSCROLL | WS_TABSTOP
+    CTEXT           "Pos",IDC_LAYERSHADE_POSTEXT,5,150,25,10,SS_SUNKEN
-    CONTROL         "Spin",IDC_LAYERSHADE_SPIN1,"Button",BS_AUTOCHECKBOX | 
+    CTEXT           "XY0",IDC_LAYERSHADE_XYTEXT0,5,166,70,10,SS_SUNKEN
-                    BS_LEFTTEXT | WS_TABSTOP,5,135,30,10
+    EDITTEXT        IDC_LAYERSHADE_GFX_X0,5,175,35,10,ES_AUTOHSCROLL | 
-    CONTROL         "Move",IDC_LAYERSHADE_MOVE1,"Button",BS_AUTOCHECKBOX | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
-                    BS_LEFTTEXT | WS_TABSTOP,65,135,30,10
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_X0,"msctls_updown32",
-    CONTROL         "Scale",IDC_LAYERSHADE_SCALE1,"Button",BS_AUTOCHECKBOX | 
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
-                    BS_LEFTTEXT | WS_TABSTOP,35,135,30,10
+                    UDS_ARROWKEYS,115,5,11,15
-    CONTROL         "Color",IDC_LAYERSHADE_COLOR1,"Button",BS_AUTOCHECKBOX | 
+    EDITTEXT        IDC_LAYERSHADE_GFX_Y0,40,175,34,10,ES_AUTOHSCROLL | 
-                    BS_LEFTTEXT | WS_TABSTOP,95,135,30,10
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
-    COMBOBOX        IDC_LAYERSHADE_TRANS1,5,146,140,81,CBS_DROPDOWNLIST | 
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_Y0,"msctls_updown32",
-                    WS_VSCROLL | WS_TABSTOP
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,125,5,11,15
+    CTEXT           "XY1",IDC_LAYERSHADE_XYTEXT1,80,166,70,10,SS_SUNKEN
+    EDITTEXT        IDC_LAYERSHADE_GFX_X1,80,175,35,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_X1,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,135,5,11,15
+    EDITTEXT        IDC_LAYERSHADE_GFX_Y1,115,175,35,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_Y1,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,145,5,11,15
+    CTEXT           "XY2",IDC_LAYERSHADE_XYTEXT2,5,201,70,10,SS_SUNKEN
+    EDITTEXT        IDC_LAYERSHADE_GFX_X2,5,210,35,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_X2,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,115,20,11,15
+    EDITTEXT        IDC_LAYERSHADE_GFX_Y2,40,210,34,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_Y2,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,125,20,11,15
+    CTEXT           "XY3",IDC_LAYERSHADE_XYTEXT3,80,201,70,10,SS_SUNKEN
+    EDITTEXT        IDC_LAYERSHADE_GFX_X3,80,210,35,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_X3,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,135,20,11,15
+    EDITTEXT        IDC_LAYERSHADE_GFX_Y3,115,210,35,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_SPIN_Y3,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,145,20,11,15
+    COMBOBOX        IDC_LAYERSHADE_GFX_TRANSLIST,5,250,145,70,
+                    CBS_DROPDOWNLIST
+    CTEXT           "Transparency Mode",IDC_LAYERSHADE_TRANSTEXT,5,241,145,
+                    10,SS_SUNKEN
+    EDITTEXT        IDC_LAYERSHADE_GFXR0,5,185,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXG0,25,185,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXB0,45,185,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXR1,80,185,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXG1,100,185,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXB1,120,185,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXR2,5,220,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXG2,25,220,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXB2,45,220,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXR3,80,220,20,12,ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXG3,100,220,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFXB3,120,220,20,12,ES_AUTOHSCROLL | 
+                    ES_NUMBER | WS_GROUP
+    EDITTEXT        IDC_LAYERSHADE_GFX_X,30,150,25,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | NOT WS_TABSTOP
+    CONTROL         "Spin1",IDC_LAYERSHADE_GFX_XSPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,95,145,11,15
+    EDITTEXT        IDC_LAYERSHADE_GFX_Y,55,150,25,10,ES_AUTOHSCROLL | 
+                    ES_READONLY | NOT WS_TABSTOP
+    CONTROL         "Spin3",IDC_LAYERSHADE_GFX_YSPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,110,145,11,15
+    COMBOBOX        IDC_LAYERSHADE_DEF_LIST,5,85,145,100,CBS_DROPDOWNLIST
 END
 
 IDD_LAYER_COLLISION DIALOG DISCARDABLE  0, 0, 156, 41
@@ -692,7 +761,7 @@ BEGIN
                     WS_VSCROLL | WS_TABSTOP
 END
 
-IDD_LAYER_TRIGGER DIALOG DISCARDABLE  0, 0, 156, 26
+IDD_LAYER_TRIGGER DIALOG DISCARDABLE  0, 0, 156, 46
 STYLE WS_CHILD
 FONT 8, "MS Sans Serif"
 BEGIN
@@ -707,6 +776,17 @@ BEGIN
     CONTROL         "Spin1",IDC_TRIGGER_HEIGHT_SPIN,"msctls_updown32",
                     UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
                     UDS_ARROWKEYS,100,5,11,10
+    RTEXT           "Target",IDC_TRIGGER_TARGET,0,25,22,8
+    EDITTEXT        IDC_TRIGGER_TARGETX,25,25,24,12,ES_AUTOHSCROLL | 
+                    ES_READONLY
+    CONTROL         "Spin1",IDC_TRIGGER_TARGETX_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,90,25,11,10
+    EDITTEXT        IDC_TRIGGER_TARGETY,50,25,25,12,ES_AUTOHSCROLL | 
+                    ES_READONLY
+    CONTROL         "Spin1",IDC_TRIGGER_TARGETY_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,100,25,11,10
 END
 
 IDD_LAYER_FX DIALOG DISCARDABLE  0, 0, 156, 56
@@ -729,6 +809,44 @@ BEGIN
                     UDS_ARROWKEYS | UDS_NOTHOUSANDS,50,25,11,13
 END
 
+IDD_LAYER_HAZARD DIALOG DISCARDABLE  0, 0, 156, 96
+STYLE WS_CHILD
+FONT 8, "MS Sans Serif"
+BEGIN
+    RTEXT           "Speed",IDC_HAZARD_SPEED_TEXT,5,5,32,8
+    EDITTEXT        IDC_HAZARD_SPEED,41,5,35,12,ES_AUTOHSCROLL | ES_READONLY
+    CONTROL         "Spin1",IDC_HAZARD_SPEED_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,75,5,11,10
+    RTEXT           "TurnRate",IDC_HAZARD_TURNRATE_TEXT,5,20,31,8
+    EDITTEXT        IDC_HAZARD_TURNRATE,41,20,35,12,ES_AUTOHSCROLL | 
+                    ES_READONLY
+    CONTROL         "Spin1",IDC_HAZARD_TURNRATE_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,75,20,11,10
+    RTEXT           "Health",IDC_HAZARD_HEALTH_TEXT,5,39,32,8
+    EDITTEXT        IDC_HAZARD_HEALTH,41,39,35,12,ES_AUTOHSCROLL | 
+                    ES_READONLY
+    CONTROL         "Spin1",IDC_HAZARD_HEALTH_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,75,39,11,10
+    RTEXT           "Attack",IDC_HAZARD_ATTACK_TEXT,5,55,31,8
+    EDITTEXT        IDC_HAZARD_ATTACK,41,55,35,12,ES_AUTOHSCROLL | 
+                    ES_READONLY
+    CONTROL         "Spin1",IDC_HAZARD_ATTACK_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,75,55,11,10
+    CONTROL         "Collision",IDC_HAZARD_COLLISION,"Button",
+                    BS_AUTOCHECKBOX | BS_LEFTTEXT | BS_RIGHT | WS_TABSTOP,90,
+                    5,50,10
+    RTEXT           "Respawn",IDC_HAZARD_RESPAWN_TEXT,5,70,31,8
+    EDITTEXT        IDC_HAZARD_RESPAWN,41,70,35,12,ES_AUTOHSCROLL | 
+                    ES_READONLY
+    CONTROL         "Spin1",IDC_HAZARD_RESPAWN_SPIN,"msctls_updown32",
+                    UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | 
+                    UDS_ARROWKEYS,75,70,11,10
+END
+
 
 /////////////////////////////////////////////////////////////////////////////
 //
@@ -791,7 +909,7 @@ BEGIN
         LEFTMARGIN, 7
         RIGHTMARGIN, 149
         TOPMARGIN, 7
-        BOTTOMMARGIN, 159
+        BOTTOMMARGIN, 289
     END
 
     IDD_LAYER_COLLISION, DIALOG
@@ -847,7 +965,7 @@ BEGIN
         LEFTMARGIN, 7
         RIGHTMARGIN, 149
         TOPMARGIN, 7
-        BOTTOMMARGIN, 19
+        BOTTOMMARGIN, 39
     END
 
     IDD_LAYER_FX, DIALOG
@@ -857,6 +975,14 @@ BEGIN
         TOPMARGIN, 7
         BOTTOMMARGIN, 49
     END
+
+    IDD_LAYER_HAZARD, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 149
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 89
+    END
 END
 #endif    // APSTUDIO_INVOKED
 

Utils/MapEdit/resource.h

@@ -24,6 +24,7 @@
 #define IDD_LAYER_PLATFORM              183
 #define IDD_LAYER_TRIGGER               184
 #define IDD_LAYER_FX                    185
+#define IDD_LAYER_HAZARD                186
 #define IDC_TOOLBAR_COMBO               1018
 #define IDC_LAYERLIST_LIST              1019
 #define IDD_TILEBANK_UPDATE             1029
@@ -40,37 +41,70 @@
 #define IDC_LAYERLIST_DELETE            1057
 #define IDC_ADDLAYER_LIST               1058
 #define IDC_LAYERSHADE_EDITR0           1060
+#define IDC_LAYERSHADE_SHADER0          1060
 #define IDC_LAYERSHADE_EDITG0           1061
+#define IDC_LAYERSHADE_SHADEG0          1061
 #define IDC_LAYERSHADE_EDITB0           1062
+#define IDC_LAYERSHADE_SHADEB0          1062
 #define IDC_LAYERSHADE_EDITR1           1064
+#define IDC_LAYERSHADE_SHADER1          1064
 #define IDC_LAYERSHADE_EDITG1           1065
+#define IDC_LAYERSHADE_SHADEG1          1065
 #define IDC_LAYERSHADE_EDITB1           1066
+#define IDC_LAYERSHADE_SHADEB1          1066
 #define IDC_LAYERSHADE_COUNTEDIT        1074
+#define IDC_LAYERSHADE_SHADECOUNT       1074
 #define IDC_LAYERSHADE_COUNTTEXT        1075
 #define IDC_SPIN2                       1076
+#define IDC_LAYERSHADE_SHADECOUNT_SPIN  1076
+#define IDC_LAYERSHADE_COUNTTEXT2       1077
 #define IDC_LAYERCOLLISION_NORMAL       1078
+#define IDC_LAYERSHADE_POSTEXT          1078
+#define IDC_LAYERSHADE_XYTEXT0          1079
 #define IDD_ELEM_LIST                   1080
+#define IDC_LAYERSHADE_XYTEXT1          1080
 #define IDC_LAYERSHADE_EDITR2           1081
+#define IDC_LAYERSHADE_SHADER2          1081
 #define IDC_LAYERSHADE_EDITG2           1082
 #define IDC_LAYERCOLLISION_DAMAGE       1082
+#define IDC_LAYERSHADE_SHADEG2          1082
 #define IDC_LAYERSHADE_EDITB2           1083
 #define IDC_LAYERCOLLISION_SLIPPERY     1083
+#define IDC_LAYERSHADE_SHADEB2          1083
 #define IDC_LAYERCOLLISION_ELECTRIC     1084
+#define IDC_LAYERSHADE_XYTEXT2          1084
 #define IDC_LAYERCOLLISION_STICKY       1085
+#define IDC_LAYERSHADE_XYTEXT3          1085
 #define IDC_LAYERSHADE_TEXT7            1086
 #define IDC_LAYERCOLLISION_WATER        1086
 #define IDC_ACTOR_SPEED_TEXT            1086
 #define IDC_LAYERSHADE_EDITR3           1087
 #define IDC_LAYERCOLLISION_SOLID        1087
 #define IDC_ACTOR_SPEED                 1087
+#define IDC_LAYERSHADE_SHADER3          1087
 #define IDC_LAYERSHADE_EDITG3           1088
 #define IDC_LAYERCOLLISION_DEATH        1088
+#define IDC_LAYERSHADE_SHADEG3          1088
 #define IDC_LAYERSHADE_EDITB3           1089
+#define IDC_LAYERSHADE_SHADEB3          1089
+#define IDC_LAYERSHADE_TRANSTEXT        1090
+#define IDC_LAYERSHADE_GFXR0            1091
 #define IDC_ACTOR_SPEED_SPIN            1092
+#define IDC_LAYERSHADE_GFXG0            1092
+#define IDC_LAYERSHADE_GFXB0            1093
 #define IDC_ACTOR_PLAYER                1094
+#define IDC_LAYERSHADE_GFXR1            1094
+#define IDC_LAYERSHADE_GFXG1            1095
+#define IDC_LAYERSHADE_GFXB1            1096
 #define IDC_ACTOR_TURNRATE_TEXT         1097
 #define IDC_ACTOR_TURNRATE              1098
 #define IDC_ACTOR_TURNRATE_SPIN         1099
+#define IDC_LAYERSHADE_GFXR2            1101
+#define IDC_LAYERSHADE_GFXG2            1102
+#define IDC_LAYERSHADE_GFXB2            1103
+#define IDC_LAYERSHADE_GFXR3            1107
+#define IDC_LAYERSHADE_GFXG3            1108
+#define IDC_LAYERSHADE_GFXB3            1109
 #define IDC_ACTOR_HEALTH_TEXT           1112
 #define IDC_ACTOR_HEALTH                1113
 #define IDC_ACTOR_HEALTH_SPIN           1114
@@ -100,26 +134,63 @@
 #define IDC_TRIGGER_HEIGHT              1142
 #define IDC_TRIGGER_WIDTH_SPIN          1143
 #define IDC_FX_SPEED_TEXT               1144
+#define IDC_TRIGGER_TARGET              1144
+#define IDC_TRIGGER_TARGETX             1145
 #define IDC_FX_SIZE_TEXT                1146
+#define IDC_TRIGGER_TARGETX_SPIN        1146
 #define IDC_FX_WIDTH                    1147
+#define IDC_TRIGGER_TARGETY             1147
 #define IDC_FX_HEIGHT                   1148
 #define IDC_FX_WIDTH_SPIN               1149
 #define IDC_FX_HEIGHT_SPIN              1150
 #define IDC_FX_SPEED                    1151
 #define IDC_FX_SPEED_SPIN               1152
-#define IDC_LAYERSHADE_BACKGFX0         1153
-#define IDC_LAYERSHADE_SPIN0            1154
-#define IDC_LAYERSHADE_BACKGFX1         1155
-#define IDC_LAYERSHADE_MOVE0            1156
-#define IDC_LAYERSHADE_SCALE0           1157
-#define IDC_LAYERSHADE_COLOR0           1158
-#define IDC_LAYERSHADE_SPIN1            1159
-#define IDC_LAYERSHADE_MOVE1            1160
-#define IDC_LAYERSHADE_SCALE1           1161
-#define IDC_LAYERSHADE_TRANS0           1162
-#define IDC_LAYERSHADE_COLOR1           1163
 #define IDC_TRIGGER_HEIGHT_SPIN         1163
-#define IDC_LAYERSHADE_TRANS1           1164
+#define IDC_TRIGGER_TARGETY_SPIN        1164
+#define IDC_HAZARD_SPEED_TEXT           1169
+#define IDC_HAZARD_TURNRATE_TEXT        1170
+#define IDC_HAZARD_HEALTH_TEXT          1171
+#define IDC_HAZARD_ATTACK_TEXT          1172
+#define IDC_HAZARD_SPEED                1173
+#define IDC_HAZARD_TURNRATE             1174
+#define IDC_HAZARD_HEALTH               1175
+#define IDC_HAZARD_ATTACK               1176
+#define IDC_HAZARD_SPEED_SPIN           1177
+#define IDC_HAZARD_TURNRATE_SPIN        1178
+#define IDC_HAZARD_HEALTH_SPIN          1179
+#define IDC_HAZARD_ATTACK_SPIN          1180
+#define IDC_HAZARD_COLLISION            1181
+#define IDC_HAZARD_RESPAWN_TEXT         1182
+#define IDC_HAZARD_RESPAWN              1183
+#define IDC_LAYERSHADE_GFX_CURRENT      1183
+#define IDC_HAZARD_RESPAWN_SPIN         1184
+#define IDC_LAYERSHADE_GFX_CURRENT_SPIN 1184
+#define IDC_LAYERSHADE_GFX_LIST         1186
+#define IDC_LAYERSHADE_GFX_GOTO         1190
+#define IDC_LAYERSHADE_GFX_DELETE       1191
+#define IDC_LAYERSHADE_GFX_X0           1192
+#define IDC_LAYERSHADE_GFX_SPIN_X0      1193
+#define IDC_LAYERSHADE_GFX_Y0           1194
+#define IDC_LAYERSHADE_GFX_SPIN_Y0      1195
+#define IDC_LAYERSHADE_GFX_X1           1196
+#define IDC_LAYERSHADE_GFX_SPIN_X1      1197
+#define IDC_LAYERSHADE_GFX_Y1           1198
+#define IDC_LAYERSHADE_GFX_SPIN_Y1      1199
+#define IDC_LAYERSHADE_GFX_X2           1200
+#define IDC_LAYERSHADE_GFX_SPIN_X2      1201
+#define IDC_LAYERSHADE_GFX_Y2           1202
+#define IDC_LAYERSHADE_GFX_SPIN_Y2      1203
+#define IDC_LAYERSHADE_GFX_X3           1204
+#define IDC_LAYERSHADE_GFX_SPIN_X3      1205
+#define IDC_LAYERSHADE_GFX_Y3           1206
+#define IDC_LAYERSHADE_GFX_SPIN_Y3      1207
+#define IDC_LAYERSHADE_GFX_TRANSLIST    1208
+#define IDC_LAYERSHADE_GFX_X            1209
+#define IDC_LAYERSHADE_GFX_NEW          1210
+#define IDC_LAYERSHADE_GFX_XSPIN        1211
+#define IDC_LAYERSHADE_GFX_Y            1212
+#define IDC_LAYERSHADE_GFX_YSPIN        1213
+#define IDC_LAYERSHADE_DEF_LIST         1214
 #define ID_TOOLBAR_TILEPALETTE          32774
 #define ID_TOOLBAR_PARAMBAR             32783
 #define ID_TOGGLE_SUBVIEW               32785
@@ -145,7 +216,7 @@
 #define _APS_3D_CONTROLS                     1
 #define _APS_NEXT_RESOURCE_VALUE        180
 #define _APS_NEXT_COMMAND_VALUE         32801
-#define _APS_NEXT_CONTROL_VALUE         1164
+#define _APS_NEXT_CONTROL_VALUE         1215
 #define _APS_NEXT_SYMED_VALUE           101
 #endif
 #endif

Utils/MkLevel/Layers/MkLevelLayerActor.cpp

@@ -72,11 +72,11 @@ int			i,ListSize=ThingList.size();
 			sThingActor			OutThing;
 
 			OutThing.Type=ThisThing.Type;
-			OutThing.Health=ThisThing.Data.Health;
+			OutThing.Health=ThisThing.Data.Actor.ActorHealth;
-			OutThing.AttackStrength=ThisThing.Data.AttackStrength;
+			OutThing.AttackStrength=ThisThing.Data.Actor.ActorAttackStrength;
-			OutThing.Speed=ThisThing.Data.Speed;
+			OutThing.Speed=ThisThing.Data.Actor.ActorSpeed;
-			OutThing.TurnRate=ThisThing.Data.TurnRate;
+			OutThing.TurnRate=ThisThing.Data.Actor.ActorTurnRate;
-			OutThing.Flags=ThisThing.Data.CollisionFlag;
+			OutThing.Flags=ThisThing.Data.Actor.ActorCollisionFlag;
 			OutThing.PointCount=PointCount;
 			fwrite(&OutThing,sizeof(sThingActor),1,File);
 

Utils/MkLevel/Layers/MkLevelLayerFX.cpp

@@ -50,11 +50,11 @@ int			i,ListSize=ThingList.size();
 			sThingFX			OutThing;
 
 			OutThing.Type=ThisThing.Type;
-			OutThing.Speed=ThisThing.Data.Speed;
+			OutThing.Speed=ThisThing.Data.FX.FXSpeed;
 			OutThing.Pos.X=ThisThing.XY[0].x;
 			OutThing.Pos.Y=ThisThing.XY[0].y;
-			OutThing.Size.X=ThisThing.Data.Width;
+			OutThing.Size.X=ThisThing.Data.FX.FXWidth;
-			OutThing.Size.Y=ThisThing.Data.Height;
+			OutThing.Size.Y=ThisThing.Data.FX.FXHeight;
 			fwrite(&OutThing,sizeof(sThingFX),1,File);
 
 		}

Utils/MkLevel/Layers/MkLevelLayerHazard.cpp

@@ -1,12 +1,12 @@
 /**********************/
-/*** Layer Platform ***/
+/*** Layer Hazard ***/
 /**********************/
 
 #include	<Davelib.h>
 #include	<List2d.h>
 
 //#include	"MkLevel.h"
-#include	"MkLevelLayerPlatform.h"
+#include	"MkLevelLayerHazard.h"
 
 
 /*****************************************************************************/
@@ -14,7 +14,7 @@
 /*** Pre-Process *************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
-void	CMkLevelLayerPlatform::PreProcess(CMkLevel *Core)
+void	CMkLevelLayerHazard::PreProcess(CMkLevel *Core)
 {
 int		i,ListSize;
 		ProcessList(Core);
@@ -24,10 +24,11 @@ int		i,ListSize;
 		for (i=0; i<ListSize; i++)
 		{
 			sMkLevelLayerThing	&ThisThing=ThingList[i];
-			RemapTable[i]=Core->AddModel(ThisThing);
+			RemapTable[i]=Core->AddModel(ThisThing.Name,ThisThing.Data.Hazard.HazardTriStart,ThisThing.Data.Hazard.HazardTriCount);
+
 		}
 
-		printf("%i Platforms\n",ThingList.size());
+		printf("%i Hazards\n",ThingList.size());
 }
 
 /*****************************************************************************/
@@ -35,7 +36,7 @@ int		i,ListSize;
 /*** Process *****************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
-void	CMkLevelLayerPlatform::Process(CMkLevel *Core)
+void	CMkLevelLayerHazard::Process(CMkLevel *Core)
 {
 }
 
@@ -44,7 +45,7 @@ void	CMkLevelLayerPlatform::Process(CMkLevel *Core)
 /** Write ********************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
-int		CMkLevelLayerPlatform::Write(FILE *File,const char *LayerName,const char *MapName)
+int		CMkLevelLayerHazard::Write(FILE *File,const char *LayerName,const char *MapName)
 {
 int			ThisPos=ftell(File);
 sThingHdr	Hdr;
@@ -57,15 +58,16 @@ int			i,ListSize=ThingList.size();
 		{
 			sMkLevelLayerThing	&ThisThing=ThingList[i];
 			int					p,PointCount=ThisThing.XY.size();
-			sThingPlatform			OutThing;
+			sThingHazard			OutThing;
 
 			OutThing.Type=ThisThing.Type;
-			OutThing.Speed=ThisThing.Data.Platform.PlatformSpeed;
+			OutThing.Speed=ThisThing.Data.Hazard.HazardSpeed;
-			OutThing.TurnRate=ThisThing.Data.Platform.PlatformTurnRate;
+			OutThing.TurnRate=ThisThing.Data.Hazard.HazardTurnRate;
-			OutThing.Flags=ThisThing.Data.Platform.PlatformCollisionFlag;
+			OutThing.Flags=ThisThing.Data.Hazard.HazardCollisionFlag;
 			OutThing.PointCount=PointCount;
+			OutThing.Respawn=ThisThing.Data.Hazard.HazardRespawn;
 			OutThing.Gfx=RemapTable[i];
-			fwrite(&OutThing,sizeof(sThingPlatform),1,File);
+			fwrite(&OutThing,sizeof(sThingHazard),1,File);
 
 			for (p=0;p<PointCount;p++)
 			{

Utils/MkLevel/Layers/MkLevelLayerHazard.h

@@ -1,19 +1,19 @@
-/**********************/
+/********************/
-/*** Layer Platform ***/
+/*** Layer Hazard ***/
-/**********************/
+/********************/
 
-#ifndef	__MKLEVEL_LAYER_PLATFORM_HEADER__
+#ifndef	__MKLEVEL_LAYER_HAZARD_HEADER__
-#define	__MKLEVEL_LAYER_PLATFORM_HEADER__
+#define	__MKLEVEL_LAYER_HAZARD_HEADER__
 
 #include	"MkLevelLayerThing.h"
 #include	<List2d.h>
 
 /*****************************************************************************/
-class	CMkLevelLayerPlatform : public CMkLevelLayerThing
+class	CMkLevelLayerHazard : public CMkLevelLayerThing
 {
 public:
-		CMkLevelLayerPlatform(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
+		CMkLevelLayerHazard(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
-const	char	*GetTypeName()		{return("PLATFORM");}
+const	char	*GetTypeName()		{return("HAZARD");}
 
 		void	PreProcess(CMkLevel *Core);
 		void	Process(CMkLevel *Core);

Utils/MkLevel/Layers/MkLevelLayerPlatform.cpp

@@ -24,7 +24,7 @@ int		i,ListSize;
 		for (i=0; i<ListSize; i++)
 		{
 			sMkLevelLayerThing	&ThisThing=ThingList[i];
-			RemapTable[i]=Core->AddModel(ThisThing);
+			RemapTable[i]=Core->AddModel(ThisThing.Name,ThisThing.Data.Platform.PlatformTriStart,ThisThing.Data.Platform.PlatformTriCount);
 		}
 
 		printf("%i Platforms\n",ThingList.size());
@@ -60,9 +60,9 @@ int			i,ListSize=ThingList.size();
 			sThingPlatform			OutThing;
 
 			OutThing.Type=ThisThing.Type;
-			OutThing.Speed=ThisThing.Data.Speed;
+			OutThing.Speed=ThisThing.Data.Platform.PlatformSpeed;
-			OutThing.TurnRate=ThisThing.Data.TurnRate;
+			OutThing.TurnRate=ThisThing.Data.Platform.PlatformTurnRate;
-			OutThing.Flags=ThisThing.Data.CollisionFlag;
+			OutThing.Flags=ThisThing.Data.Platform.PlatformCollisionFlag;
 			OutThing.PointCount=PointCount;
 			OutThing.Gfx=RemapTable[i];
 			fwrite(&OutThing,sizeof(sThingPlatform),1,File);

Utils/MkLevel/Layers/MkLevelLayerShade.cpp

@@ -13,9 +13,9 @@
 /*****************************************************************************/
 CMkLevelLayerShade::CMkLevelLayerShade(sExpLayerHdr *LayerHdr)
 {
+int		i,ListSize;
 int		*iPtr;
 u8		*Ptr=(u8*)LayerHdr;
-u8		*RGB;
 
 		Type=LayerHdr->Type;
 		SubType=LayerHdr->SubType;
@@ -24,31 +24,36 @@ u8		*RGB;
 
 		iPtr=(int*)(Ptr+sizeof(sExpLayerHdr));
 
-		Count=*iPtr++;
+		ShadeHdr.BandCount=*iPtr++;
-		List.resize(LAYER_SHADE_RGB_MAX);
+sRGBCol	*RGB=(sRGBCol*)iPtr;
-		for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
+		for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
 		{
-			List[i].Pos=*iPtr++;
+			ShadeHdr.RGB[i][0]=RGB->R;
-			RGB=(u8*)(iPtr);
+			ShadeHdr.RGB[i][1]=RGB->G;
-			List[i].RGB[0]=RGB[0];
+			ShadeHdr.RGB[i][2]=RGB->B;
-			List[i].RGB[1]=RGB[1];
+			RGB++;
-			List[i].RGB[2]=RGB[2];
-			iPtr+=4/sizeof(int);
 		}
 
-		Trans[0]=*iPtr++;
+		iPtr=(int*)RGB;
-		Flags[0]=*iPtr++;
-		Trans[1]=*iPtr++;
-		Flags[1]=*iPtr++;
-
-// Load back gfx
-char	*c=(char*)iPtr;
-		BackGfx[0]=c;  
-		c+=strlen(c)+1;
-		BackGfx[1]=c;  
 
+		ListSize=*iPtr++;
+		GfxList.resize(ListSize);
+sLayerShadeGfx	*GfxPtr=(sLayerShadeGfx*)iPtr;
+		for (i=0; i<ListSize; i++)
+		{
+			GfxList[i]=*GfxPtr++;
 		}
+		iPtr=(int*)GfxPtr;
 
+		ListSize=*iPtr++;
+		TypeNameList.resize(ListSize);
+char	*TypePtr=(char*)iPtr;
+		for (i=0; i<ListSize; i++)
+		{
+			TypeNameList[i]=TypePtr;
+			TypePtr+=strlen(TypePtr)+1;
+		}
+}
 
 /*****************************************************************************/
 /*****************************************************************************/
@@ -58,40 +63,29 @@ char	*c=(char*)iPtr;
 // Build unique tiles, including pre-genned flips, and replace tile idx with new one
 void	CMkLevelLayerShade::PreProcess(CMkLevel *Core)
 {
+int			i,ListSize=GfxList.size();
+int			Idx;
 GString		Path=Core->GetConfigStr("MISC","BackGfxDir");
-
-	for (int i=0; i<2; i++)
-	{
-		if (!BackGfx[i].Empty())
-		{
-			TexID[i]=AddBackGfx(Core,Path+BackGfx[i]+".Bmp");
-		}
-		else
-		{
-			TexID[i]=-1;
-		}
-	}
-}
-
-/*****************************************************************************/
-int		CMkLevelLayerShade::AddBackGfx(CMkLevel *Core,const char *Filename)
-{
-sBackGfxList	NewGfx;
 CTexGrab	&TexGrab=Core->GetTexGrab();
 
-			NewGfx.Name=Filename;
+		for (i=0; i<ListSize; i++)
-			NewGfx.TexID=-1;
+		{
+			sLayerShadeGfx	&ThisGfx=GfxList[i];
+			sBackGfxList	NewType;
 				
-int			Idx=BackGfxList.Add(NewGfx);
+			NewType.Name=Path+TypeNameList[ThisGfx.Gfx]+".Bmp";
+			Idx=OutTypeList.Find(NewType);
 
-			if (BackGfxList[Idx].TexID==-1)
+			if (Idx==-1)
 			{
 				TexGrab.ZeroColZero(true);
-				BackGfxList[Idx].TexID=TexGrab.AddFile(BackGfxList[Idx].Name);
+				NewType.TexID=TexGrab.AddFile(NewType.Name);
 				TexGrab.ZeroColZero(false);
-			}
 
-			return(BackGfxList[Idx].TexID);
+				Idx=OutTypeList.Add(NewType);
+			}
+			ThisGfx.Gfx=Idx;
+		}
 
 }
 
@@ -102,31 +96,25 @@ int			Idx=BackGfxList.Add(NewGfx);
 /*****************************************************************************/
 void	CMkLevelLayerShade::Process(CMkLevel *Core)
 {
+int			i,ListSize=OutTypeList.size();
 CTexGrab	&TexGrab=Core->GetTexGrab();
 
 		//printf("Process Shade Layer\n");
-		for (int i=0; i<2; i++)
+		for (i=0; i<ListSize; i++)
 		{
-			sLayerShadeGfx	&ThisGfx=Data.BackGfx[i];
+			sBackGfxList	&ThisType=OutTypeList[i];
-			if (TexID[i]==-1)
+
-			{
+			sTexOutInfo	&ThisTex=TexGrab.GetTexInfo()[ThisType.TexID];
-				ThisGfx.TPage=0;
+			ThisType.Out.TPage=ThisTex.Tpage;
-			}
+			ThisType.Out.Clut=ThisTex.Clut;
-			else
+			ThisType.Out.U=ThisTex.u;
-			{
+			ThisType.Out.V=ThisTex.v;
-				sTexOutInfo	&ThisTex=TexGrab.GetTexInfo()[TexID[i]];
+			ThisType.Out.W=ThisTex.w;
-				ThisGfx.TPage=ThisTex.Tpage;
+			ThisType.Out.H=ThisTex.h;
-				ThisGfx.Clut=ThisTex.Clut;
+//			ThisType.TPage|=Trans[i]<<5;
-				ThisGfx.U=ThisTex.u;
-				ThisGfx.V=ThisTex.v;
-				ThisGfx.W=ThisTex.w;
-				ThisGfx.H=ThisTex.h;
-				ThisGfx.TPage|=Trans[i]<<5;
-				ThisGfx.Flags=Flags[i];
 		}
 
 }
-}
 
 /*****************************************************************************/
 /*****************************************************************************/
@@ -144,19 +132,57 @@ int				ThisPos=ftell(File);
 		Hdr.Height=Height;
 		fwrite(&Hdr,sizeof(sLayerHdr),1,File);
 
-		Data.Count=Count;
+// Write Gfx Stuff
-		for (int i=0; i<Count; i++)
+		ShadeHdr.TypeList=(sLayerShadeBackGfxType*)WriteTypeList(File);
-		{
+		ShadeHdr.GfxList=(sLayerShadeBackGfx*)WriteGfxList(File);
-			Data.Data[i].Ofs=List[i].Pos;
-			Data.Data[i].RGB[0]=List[i].RGB[0];
-			Data.Data[i].RGB[1]=List[i].RGB[1];
-			Data.Data[i].RGB[2]=List[i].RGB[2];
-		}
 
-		fwrite(&Data,sizeof(sLayerShadeHdr),1,File);
+
+		fwrite(&ShadeHdr,sizeof(sLayerShadeHdr),1,File);
 		PadFile(File);
 
 		return(ThisPos);
 }
 
 /*****************************************************************************/
+int		CMkLevelLayerShade::WriteTypeList(FILE *File)
+{
+int		Pos=ftell(File);
+int		i,ListSize=OutTypeList.size();
+
+		for (i=0; i<ListSize; i++)
+		{
+			sBackGfxList	&ThisType=OutTypeList[i];
+
+			fwrite(&ThisType.Out,sizeof(sLayerShadeBackGfxType),1,File);
+		}
+		return(Pos);
+}
+
+/*****************************************************************************/
+int		CMkLevelLayerShade::WriteGfxList(FILE *File)
+{
+int		Pos=ftell(File);
+int		i,ListSize=GfxList.size();
+
+		ShadeHdr.GfxCount=GfxList.size();
+
+		for (i=0; i<ListSize; i++)
+		{
+			sLayerShadeGfx	&ThisGfx=GfxList[i];
+			sLayerShadeBackGfx	Out;
+			
+			Out.Type=ThisGfx.Gfx;
+			Out.PosX=ThisGfx.Pos.x;
+			Out.PosY=ThisGfx.Pos.y;
+			Out.Trans=ThisGfx.TransMode;
+			for (int p=0; p<4; p++)
+			{
+				Out.Ofs[i][0]=ThisGfx.Ofs[i].x;
+				Out.Ofs[i][1]=ThisGfx.Ofs[i].y;
+				Out.RGB[i][0]=ThisGfx.RGB[i].R;
+				Out.RGB[i][1]=ThisGfx.RGB[i].G;
+				Out.RGB[i][2]=ThisGfx.RGB[i].B;
+			}
+		}
+		return(Pos);
+}

Utils/MkLevel/Layers/MkLevelLayerShade.h

@@ -8,18 +8,12 @@
 #include	"MkLevelLayer.h"
 #include	<List2d.h>
 
-/*****************************************************************************/
-struct	SMkLayerShadeRGB
-{
-		int	Pos;
-		u8	RGB[3];
-};
-
 /*****************************************************************************/
 struct  sBackGfxList
 {
 		GString					Name;
 		int						TexID;
+		sLayerShadeBackGfxType	Out;
 
 bool	operator ==(sBackGfxList const &v1)		{return(Name==v1.Name);}
 };
@@ -33,18 +27,16 @@ public:
 		void	PreProcess(CMkLevel *Core);
 		void	Process(CMkLevel *Core);
 		int		Write(FILE *File,const char *LayerName,const char *MapName);
-		int		AddBackGfx(CMkLevel *Core,const char *Filename);
 
 protected:
-			int		Count;
+		int		WriteTypeList(FILE *File);
-			vector<SMkLayerShadeRGB>	List;
+		int		WriteGfxList(FILE *File);
-			GString						BackGfx[2];
-			int							Flags[2];
-			int							Trans[2];
 
-			CList<sBackGfxList>			BackGfxList;
+		CList<GString>			TypeNameList;
-			int							TexID[2];
+		CList<sLayerShadeGfx>	GfxList;
-			sLayerShadeHdr				Data;
+
+		CList<sBackGfxList>		OutTypeList;
+		sLayerShadeHdr			ShadeHdr;
 };
 
 /*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerTrigger.cpp

@@ -52,8 +52,8 @@ int			i,ListSize=ThingList.size();
 			OutThing.Type=ThisThing.Type;
 			OutThing.Pos.X=ThisThing.XY[0].x;
 			OutThing.Pos.Y=ThisThing.XY[0].y;
-			OutThing.Width=ThisThing.Data.Width;
+			OutThing.Width=ThisThing.Data.Trigger.TriggerWidth;
-			OutThing.Height=ThisThing.Data.Height;
+			OutThing.Height=ThisThing.Data.Trigger.TriggerHeight;
 			fwrite(&OutThing,sizeof(sThingTrigger),1,File);
 		}
 

Utils/MkLevel/MkLevel.cpp

@@ -23,6 +23,7 @@
 #include	"Layers\MkLevelLayerPlatform.h"
 #include	"Layers\MkLevelLayerFX.h"
 #include	"Layers\MkLevelLayerTrigger.h"
+#include	"Layers\MkLevelLayerHazard.h"
 
 //***************************************************************************
 const GString	ConfigFilename="MkLevel.ini";
@@ -172,12 +173,12 @@ int		ChildCount=ThisNode.GetPruneChildCount();
 }
 
 //***************************************************************************
-int		CMkLevel::AddModel(sMkLevelLayerThing &ThisThing)
+int		CMkLevel::AddModel(const char *Name,int TriStart,int TriCount)
 {
 sMkLevelModel	ThisModel;
 int				Idx;
 
-		ThisModel.Name=ThisThing.Name;
+		ThisModel.Name=Name;
 		Idx=ModelList.Find(ThisModel);
 
 		if (Idx!=-1)
@@ -186,13 +187,13 @@ int				Idx;
 		}
 		Idx=ModelList.size();
 		ThisModel.TriStart=ModelFaceList.GetFaceCount();
-		ThisModel.TriCount=ThisThing.Data.TriCount;
+		ThisModel.TriCount=TriCount;
 
 
 // Add tri data
-		for (int i=0;i<ThisModel.TriCount; i++)
+		for (int i=0;i<TriCount; i++)
 		{
-			sExpTri	&ThisTri=InTriList[ThisThing.Data.TriStart+i];
+			sExpTri	&ThisTri=InTriList[TriStart+i];
 			CFace	F;
 
 			ExpTri2Face(ThisTri,F);
@@ -371,6 +372,9 @@ u8		*ByteHdr=(u8*)FileHdr;
 			case LAYER_TYPE_FX:
 				LayerList.push_back(new CMkLevelLayerFX(LayerHdr));
 				break;
+			case LAYER_TYPE_HAZARD:
+				LayerList.push_back(new CMkLevelLayerHazard(LayerHdr));
+				break;
 			default:
 				GObject::Error(ERR_FATAL,"Unknown Layer Type\n");
 			}
@@ -997,6 +1001,7 @@ void	CMkLevel::WriteLayers()
 		LevelHdr.PlatformList=WriteThings(LAYER_TYPE_PLATFORM,"Platform List");
 		LevelHdr.TriggerList=WriteThings(LAYER_TYPE_TRIGGER,"Trigger List");
 		LevelHdr.FXList=WriteThings(LAYER_TYPE_FX,"FX List");
+		LevelHdr.HazardList=WriteThings(LAYER_TYPE_HAZARD,"Hazard List");
 		LevelHdr.ModelList=(sModel*)WriteModelList();
 }
 

Utils/MkLevel/MkLevel.h

@@ -60,7 +60,8 @@ public:
 
 		void			LoadModels();
 		int				AddModel(GString &Filename);
-		int				AddModel(sMkLevelLayerThing &ThisThing);
+		int				AddModel(const char *Name,int TriStart,int TriCount);
+
 		void			Load();
 
 		void			Process();

source/gfx/actor.cpp

@@ -356,6 +356,7 @@ bool		NewFlag=false;
 		}
 
 		NewActor=new ("CActorGfx") CActorGfx(ThisActor);
+
 		if (NewFlag)
 		{
 			TotalFrames=NewActor->GetTotalFrameCount();
@@ -444,6 +445,8 @@ sActorPool	*Actor=ActorList;
 CActorGfx::CActorGfx(sActorPool *ThisActor)
 {
 		PoolEntry=ThisActor;
+		ShadowXOfs=DEF_SHADOW_OFS;
+		ShadowYOfs=DEF_SHADOW_OFS;
 }
 
 /*****************************************************************************/
@@ -461,23 +464,10 @@ u16				ThisFrame=ThisAnim->Anim[Frame];
 				return(PoolEntry->ActorGfx->FrameList+ThisFrame);
 }
 
-/*****************************************************************************/
-int				CActorGfx::GetTotalFrameCount()
-{
-int		Total=0;
-		for (int Anim=0; Anim<PoolEntry->ActorGfx->AnimCount; Anim++)
-		{
-			sSpriteAnim		*ThisAnim=PoolEntry->ActorGfx->AnimList+Anim;
-			Total+=ThisAnim->FrameCount;
-		}
-
-		return(Total);
-}
-
 /*****************************************************************************/
 int	ActorOT=10;
 
-POLY_FT4	*CActorGfx::Render(DVECTOR &Pos,int Anim,int Frame,bool XFlip,bool YFlip,bool Shadow)
+POLY_FT4	*CActorGfx::Render(DVECTOR &Pos,int Anim,int Frame,bool XFlip,bool YFlip)
 {
 
 sPoolNode		*ThisNode;;
@@ -539,7 +529,7 @@ POLY_FT4		*Ft4;
 			Ft4->clut=PoolEntry->ActorGfx->Clut;
 			AddPrimToList(Ft4,ActorOT);
 
-			if (Shadow)
+			if (ShadowFlag)
 			{
 				POLY_FT4	*sFt4=GetPrimFT4();
 				*sFt4=*Ft4;

source/gfx/actor.h

@@ -136,20 +136,23 @@ class	CActorGfx
 public:
 		enum
 		{
-			ShadowXOfs	=32,
+			DEF_SHADOW_OFS=32,
-			ShadowYOfs	=32,
 		};
 
 		CActorGfx(sActorPool *ThisActor);
 virtual	~CActorGfx();
 
-		POLY_FT4		*Render(DVECTOR &Pos,int Anim,int Frame,bool FlipX=false,bool FlipY=false,bool Shadow=false);
+		POLY_FT4		*Render(DVECTOR &Pos,int Anim,int Frame,bool FlipX=false,bool FlipY=false);
 		POLY_FT4		*RotateScale(POLY_FT4 *Ft4,DVECTOR &Pos,int Angle,int XScale,int YScale);
 
 		int				getFrameCount(int Anim)		{return(PoolEntry->ActorGfx->AnimList[Anim].FrameCount);}
-		int				GetTotalFrameCount();
+		int				GetTotalFrameCount()		{return(PoolEntry->ActorGfx->FrameCount);}
 
 		sBBox			&GetBBox()					{return(BBox);}
+
+		void			SetShadow(bool f)			{ShadowFlag=f;}
+		void			SetShadowOfs(int X,int Y)	{ShadowXOfs=X; ShadowYOfs=Y;}
+
 protected:
 		void			SetUpFT4(POLY_FT4 *Ft4,sSpriteFrame *Frame,sPoolNode *Node,int X,int Y,bool XFlip,bool YFlip);
 		sSpriteFrame	*GetFrame(int Anim,int Frame);
@@ -158,6 +161,8 @@ protected:
 		sSpriteFrame	*CurrentFrame;
 
 		sBBox			BBox;
+		bool			ShadowFlag;
+		s16				ShadowXOfs,ShadowYOfs;
 };
 
 /*****************************************************************************/

source/level/layerback.cpp

@@ -41,10 +41,10 @@ CLayerBack::CLayerBack(sLevelHdr *LevelHdr,sLayerHdr *Hdr) : CLayerTile(LevelHdr
 {
 		Data=(sLayerShadeHdr*)MakePtr(Hdr,sizeof(sLayerHdr));
 
-		ASSERT(Data->Count<=LAYER_SHADE_RGB_MAX);
+		ASSERT(Data->BandCount<=LAYER_SHADE_RGB_MAX);
-		BandCount=Data->Count-1;
+		BandCount=Data->BandCount-1;
 // Setup back gfx
-		
+/*		
 		for (int i=0; i<SPRITE_MAX; i++)
 		{
 			int	Type=i&1;
@@ -79,7 +79,7 @@ CLayerBack::CLayerBack(sLevelHdr *LevelHdr,sLayerHdr *Hdr) : CLayerTile(LevelHdr
 			SpriteList[i].Pos.vx=getRndRange(512<<MOVE_SHIFT);
 			SpriteList[i].Pos.vy=getRndRange(256<<MOVE_SHIFT);
 		}
-
+*/
 
 }
 
@@ -101,10 +101,10 @@ void	CLayerBack::init(DVECTOR &MapPos,int Shift)
 		for (int i=0; i<BandCount; i++)
 		{
 			SetPolyG4(&Band[i]);
-			setRGB0(&Band[i],Data->Data[i+0].RGB[0],Data->Data[i+0].RGB[1],Data->Data[i+0].RGB[2]);
+			setRGB0(&Band[i],Data->RGB[i+0][0],Data->RGB[i+0][1],Data->RGB[i+0][2]);
-			setRGB1(&Band[i],Data->Data[i+0].RGB[0],Data->Data[i+0].RGB[1],Data->Data[i+0].RGB[2]);
+			setRGB1(&Band[i],Data->RGB[i+0][0],Data->RGB[i+0][1],Data->RGB[i+0][2]);
-			setRGB2(&Band[i],Data->Data[i+1].RGB[0],Data->Data[i+1].RGB[1],Data->Data[i+1].RGB[2]);
+			setRGB2(&Band[i],Data->RGB[i+1][0],Data->RGB[i+1][1],Data->RGB[i+1][2]);
-			setRGB3(&Band[i],Data->Data[i+1].RGB[0],Data->Data[i+1].RGB[1],Data->Data[i+1].RGB[2]);
+			setRGB3(&Band[i],Data->RGB[i+1][0],Data->RGB[i+1][1],Data->RGB[i+1][2]);
 		}
 
 		PosDx=0;
@@ -121,6 +121,7 @@ void	CLayerBack::shutdown()
 /*****************************************************************************/
 void	CLayerBack::InitSprite(sBackSprite *SpritePtr)
 {
+/*
 int		StartPos=getRnd();
 int		Pos=getRnd();
 
@@ -199,7 +200,7 @@ int	i;
 		i=getRndRange(BackRGBTableSize-1); SpritePtr->Poly.r2=BackRGBTable[i].R; SpritePtr->Poly.g2=BackRGBTable[i].G; SpritePtr->Poly.b2=BackRGBTable[i].B;
 		i=getRndRange(BackRGBTableSize-1); SpritePtr->Poly.r3=BackRGBTable[i].R; SpritePtr->Poly.g3=BackRGBTable[i].G; SpritePtr->Poly.b3=BackRGBTable[i].B;
 		}
-
+*/
 
 }
 
@@ -226,7 +227,7 @@ void	CLayerBack::render()
 const	int	OTPos=(MAX_OT-1);
 sOT		*ThisOT=OtPtr+OTPos;
 int		i,ThisY=-YOfs;
-
+/*
 // Render Back Sprites
 #if	0
 sBackSprite		*SpritePtr=SpriteList;
@@ -270,7 +271,7 @@ sBox		Box;
 			SpritePtr++;
 		}
 #endif	
-
+*/
 // Render Back Shade
 		for (i=0; i<BandCount; i++)
 		{

tools/Data/include/dstructs.h

@@ -159,26 +159,30 @@ struct	sLayerHdr
 
 //---------------------------------------------------------------------------
 // Shade Layer
-struct	sLayerShade
+struct	sLayerShadeBackGfxType
-{
-	u32		Ofs;
-	u8		RGB[4];
-};
-
-struct	sLayerShadeGfx
 {
 		u16			TPage;
 		u16			Clut;
 		u8			U,V;
 		u8			W,H;
-		u16			Flags;
+};
+
+struct	sLayerShadeBackGfx
+{
+		u16			Type;
+		u16			Trans;
+		u16			PosX,PosY;
+		s8			Ofs[4][2];
+		u8			RGB[4][3];
 };
 
 struct	sLayerShadeHdr
 {
-	u16				Count;
+	u16						BandCount;
-	sLayerShade		Data[LAYER_SHADE_RGB_MAX];
+	u16						GfxCount;
-	sLayerShadeGfx	BackGfx[2];
+	u8						RGB[4][3];
+	sLayerShadeBackGfxType	*TypeList;
+	sLayerShadeBackGfx		*GfxList;
 };
 
 //---------------------------------------------------------------------------
@@ -201,6 +205,7 @@ struct	sLevelHdr
 	u32		PlatformList;
 	u32		TriggerList;
 	u32		FXList;
+	u32		HazardList;
 
 	u16		PlayerStartX,PlayerStartY;
 
@@ -279,10 +284,10 @@ struct	sThingItem
 
 struct	sThingPlatform
 {
+	u16		Gfx;
 	u16		Type;
 	u16		Speed;
 	u16		TurnRate;
-	u16		Gfx;
 	u16		Pad;
 	u8		Flags;
 	u8		PointCount;
@@ -303,5 +308,19 @@ struct	sThingTrigger
 	u8		Width,Height;
 }; // 8
 
+struct	sThingHazard
+{
+	u16		Gfx;
+	u16		Type;
+	u16		Health;
+	u16		AttackStrength;
+	u16		Speed;
+	u16		TurnRate;
+	u16		Respawn;
+	u8		Flags;
+	u8		PointCount;
+	// Point List...
+}; // 12
+
 //***************************************************************************
 #endif