game.h

/***************************************************************************
 *   Copyright (C) 2007 by Mike Polan                                      *
 *   kanadakid@gmail.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.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
// game.h: the Game class

#ifndef GAME_H
#define GAME_H

#include <iostream>
#include <vector>

#include "case.h"
#include "common.h"
#include "textparser.h"
#include "uimanager.h"

class Game;

enum GameFlags {
        STATE_QUEUED=                   1 << 0,  
        STATE_COURT_REC_BTN=            1 << 1,  
        STATE_EVIDENCE_BTN=             1 << 2,  
        STATE_PROFILES_BTN=             1 << 3,  
        STATE_BACK_BTN=                 1 << 4,  
        STATE_PRESENT_BTN=              1 << 5,  
        STATE_EVIDENCE_PAGE=            1 << 6,  
        STATE_PROFILES_PAGE=            1 << 7,  
        STATE_EVIDENCE_INFO_PAGE=       1 << 8,  
        STATE_PROFILE_INFO_PAGE=        1 << 9,  
        STATE_NEXT_BTN=                 1 << 10, 
        STATE_TEXT_BOX=                 1 << 11, 
        STATE_CONTROLS=                 1 << 12, 
        STATE_EXAMINE=                  1 << 13, 
        STATE_MOVE=                     1 << 14, 
        STATE_TALK=                     1 << 15, 
        STATE_PRESENT_TOP_BTN=          1 << 16, 
        STATE_CROSS_EXAMINE_BTNS=       1 << 17, 
        STATE_PRESS_BTN=                1 << 18, 
        STATE_COURT_GREEN_BAR=          1 << 19, 
        STATE_CHECK_BTN=                1 << 20, 
        STATE_CHECK_EVIDENCE_IMAGE=     1 << 21, 
        STATE_CONFIRM_BTN=              1 << 22, 
        STATE_INITIAL_SCREEN=           1 << 23, 
        STATE_EPISODE_SELECTION=        1 << 24, 
        STATE_CONTINUE_SCREEN=          1 << 25  
                                                };

enum Controls {
        CONTROLS_ALL=           1 << 0,
        CONTROLS_EXAMINE=       1 << 1,
        CONTROLS_MOVE=          1 << 2,
        CONTROLS_TALK=          1 << 3,
        CONTROLS_PRESENT=       1 << 4 };

enum Position {
        POSITION_LEFT=  1,
        POSITION_RIGHT= 2 };

enum Screen {
        SCREEN_MAIN=    0,
        SCREEN_EXAMINE= 1,
        SCREEN_MOVE=    2,
        SCREEN_TALK=    3,
        SCREEN_PRESENT= 4 };

enum Stand {
        COURT_PROSECUTOR_STAND=0,
        COURT_DEFENSE_STAND,
        COURT_WITNESS_STAND };

struct _GameState {
        int drawFlags;
        
        int evidencePage;
        
        int profilesPage;
        
        // selections
        int selectedEvidence;
        int selectedProfile;
        int selectedControl;
        int selectedLocation;
        int selectedTalkOption;
        
        // trial variables
        bool requestingEvidence;
        bool requestingAnswer;
        ustring requestedEvidenceParams;
        ustring requestedAnswerParams;
        ustring requestedContrParams;
        
        ustring tempImage;
        
        Point examinePt;
        
        // region of contradiction in provided image of evidence
        ustring contradictionImg;
        Rect contradictionRegion;
        
        int prevScreen;
        
        bool hideTextBox;
        
        bool continueMusic;
        
        // testimony variables
        ustring curTestimony;
        int curTestimonyPiece;
        int barPercent; // amount of green bar filled in
        bool curExamination;
        bool curExaminationPaused; // for temporarily breaking away from cross examinations
        
        // special effects
        int shake;
        ustring fadeOut;
        ustring fadeIn;
        ustring flash;
        ustring blink;
        ustring gavel;
        ustring courtCamera;
        ustring testimonySequence;
        ustring crossExamineSequence;
        ustring exclamation;
        ustring addEvidence;
        
        StringPair crossExamineLawyers;
        
        // the current evidence being shown
        ustring shownEvidence;
        Position shownEvidencePos;
        
        // images to display for various parts of the courtroom
        ustring crOverviewDefense;
        ustring crOverviewProsecutor;
        ustring crOverviewWitness;
        
        ustring currentLocation;
        
        // scheduled events
        int queuedFlags;
        ustring queuedLocation;
        ustring queuedBlock;
        ustring resetAnimations;
        
        std::vector<StringPair> custom;
        
        std::vector<StringPair> talkOptions;
        
        std::vector<ustring> visibleEvidence;
        
        std::vector<ustring> visibleProfiles;
};
typedef struct _GameState GameState;

class Game {
        public:
                Game(const ustring &rootPath, Case::Case *pcase);
                
                ~Game();
                
                static Game* instance();
                
                bool loadStockTextures();
                
                void render();
                
                Case::Case* getCase() { return m_Case; }
                
                void onKeyboardEvent(SDL_KeyboardEvent *e);
                
                void onMouseEvent(SDL_MouseButtonEvent *e);
                
        private:
                void registerAnimations();
                
                void checkInputState();
                
                ustring getSelectedEvidence();
                
                ustring getSelectedProfile();
                
                void toggle(int flags);
                
                bool flagged(int flag);
                
                bool shouldDrawTextBox();
                
                bool canExamineRegion();
                
                void setLocation(const ustring &location);
                
                void setShownEvidence(const ustring &id, const Position &pos);
                
                void displayTestimony(const ustring &id, bool crossExamine);
                
                void selectEvidence(bool evidence=true, bool increment=true);
                
                bool isCourtLocation(const ustring &id);
                
                void updateFlags();
                
                void renderTopView();
                
                void renderMenuView();
                
                bool renderSpecialEffects();
                
                void renderTextBox();
                
                void renderControls(int flags);
                
                void renderCourtroomOverview();
                
                void renderStand(const Stand stand);
                
                void onInitialScreenClicked(const ustring &id);
                
                void onTopRightButtonClicked();
                
                void onTopLeftButtonClicked();
                
                void onBottomLeftButtonClicked();
                
                void onBottomRightButtonClicked();
                
                void onPresentCenterClicked();
                
                void onCheckButtonClicked();
                
                void onControlsClicked(const Point &p);
                
                void onMoveSceneClicked(const ustring &button);
                
                void onTalkSceneClicked(const ustring &button);
                
                void onRecPageClickEvent(const Point &p);
                
                void onRecInfoPageClickEvent(const Point &p);
                
                void onExamineButtonActivated();
                
                void onMoveButtonActivated();
                
                void onTalkButtonActivated();
                
                void onPresentButtonActivated();
                
                void onExamineThing(const Point &p);
                
                Case::Case *m_Case;
                
                TextParser *m_Parser;
                
                UI::Manager *m_UI;
                
                ustring m_CurBlock;
                
                ustring m_RootPath;
                
                GameState m_State;
                
                // friend classes
                friend class TextParser;
};

#endif

---