Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity

Browse Source
This commit is contained in:
Daveo 2001-04-30 21:49:54 +00:00
parent a115ed8b39
commit b31a2e39dc
52 changed files with 1841 additions and 886 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Utils/MapEdit/CmdMsg.h
View File

@ -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
/*****************************************************************************/

7
Utils/MapEdit/Core.cpp
View File

@ -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];

2
Utils/MapEdit/Core.h
View File

@ -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

1
Utils/MapEdit/Elem.cpp
View File

@ -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);

3
Utils/MapEdit/Elem.h
View File

@ -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;
};
/*****************************************************************************/

117
Utils/MapEdit/ExportHdr.h
View File

@ -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;
BOOL operator==(sExpTex const &v1) {return (!strcmp(Filename,v1.Filename));}
sRGBCol RGB[4];
int Gfx;
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

60
Utils/MapEdit/GUILayerHazard.cpp
View File

@ -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*/)
: CDialog(CGUILayerActor::IDD, pParent)
CGUILayerHazard::CGUILayerHazard(CWnd* pParent /*=NULL*/)
: 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)
DDX_Control(pDX, IDC_ACTOR_TURNRATE_SPIN, m_TurnRateSpin);
DDX_Control(pDX, IDC_ACTOR_SPEED_SPIN, m_SpeedSpin);
DDX_Control(pDX, IDC_ACTOR_HEALTH_SPIN, m_HealthSpin);
DDX_Control(pDX, IDC_ACTOR_ATTACK_SPIN, m_AttackSpin);
DDX_Control(pDX, IDC_ACTOR_COLLISION, m_Collision);
DDX_Control(pDX, IDC_ACTOR_PLAYER, m_Player);
DDX_Control(pDX, IDC_ACTOR_TURNRATE, m_TurnRate);
DDX_Control(pDX, IDC_ACTOR_SPEED, m_Speed);
DDX_Control(pDX, IDC_ACTOR_ATTACK, m_Attack);
DDX_Control(pDX, IDC_ACTOR_HEALTH, m_Health);
//{{AFX_DATA_MAP(CGUILayerHazard)
DDX_Control(pDX, IDC_HAZARD_TURNRATE_SPIN, m_TurnRateSpin);
DDX_Control(pDX, IDC_HAZARD_SPEED_SPIN, m_SpeedSpin);
DDX_Control(pDX, IDC_HAZARD_HEALTH_SPIN, m_HealthSpin);
DDX_Control(pDX, IDC_HAZARD_ATTACK_SPIN, m_AttackSpin);
DDX_Control(pDX, IDC_HAZARD_RESPAWN_SPIN, m_RespawnSpin);
DDX_Control(pDX, IDC_HAZARD_COLLISION, m_Collision);
DDX_Control(pDX, IDC_HAZARD_TURNRATE, m_TurnRate);
DDX_Control(pDX, IDC_HAZARD_SPEED, m_Speed);
DDX_Control(pDX, IDC_HAZARD_ATTACK, m_Attack);
DDX_Control(pDX, IDC_HAZARD_HEALTH, m_Health);
DDX_Control(pDX, IDC_HAZARD_RESPAWN, m_Respawn);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CGUILayerActor, CDialog)
//{{AFX_MSG_MAP(CGUILayerActor)
ON_EN_CHANGE(IDC_ACTOR_HEALTH, OnChangeParam)
ON_EN_CHANGE(IDC_ACTOR_ATTACK, OnChangeParam)
ON_BN_CLICKED(IDC_ACTOR_COLLISION, OnChangeParam)
ON_EN_CHANGE(IDC_ACTOR_SPEED, OnChangeParam)
ON_EN_CHANGE(IDC_ACTOR_TURNRATE, OnChangeParam)
BEGIN_MESSAGE_MAP(CGUILayerHazard, CDialog)
//{{AFX_MSG_MAP(CGUILayerHazard)
ON_EN_CHANGE(IDC_HAZARD_HEALTH, OnChangeParam)
ON_EN_CHANGE(IDC_HAZARD_ATTACK, OnChangeParam)
ON_BN_CLICKED(IDC_HAZARD_COLLISION, OnChangeParam)
ON_EN_CHANGE(IDC_HAZARD_SPEED, 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();}

25
Utils/MapEdit/GUILayerHazard.h
View File

@ -1,40 +1,41 @@
#if !defined(AFX_GUILAYERACTOR_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_)
#define AFX_GUILAYERACTOR_H__D2268E7C_1D7E_4C2F_AF3C_49BB374ED65B__INCLUDED_
#if !defined(AFX_GUILAYERHAZARD_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)
enum { IDD = IDD_LAYER_ACTOR };
//{{AFX_DATA(CGUILayerHazard)
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_)

333
Utils/MapEdit/GUILayerShade.cpp
View File

@ -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_SPIN1, m_Spin1);
DDX_Control(pDX, IDC_LAYERSHADE_SPIN0, m_Spin0);
DDX_Control(pDX, IDC_LAYERSHADE_SCALE1, m_Scale1);
DDX_Control(pDX, IDC_LAYERSHADE_SCALE0, m_Scale0);
DDX_Control(pDX, IDC_LAYERSHADE_MOVE1, m_Move1);
DDX_Control(pDX, IDC_LAYERSHADE_MOVE0, m_Move0);
DDX_Control(pDX, IDC_LAYERSHADE_COLOR1, m_Color1);
DDX_Control(pDX, IDC_LAYERSHADE_COLOR0, m_Color0);
DDX_Control(pDX, IDC_LAYERSHADE_TRANS1, m_Trans1);
DDX_Control(pDX, IDC_LAYERSHADE_TRANS0, m_Trans0);
DDX_Control(pDX, IDC_LAYERSHADE_BACKGFX1, m_Gfx1);
DDX_Control(pDX, IDC_LAYERSHADE_BACKGFX0, m_Gfx0);
DDX_Control(pDX, IDC_LAYERSHADE_EDITR0, m_R0);
DDX_Control(pDX, IDC_LAYERSHADE_EDITG0, m_G0);
DDX_Control(pDX, IDC_LAYERSHADE_EDITB0, m_B0);
DDX_Control(pDX, IDC_LAYERSHADE_EDITR1, m_R1);
DDX_Control(pDX, IDC_LAYERSHADE_EDITG1, m_G1);
DDX_Control(pDX, IDC_LAYERSHADE_EDITB1, m_B1);
DDX_Control(pDX, IDC_LAYERSHADE_EDITR2, m_R2);
DDX_Control(pDX, IDC_LAYERSHADE_EDITG2, m_G2);
DDX_Control(pDX, IDC_LAYERSHADE_EDITB2, m_B2);
DDX_Control(pDX, IDC_LAYERSHADE_EDITR3, m_R3);
DDX_Control(pDX, IDC_LAYERSHADE_EDITG3, m_G3);
DDX_Control(pDX, IDC_LAYERSHADE_EDITB3, m_B3);
DDX_Control(pDX, IDC_LAYERSHADE_COUNTEDIT, m_Count);
DDX_Control(pDX, IDC_LAYERSHADE_DEF_LIST, m_DefList);
DDX_Control(pDX, IDC_LAYERSHADE_SHADECOUNT_SPIN, m_ShadeCountSpin);
DDX_Control(pDX, IDC_LAYERSHADE_SHADECOUNT, m_ShadeCount);
DDX_Control(pDX, IDC_LAYERSHADE_SHADER0, m_ShadeR0);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEG0, m_ShadeG0);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEB0, m_ShadeB0);
DDX_Control(pDX, IDC_LAYERSHADE_SHADER1, m_ShadeR1);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEG1, m_ShadeG1);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEB1, m_ShadeB1);
DDX_Control(pDX, IDC_LAYERSHADE_SHADER2, m_ShadeR2);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEG2, m_ShadeG2);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEB2, m_ShadeB2);
DDX_Control(pDX, IDC_LAYERSHADE_SHADER3, m_ShadeR3);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEG3, m_ShadeG3);
DDX_Control(pDX, IDC_LAYERSHADE_SHADEB3, m_ShadeB3);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_CURRENT_SPIN, m_GfxCurrentSpin);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_CURRENT, m_GfxCurrent);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_LIST, m_GfxBankList);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_XSPIN, m_GfxPosXSpin);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_X, m_GfxPosX);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_YSPIN, m_GfxPosYSpin);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_Y, m_GfxPosY);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_X0, m_GfxSpinx0);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_SPIN_Y0, m_GfxSpiny0);
DDX_Control(pDX, IDC_LAYERSHADE_GFX_X0, m_Gfxx0);
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_CBN_SELCHANGE(IDC_LAYERSHADE_BACKGFX0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITB1, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITG0, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITG1, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITR0, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITR1, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITB2, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITB3, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITG2, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITG3, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITR2, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_EDITR3, OnChangeLayershadeEdit)
ON_EN_CHANGE(IDC_LAYERSHADE_COUNTEDIT, OnChangeLayershadeEdit)
ON_CBN_SELCHANGE(IDC_LAYERSHADE_BACKGFX1, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_COLOR0, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_COLOR1, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_MOVE0, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_MOVE1, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_SCALE0, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_SCALE1, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_SPIN0, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_SPIN1, OnChangeParam)
ON_CBN_SELCHANGE(IDC_LAYERSHADE_TRANS0, OnChangeParam)
ON_CBN_SELCHANGE(IDC_LAYERSHADE_TRANS1, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADECOUNT, OnChangeParam)
ON_BN_CLICKED(IDC_LAYERSHADE_GFX_GOTO, OnGoto)
ON_BN_CLICKED(IDC_LAYERSHADE_GFX_DELETE, OnDelete)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_CURRENT, OnChangeCurrent)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADER0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADER1, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG1, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB1, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADER2, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG2, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB2, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADER3, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEG3, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_SHADEB3, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_XSPIN, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_YSPIN, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_X0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFX_Y0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFXR0, OnChangeParam)
ON_EN_CHANGE(IDC_LAYERSHADE_GFXG0, 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
Val=0;
}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::LimitVal(int Min,int Max,CEdit &Dlg)
{
int Val;
if (!Dlg) return;
DWORD Sel=Dlg.GetSel(); // Retain cursor pos :o), Im getting good at this!
GetVal(Dlg,Val);
if (Val<Min) Val=Min;
if (Val>Max) Val=Max;
SetVal(Dlg,Val);
Dlg.SetSel(Sel);
}
/////////////////////////////////////////////////////////////////////////////
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)
{
int Val;
GetVal(*Map[Set][0],Val); RGB.rgbRed=Val;
GetVal(*Map[Set][1],Val); RGB.rgbGreen=Val;
GetVal(*Map[Set][2],Val); RGB.rgbBlue=Val;
}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::CheckRGB(int Set)
{
LimitVal(0,255,*Map[Set][0]);
LimitVal(0,255,*Map[Set][1]);
LimitVal(0,255,*Map[Set][2]);
}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::SetStatus(int Set,bool f)
{
Map[Set][0]->SetReadOnly(f);
Map[Set][1]->SetReadOnly(f);
Map[Set][2]->SetReadOnly(f);
}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::CheckData()
{
int i;
int Count;
SetFlag=true;
LimitVal(2,4,m_Count);
GetCount(Count);
for (i=0; i<4; i++)
{
CheckRGB(i);
SetStatus(i,i>=Count);
Val=atoi(Str);
if (Min!=-1 && Val<Min) {Val=Min;SetVal(Dlg,Val,Min,Max);}
if (Max!=-1 && Val>Max) {Val=Max;SetVal(Dlg,Val,Min,Max);}
}
SetFlag=false;
}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::OnChangeLayershadeEdit()
void CGUILayerShade::SetRGB(CEdit &DlgR,CEdit &DlgG,CEdit &DlgB,u8 &R,u8 &G,u8 &B)
{
if (SetFlag) return;
int iR,iG,iB;
iR=R;
iG=G;
iB=B;
SetVal(DlgR,iR,0,255);
SetVal(DlgG,iG,0,255);
SetVal(DlgB,iB,0,255);
R=iR;
G=iG;
B=iB;
if (theApp.GetCurrent() && m_R0)
{
CheckData();
theApp.GetCurrent()->GUIChanged();
}
}
void CGUILayerShade::OnChangeParam() {if (!SetFlag) theApp.GetCurrent()->GUIChanged();}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::GetRGB(CEdit &DlgR,CEdit &DlgG,CEdit &DlgB,u8 &R,u8 &G,u8 &B)
{
int iR,iG,iB;
iR=R;
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::SetShadeRGB(int idx,u8 &R,u8 &G,u8 &B)
{
switch(idx)
{
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::GetShadeRGB(int idx,u8 &R,u8 &G,u8 &B)
{
switch(idx)
{
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::SetGfxRGB(int idx,u8 &R,u8 &G,u8 &B)
{
switch(idx)
{
case 0: SetRGB(m_GfxR0,m_GfxG0,m_GfxB0,R,G,B); break;
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;
}
}
/////////////////////////////////////////////////////////////////////////////
void CGUILayerShade::GetGfxRGB(int idx,u8 &R,u8 &G,u8 &B)
{
switch(idx)
{
case 0: GetRGB(m_GfxR0,m_GfxG0,m_GfxB0,R,G,B); break;
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 (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());}

116
Utils/MapEdit/GUILayerShade.h
View File

@ -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;
CButton m_Spin1;
CButton m_Spin0;
CButton m_Scale1;
CButton m_Scale0;
CButton m_Move1;
CButton m_Move0;
CButton m_Color1;
CButton m_Color0;
CComboBox m_Trans1;
CComboBox m_Trans0;
CComboBox m_Gfx1;
CComboBox m_Gfx0;
CEdit m_R0;
CEdit m_G0;
CEdit m_B0;
CEdit m_R1;
CEdit m_G1;
CEdit m_B1;
CEdit m_R2;
CEdit m_G2;
CEdit m_B2;
CEdit m_R3;
CEdit m_G3;
CEdit m_B3;
CEdit m_Count;
CComboBox m_DefList;
CSpinButtonCtrl m_ShadeCountSpin;
CEdit m_ShadeCount;
CEdit m_ShadeR0;
CEdit m_ShadeG0;
CEdit m_ShadeB0;
CEdit m_ShadeR1;
CEdit m_ShadeG1;
CEdit m_ShadeB1;
CEdit m_ShadeR2;
CEdit m_ShadeG2;
CEdit m_ShadeB2;
CEdit m_ShadeR3;
CEdit m_ShadeG3;
CEdit m_ShadeB3;
CSpinButtonCtrl m_GfxCurrentSpin;
CEdit m_GfxCurrent;
CComboBox m_GfxBankList;
CEdit m_GfxPosXSpin;
CEdit m_GfxPosX;
CEdit m_GfxPosYSpin;
CEdit m_GfxPosY;
CSpinButtonCtrl m_GfxSpinx0;
CSpinButtonCtrl m_GfxSpiny0;
CEdit m_Gfxx0;
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}}

7
Utils/MapEdit/GUILayerTrigger.cpp
View File

@ -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()

5
Utils/MapEdit/GUILayerTrigger.h
View File

@ -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;

4
Utils/MapEdit/GUINewMap.cpp
View File

@ -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
}

9
Utils/MapEdit/Layer.cpp
View File

@ -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();

49
Utils/MapEdit/LayerActor.cpp
View File

@ -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_TurnRate,ThisThing.Data.TurnRate);
GUIActor.SetVal(GUIActor.m_Health,ThisThing.Data.Health);
GUIActor.SetVal(GUIActor.m_Attack,ThisThing.Data.AttackStrength);
GUIActor.m_Collision.SetCheck(ThisThing.Data.CollisionFlag);
GUIActor.m_Player.SetCheck(ThisThing.Data.PlayerFlag);
GUIActor.SetVal(GUIActor.m_Speed,ThisThing.Data.Actor.ActorSpeed);
GUIActor.SetVal(GUIActor.m_TurnRate,ThisThing.Data.Actor.ActorTurnRate);
GUIActor.SetVal(GUIActor.m_Health,ThisThing.Data.Actor.ActorHealth);
GUIActor.SetVal(GUIActor.m_Attack,ThisThing.Data.Actor.ActorAttackStrength);
GUIActor.m_Collision.SetCheck(ThisThing.Data.Actor.ActorCollisionFlag);
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.TurnRate=GUIActor.GetVal(GUIActor.m_TurnRate);
ThisThing.Data.Health=GUIActor.GetVal(GUIActor.m_Health);
ThisThing.Data.AttackStrength=GUIActor.GetVal(GUIActor.m_Attack);
ThisThing.Data.CollisionFlag=GUIActor.m_Collision.GetCheck()!=0;
ThisThing.Data.PlayerFlag=GUIActor.m_Player.GetCheck()!=0;
ThisThing.Data.Actor.ActorSpeed=GUIActor.GetVal(GUIActor.m_Speed);
ThisThing.Data.Actor.ActorTurnRate=GUIActor.GetVal(GUIActor.m_TurnRate);
ThisThing.Data.Actor.ActorHealth=GUIActor.GetVal(GUIActor.m_Health);
ThisThing.Data.Actor.ActorAttackStrength=GUIActor.GetVal(GUIActor.m_Attack);
ThisThing.Data.Actor.ActorCollisionFlag=GUIActor.m_Collision.GetCheck()!=0;
}
}

3
Utils/MapEdit/LayerActor.h
View File

@ -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);

1
Utils/MapEdit/LayerDef.h
View File

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

36
Utils/MapEdit/LayerFX.cpp
View File

@ -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 H=-(ThisThing.Data.Height);
float W=(ThisThing.Data.FX.FXWidth);
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_Width,ThisThing.Data.Width);
GUIFX.SetVal(GUIFX.m_Height,ThisThing.Data.Height);
GUIFX.SetVal(GUIFX.m_Speed,ThisThing.Data.FX.FXSpeed);
GUIFX.SetVal(GUIFX.m_Width,ThisThing.Data.FX.FXWidth);
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.Width=GUIFX.GetVal(GUIFX.m_Width);
ThisThing.Data.Height=GUIFX.GetVal(GUIFX.m_Height);
ThisThing.Data.FX.FXSpeed=GUIFX.GetVal(GUIFX.m_Speed);
ThisThing.Data.FX.FXWidth=GUIFX.GetVal(GUIFX.m_Width);
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.Height<1) Thing.Data.Height=1;
if (Thing.Data.FX.FXWidth<1) Thing.Data.FX.FXWidth=1;
if (Thing.Data.FX.FXHeight<1) Thing.Data.FX.FXHeight=1;
}

3
Utils/MapEdit/LayerFX.h
View File

@ -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);

113
Utils/MapEdit/LayerHazard.cpp
View File

@ -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);
GUIActor.DisableCallback(false);
Core->GUIAdd(GUIHazard,IDD_LAYER_HAZARD);
GUIHazard.DisableCallback(false);
GUIActor.m_HealthSpin.SetRange(0,255);
GUIActor.m_AttackSpin.SetRange(0,255);
GUIActor.m_SpeedSpin.SetRange(0,255);
GUIActor.m_TurnRateSpin.SetRange(0,255);
GUIHazard.m_HealthSpin.SetRange(0,255);
GUIHazard.m_AttackSpin.SetRange(0,255);
GUIHazard.m_SpeedSpin.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);
GUIActor.SetVal(GUIActor.m_TurnRate,ThisThing.Data.TurnRate);
GUIActor.SetVal(GUIActor.m_Health,ThisThing.Data.Health);
GUIActor.SetVal(GUIActor.m_Attack,ThisThing.Data.AttackStrength);
GUIActor.m_Collision.SetCheck(ThisThing.Data.CollisionFlag);
GUIActor.m_Player.SetCheck(ThisThing.Data.PlayerFlag);
GUIHazard.SetVal(GUIHazard.m_Speed,ThisThing.Data.Hazard.HazardSpeed);
GUIHazard.SetVal(GUIHazard.m_TurnRate,ThisThing.Data.Hazard.HazardTurnRate);
GUIHazard.SetVal(GUIHazard.m_Health,ThisThing.Data.Hazard.HazardHealth);
GUIHazard.SetVal(GUIHazard.m_Attack,ThisThing.Data.Hazard.HazardAttackStrength);
GUIHazard.m_Collision.SetCheck(ThisThing.Data.Hazard.HazardCollisionFlag);
}
else
{
GUIActor.m_Speed.SetWindowText("");
GUIActor.m_TurnRate.SetWindowText("");
GUIActor.m_Health.SetWindowText("");
GUIActor.m_Attack.SetWindowText("");
GUIActor.m_Collision.SetCheck(false);
GUIActor.m_Player.SetCheck(false);
GUIHazard.m_Speed.SetWindowText("");
GUIHazard.m_TurnRate.SetWindowText("");
GUIHazard.m_Health.SetWindowText("");
GUIHazard.m_Attack.SetWindowText("");
GUIHazard.m_Collision.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.TurnRate=GUIActor.GetVal(GUIActor.m_TurnRate);
ThisThing.Data.Health=GUIActor.GetVal(GUIActor.m_Health);
ThisThing.Data.AttackStrength=GUIActor.GetVal(GUIActor.m_Attack);
ThisThing.Data.CollisionFlag=GUIActor.m_Collision.GetCheck()!=0;
ThisThing.Data.PlayerFlag=GUIActor.m_Player.GetCheck()!=0;
ThisThing.Data.Hazard.HazardSpeed=GUIHazard.GetVal(GUIHazard.m_Speed);
ThisThing.Data.Hazard.HazardTurnRate=GUIHazard.GetVal(GUIHazard.m_TurnRate);
ThisThing.Data.Hazard.HazardHealth=GUIHazard.GetVal(GUIHazard.m_Health);
ThisThing.Data.Hazard.HazardAttackStrength=GUIHazard.GetVal(GUIHazard.m_Attack);
ThisThing.Data.Hazard.HazardCollisionFlag=GUIHazard.m_Collision.GetCheck()!=0;
}
}

23
Utils/MapEdit/LayerHazard.h
View File

@ -1,26 +1,29 @@
/*******************/
/*** Layer Actor ***/
/*******************/
/********************/
/*** Layer Hazard ***/
/********************/
#ifndef __LAYER_ACTOR_HEADER__
#define __LAYER_ACTOR_HEADER__
#ifndef __LAYER_HAZARD_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);
CLayerActor(CFile *File,int Version) {Load(File,Version);}
CLayerHazard(sLayerDef &Def);
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;
};

14
Utils/MapEdit/LayerItem.cpp
View File

@ -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 *********************************************************************/
/*****************************************************************************/

3
Utils/MapEdit/LayerItem.h
View File

@ -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);

46
Utils/MapEdit/LayerPlatform.cpp
View File

@ -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_TurnRate,ThisThing.Data.TurnRate);
GUIPlatform.m_Collision.SetCheck(ThisThing.Data.CollisionFlag);
GUIPlatform.m_MoveList.SetCurSel(ThisThing.Data.MoveType);
GUIPlatform.m_Type.SetCurSel(ThisThing.Data.PlatformType);
GUIPlatform.SetVal(GUIPlatform.m_Speed,ThisThing.Data.Platform.PlatformSpeed);
GUIPlatform.SetVal(GUIPlatform.m_TurnRate,ThisThing.Data.Platform.PlatformTurnRate);
GUIPlatform.m_Collision.SetCheck(ThisThing.Data.Platform.PlatformCollisionFlag);
GUIPlatform.m_MoveList.SetCurSel(ThisThing.Data.Platform.PlatformMoveType);
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.TurnRate=GUIPlatform.GetVal(GUIPlatform.m_TurnRate);
ThisThing.Data.CollisionFlag=GUIPlatform.m_Collision.GetCheck()!=0;
ThisThing.Data.MoveType=GUIPlatform.m_MoveList.GetCurSel();
ThisThing.Data.PlatformType=GUIPlatform.m_Type.GetCurSel();
ThisThing.Data.Platform.PlatformSpeed=GUIPlatform.GetVal(GUIPlatform.m_Speed);
ThisThing.Data.Platform.PlatformTurnRate=GUIPlatform.GetVal(GUIPlatform.m_TurnRate);
ThisThing.Data.Platform.PlatformCollisionFlag=GUIPlatform.m_Collision.GetCheck()!=0;
ThisThing.Data.Platform.PlatformMoveType=GUIPlatform.m_MoveList.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);
}

3
Utils/MapEdit/LayerPlatform.h
View File

@ -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);

551
Utils/MapEdit/LayerShade.cpp
View File

@ -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);
ScriptName=ExecPath+theApp.GetConfigStr("LayerScript","BackGfxScript");
Script.LoadAndImport(ScriptName);
GfxBank=new CElemBank(-1,-1,false,CElem::CentreModeLR | CElem::CentreModeTB);
LoadGfx();
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();
BackGfx.resize(ListSize);
for (i=0; i<ListSize; i++)
for(int i=0; i<4; i++)
{
BackGfx[i]=Script.GetGroupName(i);
TRACE1("%s\n",BackGfx[i]);
Cursor.RGB[i].R=Cursor.RGB[i].G=Cursor.RGB[i].B=255;
}
Back0=Back1=-1;
TransMode0=TransMode1=0;
Flags0=Flags1=-1;
CurrentGfx=-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.Height=TileLayerMinHeight+(Def.Height-TileLayerMinHeight)/GetScaleFactor();
// LayerDef.Width=TileLayerMinWidth+(Def.Width-TileLayerMinWidth)/GetScaleFactor();
// LayerDef.Height=TileLayerMinHeight+(Def.Height-TileLayerMinHeight)/GetScaleFactor();
RGB[0].rgbRed=255; RGB[0].rgbGreen=255; RGB[0].rgbBlue=255;
RGB[1].rgbRed=255; RGB[1].rgbGreen=0; RGB[1].rgbBlue=0;
RGB[2].rgbRed=0; RGB[2].rgbGreen=255; RGB[2].rgbBlue=0;
RGB[3].rgbRed=0; RGB[3].rgbGreen=0; RGB[3].rgbBlue=255;
Count=2;
ShadeRGB[0].R=255; ShadeRGB[0].G=255; ShadeRGB[0].B=255;
ShadeRGB[1].R=255; ShadeRGB[1].G=0; ShadeRGB[1].B=0;
ShadeRGB[2].R=0; ShadeRGB[2].G=255; ShadeRGB[2].B=0;
ShadeRGB[3].R=0; ShadeRGB[3].G=0; ShadeRGB[3].B=255;
ShadeCount=2;
}
/*****************************************************************************/
void CLayerShade::Load(CFile *File,int Version)
{
if (Version<=5)
{
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));
}
int i;
InitLayer(LayerDef);
File->Read(&Count,sizeof(int));
for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
{
File->Read(&Pos[i],sizeof(int));
File->Read(&RGB[i],sizeof(RGBQUAD));
}
if (Version>=7)
{
File->Read(&Back0,sizeof(int));
File->Read(&Back1,sizeof(int));
}
if (Version>=8)
{
File->Read(&TransMode0,sizeof(int));
File->Read(&Flags0,sizeof(int));
File->Read(&TransMode1,sizeof(int));
File->Read(&Flags1,sizeof(int));
}
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++)
{
RGBQUAD RGB;
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;
}
File->Read(&DummyInt,sizeof(int));
File->Read(&DummyInt,sizeof(int));
if (Version==8)
{
File->Read(&DummyInt,sizeof(int));
File->Read(&DummyInt,sizeof(int));
File->Read(&DummyInt,sizeof(int));
File->Read(&DummyInt,sizeof(int));
}
}
else
{
int GfxCount;
for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
{
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(&RGB[i],sizeof(RGBQUAD));
File->Write(&ShadeRGB[i],sizeof(sRGBCol));
}
File->Write(&Back0,sizeof(int));
File->Write(&Back1,sizeof(int));
File->Write(&TransMode0,sizeof(int));
File->Write(&Flags0,sizeof(int));
File->Write(&TransMode1,sizeof(int));
File->Write(&Flags1,sizeof(int));
int GfxCount=GfxList.size();
File->Write(&GfxCount,sizeof(int));
for (i=0; i<GfxCount; i++)
{
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,28 +199,102 @@ 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();
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();
return(true);
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);
}
/*****************************************************************************/
@ -182,130 +302,239 @@ bool CLayerShade::Resize(int Width,int Height)
/*****************************************************************************/
void CLayerShade::GUIInit(CCore *Core)
{
Core->GUIAdd(GUI,IDD_LAYER_SHADE);
for (int i=0; i<LAYER_SHADE_MAX; i++)
{
GUI.SetRGB(RGB[i],i);
}
GUI.SetCount(Count);
InitGfxList();
int i,ListSize;
if (Flags0 & SpinFlag) GUI.m_Spin0.SetCheck(true);
if (Flags0 & ScaleFlag) GUI.m_Scale0.SetCheck(true);
if (Flags0 & MoveFlag) GUI.m_Move0.SetCheck(true);
if (Flags0 & ColorFlag) GUI.m_Color0.SetCheck(true);
GUIShade.DisableCallback();
Core->GUIAdd(GUIShade,IDD_LAYER_SHADE);
if (Flags1 & SpinFlag) GUI.m_Spin1.SetCheck(true);
if (Flags1 & ScaleFlag) GUI.m_Scale1.SetCheck(true);
if (Flags1 & MoveFlag) GUI.m_Move1.SetCheck(true);
if (Flags1 & ColorFlag) GUI.m_Color1.SetCheck(true);
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();
// Init BankList
ListSize=BankList.size();
GUIShade.m_GfxBankList.ResetContent();
GUIShade.m_DefList.ResetContent();
for (i=0; i<ListSize; i++)
{
List0.AddString(BackGfx[i]);
List1.AddString(BackGfx[i]);
GUIShade.m_GfxBankList.AddString(BankList[i].Name);
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);
Back0=GUI.m_Gfx0.GetCurSel();
Back1=GUI.m_Gfx1.GetCurSel();
GUIShade.GetVal(GUIShade.m_ShadeCount,ShadeCount,2,4);
// Gfx
GUIShade.GetVal(GUIShade.m_GfxCurrent,CurrentGfx);
ListSize=GfxList.size();
if (!ListSize || CurrentGfx==-1) return;
Flags0=0;
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;
if (GUI.m_Spin1.GetCheck()) Flags1|=SpinFlag;
if (GUI.m_Scale1.GetCheck()) Flags1|=ScaleFlag;
if (GUI.m_Move1.GetCheck()) Flags1|=MoveFlag;
if (GUI.m_Color1.GetCheck()) Flags1|=ColorFlag;
TransMode1=GUI.m_Trans1.GetCurSel();
sLayerShadeGfx &ThisGfx=GfxList[CurrentGfx];
GUIShade.GetVal(GUIShade.m_GfxCurrent,ListSize,0,ListSize);
GUIShade.GetVal(GUIShade.m_GfxPosX,ThisGfx.Pos.x);
GUIShade.GetVal(GUIShade.m_GfxPosY,ThisGfx.Pos.y);
ThisGfx.Gfx=GUIShade.m_GfxBankList.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 ***************************************************************/
/*****************************************************************************/
void CLayerShade::Export(CCore *Core,CExport &Exp)
bool CLayerShade::LButtonControl(CCore *Core,UINT nFlags, CPoint &CursorPos,bool DownFlag)
{
Exp.ExportLayerHeader(LayerDef);//LAYER_TYPE_SHADE,LayerDef.SubType,LayerDef.Width,LayerDef.Height);
Exp.Write(&Count,sizeof(int));
for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
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)
{
Exp.Write(&Pos[i],sizeof(int));
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
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;
}
Exp.Write(&TransMode0,sizeof(int));
Exp.Write(&Flags0,sizeof(int));
Exp.Write(&TransMode1,sizeof(int));
Exp.Write(&Flags1,sizeof(int));
// Back Gfx
char Txt[256];
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);
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(&ShadeCount,sizeof(int));
for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
{
Exp.Write(&ShadeRGB[i],sizeof(sRGBCol));
}
// Write Gfx List
ListSize=GfxList.size();
Exp.Write(&ListSize,sizeof(int));
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);
Exp.Write(Txt,strlen(Txt)+1);
}
}

50
Utils/MapEdit/LayerShade.h
View File

@ -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;
CIni Script;
CList<GString> BackGfx;
int Back0,Back1;
int TransMode0,TransMode1;
int Flags0,Flags1;
CGUILayerShade GUIShade;
CIni Script;
CList<sBackList> BankList;
CElemBank *GfxBank;
sLayerShadeGfx Cursor;
int Count;
int Pos[LAYER_SHADE_RGB_MAX];
RGBQUAD RGB[LAYER_SHADE_RGB_MAX];
int ShadeCount;
sRGBCol ShadeRGB[LAYER_SHADE_RGB_MAX];
CList<sLayerShadeGfx> GfxList;
int CurrentGfx;
};

16
Utils/MapEdit/LayerThing.cpp
View File

@ -66,7 +66,14 @@ int i,ListSize;
{
sLayerThing &ThisThing=ThingList[i];
LoadThing(File,Version,ThisThing);
File->Read(&ThisThing.Data,sizeof(sLayerThingData));
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)

2
Utils/MapEdit/LayerThing.h
View File

@ -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);

84
Utils/MapEdit/LayerTrigger.cpp
View File

@ -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 H=-(ThisThing.Data.Height);
float W=(ThisThing.Data.Trigger.TriggerWidth);
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_Height,ThisThing.Data.Height);
GUITrigger.SetVal(GUITrigger.m_Width,ThisThing.Data.Trigger.TriggerWidth);
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.Height=GUITrigger.GetVal(GUITrigger.m_Height);
ThisThing.Data.Trigger.TriggerWidth=GUITrigger.GetVal(GUITrigger.m_Width);
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.Height<1) Thing.Data.Height=1;
// Thing.XY.resize(1);
if (Thing.Data.Trigger.TriggerWidth<1) Thing.Data.Trigger.TriggerWidth=1;
if (Thing.Data.Trigger.TriggerHeight<1) Thing.Data.Trigger.TriggerHeight=1;
}

3
Utils/MapEdit/LayerTrigger.h
View File

@ -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);

302
Utils/MapEdit/MapEdit.clw
View File

@ -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
Class8=CGUILayerPlatform
Class9=CGUILayerShade
Class10=CGUILayerThing
Class11=CGuiLayerThingPos
Class12=CGUIMultiBar
Class13=CGUINewMap
Class14=CGUIResize
Class15=CGUITileBank
Class16=GUIToolBar
Class17=CLayerTileCollision
Class18=CMainFrame
Class19=CMapEditApp
Class20=CAboutDlg
Class21=CMapEditDoc
Class22=CMapEditView
Class7=CGUILayerFX
Class8=CGUILayerHazard
Class9=CGUILayerItem
Class10=CGUILayerList
Class11=CGUILayerPlatform
Class12=CGUILayerShade
Class13=CGUILayerThing
Class14=CGuiLayerThingPos
Class15=CGUILayerTrigger
Class16=CGUIMultiBar
Class17=CGUINewMap
Class18=CGUIResize
Class19=CGUITileBank
Class20=GUIToolBar
Class21=CLayerTileCollision
Class22=CMainFrame
Class23=CMapEditApp
Class24=CAboutDlg
Class25=CMapEditDoc
Class26=CMapEditView
ResourceCount=20
Resource1=IDD_LAYER_THING_POS
Resource2=IDD_NEWMAP
Resource3=IDD_TILEBANK
Resource4=IDR_MAPEDITYPE (English (U.S.))
ResourceCount=21
Resource1=IDD_LAYER_COLLISION
Resource2=IDR_MAPEDITYPE (English (U.S.))
Resource3=IDD_ELEMLIST
Resource4=IDD_MULTIBAR (English (U.S.))
Resource5=IDD_LAYER_THING
Resource6=IDD_LAYER_TRIGGER
Resource7=IDD_ELEMLIST
Resource8=IDD_MULTIBAR (English (U.S.))
Resource9=IDD_ABOUTBOX (English (U.S.))
Resource10=IDD_LAYER_ACTOR
Resource11=IDD_LAYER_PLATFORM
Resource12=IDD_RESIZE
Resource13=IDD_ADDLAYER
Resource14=IDD_LAYER_FX
Resource15=IDR_MAINFRAME (English (U.S.))
Resource16=IDD_LAYER_SHADE
Resource17=IDD_LAYER_COLLISION
Resource18=IDD_TOOLBAR
Class23=CGUILayerTrigger
Resource19=IDD_LAYER_LIST
Class24=CGUILayerFX
Resource20=IDR_TOOLBAR (English (U.S.))
Resource6=IDD_NEWMAP
Resource7=IDD_LAYER_PLATFORM
Resource8=IDD_LAYER_TRIGGER
Resource9=IDD_TILEBANK
Resource10=IDR_TOOLBAR (English (U.S.))
Resource11=IDR_MAINFRAME (English (U.S.))
Resource12=IDD_ABOUTBOX (English (U.S.))
Resource13=IDD_LAYER_ACTOR
Resource14=IDD_LAYER_LIST
Resource15=IDD_RESIZE
Resource16=IDD_LAYER_THING_POS
Resource17=IDD_ADDLAYER
Resource18=IDD_LAYER_FX
Resource19=IDD_TOOLBAR
Resource20=IDD_LAYER_SHADE
Resource21=IDD_LAYER_HAZARD
[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
Control1=IDC_LAYERSHADE_EDITR0,edit,1350770688
Control2=IDC_LAYERSHADE_EDITG0,edit,1350770816
Control3=IDC_LAYERSHADE_EDITB0,edit,1350770816
ControlCount=62
Control1=IDC_LAYERSHADE_SHADER0,edit,1350770688
Control2=IDC_LAYERSHADE_SHADEG0,edit,1350770816
Control3=IDC_LAYERSHADE_SHADEB0,edit,1350770816
Control4=IDC_LAYERSHADE_COUNTTEXT,static,1342312449
Control5=IDC_LAYERSHADE_EDITR1,edit,1350770688
Control6=IDC_LAYERSHADE_EDITG1,edit,1350770816
Control7=IDC_LAYERSHADE_EDITB1,edit,1350770816
Control8=IDC_LAYERSHADE_EDITR2,edit,1350770688
Control9=IDC_LAYERSHADE_EDITG2,edit,1350770816
Control10=IDC_LAYERSHADE_EDITB2,edit,1350770816
Control5=IDC_LAYERSHADE_SHADER1,edit,1350770688
Control6=IDC_LAYERSHADE_SHADEG1,edit,1350770816
Control7=IDC_LAYERSHADE_SHADEB1,edit,1350770816
Control8=IDC_LAYERSHADE_SHADER2,edit,1350770688
Control9=IDC_LAYERSHADE_SHADEG2,edit,1350770816
Control10=IDC_LAYERSHADE_SHADEB2,edit,1350770816
Control11=IDC_LAYERSHADE_TEXT7,static,1342312449
Control12=IDC_LAYERSHADE_EDITR3,edit,1350770688
Control13=IDC_LAYERSHADE_EDITG3,edit,1350770816
Control14=IDC_LAYERSHADE_EDITB3,edit,1350770816
Control15=IDC_LAYERSHADE_COUNTEDIT,edit,1350576256
Control16=IDC_SPIN2,msctls_updown32,1342177302
Control17=IDC_LAYERSHADE_BACKGFX0,combobox,1344339971
Control18=IDC_LAYERSHADE_BACKGFX1,combobox,1344339971
Control19=IDC_LAYERSHADE_SPIN0,button,1342242851
Control20=IDC_LAYERSHADE_MOVE0,button,1342242851
Control21=IDC_LAYERSHADE_SCALE0,button,1342242851
Control22=IDC_LAYERSHADE_COLOR0,button,1342242851
Control23=IDC_LAYERSHADE_TRANS0,combobox,1344339971
Control24=IDC_LAYERSHADE_SPIN1,button,1342242851
Control25=IDC_LAYERSHADE_MOVE1,button,1342242851
Control26=IDC_LAYERSHADE_SCALE1,button,1342242851
Control27=IDC_LAYERSHADE_COLOR1,button,1342242851
Control28=IDC_LAYERSHADE_TRANS1,combobox,1344339971
Control12=IDC_LAYERSHADE_SHADER3,edit,1350770688
Control13=IDC_LAYERSHADE_SHADEG3,edit,1350770816
Control14=IDC_LAYERSHADE_SHADEB3,edit,1350770816
Control15=IDC_LAYERSHADE_SHADECOUNT,edit,1350576256
Control16=IDC_LAYERSHADE_SHADECOUNT_SPIN,msctls_updown32,1342177302
Control17=IDC_LAYERSHADE_GFX_CURRENT,edit,1350576256
Control18=IDC_LAYERSHADE_GFX_CURRENT_SPIN,msctls_updown32,1342177466
Control19=IDC_LAYERSHADE_COUNTTEXT2,static,1342312449
Control20=IDC_LAYERSHADE_GFX_LIST,combobox,1344274435
Control21=IDC_LAYERSHADE_GFX_GOTO,button,1342177280
Control22=IDC_LAYERSHADE_GFX_DELETE,button,1342177280
Control23=IDC_LAYERSHADE_POSTEXT,static,1342312449
Control24=IDC_LAYERSHADE_XYTEXT0,static,1342312449
Control25=IDC_LAYERSHADE_GFX_X0,edit,1350576256
Control26=IDC_LAYERSHADE_GFX_SPIN_X0,msctls_updown32,1342177334
Control27=IDC_LAYERSHADE_GFX_Y0,edit,1350576256
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

4
Utils/MapEdit/MapEdit.cpp
View File

@ -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));
}

24
Utils/MapEdit/MapEdit.dsp
View File

@ -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

4
Utils/MapEdit/MapEdit.h
View File

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

212
Utils/MapEdit/MapEdit.rc
View File

@ -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_EDITG0,65,15,20,12,ES_AUTOHSCROLL |
EDITTEXT IDC_LAYERSHADE_SHADER0,45,15,20,12,ES_NUMBER | WS_GROUP
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_EDITG1,65,30,20,12,ES_AUTOHSCROLL |
EDITTEXT IDC_LAYERSHADE_SHADER1,45,30,20,12,ES_NUMBER | WS_GROUP
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_EDITG2,65,45,20,12,ES_AUTOHSCROLL |
EDITTEXT IDC_LAYERSHADE_SHADER2,45,45,20,12,ES_NUMBER | WS_GROUP
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_EDITG3,65,60,20,12,ES_AUTOHSCROLL |
EDITTEXT IDC_LAYERSHADE_SHADER3,45,60,20,12,ES_NUMBER | WS_GROUP
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 |
UDS_ALIGNRIGHT | UDS_AUTOBUDDY,31,10,11,20
COMBOBOX IDC_LAYERSHADE_BACKGFX0,5,75,140,220,CBS_DROPDOWNLIST |
WS_VSCROLL | WS_TABSTOP
COMBOBOX IDC_LAYERSHADE_BACKGFX1,5,120,140,220,CBS_DROPDOWNLIST |
WS_VSCROLL | WS_TABSTOP
CONTROL "Spin",IDC_LAYERSHADE_SPIN0,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,5,90,30,10
CONTROL "Move",IDC_LAYERSHADE_MOVE0,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,65,90,30,10
CONTROL "Scale",IDC_LAYERSHADE_SCALE0,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,35,90,30,10
CONTROL "Color",IDC_LAYERSHADE_COLOR0,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,95,90,30,10
COMBOBOX IDC_LAYERSHADE_TRANS0,5,100,140,81,CBS_DROPDOWNLIST |
WS_VSCROLL | WS_TABSTOP
CONTROL "Spin",IDC_LAYERSHADE_SPIN1,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,5,135,30,10
CONTROL "Move",IDC_LAYERSHADE_MOVE1,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,65,135,30,10
CONTROL "Scale",IDC_LAYERSHADE_SCALE1,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,35,135,30,10
CONTROL "Color",IDC_LAYERSHADE_COLOR1,"Button",BS_AUTOCHECKBOX |
BS_LEFTTEXT | WS_TABSTOP,95,135,30,10
COMBOBOX IDC_LAYERSHADE_TRANS1,5,146,140,81,CBS_DROPDOWNLIST |
WS_VSCROLL | WS_TABSTOP
CONTROL "Spin2",IDC_LAYERSHADE_SHADECOUNT_SPIN,"msctls_updown32",
UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY,31,10,
11,20
EDITTEXT IDC_LAYERSHADE_GFX_CURRENT,5,100,30,12,ES_AUTOHSCROLL |
ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
CONTROL "Spin1",IDC_LAYERSHADE_GFX_CURRENT_SPIN,"msctls_updown32",
UDS_SETBUDDYINT | UDS_ALIGNLEFT | UDS_AUTOBUDDY |
UDS_ARROWKEYS | UDS_NOTHOUSANDS,125,100,11,15
CTEXT "Gfx",IDC_LAYERSHADE_COUNTTEXT2,5,75,145,10,SS_SUNKEN
COMBOBOX IDC_LAYERSHADE_GFX_LIST,5,116,145,190,CBS_DROPDOWNLIST |
WS_VSCROLL
PUSHBUTTON "Goto",IDC_LAYERSHADE_GFX_GOTO,5,130,70,15,NOT
WS_TABSTOP
PUSHBUTTON "Delete",IDC_LAYERSHADE_GFX_DELETE,80,130,70,15,NOT
WS_TABSTOP
CTEXT "Pos",IDC_LAYERSHADE_POSTEXT,5,150,25,10,SS_SUNKEN
CTEXT "XY0",IDC_LAYERSHADE_XYTEXT0,5,166,70,10,SS_SUNKEN
EDITTEXT IDC_LAYERSHADE_GFX_X0,5,175,35,10,ES_AUTOHSCROLL |
ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
CONTROL "Spin3",IDC_LAYERSHADE_GFX_SPIN_X0,"msctls_updown32",
UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY |
UDS_ARROWKEYS,115,5,11,15
EDITTEXT IDC_LAYERSHADE_GFX_Y0,40,175,34,10,ES_AUTOHSCROLL |
ES_READONLY | ES_NUMBER | NOT WS_TABSTOP
CONTROL "Spin3",IDC_LAYERSHADE_GFX_SPIN_Y0,"msctls_updown32",
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

97
Utils/MapEdit/resource.h
View File

@ -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

10
Utils/MkLevel/Layers/MkLevelLayerActor.cpp
View File

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

6
Utils/MkLevel/Layers/MkLevelLayerFX.cpp
View File

@ -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.Y=ThisThing.Data.Height;
OutThing.Size.X=ThisThing.Data.FX.FXWidth;
OutThing.Size.Y=ThisThing.Data.FX.FXHeight;
fwrite(&OutThing,sizeof(sThingFX),1,File);
}

26
Utils/MkLevel/Layers/MkLevelLayerHazard.cpp
View File

@ -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.TurnRate=ThisThing.Data.Platform.PlatformTurnRate;
OutThing.Flags=ThisThing.Data.Platform.PlatformCollisionFlag;
OutThing.Speed=ThisThing.Data.Hazard.HazardSpeed;
OutThing.TurnRate=ThisThing.Data.Hazard.HazardTurnRate;
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++)
{

16
Utils/MkLevel/Layers/MkLevelLayerHazard.h
View File

@ -1,19 +1,19 @@
/**********************/
/*** Layer Platform ***/
/**********************/
/********************/
/*** Layer Hazard ***/
/********************/
#ifndef __MKLEVEL_LAYER_PLATFORM_HEADER__
#define __MKLEVEL_LAYER_PLATFORM_HEADER__
#ifndef __MKLEVEL_LAYER_HAZARD_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){};
const char *GetTypeName() {return("PLATFORM");}
CMkLevelLayerHazard(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
const char *GetTypeName() {return("HAZARD");}
void PreProcess(CMkLevel *Core);
void Process(CMkLevel *Core);

8
Utils/MkLevel/Layers/MkLevelLayerPlatform.cpp
View File

@ -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.TurnRate=ThisThing.Data.TurnRate;
OutThing.Flags=ThisThing.Data.CollisionFlag;
OutThing.Speed=ThisThing.Data.Platform.PlatformSpeed;
OutThing.TurnRate=ThisThing.Data.Platform.PlatformTurnRate;
OutThing.Flags=ThisThing.Data.Platform.PlatformCollisionFlag;
OutThing.PointCount=PointCount;
OutThing.Gfx=RemapTable[i];
fwrite(&OutThing,sizeof(sThingPlatform),1,File);

174
Utils/MkLevel/Layers/MkLevelLayerShade.cpp
View File

@ -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,32 +24,37 @@ u8 *RGB;
iPtr=(int*)(Ptr+sizeof(sExpLayerHdr));
Count=*iPtr++;
List.resize(LAYER_SHADE_RGB_MAX);
for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
ShadeHdr.BandCount=*iPtr++;
sRGBCol *RGB=(sRGBCol*)iPtr;
for (i=0; i<LAYER_SHADE_RGB_MAX; i++)
{
List[i].Pos=*iPtr++;
RGB=(u8*)(iPtr);
List[i].RGB[0]=RGB[0];
List[i].RGB[1]=RGB[1];
List[i].RGB[2]=RGB[2];
iPtr+=4/sizeof(int);
ShadeHdr.RGB[i][0]=RGB->R;
ShadeHdr.RGB[i][1]=RGB->G;
ShadeHdr.RGB[i][2]=RGB->B;
RGB++;
}
Trans[0]=*iPtr++;
Flags[0]=*iPtr++;
Trans[1]=*iPtr++;
Flags[1]=*iPtr++;
iPtr=(int*)RGB;
// 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;
}
}
/*****************************************************************************/
/*****************************************************************************/
/*** Pre-Process *************************************************************/
@ -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)
{
GString Path=Core->GetConfigStr("MISC","BackGfxDir");
int i,ListSize=GfxList.size();
int Idx;
GString Path=Core->GetConfigStr("MISC","BackGfxDir");
CTexGrab &TexGrab=Core->GetTexGrab();
for (int i=0; i<2; i++)
{
if (!BackGfx[i].Empty())
for (i=0; i<ListSize; i++)
{
TexID[i]=AddBackGfx(Core,Path+BackGfx[i]+".Bmp");
}
else
{
TexID[i]=-1;
}
}
}
sLayerShadeGfx &ThisGfx=GfxList[i];
sBackGfxList NewType;
NewType.Name=Path+TypeNameList[ThisGfx.Gfx]+".Bmp";
Idx=OutTypeList.Find(NewType);
/*****************************************************************************/
int CMkLevelLayerShade::AddBackGfx(CMkLevel *Core,const char *Filename)
{
sBackGfxList NewGfx;
CTexGrab &TexGrab=Core->GetTexGrab();
NewGfx.Name=Filename;
NewGfx.TexID=-1;
int Idx=BackGfxList.Add(NewGfx);
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);
Idx=OutTypeList.Add(NewType);
}
return(BackGfxList[Idx].TexID);
ThisGfx.Gfx=Idx;
}
}
@ -102,30 +96,24 @@ 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];
if (TexID[i]==-1)
{
ThisGfx.TPage=0;
}
else
{
sTexOutInfo &ThisTex=TexGrab.GetTexInfo()[TexID[i]];
ThisGfx.TPage=ThisTex.Tpage;
ThisGfx.Clut=ThisTex.Clut;
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];
}
sBackGfxList &ThisType=OutTypeList[i];
sTexOutInfo &ThisTex=TexGrab.GetTexInfo()[ThisType.TexID];
ThisType.Out.TPage=ThisTex.Tpage;
ThisType.Out.Clut=ThisTex.Clut;
ThisType.Out.U=ThisTex.u;
ThisType.Out.V=ThisTex.v;
ThisType.Out.W=ThisTex.w;
ThisType.Out.H=ThisTex.h;
// ThisType.TPage|=Trans[i]<<5;
}
}
/*****************************************************************************/
@ -144,19 +132,57 @@ int ThisPos=ftell(File);
Hdr.Height=Height;
fwrite(&Hdr,sizeof(sLayerHdr),1,File);
Data.Count=Count;
for (int i=0; i<Count; i++)
{
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];
}
// Write Gfx Stuff
ShadeHdr.TypeList=(sLayerShadeBackGfxType*)WriteTypeList(File);
ShadeHdr.GfxList=(sLayerShadeBackGfx*)WriteGfxList(File);
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);
}

28
Utils/MkLevel/Layers/MkLevelLayerShade.h
View File

@ -8,18 +8,12 @@
#include "MkLevelLayer.h"
#include <List2d.h>
/*****************************************************************************/
struct SMkLayerShadeRGB
{
int Pos;
u8 RGB[3];
};
/*****************************************************************************/
struct sBackGfxList
{
GString Name;
int TexID;
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;
vector<SMkLayerShadeRGB> List;
GString BackGfx[2];
int Flags[2];
int Trans[2];
int WriteTypeList(FILE *File);
int WriteGfxList(FILE *File);
CList<sBackGfxList> BackGfxList;
int TexID[2];
sLayerShadeHdr Data;
CList<GString> TypeNameList;
CList<sLayerShadeGfx> GfxList;
CList<sBackGfxList> OutTypeList;
sLayerShadeHdr ShadeHdr;
};
/*****************************************************************************/

4
Utils/MkLevel/Layers/MkLevelLayerTrigger.cpp
View File

@ -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.Height=ThisThing.Data.Height;
OutThing.Width=ThisThing.Data.Trigger.TriggerWidth;
OutThing.Height=ThisThing.Data.Trigger.TriggerHeight;
fwrite(&OutThing,sizeof(sThingTrigger),1,File);
}

15
Utils/MkLevel/MkLevel.cpp
View File

@ -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();
}

3
Utils/MkLevel/MkLevel.h
View File

@ -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();

20
source/gfx/actor.cpp
View File

@ -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;

13
source/gfx/actor.h
View File

@ -136,20 +136,23 @@ class CActorGfx
public:
enum
{
ShadowXOfs =32,
ShadowYOfs =32,
DEF_SHADOW_OFS=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;
};
/*****************************************************************************/

23
source/level/layerback.cpp
View File

@ -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);
BandCount=Data->Count-1;
ASSERT(Data->BandCount<=LAYER_SHADE_RGB_MAX);
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]);
setRGB1(&Band[i],Data->Data[i+0].RGB[0],Data->Data[i+0].RGB[1],Data->Data[i+0].RGB[2]);
setRGB2(&Band[i],Data->Data[i+1].RGB[0],Data->Data[i+1].RGB[1],Data->Data[i+1].RGB[2]);
setRGB3(&Band[i],Data->Data[i+1].RGB[0],Data->Data[i+1].RGB[1],Data->Data[i+1].RGB[2]);
setRGB0(&Band[i],Data->RGB[i+0][0],Data->RGB[i+0][1],Data->RGB[i+0][2]);
setRGB1(&Band[i],Data->RGB[i+0][0],Data->RGB[i+0][1],Data->RGB[i+0][2]);
setRGB2(&Band[i],Data->RGB[i+1][0],Data->RGB[i+1][1],Data->RGB[i+1][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++)
{

BIN
tools/Data/bin/MkLevel.exe
View File

Binary file not shown.

43
tools/Data/include/dstructs.h
View File

@ -159,26 +159,30 @@ struct sLayerHdr
//---------------------------------------------------------------------------
// Shade Layer
struct sLayerShade
{
u32 Ofs;
u8 RGB[4];
};
struct sLayerShadeGfx
struct sLayerShadeBackGfxType
{
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;
sLayerShade Data[LAYER_SHADE_RGB_MAX];
sLayerShadeGfx BackGfx[2];
u16 BandCount;
u16 GfxCount;
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