Started to merge @ZobyTwo cmake branch

projects/mtg/CMakeLists.txt

@@ -0,0 +1,226 @@
+#MTGs common sources
+set(MTG_generic_src         
+        src/AbilityParser.cpp
+        src/ActionElement.cpp
+        src/ActionLayer.cpp
+        src/ActionStack.cpp
+        src/AIHints.cpp
+        src/AIMomirPlayer.cpp
+        src/AIPlayer.cpp
+        src/AIPlayerBaka.cpp
+        src/AIStats.cpp
+        src/AllAbilities.cpp
+        src/CardDescriptor.cpp
+        src/CardDisplay.cpp
+        src/CardGui.cpp
+        src/CardPrimitive.cpp
+        src/CardSelector.cpp
+        src/CardSelectorSingleton.cpp
+        src/CarouselDeckView.cpp
+        src/Closest.cpp
+        src/Counters.cpp
+        src/Credits.cpp
+        src/Damage.cpp
+        src/DamagerDamaged.cpp
+        src/DeckDataWrapper.cpp
+        src/DeckEditorMenu.cpp
+        src/DeckManager.cpp
+        src/DeckMenu.cpp
+        src/DeckMenuItem.cpp
+        src/DeckMetaData.cpp
+        src/DeckStats.cpp
+        src/DeckView.cpp
+        src/DuelLayers.cpp
+        src/ExtraCost.cpp
+        src/GameApp.cpp
+        src/GameLauncher.cpp
+        src/GameObserver.cpp
+        src/GameOptions.cpp
+        src/GameStateAwards.cpp
+        src/GameState.cpp
+        src/GameStateDeckViewer.cpp
+        src/GameStateDuel.cpp
+        src/GameStateMenu.cpp
+        src/GameStateOptions.cpp
+        src/GameStateShop.cpp
+        src/GameStateStory.cpp
+        src/GameStateTransitions.cpp
+        src/GridDeckView.cpp
+        src/GuiAvatars.cpp
+        src/GuiBackground.cpp
+        src/GuiCardsController.cpp
+        src/GuiCombat.cpp
+        src/GuiFrame.cpp
+        src/GuiHand.cpp
+        src/GuiLayers.cpp
+        src/GuiMana.cpp
+        src/GuiPhaseBar.cpp
+        src/GuiPlay.cpp
+        src/GuiStatic.cpp
+        src/IconButton.cpp
+        src/InteractiveButton.cpp
+        src/ManaCost.cpp
+        src/ManaCostHybrid.cpp
+        src/MenuItem.cpp
+        src/ModRules.cpp
+        src/MTGAbility.cpp
+        src/MTGCard.cpp
+        src/MTGCardInstance.cpp
+        src/MTGDeck.cpp
+        src/MTGDefinitions.cpp
+        src/MTGGamePhase.cpp
+        src/MTGGameZones.cpp
+        src/MTGPack.cpp
+        src/MTGRules.cpp
+        src/ObjectAnalytics.cpp
+        src/OptionItem.cpp
+        src/PhaseRing.cpp
+        src/Player.cpp
+        src/PlayerData.cpp
+        src/PlayGuiObject.cpp
+        src/PlayGuiObjectController.cpp
+        src/PlayRestrictions.cpp
+        src/Pos.cpp
+        src/PriceList.cpp
+        src/ReplacementEffects.cpp
+        src/Rules.cpp
+        src/SimpleMenu.cpp
+        src/SimpleMenuItem.cpp
+        src/SimpleButton.cpp
+        src/SimplePad.cpp
+        src/SimplePopup.cpp
+        src/StoryFlow.cpp
+        src/Subtypes.cpp
+        src/StyleManager.cpp
+        src/TargetChooser.cpp
+        src/TargetsList.cpp
+        src/Tasks.cpp
+        src/TextScroller.cpp
+        src/ThisDescriptor.cpp
+        src/Token.cpp
+        src/Translate.cpp
+        src/TranslateKeys.cpp
+        src/Trash.cpp
+        src/utils.cpp
+        src/WCachedResource.cpp
+        src/WDataSrc.cpp
+        src/WEvent.cpp
+        src/WFilter.cpp
+        src/WFont.cpp
+        src/WGui.cpp
+        src/WResourceManager.cpp
+        src/NetworkPlayer.cpp
+        )
+
+#the sources we need if we compile a graphical qt version
+#TODO: add declarative version since this only works with QWidget right now
+set(MTG_qt_graphic_src
+        src/qt/filedownloader.cpp
+        src/qt/corewrapper.cpp
+        include/qt/corewrapper.h #so automoc finds it
+        include/qt/filedownloader.h
+        src/Qtmain.cpp)
+
+#the sources we need to compile the testsuit
+set(MTG_qt_console_src
+        src/Qtconsole.cpp
+        src/TestSuiteAI.cpp)
+        
+set(MTG_sdl_src
+        src/SDLmain.cpp)
+        
+set(MTG_android_sdl_src
+        src/SDLmain.cpp
+        src/SDL_android_main.cpp)
+
+
+set(MTG_INCLUDE_DIRS include include/qt)
+set(JGE_INCLUDE_DIRS ../../JGE/include ../../JGE/include/hge)
+set(JGE_LIBRARY jge)
+    
+#turn moc on
+if(backend_qt_console OR backend_qt_widget)
+    set(CMAKE_INCLUDE_CURRENT_DIR ON)
+    set(CMAKE_AUTOMOC TRUE)
+endif()
+
+if(backend_qt_console)
+    if(UNIX AND NOT ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${ZIPFS_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS}
+            ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default)
+        add_executable(wagic ${MTG_generic_src} ${MTG_qt_console_src})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS} ${TINYXML_LIBRARIES}
+            ${HGE_LIBRARY})
+    else()
+        message(FATAL_ERROR "qt-console bilds are only supported on unix platforms")
+    endif()
+endif()
+
+if(backend_qt_widget)
+    if(UNIX AND NOT ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${ZIPFS_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS}
+            ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default)
+        add_executable(wagic ${MTG_generic_src} ${MTG_qt_graphic_src})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES}
+            ${HGE_LIBRARY})# ${X11_LIBRARIES})
+    else()
+        message(FATAL_ERROR "qt-widget bilds are only supported on unix platforms")
+    endif()
+endif()
+
+if(backend_sdl)
+    if(UNIX AND NOT ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${BOOST_INCLUDE_DIRS} ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR})
+        add_executable(wagic ${MTG_generic_src} ${MTG_sdl_src})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${SDL2_LIBRARY} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES} 
+            ${Boost_LIBRARIES} ${HGE_LIBRARY})
+    elseif(ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${BOOST_INCLUDE_DIRS} ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR})
+        #we should try to get rid of this hack
+        add_library(wagic SHARED ${MTG_generic_src} ${MTG_android_sdl_src}
+                    ${ANDROID_BOOST_PTHREAD_SRC_DIR}/thread.cpp
+                    ${ANDROID_BOOST_PTHREAD_SRC_DIR}/once.cpp
+                    ${ANDROID_BOOST_SYSTEM_SRC_DIR}/error_code.cpp
+                    src/TestSuiteAI.cpp)
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${SDL2_LIBRARY} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES} 
+            ${HGE_LIBRARY})
+    elseif(WIN32)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${Boost_INCLUDE_DIR} ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR} 
+            ${ZLIB_INCLUDE_DIR})
+        add_executable(wagic ${MTG_generic_src} ${MTG_sdl_src} src/TestSuiteAI.cpp src/AIPlayerBakaB.cpp)
+        link_directories(${Boost_LIBRARY_DIR} ${SDL2_LIBRARY_DIR})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${SDL2_LIBRARY} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES} 
+            ${BOOST_date_time} ${HGE_LIBRARY} ${CMAKE_SOURCE_DIR}/thirdparty/binary/win/lib/fmodvc.lib)
+    endif()
+endif()
+
+if(backend_psp)
+    if(PSP)
+        #${PSPSDK_PATH}/include
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${UNZIP_INCLUDE_DIR} ${BOOST_INCLUDE_DIRS} ${GIF_INCLUDE_DIR} ${HGETOOLS_INCLUDE_DIRS})
+        add_executable(wagic ${MTG_generic_src})
+        target_link_libraries(wagic ${JGE_LIBRARY} ${PSPSDK_LIB} ${HGETOOLS_LIBRARY} ${FREETYPE_LIB} ${JPEG_LIBRARY} 
+            ${GIF_LIBRARIES} ${PNG_LIBRARIES} z m ${MIKMOD_LIBRARY} ${TINYXML_LIBRARIES} 
+            stdc++ ${PSPSDK_REQUIRED_LIB})
+
+        set(PRXSPECS_FILE "${PSPSDK_PATH}/lib/prxspecs")
+        set(LINKFILE_FILE "${PSPSDK_PATH}/lib/linkfile.prx")
+
+        get_property(wagic_elf_location TARGET wagic PROPERTY LOCATION)
+        get_filename_component(wagic_elf_directory ${wagic_elf_location} PATH)
+
+        set_target_properties(wagic PROPERTIES LINK_FLAGS "-specs=${PRXSPECS_FILE} -Wl,-q,-T${LINKFILE_FILE}")
+        
+        add_custom_command(TARGET wagic POST_BUILD
+            COMMAND ${PSPSDK_MKSFO_COMMAND} ARGS "'Wagic, the Homebrew?!'" "${wagic_elf_directory}/PARAM.SFO"
+            COMMAND ${PSPSDK_FIXUP_IMPORTS_COMMAND} ARGS ${wagic_elf_location}
+            COMMAND ${PSPSDK_PRXGEN_COMMAND} ARGS ${wagic_elf_location} "${wagic_elf_directory}/wagic.prx"
+            COMMAND ${PSPSDK_PACK_PBP_COMMAND} ARGS ${wagic_elf_directory}/EBOOT.PBP ${wagic_elf_directory}/PARAM.SFO ${CMAKE_CURRENT_SOURCE_DIR}/icon.png NULL ${CMAKE_CURRENT_SOURCE_DIR}/pic0.png ${CMAKE_CURRENT_SOURCE_DIR}/pic1.png NULL "${wagic_elf_directory}/wagic.prx" NULL)
+    else()
+        message(FATAL_ERROR "use the cross-compile toolchain to build as the psp target")
+    endif()
+endif()

projects/mtg/include/StoryFlow.h

@@ -5,7 +5,7 @@
 #include <map>
 #include <vector>
 using namespace std;
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 #include <JGui.h>
 class GameObserver;
 class MTGDeck;

projects/mtg/include/qt/corewrapper.h

@@ -0,0 +1,189 @@
+#ifndef COREWRAPPER_H
+#define COREWRAPPER_H
+
+#include <QObject>
+#include <QElapsedTimer>
+#ifndef QT_WIDGET
+#include <QtDeclarative>
+#include <QGraphicsItem>
+#endif //QT_WIDGET
+#include "../include/JGE.h"
+#include "../include/JTypes.h"
+#include "../include/JApp.h"
+#include "../include/JFileSystem.h"
+#include "../include/JRenderer.h"
+#include "../include/JGameLauncher.h"
+
+#if (defined Q_WS_MAEMO_5)
+// For screen on/off events support
+#include <mce/dbus-names.h>
+#include <mce/mode-names.h>
+#include <QDBusConnection>
+#include <QDBusMessage>
+#include <QDBusInterface>
+#endif //Q_WS_MAEMO_5
+
+class WagicWrapper
+{
+public:
+    WagicWrapper();
+    virtual ~WagicWrapper();
+
+private:
+    JGE* m_engine;
+    JApp* m_app;
+    JGameLauncher* m_launcher;
+};
+
+
+#ifdef QT_WIDGET
+class WagicCore : public QGLWidget
+#else
+class WagicCore : public QDeclarativeItem
+#endif
+{
+private:
+#ifdef QT_WIDGET
+    typedef QGLWidget super;
+#else
+  typedef QDeclarativeItem super;
+#endif //QT_WIDGET
+    void initApp();
+
+public:
+    Q_OBJECT
+    Q_PROPERTY(int nominalWidth READ getNominalWidth CONSTANT)
+    Q_PROPERTY(int nominalHeight READ getNominalHeight CONSTANT)
+    Q_PROPERTY(float nominalRatio READ getNominalRatio CONSTANT)
+    Q_PROPERTY(bool active READ getActive WRITE setActive NOTIFY activeChanged)
+
+
+public:
+    explicit WagicCore(super *parent = 0);
+    virtual ~WagicCore();
+    static int runTestSuite();
+
+    Q_INVOKABLE void doOK() {
+        doAndEnqueue(JGE_BTN_OK);
+    };
+    Q_INVOKABLE void doNext() {
+        doAndEnqueue(JGE_BTN_PREV);
+    };
+    Q_INVOKABLE void doCancel() {
+        doAndEnqueue(JGE_BTN_SEC);
+    };
+    Q_INVOKABLE void doMenu() {
+        doAndEnqueue(JGE_BTN_MENU);
+    };
+    Q_INVOKABLE void done() {
+        while(m_buttonQueue.size())
+        {
+            m_engine->ReleaseKey(m_buttonQueue.front());
+            m_buttonQueue.pop();
+        }
+        m_engine->ResetInput();
+    };
+    Q_INVOKABLE void pixelInput(int x, int y);
+    Q_INVOKABLE qint64 getTick() {
+        return g_startTimer.elapsed();
+    };
+    Q_INVOKABLE void doScroll(int x, int y, int) {
+        m_engine->Scroll(x, y);
+    };
+    int getNominalHeight(){ return SCREEN_HEIGHT;};
+    int getNominalWidth(){ return SCREEN_WIDTH;};
+    float getNominalRatio() { return ((float)SCREEN_WIDTH / (float)SCREEN_HEIGHT);};
+    bool getActive() { return m_active; };
+    void setActive(bool active);
+    void keyPressEvent(QKeyEvent *event);
+    void keyReleaseEvent(QKeyEvent *event);
+    void initializeGL();
+    void resizeGL(int width, int height);
+    void paintGL();
+    static char* getApplicationName() {
+        return JGameLauncher::GetName();
+    };
+
+#ifdef QT_WIDGET
+    void mousePressEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+    void tapAndHoldTriggered(QTapAndHoldGesture* gesture);
+    void showEvent(QShowEvent *event);
+    void hideEvent(QHideEvent *event);
+    bool gestureEvent(QGestureEvent* event);
+    bool event(QEvent *event);
+    void wheelEvent(QWheelEvent *event);
+#else
+    void wheelEvent ( QGraphicsSceneWheelEvent * event);
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+#endif
+
+#ifdef QT_WIDGET
+public slots:
+    void start(int);
+#endif
+
+#ifdef Q_WS_MAEMO_5
+public slots:
+    void displayStateChanged(const QDBusMessage &message);
+#endif //Q_WS_MAEMO_5
+
+
+signals:
+    void activeChanged();
+
+private slots:
+
+private:
+    int lastPosx(){
+#if QT_VERSION >= 0x050100
+        return m_lastPos.x()*devicePixelRatio();
+#else
+        return m_lastPos.x();
+#endif
+    }
+    int lastPosy(){
+#if QT_VERSION >= 0x050100
+        return m_lastPos.y()*devicePixelRatio();
+#else
+        return m_lastPos.y();
+#endif
+    }
+    void timerEvent( QTimerEvent* );
+    void doAndEnqueue(JButton action) {
+        m_engine->HoldKey_NoRepeat(action);
+        m_buttonQueue.push(action);
+    }
+
+public:
+    // used mainly to mesure the delta between 2 updates
+    static QElapsedTimer g_startTimer;
+private:
+    JGE* m_engine;
+    JApp* m_app;
+    JGameLauncher* m_launcher;
+    qint64 m_lastTickCount;
+    std::queue<JButton> m_buttonQueue;
+    int m_timerId;
+    bool m_active;
+    QRect m_viewPort;
+    QPoint m_lastPos;
+#ifdef QT_WIDGET
+#if (defined Q_WS_MAEMO_5) || (defined MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
+  int mMouseDownX;
+  int mMouseDownY;
+  qint64 mLastFingerDownTime;
+#endif //Q_WS_MAEMO_5
+#endif //QT_WIDGET
+
+#ifdef Q_WS_MAEMO_5
+    QDBusConnection dBusConnection;
+    QDBusInterface* dBusInterface;
+ #endif //Q_WS_MAEMO_5
+};
+#ifndef QT_WIDGET
+QML_DECLARE_TYPE(WagicCore)
+#endif //QT_WIDGET
+
+#endif // COREWRAPPER_H

projects/mtg/include/qt/filedownloader.h

@@ -0,0 +1,147 @@
+#ifndef FILEDOWNLOADER_H
+#define FILEDOWNLOADER_H
+
+#include <QObject>
+#include <QByteArray>
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QTemporaryFile>
+#ifdef QT_WIDGET
+#include <QProgressDialog>
+#include <QPushButton>
+#include <QCoreApplication>
+#else
+#include <qdeclarative.h>
+#endif //QT_WIDGET
+
+ 
+class FileDownloader :
+#ifdef QT_WIDGET
+        public QProgressDialog
+#else
+        public QObject
+#endif //QT_WIDGET
+{
+    Q_OBJECT
+
+    Q_PROPERTY(qint64 received READ received NOTIFY receivedChanged)
+    Q_PROPERTY(QString status READ getStatus NOTIFY statusChanged)
+    Q_PROPERTY(DownloadState state READ getState NOTIFY stateChanged )
+    Q_PROPERTY(QString state_string READ getStateString NOTIFY stateStringChanged )
+    Q_ENUMS(DownloadState)
+public:
+    enum DownloadState {
+        NETWORK_ERROR,
+        DOWNLOADING_HASH,
+        DOWNLOADING_FILE,
+        DOWNLOADED
+    } ;
+
+    explicit FileDownloader(QString localPath, QString targetFile, QObject *parent = 0);
+    virtual ~FileDownloader();
+    qint64 received() const {return m_received;};
+    QString getStatus() {return m_status;};
+    DownloadState getState() {
+        return m_state;
+    };
+    QString getStateString() {
+        if(m_state == DOWNLOADING_HASH )
+            return "DOWNLOADING_HASH";
+        else if(m_state == DOWNLOADING_FILE )
+            return "DOWNLOADING_FILE";
+        else
+            return "DOWNLOADED";
+    }
+
+signals:
+    void receivedChanged(int value);
+    void statusChanged();
+    void stateChanged(DownloadState state);
+    void stateStringChanged();
+
+private slots:
+    void fileDownloaded(){
+        // let's check some error
+        if(m_downloadReply->error() != QNetworkReply::NoError) {
+            m_state = NETWORK_ERROR;
+        } else {
+            if(m_tmp.write(m_downloadReply->readAll()) == -1) return;
+            if(QFile(m_localPath).exists())
+                QFile::remove(m_localPath);
+
+            m_tmp.close();
+            computeLocalHash(m_tmp);
+            if(m_localHash == m_remoteHash) {
+                if(!m_tmp.rename(m_localPath)) return;
+                m_tmp.setAutoRemove(false);
+                m_state = DOWNLOADED;
+            }
+            else {
+                m_state = NETWORK_ERROR;
+            }
+        }
+        emit stateChanged(m_state);
+    };
+    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal){
+        if(m_tmp.write(m_downloadReply->readAll()) == -1) return;
+        if(!bytesTotal) return;
+        m_received = bytesReceived*100/bytesTotal;
+        emit receivedChanged(m_received);
+    };
+    void setDownloadUrl(QUrl url);
+    void computeLocalHash(QFile& file);
+    void requestHash(QUrl url);
+    void computeRemoteHash();
+    void handleStateChange(DownloadState state){
+#ifdef QT_WIDGET
+        switch(state) {
+        case NETWORK_ERROR:
+            if(m_localHash == "") {
+                setLabelText("Network Error");
+                setCancelButton(new QPushButton("OK"));
+                show();
+            } else {
+                emit finished(0);
+            }
+            break;
+        case DOWNLOADED:
+            emit finished(0);
+            break;
+        case DOWNLOADING_HASH:
+            break;
+        case DOWNLOADING_FILE:
+            show();
+            break;
+        }
+
+#else
+        emit stateStringChanged();
+#endif //QT_WIDGET
+    };
+#ifdef QT_WIDGET
+    void handleCancel(){
+        QCoreApplication::instance()->exit(1);
+    }
+#endif //QT_WIDGET
+
+
+private:
+    DownloadState m_state;
+    QNetworkAccessManager m_WebCtrl;
+    qint64 m_received;
+    QTemporaryFile m_tmp;
+    QString m_targetFile;
+    QString m_localPath;
+    QString m_localHash;
+    QString m_remoteHash;
+    bool m_OK;
+    QString m_status;
+    QNetworkReply* m_downloadReply;
+    QNetworkReply* m_hashReply;
+};
+#ifndef QT_WIDGET
+QML_DECLARE_TYPEINFO(FileDownloader, QML_HAS_ATTACHED_PROPERTIES)
+#endif  //QT_WIDGET
+
+#endif // FILEDOWNLOADER_H

projects/mtg/src/MTGPack.cpp

@@ -9,7 +9,7 @@
 #include "WFilter.h"
 #include "DeckDataWrapper.h"
 #include "MTGPack.h"
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 MTGPack MTGPacks::defaultBooster;
 

projects/mtg/src/ModRules.cpp

@@ -3,7 +3,7 @@
 #include "ModRules.h"
 #include "utils.h"
 #include "GameState.h"
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 
 ModRules gModRules;

projects/mtg/src/Qtconsole.cpp

@@ -0,0 +1,105 @@
+#include "../include/JGE.h"
+#include "../include/JTypes.h"
+#include "../include/JApp.h"
+#include "../include/JFileSystem.h"
+#include "../include/JRenderer.h"
+#include "../include/JGameLauncher.h"
+
+#include "TestSuiteAI.h"
+#include "GameOptions.h"
+#include "MTGDeck.h"
+#include "DebugRoutines.h"
+#include <QCoreApplication>
+#include <QElapsedTimer>
+
+class WagicWrapper
+{
+public:
+    WagicWrapper();
+    virtual ~WagicWrapper();
+
+public:
+    // used mainly to mesure the delta between 2 updates
+    static QElapsedTimer g_startTimer;
+
+private:
+    JGE* m_engine;
+    JApp* m_app;
+    JGameLauncher* m_launcher;
+};
+
+QElapsedTimer WagicWrapper::g_startTimer;
+
+int JGEGetTime()
+{
+    return (int)WagicWrapper::g_startTimer.elapsed();
+}
+
+bool JGEToggleFullscreen()
+{
+    return true;
+}
+
+void JGECreateDefaultBindings()
+{
+}
+
+WagicWrapper::WagicWrapper()
+{
+    m_launcher = new JGameLauncher();
+    u32 flags = m_launcher->GetInitFlags();
+    if ((flags&JINIT_FLAG_ENABLE3D)!=0)
+    {
+        JRenderer::Set3DFlag(true);
+    }
+
+    JGECreateDefaultBindings();
+
+    m_engine = JGE::GetInstance();
+    m_app = m_launcher->GetGameApp();
+    m_app->Create();
+    m_engine->SetApp(m_app);
+    JRenderer::GetInstance()->Enable2D();
+    g_startTimer.restart();
+}
+
+WagicWrapper::~WagicWrapper()
+{
+    if(m_launcher)
+    {
+        delete m_launcher;
+        m_launcher = NULL;
+    }
+
+    if(m_engine)
+        m_engine->SetApp(NULL);
+
+    if (m_app)
+    {
+      m_app->Destroy();
+      delete m_app;
+      m_app = NULL;
+    }
+
+    JGE::Destroy();
+    m_engine = NULL;
+}
+
+int main(int argc, char* argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    int result = 0;
+    WagicWrapper* wagicCore =  new WagicWrapper();
+    MTGCollection()->loadFolder("sets/primitives/");
+    MTGCollection()->loadFolder("sets/", "_cards.dat");
+    options.reloadProfile();
+    TestSuite testSuite("test/_tests.txt");
+    result = testSuite.run();
+    delete wagicCore;
+    DebugTrace("TestSuite done: failed test: " << result << " out of " << testSuite.nbTests + testSuite.nbAITests << " total");
+#ifdef CAPTURE_STDERR
+    OutputCapturer::debugAndClear();
+#endif
+    return result;
+}

projects/mtg/src/Qtmain.cpp

@@ -0,0 +1,109 @@
+#define GL_GLEXT_PROTOTYPES
+#include <QtOpenGL>
+#include <QTime>
+#include <QApplication>
+#include <QScopedPointer>
+#ifdef QT_WIDGET
+#include <QWidget>
+#else
+#include <QtDeclarative>
+#include "qmlapplicationviewer.h"
+#endif //QT_WIDGET
+#include "Downloader.h"
+#include "GameApp.h"
+#include "corewrapper.h"
+
+WagicCore* g_glwidget = NULL;
+
+static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] =
+{
+  { Qt::Key_Enter,        JGE_BTN_MENU },
+  { Qt::Key_Return,       JGE_BTN_MENU },
+  { Qt::Key_Escape,       JGE_BTN_MENU },
+  { Qt::Key_Backspace,    JGE_BTN_CTRL },
+  { Qt::Key_Up,           JGE_BTN_UP },
+  { Qt::Key_Down,         JGE_BTN_DOWN },
+  { Qt::Key_Left,         JGE_BTN_LEFT },
+  { Qt::Key_Right,        JGE_BTN_RIGHT },
+  { Qt::Key_Space,        JGE_BTN_OK },
+  { Qt::Key_Tab,          JGE_BTN_CANCEL },
+  { Qt::Key_J,            JGE_BTN_PRI },
+  { Qt::Key_K,            JGE_BTN_SEC },
+  { Qt::Key_Q,            JGE_BTN_PREV },
+  { Qt::Key_A,            JGE_BTN_NEXT },
+// fullscreen management seems somehow broken in JGE, it works fine with Qt directly
+//    { Qt::Key_F,            JGE_BTN_FULLSCREEN },
+};
+
+void JGECreateDefaultBindings()
+{
+  for (signed int i = sizeof(gDefaultBindings)/sizeof(gDefaultBindings[0]) - 1; i >= 0; --i)
+    JGE::BindKey(gDefaultBindings[i].keysym, gDefaultBindings[i].keycode);
+}
+
+bool JGEToggleFullscreen()
+{
+  if(g_glwidget->isFullScreen())
+  {
+    g_glwidget->showNormal();
+  }
+  else
+  {
+    g_glwidget->showFullScreen();
+  }
+  return true;
+}
+
+int JGEGetTime()
+{
+    return (int)WagicCore::g_startTimer.elapsed();
+}
+
+int main(int argc, char* argv[])
+{
+    QScopedPointer<QApplication> app
+#ifdef QT_WIDGET
+        (new QApplication(argc, argv));
+#else
+        (createApplication(argc, argv));
+
+#endif //QT_WIDGET
+
+    app->setApplicationName(WagicCore::getApplicationName());
+    DownloadRequest* downloadRequest = NULL;
+#ifdef WAGIC_RESOURCE_URL
+    Downloader*downloader = Downloader::GetInstance();
+    downloadRequest = downloader->Get(
+                "core.zip",
+                WAGIC_RESOURCE_URL
+                );
+#endif
+#ifdef QT_WIDGET
+    g_glwidget = new WagicCore();
+    if(!downloadRequest || downloadRequest->getDownloadStatus() == DownloadRequest::DOWNLOADED)
+    {
+        g_glwidget->start(0);
+    }
+    else
+    {
+        g_glwidget->connect(downloadRequest, SIGNAL(statusChanged(int)), SLOT(start(int)));
+    }
+#else
+    qmlRegisterType<WagicCore>("CustomComponents", 1, 0, "WagicCore");
+
+    QScopedPointer<QmlApplicationViewer> viewer(QmlApplicationViewer::create());
+    g_glwidget = viewer.data();
+
+    viewer->rootContext()->setContextProperty("fileDownloader", &fileDownloader);
+    viewer->setMainQmlFile(QLatin1String("qml/QmlWagic/main.qml"));
+
+    viewer->setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
+    QGLWidget *glWidget = new QGLWidget;
+    viewer->setViewport(glWidget);
+
+    viewer->showExpanded();
+    viewer->setResizeMode(QDeclarativeView::SizeRootObjectToView);
+#endif //QT_WIDGET
+
+    return app->exec();
+}

projects/mtg/src/SDLmain.cpp

@@ -0,0 +1,771 @@
+#include <SDL.h>
+#if (defined ANDROID)
+#include <SDL_opengles.h>
+#else
+#include <SDL_opengl.h>
+#ifdef WIN32
+#undef GL_VERSION_2_0
+#endif
+#endif
+
+#include "../include/JGE.h"
+#include "../include/JTypes.h"
+#include "../include/JApp.h"
+#include "../include/JFileSystem.h"
+#include "../include/JRenderer.h"
+#include "../include/JGameLauncher.h"
+#include "DebugRoutines.h"
+#include <stdexcept>
+#include <iostream>
+#include <math.h>
+
+#if (defined FORCE_GLES)
+#undef GL_ES_VERSION_2_0
+#undef GL_VERSION_2_0
+#define GL_VERSION_ES_CM_1_1 1
+#define glOrthof glOrtho
+#define glClearDepthf glClearDepth
+#endif
+
+#define ACTUAL_SCREEN_WIDTH (SCREEN_WIDTH)
+#define ACTUAL_SCREEN_HEIGHT (SCREEN_HEIGHT)
+#define ACTUAL_RATIO ((GLfloat)ACTUAL_SCREEN_WIDTH / (GLfloat)ACTUAL_SCREEN_HEIGHT)
+
+enum eDisplayMode
+{
+	DisplayMode_lowRes = 0,
+	DisplayMode_hiRes,
+	DisplayMode_fullscreen
+};
+
+unsigned int gDisplayMode = DisplayMode_lowRes;
+
+const int kHitzonePliancy = 50;
+
+// tick value equates to ms
+const int kTapEventTimeout = 250;
+
+
+uint64_t	lastTickCount;
+JGE* g_engine = NULL;
+JApp* g_app = NULL;
+JGameLauncher* g_launcher = NULL;
+#ifdef ANDROID
+JNIEnv * mJNIEnv = NULL;
+jclass * mJNIClass = NULL;
+#endif
+
+class SdlApp;
+
+SdlApp *g_SdlApp = NULL;
+
+
+#ifdef ANDROID
+// Pause
+extern "C" void Java_org_libsdl_app_SDLActivity_nativePause(
+                                    JNIEnv* env, jclass cls)
+{    
+	DebugTrace("Attempt pause");
+	if (!g_engine)
+		return;
+   g_engine->Pause();
+   DebugTrace("Pause done");
+}
+
+// Resume
+extern "C" void Java_org_libsdl_app_SDLActivity_nativeResume(
+                                    JNIEnv* env, jclass cls)
+{    
+	if (!g_engine)
+		return;
+    g_engine->Resume();
+}
+
+#include "Wagic_Version.h"
+extern "C" jstring Java_org_libsdl_app_SDLActivity_getResourceName(
+                                       JNIEnv* env, jclass cls)
+{
+    return env->NewStringUTF (WAGIC_RESOURCE_NAME);
+}
+
+extern "C" jstring Java_org_libsdl_app_SDLActivity_getResourceUrl(
+                                       JNIEnv* env, jclass cls)
+{
+    return env->NewStringUTF (WAGIC_RESOURCE_URL);
+}
+#endif
+
+
+class SdlApp
+{
+public: /* For easy interfacing with JGE static functions */
+    bool            Running;
+    SDL_Window*     window;
+    SDL_Surface*    Surf_Display;
+    SDL_Rect        viewPort;
+    Uint32          lastMouseUpTime;
+    Uint32          lastFingerDownTime;
+    int             windowed_w;
+    int             windowed_h;
+    int             windowed_pos_x;
+    int             windowed_pos_y;
+
+    int mMouseDownX;
+    int mMouseDownY;
+
+public:
+    SdlApp() : Surf_Display(NULL), window(NULL), lastMouseUpTime(0), lastFingerDownTime(0), Running(true), mMouseDownX(0), mMouseDownY(0)
+    {
+    }
+
+    int OnExecute()
+    {
+        if (OnInit() == false)
+        {
+            return -1;
+        }
+
+        SDL_Event Event;
+
+        while(Running)
+        {
+            if (g_engine)
+            {
+                for (int x = 0; x < 5 && SDL_WaitEventTimeout(&Event, 10); ++x)
+                {
+                    if(!g_engine->IsPaused())
+                        OnEvent(&Event);
+                }
+                if(!g_engine->IsPaused())
+                    OnUpdate();
+            }
+        }
+
+        OnCleanup();
+
+        return 0;
+    };
+
+public:
+    bool OnInit();
+
+    void OnResize(int width, int height)
+    {
+        DebugTrace("OnResize Width " << width << " height " << height);
+
+        if ((GLfloat)width / (GLfloat)height <= ACTUAL_RATIO)
+        {
+                viewPort.x = 0;
+                viewPort.y = -(static_cast<int>(width / ACTUAL_RATIO) - height) / 2;
+                viewPort.w = width;
+                viewPort.h = static_cast<int>(width / ACTUAL_RATIO);
+        }
+        else
+        {
+                viewPort.x = -(static_cast<int>(height * ACTUAL_RATIO) - width) / 2;
+                viewPort.y = 0;
+                viewPort.w = static_cast<int>(height * ACTUAL_RATIO);
+                viewPort.h = height;
+        }
+
+        glViewport(viewPort.x, viewPort.y, viewPort.w, viewPort.h);
+
+        JRenderer::GetInstance()->SetActualWidth(static_cast<float>(viewPort.w));
+        JRenderer::GetInstance()->SetActualHeight(static_cast<float>(viewPort.h));
+        glScissor(0, 0, width, height);
+
+#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0)
+
+        glMatrixMode (GL_PROJECTION);										// Select The Projection Matrix
+        glLoadIdentity ();													// Reset The Projection Matrix
+
+#if (defined GL_VERSION_ES_CM_1_1)
+        glOrthof(0.0f, (float) (viewPort.w)-1.0f, 0.0f, (float) (viewPort.h)-1.0f, -1.0f, 1.0f);
+#else
+        gluOrtho2D(0.0f, (float) (viewPort.w)-1.0f, 0.0f, (float) (viewPort.h)-1.0f);
+#endif
+        glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix
+        glLoadIdentity ();													// Reset The Modelview Matrix
+
+        glDisable (GL_DEPTH_TEST);
+#endif
+    }
+
+    void OnKeyPressed(const SDL_KeyboardEvent& event);
+    void OnMouseDoubleClicked(const SDL_MouseButtonEvent& event);
+    void OnMouseClicked(const SDL_MouseButtonEvent& event);
+    void OnMouseMoved(const SDL_MouseMotionEvent& event);
+    void OnMouseWheel(int x, int y);
+
+    void OnTouchEvent(const SDL_TouchFingerEvent& event);
+
+    void OnEvent(SDL_Event* Event)
+    {
+        /* if(Event->type < SDL_USEREVENT)
+        DebugTrace("Event received" << Event->type);*/
+        switch(Event->type)
+        {
+        case SDL_QUIT:
+            Running = false;
+            break;
+
+        /* On Android, this is triggered when the device orientation changed */
+        case SDL_WINDOWEVENT:
+            window = SDL_GetWindowFromID(Event->window.windowID);
+            int h,w;
+            SDL_GetWindowSize(window, &w, &h);
+            OnResize(w, h);
+            break;
+
+        case SDL_KEYDOWN:
+        case SDL_KEYUP:
+            OnKeyPressed(Event->key);
+            break;
+
+        case SDL_MOUSEMOTION:
+            OnMouseMoved(Event->motion);
+            break;
+
+        case SDL_MOUSEBUTTONDOWN:
+            OnMouseClicked(Event->button);
+            break;
+
+        case SDL_MOUSEBUTTONUP:
+            {
+                Uint32 eventTime = SDL_GetTicks();
+                if (eventTime - lastMouseUpTime <= 500)
+                {
+                    OnMouseDoubleClicked(Event->button);
+                }
+                else
+                {
+                    OnMouseClicked(Event->button);
+                }
+                lastMouseUpTime = eventTime;
+            }
+            break;
+
+        case SDL_MOUSEWHEEL:
+            OnMouseWheel(Event->wheel.x, Event->wheel.y);
+            break;
+
+        case SDL_FINGERMOTION:
+        case SDL_FINGERDOWN:
+        case SDL_FINGERUP:
+        	DebugTrace("Finger Up/Down/Motion detected:" );
+            OnTouchEvent(Event->tfinger);
+            break;
+
+        case SDL_MULTIGESTURE:
+            DebugTrace("Multigesture : touchId " << Event->mgesture.touchId
+                    << ", x " << Event->mgesture.x
+                    << ", y " << Event->mgesture.y
+                    << ", dTheta " << Event->mgesture.dTheta
+                    << ", dDist " << Event->mgesture.dDist
+                    << ", numFingers " << Event->mgesture.numFingers);
+            break;
+
+        case SDL_JOYBALLMOTION:
+            DebugTrace("Flick gesture detected, x: " << Event->jball.xrel << ", y: " << Event->jball.yrel);
+            g_engine->Scroll(Event->jball.xrel, Event->jball.yrel);
+            break;
+        }
+    }
+
+    void OnUpdate();
+
+    void OnCleanup()
+    {
+        SDL_FreeSurface(Surf_Display);
+        SDL_Quit();
+    }
+};
+
+static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] =
+{  
+	/* windows controls */
+	{ SDLK_LCTRL,         JGE_BTN_CTRL },
+	{ SDLK_RCTRL,         JGE_BTN_CTRL },
+	{ SDLK_RETURN,        JGE_BTN_MENU },
+	{ SDLK_KP_ENTER,      JGE_BTN_MENU },
+	{ SDLK_ESCAPE,        JGE_BTN_MENU },
+	{ SDLK_UP,            JGE_BTN_UP },
+	{ SDLK_DOWN,          JGE_BTN_DOWN },
+	{ SDLK_LEFT,          JGE_BTN_LEFT },
+	{ SDLK_RIGHT,         JGE_BTN_RIGHT },
+	{ SDLK_z,             JGE_BTN_UP },
+	{ SDLK_d,             JGE_BTN_RIGHT },
+	{ SDLK_s,             JGE_BTN_DOWN },
+	{ SDLK_q,             JGE_BTN_LEFT },
+	{ SDLK_a,             JGE_BTN_PREV },
+	{ SDLK_e,             JGE_BTN_NEXT },
+	{ SDLK_i,             JGE_BTN_CANCEL },
+	{ SDLK_l,             JGE_BTN_OK },
+	{ SDLK_SPACE,         JGE_BTN_OK },
+	{ SDLK_k,             JGE_BTN_SEC },
+	{ SDLK_j,             JGE_BTN_PRI },
+	{ SDLK_f,             JGE_BTN_FULLSCREEN },
+
+	/* old Qt ones, basically modified to comply with the N900 keyboard
+	{ SDLK_a,             JGE_BTN_NEXT },
+	{ SDLK_TAB,           JGE_BTN_CANCEL },
+	{ SDLK_q,             JGE_BTN_PREV },
+	{ SDLK_BACKSPACE,     JGE_BTN_CTRL },
+	*/
+
+	/* Android customs */
+	{ SDLK_AC_BACK,       JGE_BTN_MENU },
+	/* Android/maemo volume button mapping */
+	{ SDLK_VOLUMEUP,      JGE_BTN_PREV },
+	{ SDLK_VOLUMEDOWN,    JGE_BTN_SEC},
+};
+
+void JGECreateDefaultBindings()
+{
+	for (signed int i = sizeof(gDefaultBindings)/sizeof(gDefaultBindings[0]) - 1; i >= 0; --i)
+		g_engine->BindKey(gDefaultBindings[i].keysym, gDefaultBindings[i].keycode);
+}
+
+int JGEGetTime()
+{
+	return (int)SDL_GetTicks();
+}
+
+bool JGEToggleFullscreen()
+{
+	//cycle between the display modes
+	++gDisplayMode;
+	if (gDisplayMode > DisplayMode_fullscreen)
+		gDisplayMode = DisplayMode_lowRes;
+
+	SDL_DisplayMode mode;
+	SDL_GetCurrentDisplayMode(0, &mode);
+
+	int width = 0;
+	int height = 0;
+
+	switch (gDisplayMode)
+	{
+	case DisplayMode_fullscreen:
+		SDL_SetWindowSize(g_SdlApp->window, mode.w, mode.h);
+		return (SDL_SetWindowFullscreen(g_SdlApp->window, SDL_TRUE) == 0);
+
+		break;
+
+	case DisplayMode_hiRes:
+		width = SCREEN_WIDTH * 2;
+		height = SCREEN_HEIGHT * 2;
+		break;
+
+	case DisplayMode_lowRes:
+	default:
+		width = SCREEN_WIDTH;
+		height = SCREEN_HEIGHT;
+		break;
+	}
+
+	if (SDL_SetWindowFullscreen(g_SdlApp->window, SDL_FALSE) < 0)
+	{
+		return false;
+	}
+
+	int x = (mode.w - width) / 2;
+	int y = (mode.h - height) / 2;
+
+	SDL_SetWindowPosition(g_SdlApp->window, x, y);
+	SDL_SetWindowSize(g_SdlApp->window, width, height);
+
+	return true;
+}
+
+bool InitGame(void)
+{
+	g_engine = JGE::GetInstance();
+	g_app = g_launcher->GetGameApp();
+	g_app->Create();
+	g_engine->SetApp(g_app);
+#ifdef ANDROID
+    DebugTrace("Can I Set JNI Params ?");
+     if (mJNIEnv)
+        DebugTrace("mJNIEnv is ok");
+    if (mJNIEnv && mJNIClass)
+    {
+        DebugTrace("Setting JNI Params");
+        g_engine->SetJNIEnv(mJNIEnv, *mJNIClass);
+    }
+#endif	
+
+	JRenderer::GetInstance()->Enable2D();
+	lastTickCount = JGEGetTime();
+
+	return true;
+}
+
+void DestroyGame(void)
+{
+	g_engine->SetApp(NULL);
+	if (g_app)
+	{
+		g_app->Destroy();
+		delete g_app;
+		g_app = NULL;
+	}
+
+	JGE::Destroy();
+
+	g_engine = NULL;
+}
+
+void SdlApp::OnUpdate()
+{
+	static int tickCount = 0;
+	tickCount = JGEGetTime();
+	int64_t dt = (tickCount - lastTickCount);
+	lastTickCount = tickCount;
+
+	if(g_engine->IsDone())
+	{
+		SDL_Event event;
+		event.user.type = SDL_QUIT;
+		SDL_PushEvent(&event);
+	}
+
+	try
+	{
+		g_engine->SetDelta((float)dt / 1000.0f);
+		g_engine->Update((float)dt / 1000.0f);
+	}
+	catch(out_of_range& oor)
+	{
+		cerr << oor.what();
+	}
+
+	if(g_engine)
+		g_engine->Render();
+
+	SDL_GL_SwapBuffers();
+}
+
+void SdlApp::OnKeyPressed(const SDL_KeyboardEvent& event)
+{
+	if (event.type == SDL_KEYDOWN)
+	{
+		g_engine->HoldKey_NoRepeat((LocalKeySym)event.keysym.sym);
+	}
+	else if(event.type == SDL_KEYUP)
+	{
+		g_engine->ReleaseKey((LocalKeySym)event.keysym.sym);
+	}
+}
+
+void SdlApp::OnMouseMoved(const SDL_MouseMotionEvent& event)
+{
+	int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
+	int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
+
+	if (event.y >= viewPort.y &&
+		event.y <= viewPort.y + viewPort.h &&
+		event.x >= viewPort.x &&
+		event.x <= viewPort.x + viewPort.w)
+	{
+		g_engine->LeftClicked(
+			((event.x-viewPort.x)*SCREEN_WIDTH)/actualWidth,
+			((event.y-viewPort.y)*SCREEN_HEIGHT)/actualHeight);
+	}
+}
+
+void SdlApp::OnMouseDoubleClicked(const SDL_MouseButtonEvent& event)
+{
+#if (defined ANDROID) || (defined IOS)
+	if(event.button == SDL_BUTTON_LEFT) /* Left button */
+	{
+		g_engine->HoldKey_NoRepeat(JGE_BTN_OK);
+	}
+#endif
+}
+
+void SdlApp::OnMouseWheel(int x, int y)
+{
+  if(!x && y)
+  { // Vertical wheel
+    if(y > 0)
+    {
+      g_engine->HoldKey_NoRepeat(JGE_BTN_UP);
+    }
+    else
+    {
+      g_engine->HoldKey_NoRepeat(JGE_BTN_DOWN);
+    }
+  }
+  else if(x && !y)
+  { // Horizontal wheel
+    g_engine->HoldKey_NoRepeat(JGE_BTN_LEFT);
+  }
+  else
+  {
+    g_engine->HoldKey_NoRepeat(JGE_BTN_RIGHT);
+  }
+}
+
+void SdlApp::OnMouseClicked(const SDL_MouseButtonEvent& event)
+{
+	if (event.type == SDL_MOUSEBUTTONDOWN)
+	{
+		if (event.button == SDL_BUTTON_LEFT) /* Left button */
+		{
+			// this is intended to convert window coordinate into game coordinate.
+			// this is correct only if the game and window have the same aspect ratio, otherwise, it's just wrong
+			int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
+			int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
+
+			if (event.y >= viewPort.y &&
+				event.y <= viewPort.y + viewPort.h &&
+				event.x >= viewPort.x &&
+				event.x <= viewPort.x + viewPort.w)
+			{
+				g_engine->LeftClicked(
+					((event.x-viewPort.x)*SCREEN_WIDTH)/actualWidth,
+					((event.y-viewPort.y)*SCREEN_HEIGHT)/actualHeight);
+#if (!defined ANDROID) && (!defined IOS)
+				g_engine->HoldKey_NoRepeat(JGE_BTN_OK);
+#endif
+			}
+			else if(event.y < viewPort.y)
+			{
+				g_engine->HoldKey_NoRepeat(JGE_BTN_MENU);
+			}
+			else if(event.y > viewPort.y + viewPort.h)
+			{
+				g_engine->HoldKey_NoRepeat(JGE_BTN_NEXT);
+			}
+		}
+		else if(event.button == SDL_BUTTON_RIGHT) /* Right button */
+		{ /* next phase please */
+			g_engine->HoldKey_NoRepeat(JGE_BTN_PREV);
+		}
+		else if(event.button == SDL_BUTTON_MIDDLE) /* Middle button */
+		{ /* interrupt please */
+			g_engine->HoldKey_NoRepeat(JGE_BTN_SEC);
+		}
+	}
+	else if (event.type == SDL_MOUSEBUTTONUP)
+	{
+		if(event.button == SDL_BUTTON_LEFT)
+		{
+			if (event.y >= viewPort.y &&
+				event.y <= viewPort.y + viewPort.h &&
+				event.x >= viewPort.x &&
+				event.x <= viewPort.x + viewPort.w)
+			{
+#if (!defined ANDROID) && (!defined IOS)
+				g_engine->ReleaseKey(JGE_BTN_OK);
+#endif
+			}
+			else if(event.y < viewPort.y)
+			{
+				g_engine->ReleaseKey(JGE_BTN_MENU);
+			}
+			else if(event.y > viewPort.y + viewPort.h)
+			{
+				g_engine->ReleaseKey(JGE_BTN_NEXT);
+			}
+		}
+		else if(event.button == SDL_BUTTON_RIGHT)
+		{ /* next phase please */
+			g_engine->ReleaseKey(JGE_BTN_PREV);
+		}
+		else if(event.button == SDL_BUTTON_MIDDLE)
+		{ /* interrupt please */
+			g_engine->ReleaseKey(JGE_BTN_SEC);
+		}
+	}
+}
+
+void SdlApp::OnTouchEvent(const SDL_TouchFingerEvent& event)
+{
+    // only respond to the first finger for mouse type movements - any additional finger
+    // should be ignored, and will come through instead as a multigesture event
+    if (event.fingerId == 0)
+    {
+        if (event.y >= viewPort.y &&
+            event.y <= viewPort.y + viewPort.h &&
+            event.x >= viewPort.x &&
+            event.x <= viewPort.x + viewPort.w)
+        {
+            int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
+            int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
+
+            Uint32 eventTime = SDL_GetTicks();
+            if (event.type == SDL_FINGERDOWN)
+            {
+                mMouseDownX = event.x;
+                mMouseDownY = event.y;
+
+                lastFingerDownTime = eventTime;
+            }
+
+
+#if (defined ANDROID) || (defined IOS)
+            if (event.type == SDL_FINGERUP)
+            {
+                if (eventTime - lastFingerDownTime <= kTapEventTimeout)
+                {
+                    // treat an up finger within 50 pixels of the down finger coords as a double click event
+                    if (abs(mMouseDownX - event.x) < kHitzonePliancy && abs(mMouseDownY - event.y) < kHitzonePliancy)
+                    {
+                    	DebugTrace("Pressing OK BUtton");
+                        g_engine->HoldKey_NoRepeat(JGE_BTN_OK);
+                    }
+                }
+            }
+      		else      
+#endif
+			g_engine->LeftClicked(
+                ((event.x - viewPort.x) * SCREEN_WIDTH) / actualWidth,
+                ((event.y - viewPort.y) * SCREEN_HEIGHT) / actualHeight);
+	
+        }
+    }
+}
+
+bool SdlApp::OnInit()
+{
+	int window_w, window_h;
+
+	if(SDL_Init(SDL_INIT_EVERYTHING) < 0) 
+	{
+		return false;
+	}
+
+	const SDL_VideoInfo *pVideoInfo = SDL_GetVideoInfo();
+	DebugTrace("Video Display : h " << pVideoInfo->current_h << ", w " << pVideoInfo->current_w);
+
+#if (defined ANDROID) || (defined IOS)
+	window_w = pVideoInfo->current_w;
+	window_h = pVideoInfo->current_h;
+#else
+	window_w = ACTUAL_SCREEN_WIDTH;
+	window_h = ACTUAL_SCREEN_HEIGHT;
+#endif
+
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE,    	    8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,  	    8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,   	    8);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  	    8);
+
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,  	    16);
+	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE,		    32);
+
+	SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE,	    8);
+	SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE,	8);
+	SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE,	    8);
+	SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE,	8);
+
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,  1);
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,  2);
+
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+
+	if((Surf_Display = SDL_SetVideoMode(window_w, window_h, 32,
+#ifdef ANDROID
+		SDL_OPENGL | SDL_FULLSCREEN | SDL_WINDOW_BORDERLESS)) == NULL)
+	{
+#else
+		SDL_OPENGL | SDL_RESIZABLE )) == NULL)
+	{
+#endif
+		return false;
+	}
+	SDL_WM_SetCaption(g_launcher->GetName(), "");
+
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// Black Background (yes that's the way fuckers)
+#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0)
+#if (defined GL_ES_VERSION_2_0)
+	glClearDepthf(1.0f);					// Depth Buffer Setup
+#else
+	glClearDepth(1.0f);					// Depth Buffer Setup
+#endif// (defined GL_ES_VERSION_2_0)
+
+	glDepthFunc(GL_LEQUAL);				// The Type Of Depth Testing (Less Or Equal)
+	glEnable(GL_DEPTH_TEST);				// Enable Depth Testing
+
+#else
+#if (defined GL_VERSION_ES_CM_1_1)
+	glClearDepthf(1.0f);					// Depth Buffer Setup
+#else
+	glClearDepth(1.0f);					// Depth Buffer Setup
+#endif
+	glDepthFunc(GL_LEQUAL);				// The Type Of Depth Testing (Less Or Equal)
+	glEnable(GL_DEPTH_TEST);				// Enable Depth Testing
+	glShadeModel(GL_SMOOTH);				// Select Smooth Shading
+	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	// Set Perspective Calculations To Most Accurate
+
+	glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);		// Set Line Antialiasing
+	glEnable(GL_LINE_SMOOTH);				// Enable it!
+	glEnable(GL_TEXTURE_2D);
+
+#endif
+
+	glEnable(GL_CULL_FACE);				// do not calculate inside of poly's
+	glFrontFace(GL_CCW);					// counter clock-wise polygons are out
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	glEnable(GL_SCISSOR_TEST);				// Enable Clipping
+
+	JGECreateDefaultBindings();
+
+	if (!InitGame())
+	{
+		cerr << "Could not init the game\n";
+		return false;
+	}
+
+	OnResize(window_w, window_h);
+
+	return true;
+};
+
+#if (defined ANDROID) || (defined WIN32)
+int SDL_main(int argc, char * argv[])
+#else
+int main(int argc, char* argv[])
+#endif //ANDROID
+{
+
+#if (defined ANDROID)
+	if (argc > 2)
+    {
+		mJNIEnv = (JNIEnv * )argv[1];
+        mJNIClass = (jclass * )argv[2];
+    }
+#endif		
+
+	DebugTrace("I R in da native");
+
+	g_launcher = new JGameLauncher();
+
+	u32 flags = g_launcher->GetInitFlags();
+
+	if ((flags&JINIT_FLAG_ENABLE3D)!=0)
+	{
+		JRenderer::Set3DFlag(true);
+	}
+
+	g_SdlApp = new SdlApp();
+
+	int result = g_SdlApp->OnExecute();
+
+	if (g_launcher)
+		delete g_launcher;
+
+	if(g_SdlApp)
+		delete g_SdlApp;
+
+	// Shutdown
+	DestroyGame();
+
+	return result;
+}

projects/mtg/src/StyleManager.cpp

@@ -7,7 +7,7 @@
 #include "DeckDataWrapper.h"
 #include "WFilter.h"
 #include "StyleManager.h"
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 void StyleManager::killRules()
 {

projects/mtg/src/Xmain.cpp

@@ -0,0 +1,414 @@
+#include <unistd.h>
+#include <GL/gl.h>			// Header File For The OpenGL32 Library
+#include <GL/glu.h>			// Header File For The GLu32 Library
+#include <GL/glx.h>
+#include <X11/XKBlib.h>
+#include <sys/time.h>
+#include <queue>
+#include <map>
+#include <set>
+
+#include <iostream>
+
+#include "../../JGE/include/JGE.h"
+#include "../../JGE/include/JTypes.h"
+#include "../../JGE/include/JApp.h"
+#include "../../JGE/include/JFileSystem.h"
+#include "../../JGE/include/JRenderer.h"
+
+#include "../../JGE/include/JGameLauncher.h"
+
+#define ACTUAL_SCREEN_WIDTH (SCREEN_WIDTH)
+#define ACTUAL_SCREEN_HEIGHT (SCREEN_HEIGHT)
+#define ACTUAL_RATIO ((GLfloat)ACTUAL_SCREEN_WIDTH / (GLfloat)ACTUAL_SCREEN_HEIGHT)
+struct window_state_t
+{
+  bool	fullscreen;
+  int width;
+  int height;
+  int x;
+  int y;
+} window_state = { false, ACTUAL_SCREEN_WIDTH, ACTUAL_SCREEN_HEIGHT, 0, 0 };
+
+enum
+ {
+   _NET_WM_STATE_REMOVE =0,
+   _NET_WM_STATE_ADD = 1,
+   _NET_WM_STATE_TOGGLE =2
+ };
+
+
+uint64_t	lastTickCount;
+
+
+//------------------------------------------------------------------------
+
+JGE* g_engine = NULL;
+JApp* g_app = NULL;
+JGameLauncher* g_launcher = NULL;
+
+//------------------------------------------------------------------------
+
+Display* gXDisplay = NULL;
+Window gXWindow = (Window)NULL;
+GLXWindow glxWin = (GLXWindow)NULL;
+
+static std::multiset<JButton> gControllerState;
+static std::multiset<JButton> gPrevControllerState;
+
+static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] =
+  {
+    { XK_Escape,	JGE_BTN_MENU },
+    { XK_Return,	JGE_BTN_MENU },
+    { XK_BackSpace,	JGE_BTN_CTRL },
+    { XK_Up,		JGE_BTN_UP },
+    { XK_KP_Up,		JGE_BTN_UP },
+    { XK_Down,		JGE_BTN_DOWN },
+    { XK_KP_Down,	JGE_BTN_DOWN },
+    { XK_Left,		JGE_BTN_LEFT },
+    { XK_KP_Left,	JGE_BTN_LEFT },
+    { XK_Right,		JGE_BTN_RIGHT },
+    { XK_KP_Right,	JGE_BTN_RIGHT },
+    { XK_space,		JGE_BTN_OK },
+    { XK_Control_L,	JGE_BTN_OK },
+    { XK_Control_R,	JGE_BTN_OK },
+    { XK_Tab,		JGE_BTN_CANCEL },
+    { XK_Mode_switch,	JGE_BTN_PRI },
+    { XK_Caps_Lock,	JGE_BTN_SEC },
+    { XK_Shift_L,	JGE_BTN_PREV },
+    { XK_Shift_R,	JGE_BTN_NEXT },
+    { XK_F,             JGE_BTN_FULLSCREEN },
+  };
+
+GLvoid ReSizeGLScene(GLsizei width, GLsizei height)	// Resize The GL Window
+{
+
+  if ((GLfloat)width / (GLfloat)height < ACTUAL_RATIO)
+    glViewport(0, -((width/ACTUAL_RATIO)-height)/2, width, width / ACTUAL_RATIO);			// Reset The Current Viewport
+  else
+    glViewport(-(height*ACTUAL_RATIO-width)/2, 0, height * ACTUAL_RATIO, height);
+  glScissor(0, 0, width, height);
+}
+
+GLvoid SizeGLScene(GLsizei width, GLsizei height)	// Initialize The GL Window
+{
+  if (0 == height)					// Prevent A Divide By Zero By
+    height=1;						// Making Height Equal One
+
+  glViewport(0, 0, width, height);			// Reset The Current Viewport
+
+  glMatrixMode(GL_PROJECTION);				// Select The Projection Matrix
+  glLoadIdentity();					// Reset The Projection Matrix
+
+  // Calculate The Aspect Ratio Of The Window
+  gluPerspective(75.0f, ACTUAL_RATIO, 0.5f, 1000.0f);
+
+  glMatrixMode(GL_MODELVIEW);				// Select The Modelview Matrix
+  glLoadIdentity();					// Reset The Modelview Matrix
+
+  //  glutReshapeWindow(width, height);
+  ReSizeGLScene(width, height);
+}
+
+int InitGL(void)					// All Setup For OpenGL Goes Here
+{
+  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// Black Background (yes that's the way fuckers)
+  glClearDepth(1.0f);					// Depth Buffer Setup
+  glDepthFunc(GL_LEQUAL);				// The Type Of Depth Testing (Less Or Equal)
+  glEnable(GL_DEPTH_TEST);				// Enable Depth Testing
+  glShadeModel(GL_SMOOTH);				// Select Smooth Shading
+  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	// Set Perspective Calculations To Most Accurate
+
+  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);		// Set Line Antialiasing
+  glEnable(GL_LINE_SMOOTH);				// Enable it!
+
+  glEnable(GL_CULL_FACE);				// do not calculate inside of poly's
+  glFrontFace(GL_CCW);					// counter clock-wise polygons are out
+
+  glEnable(GL_TEXTURE_2D);
+
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  glEnable(GL_SCISSOR_TEST);				// Enable Clipping
+
+  return true;						// Initialization Went OK
+}
+
+
+bool InitGame(void)
+{
+  g_engine = JGE::GetInstance();
+  g_app = g_launcher->GetGameApp();
+  JGECreateDefaultBindings();
+  g_app->Create();
+  g_engine->SetApp(g_app);
+
+  JRenderer::GetInstance()->Enable2D();
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  lastTickCount = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+
+  return true;
+}
+
+
+
+void DestroyGame(void)
+{
+  g_engine->SetApp(NULL);
+  if (g_app)
+    {
+      g_app->Destroy();
+      delete g_app;
+      g_app = NULL;
+    }
+
+  JGE::Destroy();
+
+  g_engine = NULL;
+}
+
+void KillGLWindow(void) // Properly Kill The Window
+{
+  if (gXWindow && gXDisplay)
+    XDestroyWindow(gXDisplay, gXWindow);
+  gXWindow = (Window)NULL;
+}
+
+
+// Some parameters we wanna give to XGl
+static const int doubleBufferAttributes[] = {
+    GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+    GLX_RENDER_TYPE,   GLX_RGBA_BIT,
+    GLX_DOUBLEBUFFER,  True,  /* Request a double-buffered color buffer with */
+    GLX_RED_SIZE,      1,     /* the maximum number of bits per component    */
+    GLX_GREEN_SIZE,    1,
+    GLX_BLUE_SIZE,     1,
+    None
+};
+static Bool WaitForNotify(Display *dpy, XEvent *event, XPointer arg)
+{
+  return (event->type == MapNotify) && (event->xmap.window == (Window) arg);
+}
+
+/*	This Code Creates Our OpenGL Window.  Parameters Are:					*
+ *	title			- Title To Appear At The Top Of The Window				*
+ *	width			- Width Of The GL Window Or Fullscreen Mode				*
+ *	height			- Height Of The GL Window Or Fullscreen Mode			*
+ *	bits			- Number Of Bits To Use For Color (8/16/24/32)			*
+ *	fullscreenflag	- Use Fullscreen Mode (true) Or Windowed Mode (false)	*/
+BOOL CreateGLWindow(char* title, int width, int height, int bits __attribute__((unused)), bool fullscreenflag __attribute__((unused)))
+{
+  // Open a connection to the X server
+  gXDisplay = XOpenDisplay(NULL);
+  if (NULL == gXDisplay)
+    {
+      printf("Unable to open a connection to the X server\n");
+      return false;
+    }
+
+  // Get a suitable framebuffer config
+  int numReturned;
+  GLXFBConfig *fbConfigs = glXChooseFBConfig(gXDisplay, DefaultScreen(gXDisplay), doubleBufferAttributes, &numReturned);
+  if (NULL == fbConfigs)
+    {
+      printf("Unable to get a double buffered configuration\n");
+      return false;
+    }
+
+  // Create an X colormap and window with a visual matching the framebuffer config
+  XVisualInfo *vInfo = glXGetVisualFromFBConfig(gXDisplay, fbConfigs[0]);
+
+  // We must create a color map - I didn't understand why very well since we require TrueColor
+  XSetWindowAttributes  swa;
+  swa.border_pixel = 0;
+  swa.event_mask = StructureNotifyMask;
+  swa.colormap = XCreateColormap(gXDisplay, RootWindow(gXDisplay, vInfo->screen), vInfo->visual, AllocNone);
+
+  // Create the window itself
+  gXWindow = XCreateWindow(gXDisplay, RootWindow(gXDisplay, vInfo->screen), 0, 0, width, height,
+			   0, vInfo->depth, InputOutput, vInfo->visual,
+			   CWBorderPixel | CWColormap | CWEventMask, &swa);
+
+  // Create a GLX context for OpenGL rendering
+  GLXContext context = glXCreateNewContext(gXDisplay, fbConfigs[0], GLX_RGBA_TYPE, NULL, True);
+
+  // Associate the frame buffer configuration with the created X window
+  glxWin = glXCreateWindow(gXDisplay, fbConfigs[0], gXWindow, NULL);
+
+  // Map the window to the screen
+  XMapWindow(gXDisplay, gXWindow);
+
+  // Wait for the window to appear
+  XEvent event;
+  XIfEvent(gXDisplay, &event, WaitForNotify, (XPointer) gXWindow);
+
+  // Bind the GLX context to the Window
+  glXMakeContextCurrent(gXDisplay, glxWin, glxWin, context);
+
+  free(vInfo);
+  free(fbConfigs);
+
+  SizeGLScene(width, height);
+  if (!InitGL())
+    {
+      KillGLWindow();
+      printf("Initializing GL failed.");
+      return false;
+    }
+  return true;
+}
+
+
+void Update(float dt)
+{
+  gPrevControllerState = gControllerState;
+  g_engine->SetDelta(dt);
+  g_engine->Update(dt);
+}
+
+
+int DrawGLScene(void)
+{
+	g_engine->Render();
+	return true;
+}
+
+template <typename T>
+static inline bool include(multiset<T> set, T button)
+{
+  return set.end() != set.find(button);
+}
+
+void JGECreateDefaultBindings()
+{
+  for (signed int i = sizeof(gDefaultBindings)/sizeof(gDefaultBindings[0]) - 1; i >= 0; --i)
+    g_engine->BindKey(gDefaultBindings[i].keysym, gDefaultBindings[i].keycode);
+}
+
+int JGEGetTime()
+{
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
+void reshapeFunc(int width, int height)
+{
+  ReSizeGLScene(width, height);
+}
+
+bool JGEToggleFullscreen()
+{
+  Atom wmState = XInternAtom(gXDisplay, "_NET_WM_STATE", False);
+  Atom fullScreen = XInternAtom(gXDisplay, "_NET_WM_STATE_FULLSCREEN", False);
+
+  XEvent xev;
+  xev.xclient.type = ClientMessage;
+  xev.xclient.serial = 0;
+  xev.xclient.send_event = True;
+  xev.xclient.window = gXWindow;
+  xev.xclient.message_type = wmState;
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = _NET_WM_STATE_TOGGLE;
+  xev.xclient.data.l[1] = fullScreen;
+  xev.xclient.data.l[2] = 0;
+
+  if (window_state.fullscreen)
+    {
+      XSendEvent(gXDisplay, DefaultRootWindow(gXDisplay), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
+      XMoveResizeWindow(gXDisplay, gXWindow, window_state.x, window_state.y, window_state.width, window_state.height);
+      window_state.fullscreen = false;
+    }
+  else
+    {
+      XWindowAttributes xwa;
+      Window child_return;
+      int x, y;
+      XGetWindowAttributes(gXDisplay, gXWindow, &xwa);
+      XTranslateCoordinates(gXDisplay, gXWindow, DefaultRootWindow(gXDisplay), xwa.x, xwa.y, &window_state.x, &window_state.y, &child_return);
+      window_state.width = xwa.width; window_state.height = xwa.height;
+      window_state.fullscreen = true;
+
+      XSendEvent(gXDisplay, DefaultRootWindow(gXDisplay), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
+
+      XGetWindowAttributes(gXDisplay, DefaultRootWindow(gXDisplay), &xwa);
+      XMoveResizeWindow(gXDisplay, gXWindow, 0, 0, xwa.width, xwa.height);
+    }
+  return true;
+}
+
+int main(int argc, char* argv[])
+{
+  char* path = argv[0];
+  while (*path) ++path;
+  while ((*path != '/') && (path > argv[0])) --path;
+  if ('/' == *path) *path = 0;
+  if (strlen(argv[0]) != 0) chdir(argv[0]);
+
+  g_launcher = new JGameLauncher();
+
+  u32 flags = g_launcher->GetInitFlags();
+
+  if ((flags&JINIT_FLAG_ENABLE3D)!=0)
+    JRenderer::Set3DFlag(true);
+
+  // Create Our OpenGL Window
+  if (!CreateGLWindow(g_launcher->GetName(), ACTUAL_SCREEN_WIDTH, ACTUAL_SCREEN_HEIGHT, 32, window_state.fullscreen))
+    {
+      printf("Could not create the window\n");
+      return 1;								// Quit If Window Was Not Created
+    }
+
+  if (!InitGame())
+    {
+      printf("Could not init the game\n");
+      return 1;
+    }
+
+  XSelectInput(gXDisplay, gXWindow, KeyPressMask | KeyReleaseMask | StructureNotifyMask);
+  XkbSetDetectableAutoRepeat(gXDisplay, True, NULL);
+
+  static uint64_t tickCount;
+  while (!g_engine->IsDone())
+    {
+      struct timeval tv;
+      uint dt;
+      XEvent event;
+      gettimeofday(&tv, NULL);
+      tickCount = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+      dt = (tickCount - lastTickCount);
+      lastTickCount = tickCount;
+      Update((float)dt / 1000.0f);						// Update frame
+
+      DrawGLScene();						// Draw The Scene
+      glXSwapBuffers(gXDisplay, glxWin);
+      if (XCheckWindowEvent(gXDisplay, gXWindow, KeyPressMask | KeyReleaseMask | StructureNotifyMask, &event))
+	switch (event.type)
+	  {
+	  case KeyPress:
+            {
+              const KeySym sym = XKeycodeToKeysym(gXDisplay, event.xkey.keycode, 1);
+              g_engine->HoldKey_NoRepeat(sym);
+            }
+            break;
+	  case KeyRelease:
+            g_engine->ReleaseKey(XKeycodeToKeysym(gXDisplay, event.xkey.keycode, 1));
+            break;
+	  case ConfigureNotify:
+	    ReSizeGLScene(event.xconfigure.width, event.xconfigure.height);
+	    break;
+	  default:
+	    break;
+	  }
+    }
+
+  if (g_launcher)
+    delete g_launcher;
+
+  // Shutdown
+  DestroyGame();
+  KillGLWindow();							// Kill The Window
+  return 0;
+}

projects/mtg/src/qt/corewrapper.cpp

@@ -0,0 +1,596 @@
+#include <qplatformdefs.h>
+#include <QtOpenGL>
+#include "corewrapper.h"
+#include <QElapsedTimer>
+
+#ifdef TESTSUITE
+#include "TestSuiteAI.h"
+#include "GameOptions.h"
+#include "MTGDeck.h"
+#endif
+#include "DebugRoutines.h"
+
+#if (defined FORCE_GLES)
+#undef GL_ES_VERSION_2_0
+#undef GL_VERSION_2_0
+#define GL_VERSION_ES_CM_1_1 1
+#ifndef GL_OES_VERSION_1_1
+#define glOrthof glOrtho
+#define glClearDepthf glClearDepth
+#endif
+#endif
+
+#if (defined FORCE_GLES)
+#undef GL_ES_VERSION_2_0
+#undef GL_VERSION_2_0
+#define GL_VERSION_ES_CM_1_1 1
+#define glOrthof glOrtho
+#define glClearDepthf glClearDepth
+#endif
+
+#define ACTUAL_SCREEN_WIDTH (SCREEN_WIDTH)
+#define ACTUAL_SCREEN_HEIGHT (SCREEN_HEIGHT)
+#define ACTUAL_RATIO ((GLfloat)ACTUAL_SCREEN_WIDTH / (GLfloat)ACTUAL_SCREEN_HEIGHT)
+
+// in pixels
+#define kHitzonePliancy 50
+
+// tick value equates to ms
+#define kTapEventTimeout 250
+
+// swipe duration
+#define kSwipeEventMinDuration 250
+// swipe distance in pixel (from top to down)
+#define kSwipeMinDistance 200
+
+
+QElapsedTimer WagicCore::g_startTimer;
+
+WagicCore::WagicCore(super *parent) :
+    super(parent), m_engine(0), m_app(0), m_launcher(0), m_active(false)
+#ifdef Q_WS_MAEMO_5
+  , dBusConnection(QDBusConnection::systemBus()), dBusInterface(0)
+#endif //Q_WS_MAEMO_5
+{
+#ifdef QT_WIDGET
+#if (defined Q_WS_MAEMO_5)
+    setAttribute(Qt::WA_Maemo5AutoOrientation);
+    setAttribute(Qt::WA_Maemo5NonComposited);
+#endif //Q_WS_MAEMO_5
+    setAttribute(Qt::WA_AcceptTouchEvents);
+  //  setAttribute(Qt::WA_InputMethodEnabled);
+    setMouseTracking(true);
+    grabGesture(Qt::TapAndHoldGesture);
+    resize(ACTUAL_SCREEN_WIDTH, ACTUAL_SCREEN_HEIGHT);
+#else
+    setWidth(480);
+    setHeight(272);
+    setFlag(QGraphicsItem::ItemHasNoContents, false);
+#endif //QT_WIDGET
+    g_startTimer.restart();
+    m_lastTickCount = g_startTimer.elapsed();
+
+#ifdef Q_WS_MAEMO_5
+    dBusInterface = new QDBusInterface(MCE_SERVICE, MCE_REQUEST_PATH,
+                                        MCE_REQUEST_IF, dBusConnection);
+
+    // Handle screen state on / off
+    dBusConnection.connect(MCE_SERVICE, MCE_SIGNAL_PATH, MCE_SIGNAL_IF, MCE_DISPLAY_SIG, this, SLOT(displayStateChanged(const QDBusMessage &)));
+#endif
+}
+
+
+WagicWrapper::WagicWrapper()
+{
+    m_launcher = new JGameLauncher();
+    u32 flags = m_launcher->GetInitFlags();
+    if ((flags&JINIT_FLAG_ENABLE3D)!=0)
+    {
+        JRenderer::Set3DFlag(true);
+    }
+
+    JGECreateDefaultBindings();
+
+    m_engine = JGE::GetInstance();
+    m_app = m_launcher->GetGameApp();
+    m_app->Create();
+    m_engine->SetApp(m_app);
+    JRenderer::GetInstance()->Enable2D();
+}
+
+WagicWrapper::~WagicWrapper()
+{
+    if(m_launcher)
+    {
+        delete m_launcher;
+        m_launcher = NULL;
+    }
+
+    if(m_engine)
+        m_engine->SetApp(NULL);
+
+    if (m_app)
+    {
+      m_app->Destroy();
+      delete m_app;
+      m_app = NULL;
+    }
+
+    JGE::Destroy();
+    m_engine = NULL;
+}
+
+
+int WagicCore::runTestSuite()
+{
+    int result = 0;
+#ifdef TESTSUITE
+    WagicWrapper* wagicCore =  new WagicWrapper();
+    MTGCollection()->loadFolder("sets/primitives/");
+    MTGCollection()->loadFolder("sets/", "_cards.dat");
+    options.reloadProfile();
+    TestSuite testSuite("test/_tests.txt");
+    result = testSuite.run();
+    delete wagicCore;
+#endif
+    DebugTrace("TestSuite done: failed test: " << result);
+    return result;
+}
+
+void WagicCore::initApp()
+{
+    if(!m_engine)
+    {
+        m_launcher = new JGameLauncher();
+        u32 flags = m_launcher->GetInitFlags();
+        if ((flags&JINIT_FLAG_ENABLE3D)!=0)
+        {
+            JRenderer::Set3DFlag(true);
+        }
+
+        JGECreateDefaultBindings();
+
+        m_engine = JGE::GetInstance();
+        m_app = m_launcher->GetGameApp();
+        m_app->Create();
+        m_engine->SetApp(m_app);
+        JRenderer::GetInstance()->Enable2D();
+        setActive(true);
+    }
+}
+
+WagicCore::~WagicCore()
+{
+#ifdef Q_WS_MAEMO_5
+    if(dBusInterface)
+        delete dBusInterface;
+#endif //Q_WS_MAEMO_5
+
+    if(m_launcher)
+    {
+        delete m_launcher;
+        m_launcher = NULL;
+    }
+
+    if(m_engine)
+        m_engine->SetApp(NULL);
+
+    if (m_app)
+    {
+      m_app->Destroy();
+      delete m_app;
+      m_app = NULL;
+    }
+
+    JGE::Destroy();
+
+    m_engine = NULL;
+}
+
+void WagicCore::pixelInput(int x, int y)
+{
+    if(m_engine)
+        m_engine->LeftClicked(x, y);
+}
+
+void WagicCore::timerEvent( QTimerEvent* )
+{
+    qint64 tickCount;
+    quint32 dt;
+    tickCount = g_startTimer.elapsed();
+    dt = (tickCount - m_lastTickCount);
+    m_lastTickCount = tickCount;
+
+    if(!m_engine)
+        return;
+    if(m_engine->IsDone())
+        QApplication::instance()->quit();
+
+    m_engine->SetDelta((float)dt / 1000.0f);
+    m_engine->Update((float)dt / 1000.0f);
+
+    done();
+    update();
+}
+
+void WagicCore::setActive(bool active)
+{
+    if(!m_engine) return;
+
+    if(!m_active && active)
+    {
+        m_engine->Resume();
+    #if (defined Q_WS_MAEMO_5) || defined(MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
+        // 30 fps max on mobile
+        m_timerId = startTimer(33);
+    #else
+        // 200 fps max on desktop
+        m_timerId = startTimer(5);
+    #endif //Q_WS_MAEMO_5
+        m_active = active;
+        emit activeChanged();
+    }
+    else if(m_active && !active)
+    {
+        m_engine->Pause();
+    #if (defined Q_WS_MAEMO_5) || defined(MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
+        killTimer(m_timerId);
+    #endif
+        m_active = active;
+        emit activeChanged();
+    }
+}
+
+void WagicCore::initializeGL()
+{
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// Black Background (yes that's the way fuckers)
+  #if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0)
+  #if (defined GL_ES_VERSION_2_0)
+    glClearDepthf(1.0f);					// Depth Buffer Setup
+  #else
+    glClearDepth(1.0f);					// Depth Buffer Setup
+  #endif// (defined GL_ES_VERSION_2_0)
+
+    glDepthFunc(GL_LEQUAL);				// The Type Of Depth Testing (Less Or Equal)
+    glEnable(GL_DEPTH_TEST);				// Enable Depth Testing
+
+  #else
+  #if (defined GL_VERSION_ES_CM_1_1 || defined GL_OES_VERSION_1_1)
+    glClearDepthf(1.0f);					// Depth Buffer Setup
+  #else
+    glClearDepth(1.0f);					// Depth Buffer Setup
+  #endif
+
+    glDepthFunc(GL_LEQUAL);				// The Type Of Depth Testing (Less Or Equal)
+    glEnable(GL_DEPTH_TEST);				// Enable Depth Testing
+    glShadeModel(GL_SMOOTH);				// Select Smooth Shading
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	// Set Perspective Calculations To Most Accurate
+
+    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);		// Set Line Antialiasing
+    glEnable(GL_LINE_SMOOTH);				// Enable it!
+    glEnable(GL_TEXTURE_2D);
+  #endif
+
+    glEnable(GL_CULL_FACE);				// do not calculate inside of poly's
+    glFrontFace(GL_CCW);					// counter clock-wise polygons are out
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glEnable(GL_SCISSOR_TEST);				// Enable Clipping
+}
+
+#ifndef QT_WIDGET
+void WagicCore::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+    painter->beginNativePainting();
+
+    initApp();
+
+    resizeGL ( boundingRect().size().width(), boundingRect().size().height());
+
+    initializeGL();
+
+    paintGL();
+
+    painter->endNativePainting();
+}
+#endif //QT_WIDGET
+
+void WagicCore::paintGL()
+{
+    if(m_engine)
+        m_engine->Render();
+}
+
+
+void WagicCore::resizeGL(int width, int height)
+{
+    if ((GLfloat)width / (GLfloat)height <= ACTUAL_RATIO)
+    {
+      m_viewPort.setLeft(0);
+      m_viewPort.setTop(-((width/ACTUAL_RATIO)-height)/2);
+      m_viewPort.setRight(width);
+      m_viewPort.setBottom(-((width/ACTUAL_RATIO)-height)/2 + width / ACTUAL_RATIO);
+    }
+    else
+    {
+      m_viewPort.setLeft(-(height*ACTUAL_RATIO-width)/2);
+      m_viewPort.setTop(0);
+      m_viewPort.setRight(-(height*ACTUAL_RATIO-width)/2 + height * ACTUAL_RATIO);
+      m_viewPort.setBottom(height);
+    }
+
+    glViewport(m_viewPort.left(), m_viewPort.top(), m_viewPort.right()-m_viewPort.left(), m_viewPort.bottom()-m_viewPort.top());
+
+    JRenderer::GetInstance()->SetActualWidth(m_viewPort.right()-m_viewPort.left());
+    JRenderer::GetInstance()->SetActualHeight(m_viewPort.bottom()-m_viewPort.top());
+    glScissor(0, 0, width, height);
+
+#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0)
+
+    glMatrixMode (GL_PROJECTION);										// Select The Projection Matrix
+    glLoadIdentity ();													// Reset The Projection Matrix
+
+#if (defined GL_VERSION_ES_CM_1_1 || defined GL_OES_VERSION_1_1)
+    glOrthof(0.0f, (float) (m_viewPort.right()-m_viewPort.left())-1.0f, 0.0f, (float) (m_viewPort.bottom()-m_viewPort.top())-1.0f, -1.0f, 1.0f);
+#else
+    glOrtho(0.0f, (float) (m_viewPort.right()-m_viewPort.left())-1.0f, 0.0f, (float) (m_viewPort.bottom()-m_viewPort.top())-1.0f, -1.0f, 1.0f);
+#endif
+
+    glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix
+    glLoadIdentity ();													// Reset The Modelview Matrix
+
+    glDisable (GL_DEPTH_TEST);
+#endif
+}
+
+void WagicCore::keyPressEvent(QKeyEvent *event)
+{
+  switch(event->key())
+  {
+#if (defined Q_WS_MAEMO_5)
+  case Qt::Key_F7:
+    /* interrupt please */
+    m_engine->HoldKey_NoRepeat(JGE_BTN_SEC);
+    break;
+  case Qt::Key_F8:
+    /* next phase please */
+    m_engine->HoldKey_NoRepeat(JGE_BTN_PREV);
+    break;
+#endif // Q_WS_MAEMO_5
+  case Qt::Key_F:
+    JGEToggleFullscreen();
+    break;
+  default:
+    m_engine->HoldKey_NoRepeat((LocalKeySym)event->key());
+  }
+  event->accept();
+  super::keyPressEvent(event);
+}
+
+void WagicCore::keyReleaseEvent(QKeyEvent *event)
+{
+    switch(event->key())
+    {
+#if (defined Q_WS_MAEMO_5)
+    case Qt::Key_F7:
+      /* interrupt please */
+      m_engine->ReleaseKey(JGE_BTN_SEC);
+      break;
+    case Qt::Key_F8:
+      /* next phase please */
+      m_engine->ReleaseKey(JGE_BTN_PREV);
+      break;
+  #endif // Q_WS_MAEMO_5
+    default:
+      m_engine->ReleaseKey((LocalKeySym)event->key());
+    }
+
+    event->accept();
+    super::keyReleaseEvent(event);
+}
+
+#ifdef QT_WIDGET
+void WagicCore::wheelEvent(QWheelEvent *event)
+#else
+void WagicCore::wheelEvent ( QGraphicsSceneWheelEvent * event)
+#endif
+{
+    if(event->orientation() == Qt::Vertical)
+        m_engine->Scroll(0, 3*event->delta());
+    else
+
+        m_engine->Scroll(3*event->delta(), 0);
+
+    event->accept();
+}
+
+#ifdef QT_WIDGET
+void WagicCore::tapAndHoldTriggered(QTapAndHoldGesture* gesture)
+{
+    if (gesture->state() == Qt::GestureFinished) {
+        m_engine->HoldKey_NoRepeat(JGE_BTN_MENU);
+    }
+}
+
+void WagicCore::mousePressEvent(QMouseEvent *event)
+{
+  if(event->button() == Qt::LeftButton)
+  {
+    m_lastPos = event->pos();
+    // this is intended to convert window coordinate into game coordinate.
+    // this is correct only if the game and window have the same aspect ratio, otherwise, it's just wrong
+    int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
+    int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
+
+    if (lastPosy() >= m_viewPort.top() &&
+      lastPosy() <= m_viewPort.bottom() &&
+      lastPosx() <= m_viewPort.right() &&
+      lastPosx() >= m_viewPort.left()) {
+      m_engine->LeftClicked(
+                  ((lastPosx()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
+                  ((lastPosy()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
+#if (!defined Q_WS_MAEMO_5) && (!defined MEEGO_EDITION_HARMATTAN) && (!defined Q_WS_ANDROID)
+      m_engine->HoldKey_NoRepeat(JGE_BTN_OK);
+#else
+      mMouseDownX = lastPosx();
+      mMouseDownY = lastPosy();
+      mLastFingerDownTime = g_startTimer.elapsed();
+#endif
+    } else if(lastPosy()<m_viewPort.top()) {
+      m_engine->HoldKey_NoRepeat(JGE_BTN_MENU);
+    } else if(lastPosy()>m_viewPort.bottom()) {
+      m_engine->HoldKey_NoRepeat(JGE_BTN_NEXT);
+    }
+    event->accept();
+  }
+  else if(event->button() == Qt::RightButton)
+  { /* next phase please */
+    m_engine->HoldKey_NoRepeat(JGE_BTN_PREV);
+    event->accept();
+  }
+  else if(event->button() == Qt::MidButton)
+  { /* interrupt please */
+    m_engine->HoldKey_NoRepeat(JGE_BTN_SEC);
+    event->accept();
+  }
+  else
+  {
+    super::mousePressEvent(event);
+  }
+}
+
+void WagicCore::mouseReleaseEvent(QMouseEvent *event)
+{
+  if(event->button() == Qt::LeftButton)
+  {
+    m_lastPos = event->pos();
+
+    if (lastPosy() >= m_viewPort.top() &&
+      lastPosy() <= m_viewPort.bottom() &&
+      lastPosx() <= m_viewPort.right() &&
+      lastPosx() >= m_viewPort.left()) {
+#if (defined Q_WS_MAEMO_5) || (defined MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
+      if(g_startTimer.elapsed() - mLastFingerDownTime <= kTapEventTimeout )
+      {
+        if(abs(mMouseDownX - lastPosx()) < kHitzonePliancy &&
+           abs(mMouseDownY - lastPosy()) < kHitzonePliancy)
+        {
+          m_engine->HoldKey_NoRepeat(JGE_BTN_OK);
+        }
+      }
+      else if (g_startTimer.elapsed() - mLastFingerDownTime >= kSwipeEventMinDuration)
+      { // Let's swipe
+        m_engine->Scroll(lastPosx()-mMouseDownX, lastPosy()-mMouseDownY);
+      }
+#else
+//#if (!defined Q_WS_MAEMO_5) && (!defined MEEGO_EDITION_HARMATTAN)
+      m_engine->ReleaseKey(JGE_BTN_OK);
+#endif
+      m_engine->ReleaseKey(JGE_BTN_MENU);
+    } else if(lastPosy() < m_viewPort.top()) {
+      m_engine->ReleaseKey(JGE_BTN_MENU);
+    } else if(lastPosy() > m_viewPort.bottom()) {
+      m_engine->ReleaseKey(JGE_BTN_NEXT);
+    }
+    event->accept();
+  }
+  else if(event->button() == Qt::RightButton)
+  { /* next phase please */
+    m_engine->ReleaseKey(JGE_BTN_PREV);
+    event->accept();
+  }
+  else if(event->button() == Qt::MidButton)
+  { /* interrupt please */
+    m_engine->ReleaseKey(JGE_BTN_SEC);
+    event->accept();
+  }
+  else
+  {
+    super::mouseReleaseEvent(event);
+  }
+}
+
+void WagicCore::mouseMoveEvent(QMouseEvent *event)
+{
+  int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
+  int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
+
+  m_lastPos = event->pos();
+
+  if (lastPosy() >= m_viewPort.top() &&
+    lastPosy() <= m_viewPort.bottom() &&
+    lastPosx() <= m_viewPort.right() &&
+    lastPosx() >= m_viewPort.left()) {
+    m_engine->LeftClicked(
+                ((lastPosx()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
+                ((lastPosy()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
+    event->accept();
+  } else {
+    super::mouseMoveEvent(event);
+  }
+}
+
+void WagicCore::showEvent ( QShowEvent * )
+{
+  setActive(true);
+}
+
+void WagicCore::hideEvent ( QHideEvent * )
+{
+  setActive(false);
+}
+
+bool WagicCore::event(QEvent *event)
+{
+    if (event->type() == QEvent::Gesture)
+        return gestureEvent(static_cast<QGestureEvent*>(event));
+#if (defined Q_WS_MAEMO_5) || (defined MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
+    else if (event->type() == QEvent::WindowActivate)
+    {
+        showEvent(NULL);
+    }
+    else if (event->type() == QEvent::WindowDeactivate)
+    {
+        hideEvent(NULL);
+    }
+#endif
+
+    return QGLWidget::event(event);
+}
+
+bool WagicCore::gestureEvent(QGestureEvent* event)
+{
+    if (QGesture *tapAndHold = event->gesture(Qt::TapAndHoldGesture))
+        tapAndHoldTriggered(static_cast<QTapAndHoldGesture *>(tapAndHold));
+
+    return true;
+}
+
+void WagicCore::start(int)
+{
+#if (defined Q_WS_MAEMO_5) || (defined MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
+    showFullScreen();
+#else
+    show();
+#endif
+    initApp();
+}
+
+#endif //QT_WIDGET
+
+#ifdef Q_WS_MAEMO_5
+void WagicCore::displayStateChanged(const QDBusMessage &message)
+{
+  QString state = message.arguments().at(0).toString();
+  if (!state.isEmpty()) {
+    if (state == MCE_DISPLAY_ON_STRING && isActiveWindow()) {
+       setActive(true);
+    }
+    else if (state == MCE_DISPLAY_OFF_STRING) {
+        setActive(false);
+    }
+  }
+}
+#endif

projects/mtg/src/qt/filedownloader.cpp

@@ -0,0 +1,115 @@
+#include "filedownloader.h"
+#include <QDir>
+#include <QCryptographicHash>
+ 
+FileDownloader::FileDownloader(QString localPath, QString targetFile, QObject *parent) :
+#ifdef QT_WIDGET
+    QProgressDialog("Downloading resources", "", 0, 100, (QWidget*)parent, 0),
+#else
+    QObject(parent),
+#endif //QT_WIDGET
+    m_state(NETWORK_ERROR), m_received(0), m_targetFile(targetFile), m_localHash(""), m_OK(false)
+
+{
+#ifdef QT_WIDGET
+    setCancelButton(0);
+    connect(this, SIGNAL(receivedChanged(int)), SLOT(setValue(int)));
+    connect(this, SIGNAL(canceled()), SLOT(handleCancel()));
+#endif //QT_WIDGET
+    connect(this, SIGNAL(stateChanged(DownloadState)), SLOT(handleStateChange(DownloadState)));
+
+    QDir dir(QDir::homePath());
+    if(!dir.mkpath(localPath))
+    {
+        m_OK = false;
+        return;
+    }
+    dir.cd(localPath);
+    m_localPath = dir.filePath("core.zip");
+
+    QFile local(m_localPath);
+    if(local.exists()) {
+        /* a file is already present in the local path */
+        computeLocalHash(local);
+        m_state = DOWNLOADED;
+    }
+
+    if(m_WebCtrl.networkAccessible()) {
+        /* Network is OK, we request the remote hash file */
+        m_state = DOWNLOADING_HASH;
+        requestHash(QUrl("http://code.google.com/p/wagic/downloads/detail?name="+m_targetFile));
+    }
+
+    emit stateChanged(m_state);
+}
+
+void FileDownloader::setDownloadUrl(QUrl url)
+{
+    if((!url.isEmpty()))
+    {
+        if(!m_WebCtrl.networkAccessible()) {
+            m_status = "Network not accessible, press retry when the network is accessible.";
+            emit statusChanged();
+            return;
+        }
+
+        QNetworkRequest request(url);
+        m_downloadReply = m_WebCtrl.get(request);
+
+        connect(m_downloadReply, SIGNAL(downloadProgress(qint64, qint64)),
+                    SLOT(downloadProgress(qint64, qint64)));
+
+        connect(m_downloadReply, SIGNAL(finished()), SLOT(fileDownloaded()));
+        m_status = "Downloading Resources";
+
+        m_OK = m_tmp.open();
+    }
+}
+
+
+FileDownloader::~FileDownloader()
+{
+
+}
+
+void FileDownloader::requestHash(QUrl url)
+{
+    QNetworkRequest request(url);
+    m_hashReply = m_WebCtrl.get(request);
+
+    connect(m_hashReply, SIGNAL(finished()), SLOT(computeRemoteHash()));
+}
+
+void FileDownloader::computeRemoteHash()
+{
+    if(m_hashReply->error() != QNetworkReply::NoError) {
+        m_state = NETWORK_ERROR;
+    } else {
+        QString aString = m_hashReply->readAll();
+
+        int index = aString.indexOf("<span id=\"sha1\">");
+        m_remoteHash = aString.mid(index+16, 40);
+        if(m_localHash != m_remoteHash)
+        {   /* We download the real file */
+            m_state = DOWNLOADING_FILE;
+            setDownloadUrl(QUrl("http://wagic.googlecode.com/files/" + m_targetFile));
+        }
+        else
+        {
+            m_state = DOWNLOADED;
+        }
+    }
+    emit stateChanged(m_state);
+}
+
+void FileDownloader::computeLocalHash(QFile& file)
+{
+    QCryptographicHash crypto(QCryptographicHash::Sha1);
+    QFile myFile(file.fileName());
+    myFile.open(QFile::ReadOnly);
+    while(!myFile.atEnd()){
+        crypto.addData(myFile.read(8192));
+    }
+    QByteArray hash = crypto.result();
+    m_localHash = hash.toHex();
+}

projects/mtg/src/winmain.cpp

@@ -0,0 +1,821 @@
+//========================================================================
+//    NeHe OpenGL Wizard : NeHeSimple.cpp
+//    Wizard Created by: Vic Hollis
+//========================================================================
+/*
+ *		This Code Was Created By Jeff Molofee 2000
+ *		A HUGE Thanks To Fredric Echols For Cleaning Up
+ *		And Optimizing This Code, Making It More Flexible!
+ *		If You've Found This Code Useful, Please Let Me Know.
+ *		Visit My Site At nehe.gamedev.net
+ */
+
+#ifdef WIN32
+#include <windows.h>		// Header File For Windows
+#else
+typedef struct _HDC {} *HDC;
+typedef struct _HGLRC {} *HGLRC;
+typedef struct _HWND {} *HWND;
+typedef struct _HINSTANCE {} *HINSTANCE;
+typedef struct _WNDCLASS
+{
+  int wc;
+  int style;
+  int* lpfnWndProc;
+  int cbClsExtra;
+  int cbWndExtra;
+  HINSTANCE hInstance;
+  int* hIcon;
+  int* hCursor;
+  int hbrBackground;
+  char* lpszMenuName;
+  const char* lpszClassName;
+} WNDCLASS;
+typedef struct
+{
+  unsigned short dmSize;
+  unsigned int dmFields;
+  unsigned int dmBitsPerPel;
+  unsigned int dmPelsWidth;
+  unsigned int dmPelsHeight;
+} DEVMODE;
+
+typedef HINSTANCE HMODULE;
+typedef struct _RECT { int left; int right; int top; int bottom; } RECT;
+typedef struct _MSG { int wParam; int message; } MSG;
+typedef unsigned int LRESULT;
+typedef unsigned int UINT;
+typedef signed int WPARAM;
+typedef unsigned int LPARAM;
+typedef int* WNDPROC;
+typedef int* HCURSOR;
+typedef HCURSOR HICON;
+typedef HCURSOR HMENU;
+typedef struct _PIXELFORMATDESCRIPTOR {
+  int a;int b;int c;int d;int e;int f;int g;int h;int i;int j;int k;int l;int m;int n;int o;int p;int q;int r;int s;int t;int u;int v;int w;int x;int y;int z; } PIXELFORMATDESCRIPTOR;
+typedef char* LPSTR;
+
+enum { VK_CONTROL, VK_RETURN, VK_ESCAPE, VK_SPACE, VK_F1, VK_F2, VK_F3 };
+enum { MB_OK, MB_ICONINFORMATION, MB_ICONSTOP, MB_YESNO, MB_ICONEXCLAMATION, IDYES };
+enum { CS_HREDRAW, CS_VREDRAW, CS_OWNDC };
+enum { WS_EX_APPWINDOW, WS_POPUP, WS_EX_WINDOWEDGE, WS_OVERLAPPED, WS_CAPTION, WS_MINIMIZEBOX, WS_MAXIMIZEBOX, WS_SIZEBOX, WS_SYSMENU, WS_CLIPSIBLINGS, WS_CLIPCHILDREN };
+enum { WM_ACTIVATE, WM_SYSCOMMAND, WM_CLOSE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_MOUSEMOVE, WM_SIZE, WM_QUIT };
+enum { DM_BITSPERPEL, DM_PELSWIDTH, DM_PELSHEIGHT };
+enum { CDS_FULLSCREEN };
+enum { DISP_CHANGE_SUCCESSFUL };
+enum { SC_SCREENSAVE, SC_MONITORPOWER };
+enum { PFD_DRAW_TO_WINDOW, PFD_SUPPORT_OPENGL, PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, PFD_MAIN_PLANE };
+enum { SW_SHOW };
+enum { IDC_ARROW };
+enum { PM_REMOVE };
+
+static const char* IDI_WINLOGO = "";
+#define CALLBACK
+#define WINAPI
+#define ZeroMemory bzero
+int GetTickCount() { return 0; }
+long ChangeDisplaySettings(DEVMODE*, unsigned int);
+int ShowCursor(bool);
+HGLRC wglCreateContext(HDC);
+bool wglMakeCurrent(HDC, HGLRC);
+bool wglDeleteContext(HGLRC);
+int ReleaseDC(HWND, HDC);
+int MessageBox(HWND, const char*, const char*, unsigned int);
+bool DestroyWindow(HWND);
+bool UnregisterClass(const char*, HINSTANCE);
+HMODULE GetModuleHandle(char*);
+HCURSOR LoadCursor(HINSTANCE, int);
+HICON LoadIcon(HINSTANCE, const char*);
+int* RegisterClass(const WNDCLASS*);
+bool AdjustWindowRectEx(RECT*, unsigned int, bool, unsigned int);
+HWND CreateWindowEx(unsigned int, const char*, const char*, unsigned int, int, int, int, int, HWND, HMENU, HINSTANCE, void*);
+HDC GetDC(HWND);
+int ChoosePixelFormat(HDC, const PIXELFORMATDESCRIPTOR*);
+bool SetPixelFormat(HDC, int, PIXELFORMATDESCRIPTOR*);
+bool ShowWindow(HWND, int);
+bool SetForegroundWindow(HWND);
+HWND SetFocus(HWND);
+unsigned short HIWORD(unsigned int);
+unsigned short LOWORD(unsigned int);
+LRESULT DefWindowProc(HWND, unsigned int, WPARAM, LPARAM);
+void PostQuitMessage(int);
+bool PeekMessage(MSG*, HWND, unsigned int, unsigned int, unsigned int);
+bool TranslateMessage(const MSG*);
+LRESULT DispatchMessage(const MSG*);
+bool SwapBuffers(HDC);
+#endif
+
+
+
+#include <GL/gl.h>			// Header File For The OpenGL32 Library
+#include <GL/glu.h>			// Header File For The GLu32 Library
+#include <queue>
+
+#include "../../JGE/include/JGE.h"
+#include "../../JGE/include/JTypes.h"
+#include "../../JGE/include/JApp.h"
+#include "../../JGE/include/JFileSystem.h"
+#include "../../JGE/include/JRenderer.h"
+
+#include "../../JGE/include/JGameLauncher.h"
+
+//#include "..\src\GameApp.h"
+
+#ifdef WIN32
+#pragma comment( lib, "opengl32.lib" )	// Search For OpenGL32.lib While Linking
+#pragma comment( lib, "glu32.lib" )		// Search For GLu32.lib While Linking
+#pragma comment( lib, "User32.lib" )
+#pragma comment( lib, "Gdi32.lib" )
+#pragma comment( lib, "Comdlg32.lib" )
+#endif
+
+HDC			hDC=NULL;		// Private GDI Device Context
+HGLRC		hRC=NULL;		// Permanent Rendering Context
+HWND		hWnd=NULL;		// Holds Our Window Handle
+HINSTANCE	hInstance;		// Holds The Instance Of The Application
+
+bool	active=TRUE;			// Window Active Flag Set To TRUE By Default
+
+enum eDisplayMode
+{
+    DisplayMode_lowRes = 0,
+    DisplayMode_hiRes,
+    DisplayMode_fullscreen
+};
+
+unsigned int gDisplayMode = DisplayMode_lowRes;
+
+const float kActualRatio((GLfloat)SCREEN_WIDTH / (GLfloat)SCREEN_HEIGHT);
+
+DWORD	lastTickCount;
+
+BOOL	g_keys[256];
+BOOL	g_holds[256];
+
+
+//------------------------------------------------------------------------
+
+JGE* g_engine = NULL;
+JApp* g_app = NULL;
+JGameLauncher* g_launcher = NULL;
+
+//------------------------------------------------------------------------
+
+
+static u32 gButtons = 0;
+static u32 gOldButtons = 0;
+
+static const struct { LocalKeySym keysym; JButton keycode; }
+
+gDefaultBindings[] =
+{
+    { VK_CONTROL,	JGE_BTN_CTRL },
+    { VK_RETURN,	JGE_BTN_MENU },
+    { VK_ESCAPE,	JGE_BTN_MENU },
+    { VK_UP,		JGE_BTN_UP },
+    { VK_RIGHT,		JGE_BTN_RIGHT },
+    { VK_DOWN,		JGE_BTN_DOWN },
+    { VK_LEFT,		JGE_BTN_LEFT },
+    { 'Z',		JGE_BTN_UP },
+    { 'D',		JGE_BTN_RIGHT },
+    { 'S',		JGE_BTN_DOWN },
+    { 'Q',		JGE_BTN_LEFT },
+    { 'A',		JGE_BTN_PREV },
+    { 'E',		JGE_BTN_NEXT },
+    { 'I',		JGE_BTN_CANCEL },
+    { 'L',		JGE_BTN_OK },
+    { VK_SPACE,		JGE_BTN_OK },
+    { 'K',		JGE_BTN_SEC },
+    { 'J',		JGE_BTN_PRI },
+    { 'F',      JGE_BTN_FULLSCREEN },
+};
+
+void JGECreateDefaultBindings()
+{
+    for (signed int i = sizeof(gDefaultBindings)/sizeof(gDefaultBindings[0]) - 1; i >= 0; --i)
+        g_engine->BindKey(gDefaultBindings[i].keysym, gDefaultBindings[i].keycode);
+}
+
+int JGEGetTime()
+{
+    return (int)GetTickCount();
+}
+
+LRESULT	CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);	// Declaration For WndProc
+
+GLvoid ReSizeGLScene(GLsizei width, GLsizei height)		// Resize And Initialize The GL Window
+{
+    if (height==0)										// Prevent A Divide By Zero By
+        height=1;										// Making Height Equal One
+
+    JRenderer::GetInstance()->SetActualWidth(static_cast<float>(width));
+    JRenderer::GetInstance()->SetActualHeight(static_cast<float>(height));
+
+    GLsizei adjustedWidth(width);
+    GLsizei adjustedHeight(height);
+    GLint x(0);
+    GLint y(0);
+
+    if ((GLfloat)width / (GLfloat)height < kActualRatio)
+    {
+        adjustedHeight = (GLsizei)(width / kActualRatio);
+        y = -(adjustedHeight - height) / 2;
+    }
+    else
+    {
+        adjustedWidth = (GLsizei)(height * kActualRatio);
+        x = -(adjustedWidth - width) / 2;
+    }
+
+    glViewport(x, y, adjustedWidth, adjustedHeight);
+    glScissor(0, 0, width, height);
+
+    glMatrixMode (GL_PROJECTION);										// Select The Projection Matrix
+    glLoadIdentity ();													// Reset The Projection Matrix
+
+    gluOrtho2D(0.0f, (float) width - 1.0f, 0.0f, (float) height - 1.0f);
+
+    glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix
+    glLoadIdentity();													// Reset The Modelview Matrix
+    
+    glDisable (GL_DEPTH_TEST);
+}
+
+int InitGL(void)												// All Setup For OpenGL Goes Here
+{
+    glClearColor (0.0f, 0.0f, 0.0f, 0.0f);						// Black Background
+    glClearDepth (1.0f);										// Depth Buffer Setup
+    glDepthFunc (GL_LEQUAL);									// The Type Of Depth Testing (Less Or Equal)
+    glEnable (GL_DEPTH_TEST);									// Enable Depth Testing
+    glShadeModel (GL_SMOOTH);									// Select Smooth Shading
+    glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);			// Set Perspective Calculations To Most Accurate
+
+    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);						// Set Line Antialiasing
+    //glEnable(GL_LINE_SMOOTH);									// Enable it!
+
+    glEnable(GL_CULL_FACE);										// do not calculate inside of poly's
+    glFrontFace(GL_CCW);										// counter clock-wise polygons are out
+
+    glEnable(GL_TEXTURE_2D);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glEnable(GL_SCISSOR_TEST);									// Enable Clipping
+    //glScissor(20, 20, 320, 240);
+
+    return TRUE;												// Initialization Went OK
+}
+
+
+int InitGame(void)
+{
+    g_engine = JGE::GetInstance();
+
+    //JGameLauncher *launcher = new JGameLauncher();
+    g_app = g_launcher->GetGameApp();
+    g_app->Create();
+    g_engine->SetApp(g_app);
+
+    JRenderer::GetInstance()->Enable2D();
+
+    lastTickCount = GetTickCount();
+
+    ZeroMemory(g_keys, 256);
+    ZeroMemory(g_holds, 256);
+
+    //delete launcher;
+
+    return TRUE;
+}
+
+
+void DestroyGame(void)
+{
+    //	JParticleSystem::Destroy();
+    //	JMotionSystem::Destroy();
+
+    g_engine->SetApp(NULL);
+    if (g_app)
+    {
+        g_app->Destroy();
+        delete g_app;
+        g_app = NULL;
+    }
+
+    JGE::Destroy();
+
+    g_engine = NULL;
+
+}
+
+
+int DrawGLScene(void)									// Here's Where We Do All The Drawing
+{
+
+    // 	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// Clear Screen And Depth Buffer
+    // 	glLoadIdentity ();											// Reset The Modelview Matrix
+
+    //if (g_app)
+    //	g_app->Render();
+    g_engine->Render();
+
+    //	glFlush ();
+
+    return TRUE;										// Everything Went OK
+}
+
+void Update(float dt)
+{
+    g_engine->SetDelta(dt);
+    g_engine->Update(dt);
+}
+
+void KillGLWindow(void)								// Properly Kill The Window
+{
+    if (gDisplayMode == DisplayMode_fullscreen)
+    {
+        ChangeDisplaySettings(NULL,0);					// If So Switch Back To The Desktop
+        ShowCursor(TRUE);								// Show Mouse Pointer
+    }
+
+    if (hRC)											// Do We Have A Rendering Context?
+    {
+        if (!wglMakeCurrent(NULL,NULL))					// Are We Able To Release The DC And RC Contexts?
+            MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
+        if (!wglDeleteContext(hRC))						// Are We Able To Delete The RC?
+            MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
+        hRC=NULL;										// Set RC To NULL
+    }
+
+    if (hDC && !ReleaseDC(hWnd,hDC))					// Are We Able To Release The DC
+    {
+        MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
+        hDC=NULL;										// Set DC To NULL
+    }
+
+    if (hWnd && !DestroyWindow(hWnd))					// Are We Able To Destroy The Window?
+    {
+        MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
+        hWnd=NULL;										// Set hWnd To NULL
+    }
+
+    if (!UnregisterClass("OpenGL",hInstance))			// Are We Able To Unregister Class
+    {
+        MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
+        hInstance=NULL;									// Set hInstance To NULL
+    }
+}
+
+/*	This Code Creates Our OpenGL Window.  Parameters Are:					*
+ *	title			- Title To Appear At The Top Of The Window				*
+ *	bits			- Number Of Bits To Use For Color (8/16/24/32)			*/
+BOOL CreateGLWindow(char* title, int width, int height, int bits)
+{
+    int actualScreenWidth = ::GetSystemMetrics(SM_CXSCREEN);
+    int actualScreenHeight = ::GetSystemMetrics(SM_CYSCREEN);
+
+    JRenderer::GetInstance()->SetActualWidth(static_cast<float>(width));
+    JRenderer::GetInstance()->SetActualHeight(static_cast<float>(height));
+
+
+    GLuint		pixelFormat;			// Holds The Results After Searching For A Match
+    WNDCLASS	wc;						// Windows Class Structure
+    DWORD		dwExStyle;				// Window Extended Style
+    DWORD		dwStyle;				// Window Style
+    RECT		windowRect;				// Grabs Rectangle Upper Left / Lower Right Values
+
+    windowRect.left = (long) 0;
+    windowRect.top = (long) 0;
+
+    if (gDisplayMode != DisplayMode_fullscreen)
+    {
+        windowRect.left = (actualScreenWidth - width) / 2;
+        windowRect.top = (actualScreenHeight - height) / 2;
+    }
+
+    windowRect.right = windowRect.left + (long)width;		// Set Right Value To Requested Width
+    windowRect.bottom = windowRect.top + (long)height;		// Set Bottom Value To Requested Height
+
+    hInstance			= GetModuleHandle(NULL);				// Grab An Instance For Our Window
+    wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;	// Redraw On Size, And Own DC For Window.
+    wc.lpfnWndProc	= (WNDPROC) WndProc;					// WndProc Handles Messages
+    wc.cbClsExtra		= 0;									// No Extra Window Data
+    wc.cbWndExtra		= 0;									// No Extra Window Data
+    wc.hInstance		= hInstance;							// Set The Instance
+    wc.hIcon			  = LoadIcon(NULL, IDI_WINLOGO);			// Load The Default Icon
+    wc.hCursor			= LoadCursor(NULL, IDC_ARROW);			// Load The Arrow Pointer
+    wc.hbrBackground	= NULL;									// No Background Required For GL
+    wc.lpszMenuName		= NULL;									// We Don't Want A Menu
+    wc.lpszClassName	= "OpenGL";								// Set The Class Name
+
+    if (!RegisterClass(&wc))									// Attempt To Register The Window Class
+    {
+        MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;											// Return FALSE
+    }
+
+    if (gDisplayMode == DisplayMode_fullscreen)                 // Attempt Fullscreen Mode?
+    {
+        DEVMODE dmScreenSettings;								// Device Mode
+        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));	// Makes Sure Memory's Cleared
+        dmScreenSettings.dmSize=sizeof(dmScreenSettings);		// Size Of The Devmode Structure
+        dmScreenSettings.dmPelsWidth	= actualScreenWidth;	// Selected Screen Width
+        dmScreenSettings.dmPelsHeight	= actualScreenHeight;	// Selected Screen Height
+        dmScreenSettings.dmBitsPerPel	= bits;					// Selected Bits Per Pixel
+        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
+
+        // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
+        LONG result = ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN);
+        if (result != DISP_CHANGE_SUCCESSFUL)
+        {
+            // If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
+            if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
+            {
+                gDisplayMode = DisplayMode_lowRes;		// Windowed Mode Selected.  
+            }
+            else
+            {
+                // Pop Up A Message Box Letting User Know The Program Is Closing.
+                MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
+                return FALSE;									// Return FALSE
+            }
+        }
+    }
+
+    if (gDisplayMode == DisplayMode_fullscreen)                 // Are We Still In Fullscreen Mode?
+    {
+        dwExStyle=WS_EX_APPWINDOW;								// Window Extended Style
+        dwStyle=WS_POPUP;										// Windows Style
+        ShowCursor(FALSE);										// Hide Mouse Pointer
+    }
+    else
+    {
+        dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;			// Window Extended Style
+        //dwStyle=WS_OVERLAPPEDWINDOW;							// Windows Style
+        dwStyle= WS_OVERLAPPED     | \
+            WS_CAPTION        | \
+            WS_MINIMIZEBOX	   |
+            WS_SIZEBOX	   |
+            WS_MAXIMIZEBOX	   |
+            //WS_MINIMIZE		|
+            WS_SYSMENU;//        |
+        //WS_THICKFRAME ;
+    }
+
+    AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);		// Adjust Window To True Requested Size
+
+    // Create The Window
+
+    if (hWnd == NULL)
+    {
+        if (!(hWnd=CreateWindowEx(	dwExStyle,							// Extended Style For The Window
+            "OpenGL",							// Class Name
+            title,								// Window Title
+            dwStyle |							// Defined Window Style
+            WS_CLIPSIBLINGS |					// Required Window Style
+            WS_CLIPCHILDREN,					// Required Window Style
+            windowRect.left, windowRect.top,	// Window Position
+            windowRect.right-windowRect.left,	// Calculate Window Width
+            windowRect.bottom-windowRect.top,	// Calculate Window Height
+            NULL,								// No Parent Window
+            NULL,								// No Menu
+            hInstance,							// Instance
+            NULL)))								// Dont Pass Anything To WM_CREATE
+        {
+            KillGLWindow();								// Reset The Display
+            MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+            return FALSE;								// Return FALSE
+        }
+    }
+
+    static	PIXELFORMATDESCRIPTOR pfd=				// pfd Tells Windows How We Want Things To Be
+    {
+        sizeof(PIXELFORMATDESCRIPTOR),				// Size Of This Pixel Format Descriptor
+        1,											// Version Number
+        PFD_DRAW_TO_WINDOW |						// Format Must Support Window
+        PFD_SUPPORT_OPENGL |						// Format Must Support OpenGL
+        PFD_DOUBLEBUFFER,							// Must Support Double Buffering
+        PFD_TYPE_RGBA,								// Request An RGBA Format
+        bits,										// Select Our Color Depth
+        0, 0, 0, 0, 0, 0,							// Color Bits Ignored
+        0,											// No Alpha Buffer
+        0,											// Shift Bit Ignored
+        0,											// No Accumulation Buffer
+        0, 0, 0, 0,									// Accumulation Bits Ignored
+        16,											// 16Bit Z-Buffer (Depth Buffer)
+        0,											// No Stencil Buffer
+        0,											// No Auxiliary Buffer
+        PFD_MAIN_PLANE,								// Main Drawing Layer
+        0,											// Reserved
+        0, 0, 0										// Layer Masks Ignored
+    };
+
+    if (!(hDC=GetDC(hWnd)))							// Did We Get A Device Context?
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    if (!(pixelFormat=ChoosePixelFormat(hDC,&pfd)))	// Did Windows Find A Matching Pixel Format?
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    if(!SetPixelFormat(hDC,pixelFormat,&pfd))		// Are We Able To Set The Pixel Format?
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    if (!(hRC=wglCreateContext(hDC)))				// Are We Able To Get A Rendering Context?
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    if(!wglMakeCurrent(hDC,hRC))					// Try To Activate The Rendering Context
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    ShowWindow(hWnd,SW_SHOW);						// Show The Window
+    SetForegroundWindow(hWnd);						// Slightly Higher Priority
+    SetFocus(hWnd);									// Sets Keyboard Focus To The Window
+    ReSizeGLScene(width, height);					// Set Up Our Perspective GL Screen
+
+    if (!InitGL())									// Initialize Our Newly Created GL Window
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    return TRUE;									// Success
+}
+
+LRESULT CALLBACK WndProc(
+    HWND	hWnd,			// Handle For This Window
+    UINT	uMsg,			// Message For This Window
+    WPARAM	wParam,			// Additional Message Information
+    LPARAM	lParam)			// Additional Message Information
+{
+    switch (uMsg)									// Check For Windows Messages
+    {
+    case WM_ACTIVATE:							// Watch For Window Activate Message
+        {
+            if (!HIWORD(wParam))					// Check Minimization State
+            {
+                active=TRUE;						// Program Is Active
+                if (g_engine != NULL)
+                    g_engine->Resume();
+            }
+            else
+            {
+                active=FALSE;						// Program Is No Longer Active
+                if (g_engine != NULL)
+                    g_engine->Pause();
+            }
+
+            return 0;								// Return To The Message Loop
+        }
+
+    case WM_SYSCOMMAND:							// Intercept System Commands
+        {
+            switch (wParam)							// Check System Calls
+            {
+            case SC_SCREENSAVE:					// Screensaver Trying To Start?
+            case SC_MONITORPOWER:				// Monitor Trying To Enter Powersave?
+                return 0;							// Prevent From Happening
+            }
+            break;									// Exit
+        }
+
+    case WM_CLOSE:								// Did We Receive A Close Message?
+        {
+            PostQuitMessage(0);						// Send A Quit Message
+            return 0;								// Jump Back
+        }
+
+    case WM_KEYDOWN:												// Update Keyboard Buffers For Keys Pressed
+        if ((wParam >= 0) && (wParam <= 255))						// Is Key (wParam) In A Valid Range?
+        {
+            g_engine->HoldKey_NoRepeat(wParam);
+            return 0;
+        }
+        break;															// Break
+
+    case WM_KEYUP:													// Update Keyboard Buffers For Keys Released
+        if ((wParam >= 0) && (wParam <= 255))						// Is Key (wParam) In A Valid Range?
+        {
+            g_engine->ReleaseKey(wParam);
+            return 0;												// Return
+        }
+        break;
+
+    case WM_LBUTTONDOWN:
+        {
+            return 0;
+        }
+
+    case WM_LBUTTONUP:
+        {
+            return 0;
+        }
+
+    case WM_RBUTTONDOWN:
+        {
+            return 0;
+        }
+
+    case WM_RBUTTONUP:
+        {
+            return 0;
+        }
+
+    case WM_MOUSEMOVE:
+        {
+            //			Mint2D::SetMousePosition(LOWORD(lParam), HIWORD(lParam));
+            return 0;
+        }
+
+    case WM_SIZE:								// Resize The OpenGL Window
+        {
+            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
+            return 0;								// Jump Back
+        }
+    }
+
+    // Pass All Unhandled Messages To DefWindowProc
+    return DefWindowProc(hWnd,uMsg,wParam,lParam);
+}
+
+bool JGEToggleFullscreen()
+{
+     //cycle between the display modes
+    ++gDisplayMode;
+    if (gDisplayMode > DisplayMode_fullscreen)
+        gDisplayMode = DisplayMode_lowRes;
+
+    int width = 0, height = 0;
+
+    int actualScreenWidth = ::GetSystemMetrics(SM_CXSCREEN);
+    int actualScreenHeight = ::GetSystemMetrics(SM_CYSCREEN);
+
+    switch (gDisplayMode)
+    {
+    case DisplayMode_fullscreen:
+        width = actualScreenWidth;
+        height = actualScreenHeight;
+        break;
+
+    case DisplayMode_hiRes:
+        width = SCREEN_WIDTH * 2;
+        height = SCREEN_HEIGHT * 2;
+        break;
+
+    case DisplayMode_lowRes:
+    default:
+        width = SCREEN_WIDTH;
+        height = SCREEN_HEIGHT;
+        break;
+    }
+
+    DWORD dwExStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
+    DWORD dwStyle = GetWindowLong(hWnd, GWL_STYLE);
+
+    if (gDisplayMode == DisplayMode_fullscreen)
+    {
+        dwExStyle &= ~(WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE);
+        dwStyle &= ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU);
+    }
+    else
+    {
+        dwExStyle |= WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
+        dwStyle |= WS_OVERLAPPEDWINDOW;
+    }
+
+
+    int x = (actualScreenWidth - width) / 2;
+    int y = (actualScreenHeight - height) / 2;
+
+    RECT windowRect;
+    windowRect.left = x;
+    windowRect.top = y;
+
+    windowRect.right = windowRect.left + width;		
+    windowRect.bottom = windowRect.top + height;
+
+    AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);
+
+    DEVMODE dmScreenSettings;								// Device Mode
+    memset(&dmScreenSettings,0,sizeof(dmScreenSettings));	// Makes Sure Memory's Cleared
+    dmScreenSettings.dmSize=sizeof(dmScreenSettings);		// Size Of The Devmode Structure
+    dmScreenSettings.dmPelsWidth	= width;	            // Selected Screen Width
+    dmScreenSettings.dmPelsHeight	= height;	            // Selected Screen Height
+    dmScreenSettings.dmBitsPerPel	= 32;					// Selected Bits Per Pixel
+    dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
+
+    // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
+    LONG result = ChangeDisplaySettings(&dmScreenSettings, gDisplayMode == DisplayMode_fullscreen ? CDS_FULLSCREEN : 0);
+
+    SetWindowLong(hWnd,
+        GWL_EXSTYLE,
+        dwExStyle);
+    SetWindowLong(hWnd,
+        GWL_STYLE,
+        dwStyle);
+
+    SetWindowPos(hWnd, NULL, windowRect.left, windowRect.top, windowRect.right - windowRect.left, windowRect.bottom - windowRect.top, SWP_NOZORDER | SWP_FRAMECHANGED);
+
+    ReSizeGLScene(width, height);
+
+    return true;
+}
+
+int WINAPI WinMain(
+    HINSTANCE	hInstance,			// Instance
+    HINSTANCE	hPrevInstance,		// Previous Instance
+    LPSTR		lpCmdLine,			// Command Line Parameters
+    int			nCmdShow)			// Window Show State
+{
+    MSG		msg;									// Windows Message Structure
+    BOOL	done=FALSE;								// Bool Variable To Exit Loop
+
+    DWORD	tickCount;
+    int		dt;
+
+    g_launcher = new JGameLauncher();
+
+    u32 flags = g_launcher->GetInitFlags();
+
+    JGECreateDefaultBindings();
+
+    if ((flags&JINIT_FLAG_ENABLE3D)!=0)
+        JRenderer::Set3DFlag(true);
+
+    // Create Our OpenGL Window
+    if (!CreateGLWindow(g_launcher->GetName(),SCREEN_WIDTH,SCREEN_HEIGHT,32))
+    {
+        return 0;									// Quit If Window Was Not Created
+    }
+
+    if (!InitGame())								// Initialize Our Game
+    {
+        KillGLWindow();								// Reset The Display
+        MessageBox(NULL,"Game Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+        return FALSE;								// Return FALSE
+    }
+
+    while(!done)									// Loop That Runs While done=FALSE
+    {
+        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))	// Is There A Message Waiting?
+        {
+            if (msg.message==WM_QUIT)				// Have We Received A Quit Message?
+            {
+                done=TRUE;							// If So done=TRUE
+            }
+            else									// If Not, Deal With Window Messages
+            {
+                TranslateMessage(&msg);				// Translate The Message
+                DispatchMessage(&msg);				// Dispatch The Message
+            }
+        }
+        else										// If There Are No Messages
+        {
+            // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
+            if (active)								// Program Active?
+            {
+                if (g_engine->IsDone())
+                    done=TRUE;						// ESC Signalled A Quit
+                else								// Not Time To Quit, Update Screen
+                {
+                    tickCount = GetTickCount();					// Get The Tick Count
+                    dt = (tickCount - lastTickCount);
+                    lastTickCount = tickCount;
+                    Update((float)dt/1000.0f);									// Update frame
+
+                    //Mint2D::BackupKeys();
+
+                    DrawGLScene();					// Draw The Scene
+                    SwapBuffers(hDC);				// Swap Buffers (Double Buffering)
+                }
+            }
+        }
+    }
+
+    if (g_launcher)
+        delete g_launcher;
+
+    // Shutdown
+    DestroyGame();
+    KillGLWindow();								// Kill The Window
+    return (msg.wParam);							// Exit The Program
+}