scourge.h

/***************************************************************************
                          scourge.h  -  description
                             -------------------
    begin                : Sat May 3 2003
    copyright            : (C) 2003 by Gabor Torok
    email                : cctorok@yahoo.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SCOURGE_H
#define SCOURGE_H

#include <iostream>
#include <string>
#include <map>
#include "constants.h"
#include "sdlhandler.h"
#include "sdleventhandler.h"
#include "sdlscreenview.h"
#include "calendar.h"
#include "minimap.h"
#include "map.h"
#include "dungeongenerator.h"
#include "creature.h"
#include "mainmenu.h"
#include "optionsmenu.h"
#include "inventory.h"
#include "item.h"
#include "rpg/character.h"
#include "rpg/monster.h"
#include "rpg/spell.h"
#include "gui/window.h"
#include "gui/button.h"
#include "userconfiguration.h"
#include "effect.h"
#include "containergui.h"
#include "board.h"
#include "battle.h"
#include "party.h"
#include "projectile.h"
#include "multiplayer.h"
#include "net/server.h"
#include "net/client.h"
#include "net/gamestatehandler.h"
#include "netplay.h"
#include "gui/progress.h"
#include "gameadapter.h"
#include "session.h"
#include "infogui.h"
#include "conversationgui.h"
#include "gui/guitheme.h"
#include "gui/scrollinglabel.h"

using namespace std;

class Creature;
class Calendar;
class MiniMap;
class Map;
class DungeonGenerator;
class ShapePalette;
class Location;
class MainMenu;
class OptionsMenu;
class Inventory;
class UserConfiguration;
class Effect;
class DungeonGenerator;
class Window;
class ContainerGui;
class Board;
class Battle;
class Party;
class Projectile;
class Mission;
class MultiplayerDialog;
#ifdef HAVE_SDL_NET
class Server;
class Client;
#endif
class GameStateHandler;
class NetPlay;
class Progress;
class GameAdapter;
class InfoGui;
class ConversationGui;
class GuiTheme;
class ScrollingLabel;

#define IMAGES_DIR "images/"
#define RESOURCES_DIR "resources/"
#define DEFAULT_IMAGES_DIR "default/"
#define CREATURES_DIR "creatures/"
#define MAX_BATTLE_COUNT 200

class InfoMessage {
public:
  char message[300];
  void *obj;
  int x, y, z;

  InfoMessage( char *s, void *obj, int x, int y, int z ) {
    strcpy( this->message, s );
    this->obj = obj;
    this->x = x;
    this->y = y;
    this->z = z;
  }

  ~InfoMessage() {
  }
};

class Scourge : public GameAdapter,SDLEventHandler,SDLScreenView,WidgetView,DragAndDropHandler  {
 private:
  Party *party;
  Map *levelMap;
  MiniMap * miniMap;
  DungeonGenerator *dg;
//  Scourge *scourge;
  int level;
  MainMenu *mainMenu;
  OptionsMenu *optionsMenu;
  MultiplayerDialog *multiplayer;
  bool isInfoShowing;
  bool info_dialog_showing;
  Board *board;
  int nextMission;
  bool teleportFailure;
  bool inHq;
  bool missionWillAwardExpPoints;
  char infoMessage[2000];
  Inventory *inventory;
  Window *messageWin, *exitConfirmationDialog;
  InfoGui *infoGui;
  ConversationGui *conversationGui;
  Label *exitLabel;
  ScrollingList *messageList;
  Button *yesExitConfirm, *noExitConfirm;
  int movingX, movingY, movingZ;
  Uint16 cursorMapX, cursorMapY, cursorMapZ;
  Item *movingItem;
  bool needToCheckDropLocation;
  Uint16 move;
  GLint lastTick;
  int battleCount;
  Battle *battle[MAX_BATTLE_COUNT];  

  // multi-story levels
  int currentStory, oldStory;
  bool changingStory;

  static const int MAX_CONTAINER_GUI = 100;
  int containerGuiCount;
  ContainerGui *containerGui[MAX_CONTAINER_GUI];

  GLint dragStartTime;
  static const int ACTION_CLICK_TIME = 200;

  int lastMapX, lastMapY, lastMapZ, lastX, lastY;
  // how many pixels to wait between sampling 3d coordinates 
  // when dragging items (the more the faster)
  static const int POSITION_SAMPLE_DELTA = 10; 

  bool teleporting;
  
  vector<Battle *> battleRound;
  int battleTurn, rtStartTurn;

  bool mouseMoveScreen;
  Creature *targetSelectionFor;

  int layoutMode;
  NetPlay *netPlay;

  float targetWidth, targetWidthDelta;
  Uint32 lastTargetTick;

  // party ui
  bool lastEffectOn;
  int oldX;
  char version[100], min_version[20];
  Window *mainWin;
  Button *inventoryButton;
  Button *endTurnButton;
  Button *optionsButton;
  Button *quitButton;
  Button *roundButton;
  Button *player1Button;
  Button *player2Button;
  Button *player3Button;
  Button *player4Button;
  Button *groupButton;
  CardContainer *cards;
  Canvas *minPartyInfo;
  Canvas *playerInfo[MAX_PARTY_SIZE], *playerHpMp[MAX_PARTY_SIZE];
  Canvas *quickSpell[12];

  // board gui
  ScrollingList *missionList;
  ScrollingLabel *missionDescriptionLabel;
  Button *playMission, *closeBoard;
  Window *boardWin;

  Progress *progress;
  bool inBattle;
  Progress *turnProgress;
  bool mouseRot, mouseZoom;

  bool willStartDrag;
  int willStartDragX, willStartDragY;
  GLUquadric *quadric;

  bool needToCheckInfo;
  map<InfoMessage *, Uint32> infos;

protected:
  SDLHandler *sdlHandler;
  ShapePalette *shapePal;

  void processGameMouseDown(Uint16 x, Uint16 y, Uint8 button);
  void processGameMouseClick(Uint16 x, Uint16 y, Uint8 button);
  void getMapXYZAtScreenXY(Uint16 x, Uint16 y, Uint16 *mapx, Uint16 *mapy, Uint16 *mapz);
  void getMapXYAtScreenXY(Uint16 x, Uint16 y, Uint16 *mapx, Uint16 *mapy);
  void processGameMouseMove(Uint16 x, Uint16 y);
  void describeLocation(int mapx, int mapy, int mapz);


  bool getItem(Location *pos);
  // returns new z coordinate
  int dropItem(int x, int y);
  bool useLever(Location *pos);
  bool useDoor(Location *pos);
  void destroyDoor( Sint16 ox, Sint16 oy, Shape *shape );
  bool useBoard(Location *pos);
  bool useTeleporter(Location *pos);
  bool useGate(Location *pos);

public:
#define TOP_GUI_WIDTH 400
#define TOP_GUI_HEIGHT 100
#define GUI_PLAYER_INFO_W 250
#define GUI_PLAYER_INFO_H 350
#define MINIMAP_WINDOW_WIDTH 200
#define MINIMAP_WINDOW_HEIGHT 150

  static const int PARTY_GUI_WIDTH=500;
  static const int PARTY_GUI_HEIGHT=145;
  static const int PARTY_MIN_GUI_WIDTH=100;
  static const int INVENTORY_WIDTH = 420;
  static const int INVENTORY_HEIGHT = 460;
  
  static int blendA, blendB;
  static int blend[];
  void setBlendFunc();
  
  Scourge(UserConfiguration *config);
  ~Scourge();

  void receive(Widget *widget);

  inline bool startDrag(Widget *widget, int x=0, int y=0) {
    return false;
  }


  inline int getCurrentDepth() { return currentStory; }

  inline bool isHeadless() { return false; }

  inline Session *getSession() { return session; }

  int getScreenWidth();
  int getScreenHeight();

  inline Board *getBoard() { return board; }
  
  inline void setMove(Uint16 n) { move |= n; };  
  
  inline void removeMove(Uint16 n) { move &= (0xffff - n); }

  void playRound();

  Battle *getBattle(Creature *creature);
 
  inline Party *getParty() { return party; }
  
  inline Map *getMap() { return levelMap; }
  
  inline MiniMap *getMiniMap() { return miniMap; }

  void colorMiniMapPoint(int x, int y, Shape *shape, Location *pos=NULL);
  void eraseMiniMapPoint(int x, int y);

  void setMovingItem(Item *item, int x, int y, int z); 

  inline Item *getMovingItem() { return movingItem; }

  inline MainMenu *getMainMenu() { return mainMenu; }

  inline OptionsMenu *getOptionsMenu() { return optionsMenu; }

  inline MultiplayerDialog *getMultiplayerDialog() { return multiplayer; }

  inline Inventory *getInventory() { return inventory; }
  
  void drawView();

  void drawAfter();

  void drawDraggedItem();

  void drawBorder();
  
  void drawOutsideMap();

  void showCreatureInfo(Creature *creature, bool player, bool selected, bool groupMode);

  bool handleEvent(SDL_Event *event);
  
  bool handleEvent(Widget *widget, SDL_Event *event);
   
  void addGameSpeed(int speedFactor);
  
  void startItemDragFromGui(Item *item);
  
  bool startItemDrag(int x, int y, int z);
  
  void endItemDrag();
  
  bool useItem(int x, int y, int z);
  
  void startMission();  
  
  void endMission();

  inline ShapePalette *getShapePalette() { return shapePal; }  

  inline SDLHandler *getSDLHandler() { return sdlHandler; }
   
  
  //void drawTopWindow();

  void openContainerGui(Item *container);

  void closeContainerGui(ContainerGui *gui);

  void closeAllContainerGuis();
  
  void creatureDeath(Creature *creature);

  void showMessageDialog(char *message);

  void togglePlayerOnly();
  
  void toggleInventoryWindow();

  void toggleOptionsWindow();

  void showExitConfirmationDialog();

  Window *createWoodWindow(int x, int y, int w, int h, char *title);

  Window *createWindow(int x, int y, int w, int h, char *title);
  
  void missionCompleted();

  inline void setTargetSelectionFor(Creature *c) { targetSelectionFor = c; sdlHandler->setCursorMode(targetSelectionFor ? SDLHandler::CURSOR_CROSSHAIR : SDLHandler::CURSOR_NORMAL); }
  
  inline Creature *getTargetSelectionFor() { return targetSelectionFor; }

  void setUILayout();
  
  void setUILayout(int mode);
  
  int getLayoutMode() { return layoutMode; }

  // initialization events
  void initStart(int statusCount, char *message);
  void initUpdate(char *message);
  void initEnd();

  void initVideo(ShapePalette *shapePal);
  void initUI();
  void start();

  inline double getFps() { return getSDLHandler()->getFPS(); }

  inline void playSound(const char *sound) { sdlHandler->getSound()->playSound(sound); }

  inline void loadMonsterSounds( char *type, map<int, vector<string>*> *soundMap ) {
        sdlHandler->getSound()->loadMonsterSounds( type, soundMap, getUserConfiguration() );
  }

  inline void unloadMonsterSounds( char *type, map<int, vector<string>*> *soundMap ) {
        sdlHandler->getSound()->unloadMonsterSounds( type, soundMap );
  }

  inline void setDebugStr(char *s) { sdlHandler->setDebugStr(s); }

  void fightProjectileHitTurn(Projectile *proj, Creature *creature);

  void fightProjectileHitTurn(Projectile *proj, int x, int y);

  void drawWidget(Widget *w);

  void resetPartyUI();

  void refreshInventoryUI(int playerIndex);

  void refreshInventoryUI();

  void toggleRoundUI(bool startRound);

  void setFormationUI(int formation, bool playerOnly);

  void togglePlayerOnlyUI(bool playerOnly);

  void setPlayerUI(int index);

  void setPlayer(int n);

  void createBoardUI();

  void updateBoardUI(int count, const char **missionText, Color *missionColor);

  int handleBoardEvent(Widget *widget, SDL_Event *event);

  void setMissionDescriptionUI(char *s);

  // move a creature
  void moveMonster(Creature *monster);

  void removeBattle(Battle *battle);

  inline bool inTurnBasedCombat() {
    return (battleTurn < (int)battleRound.size() && 
            getUserConfiguration()->isBattleTurnBased());
  }

  bool inTurnBasedCombatPlayerTurn();

  inline InfoGui *getInfoGui() { return infoGui; }

  inline ConversationGui *getConversationGui() { return conversationGui; }

  void showItemInfoUI(Item *item, int level);

  void resetInfos();

  void createParty( Creature **pc, int *partySize );

  bool handleTargetSelectionOfCreature( Creature *potentialTarget );
  bool handleTargetSelectionOfItem( Item *item, int x=0, int y=0, int z=0 );
  bool handleTargetSelectionOfLocation( Uint16 mapx, Uint16 mapy, Uint16 mapz );

  void teleport( bool toHQ=true );

  inline Window *getPartyWindow() { return mainWin; }

 protected:

   void drawPortrait( Widget *w, Creature *p );

  void resetBattles();

   int initMultiplayer();

  void decodeName(int name, Uint16* mapx, Uint16* mapy, Uint16* mapz);
  void createUI();
  // change the player's selX,selY values as specified by keyboard movement
  void handleKeyboardMovement();  

  void decideMonsterAction(Creature *monster);

  void refreshContainerGui(Item *container);

  void createPartyUI();

  bool handlePartyEvent(Widget *widget, SDL_Event *event);

  void updatePartyUI();

  void moveProjectiles();
  bool fightCurrentBattleTurn();
  void resetNonParticipantAnimation( Battle *battle );
  bool createBattleTurns();
  void resetUIAfterBattle();
  void moveCreatures();

  void checkForDropTarget();
  void checkForInfo();
  void drawInfos();

  void quickSpellAction( int index );
};

#endif

---