case.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.             *
 ***************************************************************************/
// case.h: various Case related classes

#ifndef CASE_H
#define CASE_H

#include <map>
#include <vector>
#include "SDL.h"
#include "SDL_mixer.h"

#include "character.h"
#include "common.h"

namespace Case {

enum LawSystem { TWO_DAY=0, THREE_DAY };

enum BackgroundType { BG_SINGLE_SCREEN=0, BG_DOUBLE_SCREEN };

struct _Overview {
        ustring name;
        
        ustring author;
        
        LawSystem lawSys;
};
typedef struct _Overview Overview;

struct _Overrides {
        int textboxAlpha;
        
        ustring titleScreen;
};
typedef struct _Overrides Overrides;

struct _Background {
        ustring id;
        
        BackgroundType type;
        
        SDL_Surface *texture;
};
typedef struct _Background Background;

struct _Evidence {
        ustring id;
        
        ustring name;
        
        ustring caption;
        
        ustring description;
        
        ustring checkID;
        
        SDL_Surface *texture;
        
        SDL_Surface *thumb;
};
typedef struct _Evidence Evidence;

struct _Hotspot {
        Rect rect;
        
        ustring block;
};
typedef struct _Hotspot Hotspot;

struct _Location {
        ustring id;
        
        ustring name;
        
        ustring triggerBlock;
        
        ustring character;
        
        ustring music;
        
        ustring bg;
        
        SDL_Surface *bgScaled;
        
        std::vector<Hotspot> hotspots;
        
        std::vector<ustring> moveLocations; 
};
typedef struct _Location Location;

struct _Image {
        ustring id;
        
        SDL_Surface *texture;
};
typedef struct _Image Image;

struct _TestimonyPiece {
        ustring text;
        
        ustring presentId;
        
        ustring presentBlock;
        
        ustring pressBlock;
        
        bool hidden;
};
typedef struct _TestimonyPiece TestimonyPiece;

struct _Testimony {
        Glib::ustring id;
        
        Glib::ustring title;
        
        Glib::ustring speaker;
        
        Glib::ustring nextBlock;
        
        Glib::ustring followLocation;
        
        Glib::ustring xExamineEndBlock;
        
        std::vector<TestimonyPiece> pieces;
};
typedef struct _Testimony Testimony;

}; // namespace Case

// typedefs for cleaner code
typedef std::map<ustring, Character> CharacterMap;
typedef std::map<ustring, Case::Background> BackgroundMap;
typedef std::map<ustring, Case::Evidence> EvidenceMap;
typedef std::map<ustring, Case::Image> ImageMap;
typedef std::map<ustring, Case::Location> LocationMap;
typedef std::map<ustring, Case::Testimony> TestimonyMap;
typedef std::map<ustring, ustring> BufferMap;

typedef std::vector<ustring> StringVector;

namespace Case {

class Case {
        public:
                Case();
                
                ~Case();
                
                void setOverview(const Overview &overview);
                
                Overview getOverview() const { return m_Overview; }
                
                void setOverrides(const Overrides &ov) { m_Overrides=ov; }
                
                Overrides getOverrides() const { return m_Overrides; }
                
                void setInitialBlockId(const ustring &id) { m_InitialBlockId=id; }
                
                ustring getInitialBlockId() const { return m_InitialBlockId; }
                
                void addCharacter(const Character &character);
                
                void addBackground(const Background &bg);
                
                void addEvidence(const Evidence &evidence);
                
                void addImage(const Image &image);
                
                void addLocation(const Location &loc);
                
                void addTestimony(const Testimony &testimony);
                
                void addBuffer(const ustring &id, const ustring &contents);
                
                Character* getCharacter(const ustring &id);
                
                Background* getBackground(const ustring &id);
                
                Evidence* getEvidence(const ustring &id);
                
                Image* getImage(const ustring &id);
                
                Location* getLocation(const ustring &id);
                
                Testimony* getTestimony(const ustring &id);
                
                std::vector<Evidence*> getEvidenceFromIds(const StringVector &vec);
                
                std::vector<Character*> getCharactersFromIds(const StringVector &vec);
                
                void clear();
                
                CharacterMap getCharacters() const { return m_Characters; }
                
                BackgroundMap getBackgrounds() const { return m_Backgrounds; }
                
                EvidenceMap getEvidence() const { return m_Evidence; }
                
                ImageMap getImages() const { return m_Images; }
                
                LocationMap getLocations() const { return m_Locations; }
                
                TestimonyMap getTestimonies() const { return m_Testimonies; }
                
                BufferMap getBuffers() const { return m_Buffers; }
        
        private:
                Overrides m_Overrides;
                
                Overview m_Overview;
                
                ustring m_InitialBlockId;
                
                CharacterMap m_Characters;
                
                BackgroundMap m_Backgrounds;
                
                EvidenceMap m_Evidence;
                
                ImageMap m_Images;
                
                LocationMap m_Locations;
                
                TestimonyMap m_Testimonies;
                
                BufferMap m_Buffers;
};

}; // namespace Case

#endif

---