Merge branch 'master' of github.com:huderlem/porymap

include/core/metatile.h

@@ -10,7 +10,10 @@ public:
     Metatile();
 public:
     QList<Tile> *tiles = nullptr;
+    uint8_t behavior;
+    uint8_t layerType;
 
+    Metatile *copy();
     static int getBlockIndex(int);
 };
 

include/core/tileset.h

@@ -17,16 +17,24 @@ public:
     QString tiles_label;
     QString palettes_label;
     QString metatiles_label;
+    QString metatiles_path;
     QString callback_label;
     QString metatile_attrs_label;
+    QString metatile_attrs_path;
+    QString tilesImagePath;
+    QImage tilesImage;
+    QList<QString> palettePaths;
 
     QList<QImage> *tiles = nullptr;
     QList<Metatile*> *metatiles = nullptr;
     QList<QList<QRgb>> *palettes = nullptr;
 
+    Tileset* copy();
+
     static Tileset* getBlockTileset(int, Tileset*, Tileset*);
     static Metatile* getMetatile(int, Tileset*, Tileset*);
     static QList<QList<QRgb>> getBlockPalettes(Tileset*, Tileset*);
+    static QList<QRgb> getPalette(int, Tileset*, Tileset*);
 };
 
 #endif // TILESET_H

include/editor.h

@@ -68,9 +68,10 @@ public:
     void updateDiveMap(QString mapName);
     void updateEmergeMap(QString mapName);
     void setSelectedConnectionFromMap(QString mapName);
-    void updatePrimaryTileset(QString tilesetLabel);
-    void updateSecondaryTileset(QString tilesetLabel);
+    void updatePrimaryTileset(QString tilesetLabel, bool forceLoad = false);
+    void updateSecondaryTileset(QString tilesetLabel, bool forceLoad = false);
     void toggleBorderVisibility(bool visible);
+    Tileset *getCurrentMapPrimaryTileset();
 
     DraggablePixmapItem *addMapEvent(Event *event);
     void selectMapEvent(DraggablePixmapItem *object);

include/mainwindow.h

@@ -12,6 +12,7 @@
 #include "project.h"
 #include "map.h"
 #include "editor.h"
+#include "tileseteditor.h"
 
 namespace Ui {
 class MainWindow;
@@ -42,6 +43,7 @@ private slots:
     void onLoadMapRequested(QString, QString);
     void onMapChanged(Map *map);
     void onMapNeedsRedrawing();
+    void onTilesetsSaved(QString, QString);
 
     void on_action_Save_triggered();
     void on_tabWidget_2_currentChanged(int index);
@@ -92,6 +94,7 @@ private slots:
     void onAddNewMapToGroupClick(QAction* triggeredAction);
     void onTilesetChanged(QString);
     void currentMetatilesSelectionChanged();
+    void onTilesetEditorClosed();
 
     void on_action_Export_Map_Image_triggered();
 
@@ -123,8 +126,11 @@ private slots:
 
     void resetMapViewScale();
 
+    void on_actionTileset_Editor_triggered();
+
 private:
     Ui::MainWindow *ui;
+    TilesetEditor *tilesetEditor = nullptr;
     QStandardItemModel *mapListModel;
     QList<QStandardItem*> *mapGroupsModel;
     QMap<QString, QModelIndex> mapListIndexes;
@@ -153,6 +159,7 @@ private:
     void initEditor();
     void loadUserSettings();
     void openRecentProject();
+    void updateTilesetEditor();
 };
 
 enum MapListUserRoles {

include/project.h

@@ -40,14 +40,16 @@ public:
     QStringList *secretBaseIds = nullptr;
     QStringList *bgEventFacingDirections = nullptr;
     QStringList mapsWithConnections;
+    QMap<QString, int> metatileBehaviorMap;
+    QMap<int, QString> metatileBehaviorMapInverse;
 
     QMap<QString, Map*> *map_cache;
     Map* loadMap(QString);
     Map* getMap(QString);
 
     QMap<QString, Tileset*> *tileset_cache = nullptr;
-    Tileset* loadTileset(QString);
-    Tileset* getTileset(QString);
+    Tileset* loadTileset(QString, Tileset *tileset = nullptr);
+    Tileset* getTileset(QString, bool forceLoad = false);
 
     Blockdata* readBlockdata(QString);
     void loadBlockdata(Map*);
@@ -72,6 +74,8 @@ public:
     void readMapsWithConnections();
     void loadMapTilesets(Map*);
     void loadTilesetAssets(Tileset*);
+    void loadTilesetTiles(Tileset*, QImage);
+    void loadTilesetMetatiles(Tileset*);
 
     void saveBlockdata(Map*);
     void saveMapBorder(Map*);
@@ -83,6 +87,7 @@ public:
     void saveMapGroupsTable();
     void saveMapConstantsHeader();
     void saveHealLocationStruct(Map*);
+    void saveTilesets(Tileset*, Tileset*);
 
     QList<QStringList>* parseAsm(QString text);
     QStringList getSongNames();
@@ -100,9 +105,11 @@ public:
     void readCoordEventWeatherNames();
     void readSecretBaseIds();
     void readBgEventFacingDirections();
+    void readMetatileBehaviors();
 
     void loadEventPixmaps(QList<Event*> objects);
     QMap<QString, int> getEventObjGfxConstants();
+    QString fixPalettePath(QString path);
     QString fixGraphicPath(QString path);
 
     void readMapEvents(Map *map);
@@ -127,6 +134,10 @@ private:
     QString getMapLayoutFilepath(QString);
     void saveMapHeader(Map*);
     void saveMapConnections(Map*);
+    void saveTilesetMetatileAttributes(Tileset*);
+    void saveTilesetMetatiles(Tileset*);
+    void saveTilesetTilesImage(Tileset*);
+    void saveTilesetPalettes(Tileset*, bool);
     void updateMapsWithConnections(Map*);
     void saveMapsWithConnections();
     void saveMapLayoutsTable();

include/ui/imageproviders.h

@@ -8,7 +8,8 @@
 
 QImage getCollisionMetatileImage(Block);
 QImage getCollisionMetatileImage(int, int);
-QImage getMetatileImage(int, Tileset*, Tileset*);
-QImage getTileImage(int, Tileset*, Tileset*);
+QImage getMetatileImage(uint16_t, Tileset*, Tileset*);
+QImage getTileImage(uint16_t, Tileset*, Tileset*);
+QImage getColoredTileImage(uint16_t, Tileset*, Tileset*, int);
 
 #endif // IMAGEPROVIDERS_H

include/ui/metatilelayersitem.h

@@ -0,0 +1,29 @@
+#ifndef METATILELAYERSITEM_H
+#define METATILELAYERSITEM_H
+
+#include "tileset.h"
+#include <QGraphicsPixmapItem>
+#include <QGraphicsSceneMouseEvent>
+
+class MetatileLayersItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
+public:
+    MetatileLayersItem(Metatile *metatile, Tileset *primaryTileset, Tileset *secondaryTileset) {
+        this->metatile = metatile;
+        this->primaryTileset = primaryTileset;
+        this->secondaryTileset = secondaryTileset;
+    }
+    void draw();
+    void setTilesets(Tileset*, Tileset*);
+    void setMetatile(Metatile*);
+private:
+    Metatile* metatile;
+    Tileset *primaryTileset;
+    Tileset *secondaryTileset;
+signals:
+    void tileChanged(int, int);
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+};
+
+#endif // METATILELAYERSITEM_H

include/ui/paletteeditor.h

@@ -0,0 +1,43 @@
+#ifndef PALETTEEDITOR_H
+#define PALETTEEDITOR_H
+
+#include <QMainWindow>
+#include <QSlider>
+#include <QFrame>
+#include "project.h"
+
+namespace Ui {
+class PaletteEditor;
+}
+
+class PaletteEditor :  public QMainWindow {
+    Q_OBJECT
+public:
+    explicit PaletteEditor(Project*, Tileset*, Tileset*, QWidget *parent = nullptr);
+    ~PaletteEditor();
+    void setPaletteId(int);
+
+private:
+    Ui::PaletteEditor *ui;
+    Project *project = nullptr;
+    QList<QList<QSlider*>> sliders;
+    QList<QFrame*> frames;
+    Tileset *primaryTileset;
+    Tileset *secondaryTileset;
+    void disableSliderSignals();
+    void enableSliderSignals();
+    void initColorSliders();
+    void refreshColorSliders();
+    void refreshColors();
+    void refreshColor(int);
+    void setColor(int);
+
+signals:
+    void closed();
+    void changedPaletteColor();
+    void changedPalette(int);
+private slots:
+    void on_spinBox_PaletteId_valueChanged(int arg1);
+};
+
+#endif // PALETTEEDITOR_H

include/ui/tileseteditor.h

@@ -1,22 +1,90 @@
 #ifndef TILESETEDITOR_H
 #define TILESETEDITOR_H
 
-#include <QDialog>
+#include <QMainWindow>
+#include "project.h"
+#include "paletteeditor.h"
+#include "tileseteditormetatileselector.h"
+#include "tileseteditortileselector.h"
+#include "metatilelayersitem.h"
 
 namespace Ui {
 class TilesetEditor;
 }
 
-class TilesetEditor : public QDialog
+class TilesetEditor : public QMainWindow
 {
     Q_OBJECT
 
 public:
-    explicit TilesetEditor(QWidget *parent = nullptr);
+    explicit TilesetEditor(Project*, QString, QString, QWidget *parent = nullptr);
     ~TilesetEditor();
+    void setTilesets(QString, QString);
+    void init(Project*, QString, QString);
+
+private slots:
+    void onHoveredMetatileChanged(uint16_t);
+    void onHoveredMetatileCleared();
+    void onSelectedMetatileChanged(uint16_t);
+    void onHoveredTileChanged(uint16_t);
+    void onHoveredTileCleared();
+    void onSelectedTilesChanged();
+    void onMetatileLayerTileChanged(int, int);
+    void onPaletteEditorClosed();
+    void onPaletteEditorChangedPaletteColor();
+    void onPaletteEditorChangedPalette(int);
+
+    void on_spinBox_paletteSelector_valueChanged(int arg1);
+
+    void on_checkBox_xFlip_stateChanged(int arg1);
+
+    void on_checkBox_yFlip_stateChanged(int arg1);
+
+    void on_comboBox_metatileBehaviors_currentIndexChanged(const QString &arg1);
+
+    void on_comboBox_layerType_currentIndexChanged(int index);
+
+    void on_actionSave_Tileset_triggered();
+
+    void on_actionImport_Primary_Tiles_triggered();
+
+    void on_actionImport_Secondary_Tiles_triggered();
+
+    void on_actionChange_Metatiles_Count_triggered();
+
+    void on_actionChange_Palettes_triggered();
 
 private:
+    void closeEvent(QCloseEvent*);
+    void initMetatileSelector();
+    void initTileSelector();
+    void initSelectedTileItem();
+    void initMetatileLayersItem();
+    void drawSelectedTiles();
+    void importTilesetTiles(Tileset*, bool);
+    void refresh();
     Ui::TilesetEditor *ui;
+    TilesetEditorMetatileSelector *metatileSelector = nullptr;
+    TilesetEditorTileSelector *tileSelector = nullptr;
+    MetatileLayersItem *metatileLayersItem = nullptr;
+    PaletteEditor *paletteEditor = nullptr;
+    Project *project = nullptr;
+    Metatile *metatile = nullptr;
+    int paletteId;
+    bool tileXFlip;
+    bool tileYFlip;
+    bool hasUnsavedChanges;
+    Tileset *primaryTileset = nullptr;
+    Tileset *secondaryTileset = nullptr;
+    QGraphicsScene *metatilesScene = nullptr;
+    QGraphicsScene *tilesScene = nullptr;
+    QGraphicsScene *selectedTileScene = nullptr;
+    QGraphicsPixmapItem *selectedTilePixmapItem = nullptr;
+    QGraphicsScene *metatileLayersScene = nullptr;
+
+signals:
+    void tilesetsSaved(QString, QString);
+    void closed();
 };
 
 #endif // TILESETEDITOR_H

include/ui/tileseteditormetatileselector.h

@@ -0,0 +1,44 @@
+#ifndef TILESETEDITORMETATILESELECTOR_H
+#define TILESETEDITORMETATILESELECTOR_H
+
+#include "selectablepixmapitem.h"
+#include "tileset.h"
+
+class TilesetEditorMetatileSelector: public SelectablePixmapItem {
+    Q_OBJECT
+public:
+    TilesetEditorMetatileSelector(Tileset *primaryTileset, Tileset *secondaryTileset): SelectablePixmapItem(32, 32, 1, 1) {
+        this->primaryTileset = primaryTileset;
+        this->secondaryTileset = secondaryTileset;
+        this->numMetatilesWide = 8;
+        setAcceptHoverEvents(true);
+    }
+    void draw();
+    void select(uint16_t metatileId);
+    void setTilesets(Tileset*, Tileset*);
+    uint16_t getSelectedMetatile();
+
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+    void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent*);
+
+private:
+    Tileset *primaryTileset = nullptr;
+    Tileset *secondaryTileset = nullptr;
+    uint16_t selectedMetatile;
+    int numMetatilesWide;
+    void updateSelectedMetatile();
+    uint16_t getMetatileId(int x, int y);
+    QPoint getMetatileIdCoords(uint16_t);
+    uint16_t getValidMetatileId(uint16_t);
+
+signals:
+    void hoveredMetatileChanged(uint16_t);
+    void hoveredMetatileCleared();
+    void selectedMetatileChanged(uint16_t);
+};
+
+#endif // TILESETEDITORMETATILESELECTOR_H

include/ui/tileseteditortileselector.h

@@ -0,0 +1,52 @@
+#ifndef TILESETEDITORTILESELECTOR_H
+#define TILESETEDITORTILESELECTOR_H
+
+#include "selectablepixmapitem.h"
+#include "tileset.h"
+
+class TilesetEditorTileSelector: public SelectablePixmapItem {
+    Q_OBJECT
+public:
+    TilesetEditorTileSelector(Tileset *primaryTileset, Tileset *secondaryTileset): SelectablePixmapItem(16, 16, 2, 2) {
+        this->primaryTileset = primaryTileset;
+        this->secondaryTileset = secondaryTileset;
+        this->numTilesWide = 16;
+        this->paletteId = 0;
+        this->xFlip = false;
+        this->yFlip = false;
+        setAcceptHoverEvents(true);
+    }
+    void draw();
+    void select(uint16_t metatileId);
+    void setTilesets(Tileset*, Tileset*);
+    void setPaletteId(int);
+    void setTileFlips(bool, bool);
+    QList<uint16_t> getSelectedTiles();
+
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+    void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent*);
+
+private:
+    Tileset *primaryTileset;
+    Tileset *secondaryTileset;
+    QList<uint16_t> selectedTiles;
+    int numTilesWide;
+    int paletteId;
+    bool xFlip;
+    bool yFlip;
+    void updateSelectedTiles();
+    uint16_t getTileId(int x, int y);
+    QPoint getTileCoords(uint16_t);
+    QList<QRgb> getCurPaletteTable();
+
+signals:
+    void hoveredTileChanged(uint16_t);
+    void hoveredTileCleared();
+    void selectedTilesChanged();
+};
+
+#endif // TILESETEDITORTILESELECTOR_H