onceupon.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 *
 * This file is dual-licensed.
 * In addition to the GPLv3 license mentioned above, this code is also
 * licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
 * full text of the license.
 *
 */

#ifndef GOB_PREGOB_ONCEUPON_ONCEUPON_H
#define GOB_PREGOB_ONCEUPON_ONCEUPON_H

#include "common/system.h"
#include "common/str.h"

#include "gob/pregob/pregob.h"

#include "gob/pregob/onceupon/stork.h"

namespace Gob {

class Surface;
class Font;

class ANIObject;

namespace OnceUpon {

class OnceUpon : public PreGob {
public:
    static const uint kLanguageCount = 5;


    OnceUpon(GobEngine *vm);
    ~OnceUpon() override;


protected:
    struct MenuButton {
        bool needDraw; 

        int16 left;   
        int16 top;    
        int16 right;  
        int16 bottom; 

        int16 srcLeft;   
        int16 srcTop;    
        int16 srcRight;  
        int16 srcBottom; 

        int16 dstX; 
        int16 dstY; 

        uint id; 
    };

    struct StorkParam {
        const char *backdrop; 

        uint  houseCount;         
        const MenuButton *houses; 

        const Stork::BundleDrop *drops; 
    };

    void init();
    void deinit();

    bool doCopyProtection(const uint8 colors[7], const uint8 shapes[7 * 20], const uint8 obfuscate[4]);

    void showIntro();

    void doStartMenu(const MenuButton *animalsButton, uint animalCount,
                     const MenuButton *animalButtons, const char * const *animalNames);

    void playGame();


    virtual const StorkParam &getStorkParameters() const = 0;


private:
    enum MenuAction {
        kMenuActionNone = 0, 
        kMenuActionAnimals , 
        kMenuActionPlay    , 
        kMenuActionRestart , 
        kMenuActionMainMenu, 
        kMenuActionQuit      
    };

    enum Difficulty {
        kDifficultyBeginner     = 0,
        kDifficultyIntermediate = 1,
        kDifficultyAdvanced     = 2,
        kDifficultyCount
    };

    enum Sound {
        kSoundClick = 0,
        kSoundStork    ,
        kSoundJump     ,
        kSoundCount
    };

    enum CharGenAction {
        kCharGenDone    = 0, 
        kCharGenAbort      , 
        kCharGenRestart      
    };

    struct ScreenBackup {
        Surface *screen; 
        int palette;     

        bool changedCursor; 
        bool cursorVisible; 

        ScreenBackup();
        ~ScreenBackup();
    };


    static const int kSectionCount = 15;

    static const MenuButton kMainMenuDifficultyButton[]; 
    static const MenuButton kSectionButtons[];           

    static const MenuButton kIngameButtons[];            

    static const MenuButton kAnimalNamesBack;   
    static const MenuButton kLanguageButtons[]; 

    static const MenuButton kSectionStorkHouses[];

    static const MenuButton kCharGenHeadButtons[];
    static const MenuButton kCharGenHeads[];
    static const MenuButton kCharGenHairButtons[];
    static const MenuButton kCharGenJacketButtons[];
    static const MenuButton kCharGenTrousersButtons[];
    static const MenuButton kCharGenNameEntry[];

    static const char *kSound[kSoundCount];


    static const AnimProperties kClownAnimations[];
    static const AnimProperties kTitleAnimation;
    static const AnimProperties kSectionStorkAnimations[];
    static const AnimProperties kSectionEndAnimations[];


    typedef bool (OnceUpon::*SectionFunc)();
    static const SectionFunc kSectionFuncs[kSectionCount];


    bool _openedArchives;

    // Fonts
    Font *_jeudak;
    Font *_lettre;
    Font *_plettre;
    Font *_glettre;

    int _palette;

    bool _quit; 

    Difficulty _difficulty; 
    int        _section;    

    Common::String _name; 

    uint8 _house;

    uint8 _head;
    uint8 _colorHair;
    uint8 _colorJacket;
    uint8 _colorTrousers;


    // -- General helpers --

    void setGamePalette(uint palette); 
    void setGameCursor();              

    void drawLineByLine(const Surface &src, int16 left, int16 top, int16 right, int16 bottom,
                        int16 x, int16 y) const;

    void backupScreen(ScreenBackup &backup, bool setDefaultCursor = false);
    void restoreScreen(ScreenBackup &backup);

    Common::String fixString(const Common::String &str) const; 
    void fixTXTStrings(TXTFile &txt) const override;                    


    // -- Copy protection helpers --

    int8 cpSetup(const uint8 colors[7], const uint8 shapes[7 * 20],
                 const uint8 obfuscate[4], const Surface sprites[2]);
    int8 cpFindShape(int16 x, int16 y) const;
    void cpWrong();


    // -- Show different game screens --

    void showWait(uint palette = 0xFFFF); 
    void showQuote();                     
    void showTitle();                     
    void showChapter(int chapter);        
    void showByeBye();                    

    void handleAnimalNames(uint count, const MenuButton *buttons, const char * const *names);


    // -- Menu helpers --

    MenuAction handleStartMenu(const MenuButton *animalsButton); 
    MenuAction handleMainMenu();                                 
    MenuAction handleIngameMenu();                               

    void drawStartMenu(const MenuButton *animalsButton); 
    void drawMainMenu();                                 
    void drawIngameMenu();                               

    void drawMenuDifficulty();

    void clearIngameMenu(const Surface &background);

    MenuAction doIngameMenu();
    MenuAction doIngameMenu(int16 &key, MouseButtons &mouseButtons);


    // -- Menu button helpers --

    int checkButton(const MenuButton *buttons, uint count, int16 x, int16 y, int failValue = -1) const;

    void drawButton (Surface &dest, const Surface &src, const MenuButton &button, int transp = -1) const;
    void drawButtons(Surface &dest, const Surface &src, const MenuButton *buttons, uint count, int transp = -1) const;

    void drawButtonBorder(const MenuButton &button, uint8 color);


    // -- Animal names helpers --

    void anSetupChooser();
    void anSetupNames(const MenuButton &animal);
    void anPlayAnimalName(const Common::String &animal, uint language);


    // -- Game sections --

    bool playSection();

    bool sectionStork();
    bool sectionChapter1();
    bool sectionParents();
    bool sectionChapter2();
    bool sectionForest0();
    bool sectionChapter3();
    bool sectionEvilCastle();
    bool sectionChapter4();
    bool sectionForest1();
    bool sectionChapter5();
    bool sectionBossFight();
    bool sectionChapter6();
    bool sectionForest2();
    bool sectionChapter7();
    bool sectionEnd();

    CharGenAction characterGenerator();
    void charGenSetup(uint stage);
    void charGenDrawName();

    static bool enterString(Common::String &name, int16 key, uint maxLength, const Font &font);
};

} // End of namespace OnceUpon

} // End of namespace Gob

#endif // GOB_PREGOB_ONCEUPON_ONCEUPON_H