spritedata.h

Go to the documentation of this file.

/*
  * Copyright 2020 Twilight
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
*/
#pragma once
#include <QObject>
#include <QVector>
#include "optional"
#include <pse-common/types.h>
#include "../../savefile_autoport.h"
 
class SaveFile;
struct SpriteDBEntry;
struct MapDBEntrySprite;
struct MapDBEntry;
struct TmpSpritePos;

struct SAVEFILE_AUTOPORT SpriteMovementStatus : public QObject
{
  Q_OBJECT
  Q_ENUMS(SpriteMovementStatus_)
 
public:
  enum SpriteMovementStatus_ : var8
  {
    UnInit = 0, 
    Ready,      
    Delayed,    
    Moving      
  };
};

struct SAVEFILE_AUTOPORT SpriteFacing : public QObject
{
  Q_OBJECT
  Q_ENUMS(SpriteFacing_)
 
public:
  Q_INVOKABLE static var8 random(); 
 
  // Place these in same scope
  enum SpriteFacing_ : var8
  {
    Down = 4 * 0,
    Up = 4 * 1,
    Left = 4 * 2,
    Right = 4 * 3,
    None = 0xFF
  };
};

struct SAVEFILE_AUTOPORT SpriteMobility : public QObject
{
  Q_OBJECT
  Q_ENUMS(SpriteMobility_)
 
public:
  Q_INVOKABLE static var8 random(); 
 
  enum SpriteMobility_ : var8
  {
    Moving = 0xFF,
    NotMoving = 0xFE,
    MovingWithoutCollision = 0x00
  };
};

struct SAVEFILE_AUTOPORT SpriteMovement : public QObject
{
  Q_OBJECT
  Q_ENUMS(SpriteMovement_)
 
public:
  Q_INVOKABLE static var8 random(); 
 
  enum SpriteMovement_ : var8 {
    UpDown = 0x01,
    LeftRight = 0x02,
    Down = 0xD0,
    Up = 0xD1,
    Left = 0xD2,
    Right = 0xD3,
 
    // Allow to be moved with strength
    // Does this apply only to boulders or any sprite or does it enable it
    // For special scripted sprites???
    StrengthMovement = 0x10
  };
};

struct SAVEFILE_AUTOPORT SpriteGrass : public QObject
{
  Q_OBJECT
  Q_ENUMS(SpriteGrass_)
 
public:
  Q_INVOKABLE static var8 random(); 
 
  enum SpriteGrass_ : var8
  {
    InGrass = 0x00,
    NotInGrass = 0x80
  };
};

class SAVEFILE_AUTOPORT SpriteData : public QObject
{
  Q_OBJECT
 
  Q_PROPERTY(int pictureID MEMBER pictureID NOTIFY pictureIDChanged)
  Q_PROPERTY(int movementStatus MEMBER movementStatus NOTIFY movementStatusChanged)
  Q_PROPERTY(int imageIndex MEMBER imageIndex NOTIFY imageIndexChanged)
  Q_PROPERTY(int faceDir MEMBER faceDir NOTIFY faceDirChanged)
  Q_PROPERTY(int yDisp MEMBER yDisp NOTIFY yDispChanged)
  Q_PROPERTY(int xDisp MEMBER xDisp NOTIFY xDispChanged)
  Q_PROPERTY(int mapY MEMBER mapY NOTIFY mapYChanged)
  Q_PROPERTY(int mapX MEMBER mapX NOTIFY mapXChanged)
  Q_PROPERTY(int movementByte MEMBER movementByte NOTIFY movementByteChanged)
  Q_PROPERTY(int grassPriority MEMBER grassPriority NOTIFY grassPriorityChanged)
  Q_PROPERTY(int yPixels MEMBER yPixels NOTIFY yPixelsChanged)
  Q_PROPERTY(int xPixels MEMBER xPixels NOTIFY xPixelsChanged)
  Q_PROPERTY(int intraAnimationFrameCounter MEMBER intraAnimationFrameCounter NOTIFY intraAnimationFrameCounterChanged)
  Q_PROPERTY(int animFrameCounter MEMBER animFrameCounter NOTIFY animFrameCounterChanged)
  Q_PROPERTY(int walkAnimationCounter MEMBER walkAnimationCounter NOTIFY walkAnimationCounterChanged)
  Q_PROPERTY(int movementDelay MEMBER movementDelay NOTIFY movementDelayChanged)
  Q_PROPERTY(int imageBaseOffset MEMBER imageBaseOffset NOTIFY imageBaseOffsetChanged)
  Q_PROPERTY(int rangeDirByte READ getRangeDirByte WRITE setRangeDirByte RESET resetRangeDirByte NOTIFY rangeDirByteChanged)
  Q_PROPERTY(int textID READ getTextID WRITE setTextID RESET resetTextID NOTIFY textIDChanged)
  Q_PROPERTY(int trainerClassOrItemID READ getTrainerClassOrItemID WRITE setTrainerClassOrItemID RESET resetTrainerClassOrItemID NOTIFY trainerClassOrItemIDChanged)
  Q_PROPERTY(int trainerSetID READ getTrainerSetID WRITE setTrainerSetID RESET resetTrainerSetID NOTIFY trainerSetIDChanged)
  Q_PROPERTY(int missableIndex READ getMissableIndex WRITE setMissableIndex RESET resetMissableIndex NOTIFY missableIndexChanged)
  Q_PROPERTY(int yStepVector READ getYStepVector WRITE setYStepVector NOTIFY yStepVectorChanged)
  Q_PROPERTY(int xStepVector READ getXStepVector WRITE setXStepVector NOTIFY xStepVectorChanged)
 
public:
  SpriteData(bool blankNPC = false,
             SaveFile* saveFile = nullptr,
             var8 index = 0);

  SpriteData(MapDBEntrySprite* entry);
 
  virtual ~SpriteData();
 
  void load(bool blankNPC = false,
            SaveFile* saveFile = nullptr,
            var8 index = 0);

  void load(MapDBEntrySprite* spriteData);
 
  void loadSpriteData1(SaveFile* saveFile,
            var8 index); 
  void loadSpriteData2(SaveFile* saveFile,
            var8 index); 
  void loadSpriteDataNPC(SaveFile* saveFile,
            var8 index); 
  void checkMissable(SaveFile* saveFile,
            var8 index); 
 
  void save(SaveFile* saveFile,
            var8 index);
  void saveSpriteData1(SaveFile* saveFile,
            var8 index); 
  void saveSpriteData2(SaveFile* saveFile,
            var8 index); 
  void saveSpriteDataNPC(SaveFile* saveFile,
            var8 index); 
 
  SpriteDBEntry* toSprite(); 
 
  // Can't be Q_INVOKABLE for some reason, can't be placed into the
  // Qt Meta System
  static void saveMissables(SaveFile* saveFile,
                       QVector<SpriteData*> spriteData);
 
  // These allow QML to work with std::optional values including resetting them
  // They are interfaced with a Q_PROPERTY
  int getRangeDirByte();              
  void setRangeDirByte(int val);      
  void resetRangeDirByte();           
  int getTextID();                    
  void setTextID(int val);            
  void resetTextID();                 
  int getTrainerClassOrItemID();      
  void setTrainerClassOrItemID(int val); 
  void resetTrainerClassOrItemID();   
  int getTrainerSetID();              
  void setTrainerSetID(int val);      
  void resetTrainerSetID();           
  int getMissableIndex();             
  void setMissableIndex(int val);     
  void resetMissableIndex();          
 
  // These allow QML to work with values that require a var8 as QML can only
  // read and write int's
  // They are interfaced with a Q_PROPERTY
  int getYStepVector();         
  void setYStepVector(int val); 
  int getXStepVector();         
  void setXStepVector(int val); 
 
signals:
  void pictureIDChanged();
  void movementStatusChanged();
  void imageIndexChanged();
  void faceDirChanged();
  void yDispChanged();
  void xDispChanged();
  void mapYChanged();
  void mapXChanged();
  void movementByteChanged();
  void grassPriorityChanged();
  void yStepVectorChanged();
  void xStepVectorChanged();
  void yPixelsChanged();
  void xPixelsChanged();
  void intraAnimationFrameCounterChanged();
  void animFrameCounterChanged();
  void walkAnimationCounterChanged();
  void movementDelayChanged();
  void imageBaseOffsetChanged();
  void rangeDirByteChanged();
  void textIDChanged();
  void trainerClassOrItemIDChanged();
  void trainerSetIDChanged();
  void missableIndexChanged();
 
public slots:
  void reset(bool blankNPC = false); 
  static QVector<SpriteData*> randomizeAll(QVector<MapDBEntrySprite*> mapSprites); 
  void randomize(QVector<TmpSpritePos*>* tmpPos); 
 
  void setTo(MapDBEntrySprite* spriteData); 
  static QVector<SpriteData*> setToAll(QVector<MapDBEntrySprite*> spriteSigns); 
 
public:

  int pictureID;

  int movementStatus;

  int imageIndex;

  int faceDir;

  int yDisp;
  int xDisp;

  int mapY;
  int mapX;

  int movementByte;

  int grassPriority;


  var8 yStepVector;
  var8 xStepVector;

  int yPixels;
  int xPixels;

  int intraAnimationFrameCounter;

  int animFrameCounter;

 
  int walkAnimationCounter;

  int movementDelay;

  int imageBaseOffset;
 
  /*
   * Sprite data that applies to all non-player sprites
   * (All sprites that aren't sprite #0)
   * In reality though the game doesn't use any sprite data at all for the
   * player so none of this matters to begin with
  */

  std::optional<int> rangeDirByte;

  std::optional<int> textID;

  std::optional<int> trainerClassOrItemID;

  std::optional<int> trainerSetID;


  std::optional<int> missableIndex;
};