Gamestate.h

Go to the documentation of this file.

/* This file is part of the Zenipex Library (zenilib).
 * Copyright (C) 2011 Mitchell Keith Bloch (bazald).
 *
 * zenilib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * zenilib 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with zenilib.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ZENI_GAMESTATE_H
#define ZENI_GAMESTATE_H

#include <Zeni/Core.h>

#include <SDL/SDL.h>

#if SDL_VERSION_ATLEAST(2,0,0)
#include <SDL/SDL_keycode.h>
#elif !defined(ANDROID)
#include <SDL/SDL_keysym.h>
typedef SDLKey SDL_Keycode;
typedef SDL_keysym SDL_Keysym;
#endif

#include <map>

struct android_app;
struct AInputEvent;

namespace Zeni {

  class ZENI_REST_DLL Gamestate;

  // Derive from this class
  class ZENI_REST_DLL Gamestate_Base {
    friend class Gamestate;

    Gamestate_Base(const Gamestate_Base &rhs);
    Gamestate_Base & operator=(const Gamestate_Base &rhs);

  public:
    Gamestate_Base() : m_count(0), m_pausable(false) {}
    virtual ~Gamestate_Base() {}

    // The control loop

#ifdef ANDROID
    virtual void on_event(android_app &app, const AInputEvent &event);
#else
    virtual void on_event(const SDL_Event &event);
#endif
    virtual void perform_logic() {}
    virtual void prerender() {}
    virtual void render();

    virtual void on_push();
    virtual void on_cover();
    virtual void on_uncover();
    virtual void on_pop();

    inline const bool & is_pausable() const;
    inline void set_pausable(const bool &pausable_);

    // Converters

#ifndef ANDROID
    static char to_char(const SDL_Keysym &ks); 
    static SDL_Keycode to_sym(const String &text_version); 
    static String to_text(const SDL_Keycode &sym); 
#endif

  protected:
    // Event handlers

#ifndef ANDROID
    // Keyboard events
    virtual void on_key(const SDL_KeyboardEvent &event); 
    // Mouse events
    virtual void on_mouse_motion(const SDL_MouseMotionEvent &event); 
    virtual void on_mouse_button(const SDL_MouseButtonEvent &event); 
#if SDL_VERSION_ATLEAST(1,3,0)
    virtual void on_mouse_wheel(const SDL_MouseWheelEvent &event); 
#endif
    // Controller events
    virtual void on_controller_axis(const SDL_ControllerAxisEvent &event); 
    virtual void on_controller_button(const SDL_ControllerButtonEvent &event); 
    virtual void on_controller_device(const SDL_ControllerDeviceEvent &event); 
    // Quit events
    virtual void on_quit(const SDL_QuitEvent &event); 
    // Annoying events
#if SDL_VERSION_ATLEAST(1,3,0)
    virtual void on_window_event(const SDL_WindowEvent &event); 
#endif
    virtual void on_system_wm_event(const SDL_SysWMEvent &event); 
#if !SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_active(const SDL_ActiveEvent &event); 
    virtual void on_video_resize(const SDL_ResizeEvent &event); 
#endif
#if !SDL_VERSION_ATLEAST(1,3,0)
    virtual void on_video_expose(const SDL_ExposeEvent &event); 
#endif
    // Custom events
    virtual void on_user_event(const SDL_UserEvent &event); 
#endif

  private:
    inline void increment();
    inline void decrement();
    int m_count;

    bool m_pausable;
  };

  class ZENI_REST_DLL Gamestate {
  public:
    inline Gamestate();
    inline Gamestate(Gamestate_Base * const &state);
    ~Gamestate();

    inline Gamestate(const Gamestate &state);
    inline Gamestate & operator=(const Gamestate &state);

#ifdef ANDROID
    inline void on_event(android_app &app, const AInputEvent &event);
#else
    inline void on_event(const SDL_Event &event);
#endif
    inline void perform_logic();
    inline void prerender();
    inline void render();

    inline void on_push();
    inline void on_cover();
    inline void on_uncover();
    inline void on_pop();

    inline const bool & is_pausable() const;

    inline Gamestate_Base & get();

  private:
    Gamestate_Base *m_state;
  };

}

#endif