mirror of
https://github.com/ddnet/ddnet.git
synced 2024-10-21 00:08:19 +00:00
663 lines
15 KiB
C++
663 lines
15 KiB
C++
#ifndef GAME_EDITOR_EDITOR_ACTIONS_H
|
|
#define GAME_EDITOR_EDITOR_ACTIONS_H
|
|
|
|
#include "editor.h"
|
|
#include "editor_action.h"
|
|
|
|
class CEditorActionLayerBase : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionLayerBase(CEditor *pEditor, int GroupIndex, int LayerIndex);
|
|
|
|
virtual void Undo() override {}
|
|
virtual void Redo() override {}
|
|
|
|
protected:
|
|
int m_GroupIndex;
|
|
int m_LayerIndex;
|
|
std::shared_ptr<CLayer> m_pLayer;
|
|
};
|
|
|
|
class CEditorBrushDrawAction : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorBrushDrawAction(CEditor *pEditor, int Group);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
bool IsEmpty() override;
|
|
|
|
private:
|
|
int m_Group;
|
|
// m_vTileChanges is a list of changes for each layer that was modified.
|
|
// The std::pair is used to pair one layer (index) with its history (2D map).
|
|
// EditorTileStateChangeHistory<T> is a 2D map, storing a change item at a specific y,x position.
|
|
std::vector<std::pair<int, EditorTileStateChangeHistory<STileStateChange>>> m_vTileChanges;
|
|
EditorTileStateChangeHistory<STeleTileStateChange> m_TeleTileChanges;
|
|
EditorTileStateChangeHistory<SSpeedupTileStateChange> m_SpeedupTileChanges;
|
|
EditorTileStateChangeHistory<SSwitchTileStateChange> m_SwitchTileChanges;
|
|
EditorTileStateChangeHistory<STuneTileStateChange> m_TuneTileChanges;
|
|
|
|
int m_TotalTilesDrawn;
|
|
int m_TotalLayers;
|
|
|
|
void Apply(bool Undo);
|
|
void SetInfos();
|
|
};
|
|
|
|
// ---------------------------------------------------------
|
|
|
|
class CEditorActionQuadPlace : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionQuadPlace(CEditor *pEditor, int GroupIndex, int LayerIndex, std::vector<CQuad> &vBrush);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
std::vector<CQuad> m_vBrush;
|
|
};
|
|
|
|
class CEditorActionSoundPlace : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionSoundPlace(CEditor *pEditor, int GroupIndex, int LayerIndex, std::vector<CSoundSource> &vBrush);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
std::vector<CSoundSource> m_vBrush;
|
|
};
|
|
|
|
// -------------------------------------------------------------
|
|
|
|
class CEditorActionDeleteQuad : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionDeleteQuad(CEditor *pEditor, int GroupIndex, int LayerIndex, std::vector<int> const &vQuadsIndices, std::vector<CQuad> const &vDeletedQuads);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
std::vector<int> m_vQuadsIndices;
|
|
std::vector<CQuad> m_vDeletedQuads;
|
|
};
|
|
|
|
// -------------------------------------------------------------
|
|
|
|
class CEditorActionEditQuadPoint : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionEditQuadPoint(CEditor *pEditor, int GroupIndex, int LayerIndex, int QuadIndex, std::vector<CPoint> const &vPreviousPoints, std::vector<CPoint> const &vCurrentPoints);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_QuadIndex;
|
|
std::vector<CPoint> m_vPreviousPoints;
|
|
std::vector<CPoint> m_vCurrentPoints;
|
|
};
|
|
|
|
class CEditorActionEditQuadProp : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionEditQuadProp(CEditor *pEditor, int GroupIndex, int LayerIndex, int QuadIndex, EQuadProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_QuadIndex;
|
|
EQuadProp m_Prop;
|
|
int m_Previous;
|
|
int m_Current;
|
|
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionEditQuadPointProp : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionEditQuadPointProp(CEditor *pEditor, int GroupIndex, int LayerIndex, int QuadIndex, int PointIndex, EQuadPointProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_QuadIndex;
|
|
int m_PointIndex;
|
|
EQuadPointProp m_Prop;
|
|
int m_Previous;
|
|
int m_Current;
|
|
|
|
void Apply(int Value);
|
|
};
|
|
|
|
// -------------------------------------------------------------
|
|
|
|
class CEditorActionBulk : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionBulk(CEditor *pEditor, const std::vector<std::shared_ptr<IEditorAction>> &vpActions, const char *pDisplay = nullptr, bool Reverse = false);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
std::vector<std::shared_ptr<IEditorAction>> m_vpActions;
|
|
std::string m_Display;
|
|
bool m_Reverse;
|
|
};
|
|
|
|
//
|
|
|
|
class CEditorActionTileChanges : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionTileChanges(CEditor *pEditor, int GroupIndex, int LayerIndex, const char *pAction, const EditorTileStateChangeHistory<STileStateChange> &Changes);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
EditorTileStateChangeHistory<STileStateChange> m_Changes;
|
|
int m_TotalChanges;
|
|
|
|
void ComputeInfos();
|
|
void Apply(bool Undo);
|
|
};
|
|
|
|
// -------------------------------------------------------------
|
|
|
|
class CEditorActionAddLayer : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionAddLayer(CEditor *pEditor, int GroupIndex, int LayerIndex, bool Duplicate = false);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
bool m_Duplicate;
|
|
};
|
|
|
|
class CEditorActionDeleteLayer : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionDeleteLayer(CEditor *pEditor, int GroupIndex, int LayerIndex);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
};
|
|
|
|
class CEditorActionGroup : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionGroup(CEditor *pEditor, int GroupIndex, bool Delete);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_GroupIndex;
|
|
bool m_Delete;
|
|
std::shared_ptr<CLayerGroup> m_pGroup;
|
|
};
|
|
|
|
class CEditorActionEditGroupProp : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionEditGroupProp(CEditor *pEditor, int GroupIndex, EGroupProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_GroupIndex;
|
|
EGroupProp m_Prop;
|
|
int m_Previous;
|
|
int m_Current;
|
|
|
|
void Apply(int Value);
|
|
};
|
|
|
|
template<typename E>
|
|
class CEditorActionEditLayerPropBase : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionEditLayerPropBase(CEditor *pEditor, int GroupIndex, int LayerIndex, E Prop, int Previous, int Current);
|
|
|
|
virtual void Undo() override {}
|
|
virtual void Redo() override {}
|
|
|
|
protected:
|
|
E m_Prop;
|
|
int m_Previous;
|
|
int m_Current;
|
|
};
|
|
|
|
class CEditorActionEditLayerProp : public CEditorActionEditLayerPropBase<ELayerProp>
|
|
{
|
|
public:
|
|
CEditorActionEditLayerProp(CEditor *pEditor, int GroupIndex, int LayerIndex, ELayerProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionEditLayerTilesProp : public CEditorActionEditLayerPropBase<ETilesProp>
|
|
{
|
|
public:
|
|
CEditorActionEditLayerTilesProp(CEditor *pEditor, int GroupIndex, int LayerIndex, ETilesProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
void SetSavedLayers(const std::map<int, std::shared_ptr<CLayer>> &SavedLayers);
|
|
|
|
private:
|
|
std::map<int, std::shared_ptr<CLayer>> m_SavedLayers;
|
|
|
|
void RestoreLayer(int Layer, const std::shared_ptr<CLayerTiles> &pLayerTiles);
|
|
};
|
|
|
|
class CEditorActionEditLayerQuadsProp : public CEditorActionEditLayerPropBase<ELayerQuadsProp>
|
|
{
|
|
public:
|
|
CEditorActionEditLayerQuadsProp(CEditor *pEditor, int GroupIndex, int LayerIndex, ELayerQuadsProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionEditLayersGroupAndOrder : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionEditLayersGroupAndOrder(CEditor *pEditor, int GroupIndex, const std::vector<int> &LayerIndices, int NewGroupIndex, const std::vector<int> &NewLayerIndices);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_GroupIndex;
|
|
std::vector<int> m_LayerIndices;
|
|
int m_NewGroupIndex;
|
|
std::vector<int> m_NewLayerIndices;
|
|
};
|
|
|
|
// --------------
|
|
|
|
class CEditorActionAppendMap : public IEditorAction
|
|
{
|
|
public:
|
|
struct SPrevInfo
|
|
{
|
|
int m_Groups;
|
|
int m_Images;
|
|
int m_Sounds;
|
|
int m_Envelopes;
|
|
};
|
|
|
|
public:
|
|
CEditorActionAppendMap(CEditor *pEditor, const char *pMapName, const SPrevInfo &PrevInfo, std::vector<int> &vImageIndexMap);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
char m_aMapName[IO_MAX_PATH_LENGTH];
|
|
SPrevInfo m_PrevInfo;
|
|
std::vector<int> m_vImageIndexMap;
|
|
};
|
|
|
|
// --------------
|
|
|
|
class CEditorActionTileArt : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionTileArt(CEditor *pEditor, int PreviousImageCount, const char *pTileArtFile, std::vector<int> &vImageIndexMap);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_PreviousImageCount;
|
|
char m_aTileArtFile[IO_MAX_PATH_LENGTH];
|
|
std::vector<int> m_vImageIndexMap;
|
|
};
|
|
|
|
// ----------------------
|
|
|
|
class CEditorCommandAction : public IEditorAction
|
|
{
|
|
public:
|
|
enum class EType
|
|
{
|
|
DELETE,
|
|
ADD,
|
|
EDIT,
|
|
MOVE_UP,
|
|
MOVE_DOWN
|
|
};
|
|
|
|
CEditorCommandAction(CEditor *pEditor, EType Type, int *pSelectedCommandIndex, int CommandIndex, const char *pPreviousCommand = nullptr, const char *pCurrentCommand = nullptr);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
EType m_Type;
|
|
int *m_pSelectedCommandIndex;
|
|
int m_CommandIndex;
|
|
std::string m_PreviousCommand;
|
|
std::string m_CurrentCommand;
|
|
};
|
|
|
|
// ------------------------------
|
|
|
|
class CEditorActionEnvelopeAdd : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionEnvelopeAdd(CEditor *pEditor, const std::shared_ptr<CEnvelope> &pEnv);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
std::shared_ptr<CEnvelope> m_pEnv;
|
|
};
|
|
|
|
class CEditorActionEveloppeDelete : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionEveloppeDelete(CEditor *pEditor, int EnvelopeIndex);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvelopeIndex;
|
|
std::shared_ptr<CEnvelope> m_pEnv;
|
|
};
|
|
|
|
class CEditorActionEnvelopeEdit : public IEditorAction
|
|
{
|
|
public:
|
|
enum class EEditType
|
|
{
|
|
SYNC,
|
|
ORDER
|
|
};
|
|
|
|
CEditorActionEnvelopeEdit(CEditor *pEditor, int EnvelopeIndex, EEditType EditType, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvelopeIndex;
|
|
EEditType m_EditType;
|
|
int m_Previous;
|
|
int m_Current;
|
|
std::shared_ptr<CEnvelope> m_pEnv;
|
|
};
|
|
|
|
class CEditorActionEnvelopeEditPoint : public IEditorAction
|
|
{
|
|
public:
|
|
enum class EEditType
|
|
{
|
|
TIME,
|
|
VALUE,
|
|
CURVE_TYPE,
|
|
HANDLE
|
|
};
|
|
|
|
CEditorActionEnvelopeEditPoint(CEditor *pEditor, int EnvelopeIndex, int PointIndex, int Channel, EEditType EditType, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvelopeIndex;
|
|
int m_PointIndex;
|
|
int m_Channel;
|
|
EEditType m_EditType;
|
|
int m_Previous;
|
|
int m_Current;
|
|
std::shared_ptr<CEnvelope> m_pEnv;
|
|
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionAddEnvelopePoint : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionAddEnvelopePoint(CEditor *pEditor, int EnvIndex, int Time, ColorRGBA Channels);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvIndex;
|
|
int m_Time;
|
|
ColorRGBA m_Channels;
|
|
};
|
|
|
|
class CEditorActionDeleteEnvelopePoint : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionDeleteEnvelopePoint(CEditor *pEditor, int EnvIndex, int PointIndex);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvIndex;
|
|
int m_PointIndex;
|
|
CEnvPoint_runtime m_Point;
|
|
};
|
|
|
|
class CEditorActionEditEnvelopePointValue : public IEditorAction
|
|
{
|
|
public:
|
|
enum class EType
|
|
{
|
|
TANGENT_IN,
|
|
TANGENT_OUT,
|
|
POINT
|
|
};
|
|
|
|
CEditorActionEditEnvelopePointValue(CEditor *pEditor, int EnvIndex, int PointIndex, int Channel, EType Type, int OldTime, int OldValue, int NewTime, int NewValue);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvIndex;
|
|
int m_PtIndex;
|
|
int m_Channel;
|
|
EType m_Type;
|
|
int m_OldTime;
|
|
int m_OldValue;
|
|
int m_NewTime;
|
|
int m_NewValue;
|
|
|
|
void Apply(bool Undo);
|
|
};
|
|
|
|
class CEditorActionResetEnvelopePointTangent : public IEditorAction
|
|
{
|
|
public:
|
|
CEditorActionResetEnvelopePointTangent(CEditor *pEditor, int EnvIndex, int PointIndex, int Channel, bool In);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_EnvIndex;
|
|
int m_PointIndex;
|
|
int m_Channel;
|
|
bool m_In;
|
|
int m_Previous[2];
|
|
};
|
|
|
|
class CEditorActionEditLayerSoundsProp : public CEditorActionEditLayerPropBase<ELayerSoundsProp>
|
|
{
|
|
public:
|
|
CEditorActionEditLayerSoundsProp(CEditor *pEditor, int GroupIndex, int LayerIndex, ELayerSoundsProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionDeleteSoundSource : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionDeleteSoundSource(CEditor *pEditor, int GroupIndex, int LayerIndex, int SourceIndex);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_SourceIndex;
|
|
CSoundSource m_Source;
|
|
};
|
|
|
|
class CEditorActionEditSoundSource : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
enum class EEditType
|
|
{
|
|
SHAPE
|
|
};
|
|
|
|
CEditorActionEditSoundSource(CEditor *pEditor, int GroupIndex, int LayerIndex, int SourceIndex, EEditType Type, int Value);
|
|
~CEditorActionEditSoundSource() override;
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_SourceIndex;
|
|
EEditType m_EditType;
|
|
int m_CurrentValue;
|
|
|
|
std::vector<int> m_vOriginalValues;
|
|
void *m_pSavedObject;
|
|
|
|
void Save();
|
|
};
|
|
|
|
class CEditorActionEditSoundSourceProp : public CEditorActionEditLayerPropBase<ESoundProp>
|
|
{
|
|
public:
|
|
CEditorActionEditSoundSourceProp(CEditor *pEditor, int GroupIndex, int LayerIndex, int SourceIndex, ESoundProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_SourceIndex;
|
|
|
|
private:
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionEditRectSoundSourceShapeProp : public CEditorActionEditLayerPropBase<ERectangleShapeProp>
|
|
{
|
|
public:
|
|
CEditorActionEditRectSoundSourceShapeProp(CEditor *pEditor, int GroupIndex, int LayerIndex, int SourceIndex, ERectangleShapeProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_SourceIndex;
|
|
|
|
private:
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionEditCircleSoundSourceShapeProp : public CEditorActionEditLayerPropBase<ECircleShapeProp>
|
|
{
|
|
public:
|
|
CEditorActionEditCircleSoundSourceShapeProp(CEditor *pEditor, int GroupIndex, int LayerIndex, int SourceIndex, ECircleShapeProp Prop, int Previous, int Current);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_SourceIndex;
|
|
|
|
private:
|
|
void Apply(int Value);
|
|
};
|
|
|
|
class CEditorActionNewEmptySound : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionNewEmptySound(CEditor *pEditor, int GroupIndex, int LayerIndex, int x, int y);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_X;
|
|
int m_Y;
|
|
};
|
|
|
|
class CEditorActionNewEmptyQuad : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionNewEmptyQuad(CEditor *pEditor, int GroupIndex, int LayerIndex, int x, int y);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_X;
|
|
int m_Y;
|
|
};
|
|
|
|
class CEditorActionNewQuad : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionNewQuad(CEditor *pEditor, int GroupIndex, int LayerIndex);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
CQuad m_Quad;
|
|
};
|
|
|
|
class CEditorActionMoveSoundSource : public CEditorActionLayerBase
|
|
{
|
|
public:
|
|
CEditorActionMoveSoundSource(CEditor *pEditor, int GroupIndex, int LayerIndex, int SourceIndex, CPoint OriginalPosition, CPoint CurrentPosition);
|
|
|
|
void Undo() override;
|
|
void Redo() override;
|
|
|
|
private:
|
|
int m_SourceIndex;
|
|
CPoint m_OriginalPosition;
|
|
CPoint m_CurrentPosition;
|
|
};
|
|
|
|
#endif
|