upped build number

don't know if we can compute travis build number minus the last build of
this

.travis.yml

@@ -1,24 +1,65 @@
 language: cpp
+branches:
+  except:
+    - latest-master
+
 before_install:
-- export PSPDEV="$TRAVIS_BUILD_DIR/opt/pspsdk"
-- export PSPSDK="$PSPDEV/psp/sdk"
-- export PATH="$PATH:$PSPDEV/bin:$PSPSDK/bin"
-- export ANDROID="android-sdk-linux/tools/android"
+  - export BUILD_PSP=YES
+  - export BUILD_ANDROID=YES
+  - export BUILD_Qt=YES
+  - export BUILD_MAC=NO
+# Only building on Mac when not handling pull request
+  - if [ "$TRAVIS_PULL_REQUEST" ==  "false" ]; then
+      export BUILD_MAC=YES;
+    fi
+  - sudo apt-get update -qq
+# Building for PSP here
+  - if [ "$BUILD_PSP" == "YES" ]; then
+      export PSPDEV="$TRAVIS_BUILD_DIR/opt/pspsdk" &&
+      export PSPSDK="$PSPDEV/psp/sdk" &&
+      export PATH="$PATH:$PSPDEV/bin:$PSPSDK/bin" &&
+      wget -O sdk.lzma http://superb-sea2.dl.sourceforge.net/project/minpspw/SDK%20%2B%20devpak/pspsdk%200.11.2/minpspw_0.11.2-amd64.tar.lzma;
+    fi
+# Building for Qt here
+  - if [ "$BUILD_Qt" == "YES" ]; then
+      sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu trusty universe" &&
+      sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu trusty main" &&
+      sudo apt-get -qq update &&
+      sudo apt-get -qq install qt5-qmake qtbase5-dev qtdeclarative5-dev qttools5-dev qtmultimedia5-dev pulseaudio libpulse-dev &&
+      export QMAKE="qmake -qt=qt5";
+    fi
+# Building for Android here
+  - if [ "$BUILD_ANDROID" == "YES" ]; then
+      export ANDROID="android-sdk-linux/tools/android" &&
+      if [ `uname -m` = x86_64 ]; then sudo apt-get install -qq --force-yes libgd2-xpm ia32-libs ia32-libs-multiarch jq; fi &&
+      wget http://dl.google.com/android/ndk/android-ndk-r9-linux-x86_64.tar.bz2 -nv &&
+      wget http://dl.google.com/android/android-sdk_r24.3.4-linux.tgz -nv;
+    fi
+    
 install:
-- sudo apt-get update -qq
-- if [ `uname -m` = x86_64 ]; then sudo apt-get install -qq --force-yes libgd2-xpm ia32-libs ia32-libs-multiarch jq; fi
-- wget -O sdk.lzma http://sourceforge.net/projects/minpspw/files/SDK%20%2B%20devpak/pspsdk%200.11.2/minpspw_0.11.2-amd64.tar.lzma/download
-- tar -x --xz -f sdk.lzma
-- wget http://dl.google.com/android/ndk/android-ndk-r9-linux-x86_64.tar.bz2 -nv
-- wget http://dl.google.com/android/android-sdk_r22-linux.tgz -nv
-- tar --absolute-names -jxf android-ndk-r9-linux-x86_64.tar.bz2
-- tar -zxf android-sdk_r22-linux.tgz
-- $ANDROID list sdk -a
-- echo yes | $ANDROID update sdk -a --filter 1,2,4,18 --no-ui --force > log.txt
+- if [ "$BUILD_PSP" == "YES" ]; then
+    tar -x --xz -f sdk.lzma;
+  fi
+- if [ "$BUILD_ANDROID" == "YES" ]; then
+    tar --absolute-names -jxf android-ndk-r9-linux-x86_64.tar.bz2 &&
+    tar -zxf android-sdk_r24.3.4-linux.tgz &&
+    $ANDROID list sdk --extended -a &&
+    echo yes | $ANDROID update sdk -a -t tools,platform-tools,build-tools-23.0.1,android-10 --no-ui --force --no-https;
+  fi
 - sudo pip install pyjavaproperties
-script: ./travis-script.sh
+- sudo pip install github3.py
+- sudo pip install cpp-coveralls
+
 env:
   global:
-    secure: YocijVYZa1oDPviFubPIpmBmXyw0gQ7D0YA6tC01wExXvY+8tGUh1HQ5uXn8LotRZ+Ob5HLHDaCzkKWF8+57ILSMeHrnf6tcRyyeO7wjNY9P7WvSZyCjvqnWzsUN9tiMmsEzhTz2MaUgsY6ocB/4nbWZwfQvL7z+s7z41R4J1I4=
-script: "./travis-script.sh"
-after_success: ./upload-binaries.sh
+  - secure: "EBzr1+qjQsOhn0s+tcFmXR1jP9B0xiOSXuXbRXWZ1OEHNvp8+A5/pS84LYVFlaZqmxr5dApxvPtwhgLIUbQ3EPXm8LpC3KgSD4dS+9/QMbxhe5TK4oczgFRGcDTMJQZsCzhOh7hp3tbcbJg5Gp+VT7aFjFQSHDGwhzSJXsXwh/8="
+  - secure: "X5dTQfofqAutnXxmu11Ep2MQ5QYnMN8m0AITRtwymhEF2UclcOudI1+skPtuhAGbWQnSO+lhunV3cvMfw2/Ml3k/VDz6VdFSKFrzAu7ja1VLJfcxr7chi0s8q30pVBb66tGydjIBac3B+RQyqgmZQW1frbRrhC/kPFQ6wPWOJdQ="
+  - secure: "T97NUPnxCpVZ/c5HH0zfo0FO3DPSRMSmze58ubW5EUTZOjAMtEt+OFdsrNZvUTCugUj2M1agtonZbAbczpaAL+lgZcHDgXgWMkfO0pMnsWX1yyCNqMuE/iTMpJr/xsLQeyWlftWjJLsseQU45abZsd1XVmda/G+ZhrDLF1y55SA="
+
+script: "tools/travis-script.sh"
+
+after_success:
+- coveralls -b . -e JGE/src -e JGE/include -i projects/mtg/include -i projects/mtg/src --gcov-options '\-lp'
+- python tools/upload-binaries.py -t $GH_TOKEN -s $TRAVIS_COMMIT -l core.zip -r Wagic-core.zip -b $TRAVIS_BRANCH
+- python tools/upload-binaries.py -t $GH_TOKEN -s $TRAVIS_COMMIT -l projects/mtg/Android/bin/Wagic-debug.apk -r Wagic-android.apk -b $TRAVIS_BRANCH
+- python tools/upload-binaries.py -t $GH_TOKEN -s $TRAVIS_COMMIT -l projects/mtg/psprelease.zip -r Wagic-psp.zip -b $TRAVIS_BRANCH

CHANGELOG.md

@@ -0,0 +1,190 @@
+# Changelog
+
+## [latest-master] (https://github.com/WagicProject/wagic/tree/latest-master)
+#### 7/7/16
+- *Merged pull-request:* Sorted Primitives and Cleanup Tabs [#\727] (https://github.com/WagicProject/wagic/pull/719) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* push to wagicproject [#\725] (https://github.com/WagicProject/wagic/pull/725) ([zethfoxster](https://github.com/zethfoxster))
+
+#### 7/4/16
+- *Merged pull-request:* Sorted Primitives & Updated Premium Deck Series [#\719] (https://github.com/WagicProject/wagic/pull/719) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* Fails but I have no idea why [#\717] (https://github.com/WagicProject/wagic/pull/717) ([zethfoxster](https://github.com/zethfoxster))
+
+- *Merged pull-request:* Updated Sets [#\715] (https://github.com/WagicProject/wagic/pull/715) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 7/2/16
+- *Merged pull-request:* Updated Masters, Beginners, Duels and Vault Sets [#\714] (https://github.com/WagicProject/wagic/pull/714) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 7/1/16
+- *Merged pull-request:* Cleaned and Sorted all Core and Expansion Sets [#\713] (https://github.com/WagicProject/wagic/pull/713) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* Soulbond Pair Indicator [#\712] (https://github.com/WagicProject/wagic/pull/712) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 6/30/16
+- *Merged pull-request:* Sorted Primitives [#\711] (https://github.com/WagicProject/wagic/pull/711) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* Add Shackle Ability [#\710] (https://github.com/WagicProject/wagic/pull/710) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* Fix Cascade, Crash fix on lastController and some corrections [#\709] (https://github.com/WagicProject/wagic/pull/709) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 6/29/16
+- *Merged pull-request:* Updated Primitives and Hide Highlight Border [#\707] (https://github.com/WagicProject/wagic/pull/707) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Committed:* Pretty huge patch here(sorry old habits never die :( )  [#\6ee00c1] (https://github.com/WagicProject/wagic/commit/6ee00c138ce374d54cb3ee034575ce440288ca0e) ([zethfoxster](https://github.com/zethfoxster))
+
+#### 6/23/16
+- *Merged pull-request:* Fix producecolor:color [#\704] (https://github.com/WagicProject/wagic/pull/704) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 6/17/16
+- *Merged pull-request:* Force Mounting 2 [#\699] (https://github.com/WagicProject/wagic/pull/699) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 6/16/16
+- *Merged pull-request:* Import Deck Options [#\697] (https://github.com/WagicProject/wagic/pull/697) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 6/11/16
+- *Merged pull-request:* Refactor & Devotion [#\690] (https://github.com/WagicProject/wagic/pull/690) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 6/9/16
+- *Closed issue:* Clone goes to graveyard before being able to copy anything [\#546](https://github.com/WagicProject/wagic/issues/546)
+
+- *Closed issue:* Blinking an aura causes freeze [\#541](https://github.com/WagicProject/wagic/issues/541)
+
+- *Closed issue:* Profile name at upper left side is not being updated correctly [\#469](https://github.com/WagicProject/wagic/issues/469)
+
+- *Closed issue:* Giving card C protection from X does not remove cards attached to C which have quality X [\#464](https://github.com/WagicProject/wagic/issues/464)
+
+- *Closed issue:* (graphical glitch) wood / gold textures [\#461](https://github.com/WagicProject/wagic/issues/461)
+
+- *Closed issue:* Clone does not get all P/T bonuses [\#448](https://github.com/WagicProject/wagic/issues/448)
+
+- *Closed issue:* Card "threaten" messes up the GUI [\#473](https://github.com/WagicProject/wagic/issues/473)
+
+#### 6/7/16
+- *Closed issue:* Emrakul isn't killed by creatures with deathtouch [\#597](https://github.com/WagicProject/wagic/issues/597)
+
+#### 6/3/16
+- *Merged pull-request:* Cost Increaser & Reducer Fix [#\676] (https://github.com/WagicProject/wagic/pull/676) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 5/30/16
+- *Fixed Bug:* deckstats crash when "unlock cards" is used [#\668] (https://github.com/WagicProject/wagic/issues/668) ([zethfoxster](https://github.com/zethfoxster))
+
+#### 5/26/16
+- *Closed issue:* Nasty memleak crashing devices and its fix. [#\664] (https://github.com/WagicProject/wagic/issues/664) ([zethfoxster](https://github.com/zethfoxster))
+
+#### 11/08/15
+- *Merged pull-request:* produce mana for lands you/opponent could produce [#\658] (https://github.com/WagicProject/wagic/pull/658) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 11/07/15
+- *Merged pull-request:* Manacost Changes, Anyzone for CDA, PayZero Cost [#\656] (https://github.com/WagicProject/wagic/pull/656) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 10/31/15
+- *Merged pull-request:* Exile Zone, Altercost and Hand modifier [#\653] (https://github.com/WagicProject/wagic/pull/653) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 10/17/15
+- *Merged pull-request:* Fix issue #473 #784 [#\646] (https://github.com/WagicProject/wagic/pull/646) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 10/15/15
+- *Merged pull-request:* Bug Fix: Planeswalker Rule & ABlink return to play ability for Aura cards [#\644] (https://github.com/WagicProject/wagic/pull/644) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 10/14/15
+- *Merged pull-request:* Fix Legend Rule [#\643] (https://github.com/WagicProject/wagic/pull/643) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 10/12/15
+- *Merged pull-request:* Fix crash bug, support doubled res texture for background, avatars, menutitle [#\641] (https://github.com/WagicProject/wagic/pull/641) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 10/02/15
+- *Merged pull-request:* LKI for power, toughness and basic abilities, produceextra ability [#\636] (https://github.com/WagicProject/wagic/pull/636) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 09/29/15
+- *Merged pull-request:* Fix Recover Cards, Cloner, Copier, and Preliminary support for Madness [#\635] (https://github.com/WagicProject/wagic/pull/635) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 09/22/15
+- *Merged pull-request:* Auraward, unattach event and statebased action for protection from quality [#\631] (https://github.com/WagicProject/wagic/pull/631) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 09/19/15
+- *Merged pull-request:* PT Switch like Layer 7e and Token Indicator [#\626] (https://github.com/WagicProject/wagic/pull/626) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 09/18/15
+- *Merged pull-request:* Token Cloning fix and colored PT [#\624] (https://github.com/WagicProject/wagic/pull/624) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 09/15/15
+- *Merged pull-request:* CDA and X manacost on stack [\#623] (https://github.com/WagicProject/wagic/pull/623) ([kevlahnota](https://github.com/kevlahnota))
+
+#### 08/12/14
+- *Merged pull-request:* Fix for guild_keywords Devotion, added some "Chroma" cards [\#606](https://github.com/WagicProject/wagic/pull/606) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* added guild keywords, added specific life cost [\#605](https://github.com/WagicProject/wagic/pull/605) ([kevlahnota](https://github.com/kevlahnota))
+
+- *Merged pull-request:* Buyback issue and a fix [\#604](https://github.com/WagicProject/wagic/pull/604) ([apollovy](https://github.com/apollovy))
+
+- *Merged pull-request:* Feature/ios update xcode5.1 [\#602](https://github.com/WagicProject/wagic/pull/602) ([mjnguyen](https://github.com/mjnguyen))
+
+- *Merged pull-request:* Remove dead code and fix circular initialization [\#601](https://github.com/WagicProject/wagic/pull/601) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* update android build tools version [\#600](https://github.com/WagicProject/wagic/pull/600) ([Rolzad73](https://github.com/Rolzad73))
+
+- *Merged pull-request:* Attempt to make android tools fetching for TravisCI explicit and futureproof [\#599](https://github.com/WagicProject/wagic/pull/599) ([Rolzad73](https://github.com/Rolzad73))
+
+- *Merged pull-request:* Damager keyword [\#598](https://github.com/WagicProject/wagic/pull/598) ([bjornsnoen](https://github.com/bjornsnoen))
+
+- *Merged pull-request:* Fix a rarity mistake and a grammatical error [\#596](https://github.com/WagicProject/wagic/pull/596) ([bjornsnoen](https://github.com/bjornsnoen))
+
+- *Merged pull-request:* Fix bug where the phase wheel got out of sync [\#588](https://github.com/WagicProject/wagic/pull/588) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* More easing [\#586](https://github.com/WagicProject/wagic/pull/586) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Added Avatar Tokens created by Ajani Goldmane. [\#585](https://github.com/WagicProject/wagic/pull/585) ([bjornsnoen](https://github.com/bjornsnoen))
+
+- *Merged pull-request:* Cleanup, usability fixes and source code documentation for DeckView.h and GridDeckView.h [\#583](https://github.com/WagicProject/wagic/pull/583) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Fixed bug:* Blight does not destroy at the end of turn but right now [\#592](https://github.com/WagicProject/wagic/issues/592)
+
+- *Fixed bug:* game freezes on Android when the phone returns from "sleep mode" [\#544](https://github.com/WagicProject/wagic/issues/544)
+
+- *Fixed bug:* Android port needs to be able to respond to attaching/detaching devices to it [\#522](https://github.com/WagicProject/wagic/issues/522)
+
+## [alpha-195] (https://github.com/WagicProject/wagic/tree/alpha-195)
+#### 07/12/13
+- *Merged pull-request:* Reset positions and filters when reopening the editor [\#578](https://github.com/WagicProject/wagic/pull/578) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Deck viewer [\#577](https://github.com/WagicProject/wagic/pull/577) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Do not specify the system directory in JGE [\#576](https://github.com/WagicProject/wagic/pull/576) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Changed Travis build file to use Android API 10 and Android build tools 18.1.1 [\#575](https://github.com/WagicProject/wagic/pull/575) ([Rolzad73](https://github.com/Rolzad73))
+
+- *Merged pull-request:* Feature/play from grave [\#574](https://github.com/WagicProject/wagic/pull/574) ([pankdm](https://github.com/pankdm))
+
+- *Merged pull-request:* Fix Valgrind warnings appearing during the test suit. [\#573](https://github.com/WagicProject/wagic/pull/573) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Strings 2 [\#572](https://github.com/WagicProject/wagic/pull/572) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Android travis ci [\#570](https://github.com/WagicProject/wagic/pull/570) ([xawotihs](https://github.com/xawotihs))
+
+- *Merged pull-request:* Android NDK build fix [\#569](https://github.com/WagicProject/wagic/pull/569) ([Rolzad73](https://github.com/Rolzad73))
+
+- *Merged pull-request:* Add a few namespaces and fix header guards. [\#564](https://github.com/WagicProject/wagic/pull/564) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Updated deckmenu.cpp to properly render deck description and summary [\#562](https://github.com/WagicProject/wagic/pull/562) ([citiral](https://github.com/citiral))
+
+- *Merged pull-request:* Fix some valgrind memcheck warnings. However there remains one... [\#561](https://github.com/WagicProject/wagic/pull/561) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Remove some dead code [\#560](https://github.com/WagicProject/wagic/pull/560) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Show output only for failing tests [\#559](https://github.com/WagicProject/wagic/pull/559) ([pankdm](https://github.com/pankdm))
+
+- *Merged pull-request:* Defines/Typos [\#557](https://github.com/WagicProject/wagic/pull/557) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Simplify Damage::resolve a bit [\#556](https://github.com/WagicProject/wagic/pull/556) ([ZobyTwo](https://github.com/ZobyTwo))
+
+- *Merged pull-request:* Fix cranial plating [\#555](https://github.com/WagicProject/wagic/pull/555) ([pankdm](https://github.com/pankdm))
+
+- *Merged pull-request:* Android cleanup [\#1](https://github.com/WagicProject/wagic/pull/1) ([Rolzad73](https://github.com/Rolzad73))
+
+- *Fixed bug:* Iona and Nin don't work [\#527](https://github.com/WagicProject/wagic/issues/527)
+
+- *Closed issue:* Less verbose output of tests at Travis [\#558](https://github.com/WagicProject/wagic/issues/558)
+
+## [wagic-0.19.2] (https://github.com/WagicProject/wagic/tree/wagic-v0.19.2)
+#### 28/10/13

JGE/include/Downloader.h

@@ -0,0 +1,128 @@
+#ifndef DOWNLOADER_H
+#define DOWNLOADER_H
+
+//-------------------------------------------------------------------------------------
+//
+// This class handles download of remote resources (any kind of file)
+// All the resources are stored locally in the userPath
+// For every resources, the downloader verifies if the resource was modifed
+// on the server before downloading the update. The Downloader maintains a catalogue
+// of resource downloaded to be able to check if they need to be updated.
+//
+// The interface can be used completly synchronously by the application and some
+// context or message loop is needed in the implementation of this interface
+//
+// Note that the Downloader could in theory by implemented on top of JNetwork.
+//
+//-------------------------------------------------------------------------------------
+#include <string>
+#include <ostream>
+#include <istream>
+#include <fstream>
+#include <map>
+#include "Threading.h"
+#ifdef QT_CONFIG
+#include <QObject>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QNetworkAccessManager>
+#endif
+
+using namespace std;
+
+class DownloadRequest
+        #ifdef QT_CONFIG
+        : public QObject
+        #endif
+{
+#ifdef QT_CONFIG
+    Q_OBJECT
+
+private slots:
+#endif
+    void fileDownloaded();
+    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+
+#ifdef QT_CONFIG
+signals:
+    void percentChanged(int percent);
+    void statusChanged(int);
+#endif
+
+public:
+    typedef enum {
+        NOT_PRESENT,
+        DOWNLOADING,
+        DOWNLOADED,
+        DOWNLOAD_ERROR
+    } DownloadStatus;
+
+protected:
+    string mLocalPath;
+    string mRemoteResourceURL;
+    // previous one is the original, next one can change after redirection
+    string mRequestedRemoteResourceURL;
+    string mETag;
+    DownloadStatus mDownloadStatus;
+    bool mUpgradeAvailable;
+    size_t mTotalSize;
+    size_t mCurrentSize;
+    ofstream mFile;
+#ifdef QT_CONFIG
+    QNetworkReply* mNetworkReply;
+    static QNetworkAccessManager networkAccessManager;
+#endif
+
+
+public:
+    DownloadRequest(string localPath="",
+                    string remoteResourceURL="",
+                    string ETag = "",
+                    DownloadStatus downloadStatus=NOT_PRESENT,
+                    size_t totalSize = 0,
+                    size_t currentSize = 0);
+    ~DownloadRequest();
+    static bool NetworkIsAccessible();
+
+    string getTempLocalPath() const { return (mLocalPath+".tmp"); };
+    string getLocalPath() const { return mLocalPath; };
+    string getRemoteResource() const { return mRemoteResourceURL; };
+    string getETag() const { return mETag; };
+    void startGet();
+    void startHead();
+    DownloadStatus getDownloadStatus() const { return mDownloadStatus; };
+    bool upgradeAvailable() const { return mUpgradeAvailable; };
+    void getSizes(size_t& totalSize, size_t&currentSize) {
+        totalSize = mTotalSize;
+        currentSize = mCurrentSize;
+    };
+
+    friend ostream& operator<<(ostream& out, const DownloadRequest& d);
+    friend istream& operator>>(istream&, DownloadRequest&);
+    friend class Downloader;
+};
+
+
+class Downloader
+{
+protected:
+    Downloader(string globalRemoteURL="", string localCacheRecords="");
+    virtual ~Downloader();
+    static Downloader* mInstance;
+    string mGlobalRemoteURL;
+    string mLocalCacheRecords;
+    boost::mutex mMutex;
+    map<string, DownloadRequest*> mRequestMap;
+
+public:
+    static Downloader* GetInstance();
+    static void Release();
+
+    void Update();
+    DownloadRequest* Get(string localPath, string remoteResourceURL="");
+
+    friend ostream& operator<<(ostream& out, const Downloader& d);
+    friend istream& operator>>(istream&, Downloader&);
+};
+
+#endif // DOWNLOADER_H

JGE/include/JAnimator.h

@@ -297,7 +297,6 @@ public:
 private:
 	float mTimer;
 	float mFrameTime;
-	JAnimator* mAnimator;
 	vector<JAnimatorObject *> mObjects;
 
 };

JGE/include/JDistortionMesh.h

@@ -37,7 +37,6 @@ private:
 	float mTexY;
 	float mTexWidth;
 	float mTexHeight;
-	JTexture* mTexture;
 	JQuad* mQuad;
 	
 	

JGE/include/JFileSystem.h

@@ -128,6 +128,7 @@ public:
     bool readIntoString(const string & FilePath, string & target);
     bool openForWrite(ofstream & File, const string & FilePath, ios_base::openmode mode = ios_base::out );
     bool Rename(string from, string to);
+    bool Remove(string aFile);
 
     //Returns true if strFilename exists somewhere in the fileSystem
     bool FileExists(const string& strFilename);
@@ -163,4 +164,4 @@ protected:
 
 
 
-#endif
+#endif

JGE/include/JLBFont.h

@@ -178,8 +178,6 @@ private:
 	float       mSpacing;
 
 	PIXEL_TYPE		mColor;
-	int			mBlend;
-
 	int			mBase;
 
 };

JGE/include/JRenderer.h

@@ -598,8 +598,6 @@ private:
   GLint     prog2_positionLoc;
   GLint     prog2_texCoordLoc;
   GLint     prog2_colorLoc;
-  // MVP matrix
-  ESMatrix  prog2_mvpMatrix;
   // Uniform locations
   GLint     prog2_mvpLoc;
 
@@ -612,13 +610,11 @@ private:
   int mCurrentTextureFormat;
 #endif
 
+#ifdef PSP
 	bool mVsync;
-
+    int mTexCounter;
+#endif
 	int mSwizzle;
-	int mTexCounter;
-  
-
-
 	int mCurrentTextureFilter;
 
 	int mCurrTexBlendSrc;

JGE/include/JSoundSystem.h

@@ -23,28 +23,32 @@
 #include "SLES/OpenSLES_Android.h"
 
 #elif defined USE_PHONON
-    #include <phonon/AudioOutput>
-    #include <phonon/MediaObject>
+#include <phonon/AudioOutput>
+#include <phonon/MediaObject>
+#elif (defined QT_CONFIG)
+#include "QMediaPlayer"
+#include "QMediaPlaylist"
+#include "QSoundEffect"
 #elif defined WIN32
-    #include <windows.h>
+#include <windows.h>
 #define WITH_FMOD
 #elif defined (PSP)
-    #include <pspgu.h>
-    #include <pspkernel.h>
-    #include <pspdisplay.h>
-    #include <pspdebug.h>
-    #include <pspctrl.h>
-    #include <time.h>
-    #include <string.h>
-    #include <pspaudiolib.h>
-    #include <psprtc.h>
+#include <pspgu.h>
+#include <pspkernel.h>
+#include <pspdisplay.h>
+#include <pspdebug.h>
+#include <pspctrl.h>
+#include <time.h>
+#include <string.h>
+#include <pspaudiolib.h>
+#include <psprtc.h>
 
-    #include "JAudio.h"
-    #include "JMP3.h"
+#include "JAudio.h"
+#include "JMP3.h"
 #endif
 
 #ifdef WITH_FMOD
-    #include "../Dependencies/include/fmod.h"
+#include "../Dependencies/include/fmod.h"
 #endif
 
 //------------------------------------------------------------------------------------------------
@@ -67,7 +71,7 @@ public:
 #ifdef USE_PHONON
     Phonon::AudioOutput* mOutput;
     Phonon::MediaObject* mMediaObject;
-    public slots:
+public slots:
     void seekAtTheBegining();
 #elif defined (PSP)
     JMP3* mTrack;
@@ -82,6 +86,10 @@ public:
     SLPlayItf playInterface;
     SLSeekItf seekInterface;
     SLVolumeItf musicVolumeInterface;
+#elif (defined QT_CONFIG)
+    QMediaPlaylist* playlist;
+    QMediaPlayer* player;
+    string fullpath;
 #else
     void* mTrack;
 #endif  //WITH_FMOD
@@ -92,13 +100,15 @@ public:
 //------------------------------------------------------------------------------------------------    
 class JSample
 {
- public:
+public:
     JSample();
     ~JSample();
 
     unsigned long fileSize();
-
-#if defined (PSP)
+#if (defined QT_CONFIG) && (!defined USE_PHONON)
+    QMediaPlayer* effect;
+    void* mSample;
+#elif defined (PSP)
     WAVDATA *mSample;
 #elif defined (IOS)
     std::string filename;
@@ -133,126 +143,130 @@ class JSoundSystem
 
 public:
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Get the singleton instance
-	///
-	//////////////////////////////////////////////////////////////////////////
-	static JSoundSystem* GetInstance();
+    //////////////////////////////////////////////////////////////////////////
+    /// Get the singleton instance
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    static JSoundSystem* GetInstance();
 
-	static void Destroy();
+    static void Destroy();
 
 
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Load music.
-	///
-	/// @note MP3 is the only supported format for the moment.
-	///
-	/// @param filename - Name of the music file.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	JMusic *LoadMusic(const char *fileName);
+    //////////////////////////////////////////////////////////////////////////
+    /// Load music.
+    ///
+    /// @note MP3 is the only supported format for the moment.
+    ///
+    /// @param filename - Name of the music file.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    JMusic *LoadMusic(const char *fileName);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Delete music from memory.
-	///
-	/// @param music - Music to be deleted.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	//void FreeMusic(JMusic *music);
+    //////////////////////////////////////////////////////////////////////////
+    /// Delete music from memory.
+    ///
+    /// @param music - Music to be deleted.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    //void FreeMusic(JMusic *music);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Play music.
-	///
-	/// @param music - Music to be played.
-	/// @param looping - Play the music in a loop.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	void PlayMusic(JMusic *music, bool looping = false);
+    //////////////////////////////////////////////////////////////////////////
+    /// Play music.
+    ///
+    /// @param music - Music to be played.
+    /// @param looping - Play the music in a loop.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    void PlayMusic(JMusic *music, bool looping = false);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Stop playing.
-	///
-	/// @param music - Music to be stopped.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	void StopMusic(JMusic *music);
+    //////////////////////////////////////////////////////////////////////////
+    /// Stop playing.
+    ///
+    /// @param music - Music to be stopped.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    void StopMusic(JMusic *music);
 
     
-	//////////////////////////////////////////////////////////////////////////
-	/// Resume playing.
-	///
-	/// @param music - Music to be resumed.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	void ResumeMusic(JMusic *music);
+    //////////////////////////////////////////////////////////////////////////
+    /// Resume playing.
+    ///
+    /// @param music - Music to be resumed.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    void ResumeMusic(JMusic *music);
     
-	//////////////////////////////////////////////////////////////////////////
-	/// Pause playing.
-	///
-	/// @param music - Music to be paused.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	void PauseMusic(JMusic *music);
+    //////////////////////////////////////////////////////////////////////////
+    /// Pause playing.
+    ///
+    /// @param music - Music to be paused.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    void PauseMusic(JMusic *music);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Load sound effect.
-	///
-	/// @note WAV sound effect only.
-	///
-	/// @param fileName - Sound effect for loading.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	JSample *LoadSample(const char *fileName);
+    //////////////////////////////////////////////////////////////////////////
+    /// Load sound effect.
+    ///
+    /// @note WAV sound effect only.
+    ///
+    /// @param fileName - Sound effect for loading.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    JSample *LoadSample(const char *fileName);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Delete sound effect from memory.
-	///
-	/// @param sample - Sound to be deleted.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	//void FreeSample(JSample *sample);
+    //////////////////////////////////////////////////////////////////////////
+    /// Delete sound effect from memory.
+    ///
+    /// @param sample - Sound to be deleted.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    //void FreeSample(JSample *sample);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Play sound effect.
-	///
-	/// @param sample - Sound for playing.
-	///
-	//////////////////////////////////////////////////////////////////////////
-	void PlaySample(JSample *sample);
+    //////////////////////////////////////////////////////////////////////////
+    /// Play sound effect.
+    ///
+    /// @param sample - Sound for playing.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    void PlaySample(JSample *sample);
 
-	//////////////////////////////////////////////////////////////////////////
-	/// Set volume for audio playback.
-	///
-	/// @param volume - New volume.
-	///
-	//////////////////////////////////////////////////////////////////////////
-  void SetVolume(int volume);
+    //////////////////////////////////////////////////////////////////////////
+    /// Set volume for audio playback.
+    ///
+    /// @param volume - New volume.
+    ///
+    //////////////////////////////////////////////////////////////////////////
+    void SetVolume(int volume);
 
-	void SetMusicVolume(int volume);
+    void SetMusicVolume(int volume);
 
-  void SetSfxVolume(int volume);
+    void SetSfxVolume(int volume);
 
-  	int mChannel;
+    int mChannel;
 protected:
-	JSoundSystem();
-	~JSoundSystem();
+    JSoundSystem();
+    ~JSoundSystem();
 
-	void InitSoundSystem();
-	void DestroySoundSystem();
+    void InitSoundSystem();
+    void DestroySoundSystem();
 
 private:
-
-	JMusic *mCurrentMusic;
+#if (defined PSP || defined ANDROID)
+    JMusic *mCurrentMusic;
     JSample *mCurrentSample;
+#endif
 
-	int mVolume;
-  int mMusicVolume;
-  int mSampleVolume;
+    int mVolume;
+#ifndef IOS
+    int mMusicVolume;
+#endif
+    int mSampleVolume;
 
 
-	static JSoundSystem* mInstance;
+    static JSoundSystem* mInstance;
 
 };
 
 #endif
+

JGE/include/JSpline.h

@@ -18,12 +18,11 @@ using namespace std;
 
 #define MID_POINT_THRESHOLD			1.0f
 
-
 //////////////////////////////////////////////////////////////////////////
 /// Position of a single dot on screen.
 /// 
 //////////////////////////////////////////////////////////////////////////
-class Point
+class JPoint
 {
 public:
 
@@ -34,13 +33,13 @@ public:
 	/// @param _y - Y position.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-	Point(float _x, float _y) { x = _x; y = _y; }
+    JPoint(float _x, float _y) { x = _x; y = _y; }
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Constructor, set position to default (0.0f, 0.0f)
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-	Point() { x = 0.0f; y = 0.0f; }
+    JPoint() { x = 0.0f; y = 0.0f; }
 
 	float x;	///< X position.
 	float y;	///< Y position.
@@ -95,7 +94,7 @@ public:
 	/// @param pt - Control point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-	void AddControlPoint(const Point &pt);
+    void AddControlPoint(const JPoint &pt);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Get a control point of the spline.
@@ -105,7 +104,7 @@ public:
 	/// @return Control point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-	void GetControlPoint(Point &point, int index);
+    void GetControlPoint(JPoint &point, int index);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Work out all pixels of the spline.
@@ -128,7 +127,7 @@ public:
 	/// @return Position of the desire point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-	void PointOnCurve(Point &out, float t, const Point &p0, const Point &p1, const Point &p2, const Point &p3);
+    void PointOnCurve(JPoint &out, float t, const JPoint &p0, const JPoint &p1, const JPoint &p2, const JPoint &p3);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Get a number of pixels for this spline.
@@ -146,7 +145,7 @@ public:
 	/// @return Position of the desire point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-	void GetPixel(Point &point, int index);
+    void GetPixel(JPoint &point, int index);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Render the spline to screen.
@@ -156,8 +155,8 @@ public:
 
 private:
 
-	vector<Point> mMidPoints;
-	vector<Point> mPixels;
+    vector<JPoint> mMidPoints;
+    vector<JPoint> mPixels;
 	int mCount;
 
 };

JGE/include/Threading.h

@@ -1,7 +1,7 @@
 #ifndef THREADING_H
 #define THREADING_H
 
-#if !defined(PSP) && !defined(QT_CONFIG)
+#if !defined(PSP) && !defined(QT_CONFIG) && !(__cplusplus > 199711L)
 #include <boost/date_time.hpp>
 
 #ifdef WIN32
@@ -14,7 +14,7 @@
 #endif
 
 #include <boost/thread/mutex.hpp>
-#elif !defined(QT_CONFIG)
+#elif defined(PSP)
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
 
@@ -26,7 +26,7 @@
 namespace boost
 {
     /**
-    ** PSP specific variant of a boost mutex & scoped_lock 
+    ** PSP specific variant of a boost mutex & scoped_lock
     */
 
     template <class Mutex>
@@ -60,7 +60,7 @@ namespace boost
         {
             sceKernelDeleteSema(mID);
         }
-        
+
         void lock()
         {
             int result = sceKernelWaitSema(mID, 1, 0);
@@ -142,7 +142,7 @@ namespace boost
             }
 
         }
-        
+
         int mID;
         int mThreadID;
         volatile int mRecursionCount;
@@ -164,7 +164,7 @@ namespace boost
 
 
     /**
-    ** Emulating boost::thread configuration glue, with some shortcuts 
+    ** Emulating boost::thread configuration glue, with some shortcuts
     ** This detail namespace is a distillation of boost's thread.hpp, thread_data.hpp.
     */
     namespace detail
@@ -212,13 +212,13 @@ namespace boost
     **
     ** The intent of its usage is this form only:
     ** mWorkerThread = boost::thread(ThreadProc, this);
-	** where ThreadProc is a static member function of the 'this' class,eg:
-	** static void FOO::ThreadProc(void* inParam)
-	** {
-	**		FOO* instance = reinterpret_cast<FOO*>(inParam);
-	**		// now you have class instance data available...
-	** }
-	** 
+    ** where ThreadProc is a static member function of the 'this' class,eg:
+    ** static void FOO::ThreadProc(void* inParam)
+    ** {
+    **		FOO* instance = reinterpret_cast<FOO*>(inParam);
+    **		// now you have class instance data available...
+    ** }
+    **
     ** Any other variant of a thread proc with more than one param is unimplemented.
     */
     class thread
@@ -227,7 +227,7 @@ namespace boost
         ** Helper class for sceKernelStartThread, which passes args by value, not by reference
         ** We use this struct to wrap any pointers that we want to pass to the worker thread.
         */
-        struct CallbackData 
+        struct CallbackData
         {
             CallbackData(detail::thread_data_ptr inThreadInfo)
                 : mThreadInfo(inThreadInfo)
@@ -307,13 +307,11 @@ namespace boost
     }
 }
 
-#elif defined(QT_CONFIG)
+#elif defined(QT_CONFIG) && (__cplusplus <= 199711L)
 
 #include <QMutex>
 #include <QThread>
-
-#include <boost/bind.hpp>
-#include <boost/shared_ptr.hpp>
+#include <QSharedPointer>
 
 #include "../include/JLogger.h"
 
@@ -420,23 +418,25 @@ namespace boost
             virtual void run() = 0;
         };
 
-        typedef boost::shared_ptr<detail::thread_data_base> thread_data_ptr;
 
-        template<typename F>
+        typedef QSharedPointer<detail::thread_data_base> thread_data_ptr;
+
+        template<typename F, typename A1>
         class thread_data : public detail::thread_data_base
         {
         public:
-            thread_data(F f_) : f(f_)
+            thread_data(F f_, A1 a1_) : f(f_), a1(a1_)
             {
             }
 
             void run()
             {
-                f();
+                f(a1);
             }
 
         private:
             F f;
+            A1 a1;
 
             void operator=(thread_data&);
             thread_data(thread_data&);
@@ -493,7 +493,7 @@ namespace boost
         }
 
         template <class F,class A1>
-        thread(F f, A1 a1) : mThreadInfo(make_thread_info(boost::bind(boost::type<void>(), f, a1)))
+        thread(F f, A1 a1) : mThreadInfo(make_thread_info(f, a1))
         {
             mpThread = new threadImpl(mThreadInfo);
             LOG("Calling start func");
@@ -510,10 +510,10 @@ namespace boost
         }
 
     private:
-        template<typename F>
-        static inline detail::thread_data_ptr make_thread_info(F f)
+        template<typename F, typename A1>
+        static inline detail::thread_data_ptr make_thread_info(F f, A1 a1)
         {
-            return detail::thread_data_ptr(new detail::thread_data<F>(f));
+            return detail::thread_data_ptr(new detail::thread_data<F, A1>(f, a1));
         }
 
         detail::thread_data_ptr mThreadInfo;
@@ -537,6 +537,80 @@ namespace boost
     }
 }
 
+#elif (__cplusplus > 199711L)
+
+#include <thread>
+#include <mutex>
+
+namespace boost
+{
+    typedef std::thread thread;
+
+    template <class Mutex>
+    struct unique_lock
+    {
+        unique_lock(Mutex& inMutex) : mMutex(&inMutex)
+        {
+            mMutex->lock();
+        }
+
+        ~unique_lock()
+        {
+            mMutex->unlock();
+        }
+
+        Mutex* mMutex;
+    };
+
+    class mutex
+    {
+    public:
+
+        typedef unique_lock<mutex> scoped_lock;
+
+        mutex()
+          : mQMutex()
+        {
+        }
+
+        ~mutex()
+        {
+        }
+
+        void lock()
+        {
+            mQMutex.lock();
+        }
+
+        void unlock()
+        {
+            mQMutex.unlock();
+        }
+
+        std::mutex mQMutex;
+
+    private:
+        mutex(mutex const&);
+        mutex& operator=(mutex const&);
+    };
+
+    namespace posix_time
+    {
+        typedef unsigned int milliseconds;
+    }
+
+    /**
+    ** boost's platform neutral sleep call.
+    */
+    namespace this_thread
+    {
+        inline void sleep(boost::posix_time::milliseconds const& time)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(time));
+        }
+    }
+}
+
 #endif
 
 #endif // THREADING_H

JGE/include/qt/corewrapper.h

@@ -136,6 +136,20 @@ signals:
 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);
@@ -154,6 +168,7 @@ private:
     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;

JGE/src/Downloader.cpp

@@ -0,0 +1,298 @@
+#include "DebugRoutines.h"
+#include "JFileSystem.h"
+#include "Downloader.h"
+
+#define RECORDS_DEFAULT_FILE "cache/records.txt"
+
+#ifdef QT_CONFIG
+QNetworkAccessManager DownloadRequest::networkAccessManager;
+#endif
+
+DownloadRequest::DownloadRequest(string localPath,
+                    string remoteResourceURL,
+                    string ETag,
+                    DownloadStatus downloadStatus,
+                    size_t totalSize,
+                    size_t currentSize):
+    mLocalPath(localPath),
+    mRemoteResourceURL(remoteResourceURL),
+    mRequestedRemoteResourceURL(remoteResourceURL),
+    mETag(ETag),
+    mDownloadStatus(downloadStatus),
+    mUpgradeAvailable(false),
+    mTotalSize(totalSize),
+    mCurrentSize(currentSize)
+{
+}
+
+DownloadRequest::~DownloadRequest()
+{
+}
+
+void DownloadRequest::startHead()
+{
+#ifdef QT_CONFIG
+    QNetworkRequest request(QUrl(QString(mRequestedRemoteResourceURL.c_str())));
+    request.setRawHeader("If-None-Match", mETag.c_str());
+    mNetworkReply = networkAccessManager.head(request);
+    connect(mNetworkReply, SIGNAL(finished()), SLOT(fileDownloaded()));
+#endif
+}
+
+void DownloadRequest::startGet()
+{
+#ifdef QT_CONFIG
+    mNetworkReply = networkAccessManager.get(QNetworkRequest(QUrl(QString(mRequestedRemoteResourceURL.c_str()))));
+#endif
+    mFile.close();
+    JFileSystem::GetInstance()->Remove(getTempLocalPath());
+    JFileSystem::GetInstance()->openForWrite(mFile, getTempLocalPath());
+#ifdef QT_CONFIG
+    connect(mNetworkReply, SIGNAL(downloadProgress(qint64, qint64)),
+                SLOT(downloadProgress(qint64, qint64)));
+    connect(mNetworkReply, SIGNAL(finished()), SLOT(fileDownloaded()));
+#endif
+}
+
+void DownloadRequest::fileDownloaded()
+{
+    do {
+        QByteArray eTagByteArray = mNetworkReply->rawHeader("ETag");
+        if(!eTagByteArray.isEmpty()) {
+            string oldETag = mETag;
+            mETag = QString(eTagByteArray).toStdString();
+            if(oldETag!="" && oldETag != mETag)
+                mUpgradeAvailable = true;
+        }
+
+        // let's check some error
+        if(mNetworkReply->error() != QNetworkReply::NoError) {
+            DebugTrace(mNetworkReply->errorString().toStdString());
+            mDownloadStatus = DownloadRequest::DOWNLOAD_ERROR;
+            mFile.close();
+            JFileSystem::GetInstance()->Remove(getTempLocalPath());
+            break;
+        }
+
+        // check if we're getting redirected
+        QVariant redirectionTarget = mNetworkReply->attribute(QNetworkRequest::RedirectionTargetAttribute);
+        if (!redirectionTarget.isNull()) {
+            QUrl newUrl = QUrl(mRequestedRemoteResourceURL.c_str()).resolved(redirectionTarget.toUrl());
+            DebugTrace(string("Redirect to ")+ newUrl.toString().toStdString());
+
+            mRequestedRemoteResourceURL = newUrl.toString().toStdString();
+            mNetworkReply->deleteLater();
+            if(mFile.is_open())
+                startGet();
+            else
+                startHead();
+            return;
+        }
+
+        if(mFile.is_open())
+        {
+            QByteArray byteArray = mNetworkReply->readAll();
+            mFile.write(byteArray.constData(), byteArray.size());
+            mFile.close();
+            if(!JFileSystem::GetInstance()->Rename(getTempLocalPath(), mLocalPath)) {
+                mDownloadStatus = DownloadRequest::DOWNLOAD_ERROR;
+                break;
+            }
+        }
+        mDownloadStatus = DownloadRequest::DOWNLOADED;
+    } while(0);
+
+    Downloader::GetInstance()->Update();
+    mNetworkReply->deleteLater();
+
+    emit statusChanged((int)mDownloadStatus);
+}
+
+void DownloadRequest::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
+{
+    QByteArray byteArray = mNetworkReply->readAll();
+    mFile.write(byteArray.constData(), byteArray.size());
+    mCurrentSize = bytesReceived;
+    mTotalSize = bytesTotal;
+    int percent = 0;
+    if(bytesTotal)
+        percent = (bytesReceived/bytesTotal)*100;
+    emit percentChanged(percent);
+}
+
+Downloader* Downloader::mInstance = 0;
+
+Downloader::Downloader(string globalRemoteURL, string localcacheRecords):
+    mGlobalRemoteURL(globalRemoteURL),
+    mLocalCacheRecords(localcacheRecords)
+{
+    JFileSystem::GetInstance()->MakeDir("cache");
+
+    izfstream downloadRecords;
+    if(mLocalCacheRecords.empty())
+        mLocalCacheRecords = RECORDS_DEFAULT_FILE;
+    if(JFileSystem::GetInstance()->openForRead(downloadRecords, mLocalCacheRecords))
+    {// File exists, let's read it.
+        downloadRecords >> (*this);
+    }
+    JFileSystem::GetInstance()->CloseFile();
+}
+
+Downloader::~Downloader()
+{
+    map<string, DownloadRequest*>::iterator ite;
+    for(ite = mRequestMap.begin(); ite != mRequestMap.end(); ite++)
+    {
+        delete (*ite).second;
+    }
+    mRequestMap.erase(mRequestMap.begin(), mRequestMap.end());
+}
+
+Downloader* Downloader::GetInstance()
+{
+    if(!mInstance)
+    {
+        mInstance = new Downloader();
+    }
+    return mInstance;
+}
+
+void Downloader::Release()
+{
+    if(mInstance)
+    {
+        delete mInstance;
+        mInstance = 0;
+    }
+}
+
+bool DownloadRequest::NetworkIsAccessible()
+{
+    bool result = false;
+
+#ifdef QT_CONFIG
+    networkAccessManager.setNetworkAccessible(QNetworkAccessManager::Accessible);
+    result = networkAccessManager.networkAccessible();
+#endif
+
+    return result;
+}
+
+DownloadRequest* Downloader::Get(string localPath, string remoteResourceURL)
+{
+    map<string, DownloadRequest*>::iterator ite = mRequestMap.find(localPath);
+    if(ite == mRequestMap.end())
+    { // request does not exist, let's create it
+        DownloadRequest* request = new DownloadRequest(localPath, remoteResourceURL);
+        std::pair<std::map<string,DownloadRequest*>::iterator,bool> ret;
+        ret = mRequestMap.insert ( std::pair<string,DownloadRequest*>(localPath, request) );
+        if (ret.second==false) {
+            DebugTrace("Downloader::Get Error inserting request in Map");
+            return 0;
+        }
+        ite = ret.first;
+    }
+
+    // Now, we can check the server
+    if((*ite).second->getDownloadStatus() == DownloadRequest::NOT_PRESENT ||
+            (*ite).second->upgradeAvailable())
+    {   // File is not here or an update is available, let's get it
+        (*ite).second->startGet();
+        (*ite).second->mDownloadStatus = DownloadRequest::DOWNLOADING;
+    }
+    else if ((*ite).second->getDownloadStatus() == DownloadRequest::DOWNLOADED)
+    {   // File is here, let's check if there is some update without blocking the playback
+        (*ite).second->startHead();
+    }
+
+    return (*ite).second;
+}
+
+void Downloader::Update()
+{
+    ofstream downloadRecords;
+    if(JFileSystem::GetInstance()->openForWrite(downloadRecords, mLocalCacheRecords))
+    {
+        downloadRecords << (*this);
+    }
+    downloadRecords.close();
+}
+
+ostream& operator<<(ostream& out, const DownloadRequest& d)
+{
+//    HEAD request fails, so this line erase cache record after upgrade check :(
+//    if(d.getDownloadStatus() == DownloadRequest::DOWNLOADED)
+    {
+        out << "localPath=" << d.mLocalPath << endl;
+        out << "remoteResource=" << d.mRemoteResourceURL << endl;
+        out << "ETag=" << d.mETag << endl;
+        out << "upgradeAvailable=" << d.mUpgradeAvailable <<endl;
+    }
+
+    return out;
+}
+
+istream& operator>>(istream& in, DownloadRequest& d)
+{
+    string s;
+
+    while(std::getline(in, s))
+    {
+        size_t limiter = s.find("=");
+        string areaS;
+        if (limiter != string::npos)
+        {
+            areaS = s.substr(0, limiter);
+            if (areaS.compare("localPath") == 0)
+            {
+                d.mLocalPath = s.substr(limiter + 1);
+            }
+            else if (areaS.compare("remoteResource") == 0)
+            {
+                d.mRemoteResourceURL = s.substr(limiter + 1);
+                d.mRequestedRemoteResourceURL = d.mRemoteResourceURL;
+            }
+            else if (areaS.compare("ETag") == 0)
+            {
+                d.mETag = s.substr(limiter + 1);
+                d.mDownloadStatus = DownloadRequest::DOWNLOADED;
+            }
+            else if (areaS.compare("upgradeAvailable") == 0)
+            {
+                d.mUpgradeAvailable = (bool)atoi(s.substr(limiter + 1).c_str());
+                break;
+            }
+        }
+    }
+
+    return in;
+}
+
+ostream& operator<<(ostream& out, const Downloader& d)
+{
+    map<string, DownloadRequest*>::const_iterator ite;
+    for(ite = d.mRequestMap.begin(); ite != d.mRequestMap.end(); ite++)
+    {
+        out << (*(*ite).second) << endl;
+    }
+    return out;
+}
+
+istream& operator>>(istream& in, Downloader& d)
+{
+    while(!in.eof())
+    {
+        DownloadRequest* downloadRequest = new DownloadRequest();
+        in >> (*downloadRequest);
+
+        if(!downloadRequest->getLocalPath().empty() &&
+           !downloadRequest->getRemoteResource().empty() &&
+           !downloadRequest->getETag().empty()) {
+            d.mRequestMap[downloadRequest->getLocalPath()] = downloadRequest;
+        } else {
+            delete downloadRequest;
+        }
+    }
+    return in;
+}
+

JGE/src/JFileSystem.cpp

@@ -38,6 +38,12 @@ The content that users should not be touching.
 #include <QDir>
 #endif
 
+/*
+#ifdef IOS
+#include <Foundation/Foundation.h>
+#endif
+*/
+
 JFileSystem* JFileSystem::mInstance = NULL;
 
 JZipCache::JZipCache()
@@ -248,7 +254,7 @@ void JFileSystem::clearZipCache()
 
 bool JFileSystem::AttachZipFile(const string &zipfile, char *password /* = NULL */)
 {
-    if (mZipAvailable && mZipFile != NULL)
+    if (mZipAvailable && mZipFile.is_open())
     {
         if (mZipFileName != zipfile)
             DetachZipFile();		// close the previous zip file
@@ -313,11 +319,15 @@ bool JFileSystem::readIntoString(const string & FilePath, string & target)
 
     int fileSize = GetFileSize(file);
 
+#ifndef __MINGW32__
     try {
+#endif
         target.resize((std::string::size_type) fileSize);
+#ifndef __MINGW32__
     } catch (bad_alloc&) {
         return false;
     }
+#endif
 
 
     if (fileSize)
@@ -553,7 +563,13 @@ bool JFileSystem::Rename(string _from, string _to)
     string from = mUserFSPath + _from;
     string to = mUserFSPath + _to;
     std::remove(to.c_str());
-    return rename(from.c_str(), to.c_str()) ? true: false;
+    return (rename(from.c_str(), to.c_str()) == 0);
+}
+
+bool JFileSystem::Remove(string aFile)
+{
+    string toRemove = mUserFSPath + aFile;
+    return (std::remove(toRemove.c_str()) == 0);
 }
 
 int JFileSystem::GetFileSize(izfstream & file)

JGE/src/JSpline.cpp

@@ -71,7 +71,7 @@ bool JSpline::Load(const char *filename, float xscale, float yscale)
 		element->QueryFloatAttribute("x", &xx);
 		element->QueryFloatAttribute("y", &yy);
 
-		Point pt(xx*xscale, yy*yscale);
+        JPoint pt(xx*xscale, yy*yscale);
 		AddControlPoint(pt);
 		
 	}
@@ -84,7 +84,7 @@ bool JSpline::Load(const char *filename, float xscale, float yscale)
 
 
 
-void JSpline::PointOnCurve(Point &out, float t, const Point &p0, const Point &p1, const Point &p2, const Point &p3)
+void JSpline::PointOnCurve(JPoint &out, float t, const JPoint &p0, const JPoint &p1, const JPoint &p2, const JPoint &p3)
 {
 	float t2 = t * t;
 	float t3 = t2 * t;
@@ -113,8 +113,8 @@ void JSpline::GeneratePixels()
 	x = mMidPoints[1].x;
 	y = mMidPoints[1].y;
 
-	Point newPt(x, y);
-	Point extraPt;
+    JPoint newPt(x, y);
+    JPoint extraPt;
 
 	mPixels.push_back(newPt);
 
@@ -151,13 +151,13 @@ void JSpline::GeneratePixels()
 }
 
 
-void JSpline::AddControlPoint(const Point &pt)
+void JSpline::AddControlPoint(const JPoint &pt)
 {
 	mMidPoints.push_back(pt);
 }
 
 
-void JSpline::GetControlPoint(Point &point, int index)
+void JSpline::GetControlPoint(JPoint &point, int index)
 {
 	if (index < (int)mMidPoints.size())
 	{
@@ -167,7 +167,7 @@ void JSpline::GetControlPoint(Point &point, int index)
 }
 
 
-void JSpline::GetPixel(Point &point, int index)
+void JSpline::GetPixel(JPoint &point, int index)
 {
 	if (index < (int)mPixels.size())
 	{

JGE/src/Qtmain.cpp

@@ -9,11 +9,11 @@
 #include <QtDeclarative>
 #include "qmlapplicationviewer.h"
 #endif //QT_WIDGET
-#include "filedownloader.h"
+#include "Downloader.h"
 #include "GameApp.h"
 #include "corewrapper.h"
 
-QWidget* g_glwidget = NULL;
+WagicCore* g_glwidget = NULL;
 
 static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] =
 {
@@ -69,18 +69,25 @@ int main(int argc, char* argv[])
 
 #endif //QT_WIDGET
 
-    if(argc >= 2 && string(argv[1]) == "testsuite")
-    {
-        int result = 0;
-        result += WagicCore::runTestSuite();
-        return result;
-    }
-
     app->setApplicationName(WagicCore::getApplicationName());
-    FileDownloader fileDownloader(USERDIR, WAGIC_RESOURCE_NAME);
+    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();
-    g_glwidget->connect(&fileDownloader, SIGNAL(finished(int)), SLOT(start(int)));
+    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");
 

JGE/src/SDLmain.cpp

@@ -78,7 +78,20 @@ extern "C" void Java_org_libsdl_app_SDLActivity_nativeResume(
 {    
 	if (!g_engine)
 		return;
-	g_engine->Resume();
+    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
 

JGE/src/iOS/EAGLViewController.h

@@ -10,5 +10,6 @@ void resumeGame();
 @property (nonatomic, retain) id eaglView;
 @property (nonatomic, retain) UITextField *inputField;
 @property (nonatomic, assign) BOOL bannerIsVisible;
+- (void)toggleKeyboardWithState: (NSString *) initialText;
 
 @end

JGE/src/iOS/EAGLViewController.m

@@ -53,28 +53,28 @@
 
 - (void)viewWillAppear:(BOOL)animated {
 	NSLog(@"EAGL ViewController - view Will Appear");
-    [self.view resumeGame];
+    [(id)self.view resumeGame];
 }
 
 
 - (void)viewWillDisappear:(BOOL)animated
 {
-    [self.view pauseGame];
+    [(id)self.view pauseGame];
 }
 
 - (void)pauseGame
 {
-    [self.view pauseGame];
+    [(id)self.view pauseGame];
 }
 
 - (void)resumeGame
 {
-    [self.view resumeGame];
+    [(id)self.view resumeGame];
 }
 
 - (void)endGame
 {
-    [self.view endGame];
+    [(id)self.view endGame];
 }
 
 - (void)viewDidAppear:(BOOL)animated {

JGE/src/iOS/wagicAppDelegate.m

@@ -337,7 +337,7 @@
 
 - (void)applicationWillTerminate:(UIApplication *)application
 {
-    [self.glViewController.view destroyGame];
+    [(id)self.glViewController.view destroyGame];
 }
 
 - (void)initializeKeyboard: (id) initialState

JGE/src/pc/JSfx.cpp

@@ -22,6 +22,8 @@
 JMusic::JMusic()
 #ifdef USE_PHONON
   : mOutput(0), mMediaObject(0)
+#elif defined QT_CONFIG
+    : playlist(0), player(0)
 #endif
 {
 }
@@ -40,11 +42,16 @@ int JMusic::getPlayTime(){
 
 JMusic::~JMusic()
 {
-#ifdef USE_PHONON
+#if defined USE_PHONON
   if(mOutput)
     delete mOutput;
   if(mMediaObject)
     delete mMediaObject;
+#elif defined QT_CONFIG
+    if(player)
+        delete player;
+    if(playlist)
+        delete playlist;
 #elif defined WITH_FMOD
   JSoundSystem::GetInstance()->StopMusic(this);
   if (mTrack) FSOUND_Sample_Free(mTrack);
@@ -69,7 +76,10 @@ JSample::JSample()
 
 JSample::~JSample()
 {
-#ifdef USE_PHONON
+#if (defined QT_CONFIG) && (!defined USE_PHONON)
+    if(effect)
+        delete effect;
+#elif USE_PHONON
   if(mOutput)
     delete mOutput;
   if(mMediaObject)
@@ -144,65 +154,84 @@ void JSoundSystem::DestroySoundSystem()
 
 JMusic *JSoundSystem::LoadMusic(const char *fileName)
 {
-#ifdef USE_PHONON
-  JMusic* music = new JMusic();
-  if (music)
-  {
-    music->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
-    music->mMediaObject = new Phonon::MediaObject(0);
-    string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
-    music->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
-    Phonon::Path mediapath = Phonon::createPath(music->mMediaObject, music->mOutput);
-    Q_ASSERT(mediapath.isValid());
-  }
-  return music;
-#elif (defined WITH_FMOD)
-  JMusic* music = new JMusic();
-  if (music)
+    JMusic* music = NULL;
+#if (defined QT_CONFIG)  && (!defined USE_PHONON)
+    music = new JMusic();
+    if (music)
     {
-      JFileSystem* fileSystem = JFileSystem::GetInstance();
-      if (fileSystem->OpenFile(fileName))
-	{
-	  int size = fileSystem->GetFileSize();
-	  char *buffer = new char[size];
-	  fileSystem->ReadFile(buffer, size);
-	  music->mTrack = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
-
-	  delete[] buffer;
-	  fileSystem->CloseFile();
-	}
+        music->player = new QMediaPlayer;
+        music->player->setVolume(100);
+        music->playlist = new QMediaPlaylist;
+        music->fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
+        music->playlist->addMedia(QUrl::fromLocalFile(music->fullpath.c_str()));
+        music->playlist->setCurrentIndex(0);
+    }
+#elif defined USE_PHONON
+    music = new JMusic();
+    if (music)
+    {
+        music->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
+        music->mMediaObject = new Phonon::MediaObject(0);
+        string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
+        music->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
+        Phonon::Path mediapath = Phonon::createPath(music->mMediaObject, music->mOutput);
+        Q_ASSERT(mediapath.isValid());
+    }
+#elif (defined WITH_FMOD)
+    music = new JMusic();
+    if (music)
+    {
+        JFileSystem* fileSystem = JFileSystem::GetInstance();
+        if (fileSystem->OpenFile(fileName))
+        {
+            int size = fileSystem->GetFileSize();
+            char *buffer = new char[size];
+            fileSystem->ReadFile(buffer, size);
+            music->mTrack = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
+
+            delete[] buffer;
+            fileSystem->CloseFile();
+        }
     }
-  return music;
 #else
     cerr << fileName << endl;
-  return NULL;
 #endif
+    return music;
 }
 
 
 void JSoundSystem::PlayMusic(JMusic *music, bool looping)
 {
-#ifdef USE_PHONON
-  if (music && music->mMediaObject && music->mOutput)
-  {
-    if(looping)
+#if (defined QT_CONFIG)  && (!defined USE_PHONON)
+    if(music && music->player && music->playlist)
     {
-      music->mMediaObject->connect(music->mMediaObject, SIGNAL(aboutToFinish()), music, SLOT(seekAtTheBegining()));
+        if(looping)
+            music->playlist->setPlaybackMode(QMediaPlaylist::Loop);
+
+        music->player->setPlaylist(music->playlist);
+        music->player->play();
     }
-    music->mOutput->setVolume((qreal)mVolume*0.01);
-    music->mMediaObject->play();
-
-  }
-#elif (defined WITH_FMOD)
-  if (music && music->mTrack)
+#elif USE_PHONON
+    if (music && music->mMediaObject && music->mOutput)
     {
-      mChannel = FSOUND_PlaySound(mChannel, music->mTrack);
-      SetMusicVolume(mVolume);
+        if(looping)
+        {
+            music->mMediaObject->connect(music->mMediaObject, SIGNAL(aboutToFinish()), music, SLOT(seekAtTheBegining()));
+        }
+        music->mOutput->setVolume((qreal)mVolume*0.01);
+        music->mMediaObject->play();
 
-      if (looping)
-	FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_NORMAL);
-      else
-	FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_OFF);
+    }
+#elif (defined WITH_FMOD)
+    if (music && music->mTrack)
+    {
+        mChannel = FSOUND_PlaySound(mChannel, music->mTrack);
+        SetMusicVolume(mVolume);
+
+        if (looping)
+            FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_NORMAL);
+        else
+            FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_OFF);
     }
 #else
     music = 0;
@@ -213,7 +242,12 @@ void JSoundSystem::PlayMusic(JMusic *music, bool looping)
 
 void JSoundSystem::StopMusic(JMusic *music)
 {
-#ifdef USE_PHONON
+#if (defined QT_CONFIG) && (!defined USE_PHONON)
+    if (music && music->player && music->playlist)
+    {
+        music->player->stop();
+    }
+#elif defined USE_PHONON
   if (music && music->mMediaObject && music->mOutput)
   {
     music->mMediaObject->stop();
@@ -264,47 +298,61 @@ void JSoundSystem::SetSfxVolume(int volume){
 
 JSample *JSoundSystem::LoadSample(const char *fileName)
 {
-#if (defined USE_PHONON)
-  JSample* sample = new JSample();
-  if (sample)
-  {
-    sample->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
-    sample->mMediaObject = new Phonon::MediaObject(0);
-    string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
-    sample->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
-    Phonon::Path mediapath = Phonon::createPath(sample->mMediaObject, sample->mOutput);
-    Q_ASSERT(mediapath.isValid());
-  }
-  return sample;
-#elif (defined WITH_FMOD)
-  JSample* sample = new JSample();
-  if (sample)
+    JSample* sample = NULL;
+#if (defined QT_CONFIG) && (!defined USE_PHONON)
+    sample = new JSample();
+    if (sample)
     {
-      JFileSystem* fileSystem = JFileSystem::GetInstance();
-      if (fileSystem->OpenFile(fileName))
-	{
-	  int size = fileSystem->GetFileSize();
-	  char *buffer = new char[size];
-	  fileSystem->ReadFile(buffer, size);
-	  sample->mSample = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
+        string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
+        sample->effect = new QMediaPlayer;
+        sample->effect->setMedia(QUrl::fromLocalFile(fullpath.c_str()));
+        sample->effect->setVolume(100);
+        sample->mSample = &(sample->effect);
+    }
+#elif (defined USE_PHONON)
+    sample = new JSample();
+    if (sample)
+    {
+        sample->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
+        sample->mMediaObject = new Phonon::MediaObject(0);
+        string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
+        sample->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
+        Phonon::Path mediapath = Phonon::createPath(sample->mMediaObject, sample->mOutput);
+        Q_ASSERT(mediapath.isValid());
+    }
+#elif (defined WITH_FMOD)
+    sample = new JSample();
+    if (sample)
+    {
+        JFileSystem* fileSystem = JFileSystem::GetInstance();
+        if (fileSystem->OpenFile(fileName))
+        {
+            int size = fileSystem->GetFileSize();
+            char *buffer = new char[size];
+            fileSystem->ReadFile(buffer, size);
+            sample->mSample = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
 
-	  delete[] buffer;
-	  fileSystem->CloseFile();
-	}else
-	sample->mSample = NULL;
+            delete[] buffer;
+            fileSystem->CloseFile();
+        }else
+            sample->mSample = NULL;
 
     }
-  return sample;
 #else
     cerr << fileName << endl;
-  return NULL;
 #endif
+    return sample;
 }
 
 
 void JSoundSystem::PlaySample(JSample *sample)
 {
-#ifdef USE_PHONON
+#if (defined QT_CONFIG) && (!defined USE_PHONON)
+    if(sample)
+    {
+        sample->effect->play();
+    }
+#elif defined USE_PHONON
   if (sample && sample->mMediaObject && sample->mOutput)
   {
     sample->mOutput->setVolume((qreal)mSampleVolume*0.01);

JGE/src/pc/JSocket.cpp

@@ -7,6 +7,7 @@
 #include <winsock.h>
 #include <fcntl.h>
 #elif LINUX
+#include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>

JGE/src/qt/corewrapper.cpp

@@ -418,29 +418,29 @@ void WagicCore::mousePressEvent(QMouseEvent *event)
 {
   if(event->button() == Qt::LeftButton)
   {
-    QPoint lastPos = event->pos();
+    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 (lastPos.y() >= m_viewPort.top() &&
-      lastPos.y() <= m_viewPort.bottom() &&
-      lastPos.x() <= m_viewPort.right() &&
-      lastPos.x() >= m_viewPort.left()) {
+    if (lastPosy() >= m_viewPort.top() &&
+      lastPosy() <= m_viewPort.bottom() &&
+      lastPosx() <= m_viewPort.right() &&
+      lastPosx() >= m_viewPort.left()) {
       m_engine->LeftClicked(
-                  ((lastPos.x()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
-                  ((lastPos.y()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
+                  ((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 = lastPos.x();
-      mMouseDownY = lastPos.y();
+      mMouseDownX = lastPosx();
+      mMouseDownY = lastPosy();
       mLastFingerDownTime = g_startTimer.elapsed();
 #endif
-    } else if(lastPos.y()<m_viewPort.top()) {
+    } else if(lastPosy()<m_viewPort.top()) {
       m_engine->HoldKey_NoRepeat(JGE_BTN_MENU);
-    } else if(lastPos.y()>m_viewPort.bottom()) {
+    } else if(lastPosy()>m_viewPort.bottom()) {
       m_engine->HoldKey_NoRepeat(JGE_BTN_NEXT);
     }
     event->accept();
@@ -465,33 +465,33 @@ void WagicCore::mouseReleaseEvent(QMouseEvent *event)
 {
   if(event->button() == Qt::LeftButton)
   {
-    QPoint lastPos = event->pos();
+    m_lastPos = event->pos();
 
-    if (lastPos.y() >= m_viewPort.top() &&
-      lastPos.y() <= m_viewPort.bottom() &&
-      lastPos.x() <= m_viewPort.right() &&
-      lastPos.x() >= m_viewPort.left()) {
+    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 - lastPos.x()) < kHitzonePliancy &&
-           abs(mMouseDownY - lastPos.y()) < kHitzonePliancy)
+        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(lastPos.x()-mMouseDownX, lastPos.y()-mMouseDownY);
+        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(lastPos.y() < m_viewPort.top()) {
+    } else if(lastPosy() < m_viewPort.top()) {
       m_engine->ReleaseKey(JGE_BTN_MENU);
-    } else if(lastPos.y() > m_viewPort.bottom()) {
+    } else if(lastPosy() > m_viewPort.bottom()) {
       m_engine->ReleaseKey(JGE_BTN_NEXT);
     }
     event->accept();
@@ -517,15 +517,15 @@ void WagicCore::mouseMoveEvent(QMouseEvent *event)
   int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
   int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
 
-  QPoint lastPos = event->pos();
+  m_lastPos = event->pos();
 
-  if (lastPos.y() >= m_viewPort.top() &&
-    lastPos.y() <= m_viewPort.bottom() &&
-    lastPos.x() <= m_viewPort.right() &&
-    lastPos.x() >= m_viewPort.left()) {
+  if (lastPosy() >= m_viewPort.top() &&
+    lastPosy() <= m_viewPort.bottom() &&
+    lastPosx() <= m_viewPort.right() &&
+    lastPosx() >= m_viewPort.left()) {
     m_engine->LeftClicked(
-                ((lastPos.x()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
-                ((lastPos.y()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
+                ((lastPosx()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
+                ((lastPosy()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
     event->accept();
   } else {
     super::mouseMoveEvent(event);

JGE/src/unzip/crypt.h

@@ -87,13 +87,13 @@ static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned lon
 #    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
 #  endif
 
-static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
-    const char *passwd;         /* password string */
-    unsigned char *buf;         /* where to write header */
-    int bufSize;
-    unsigned long* pkeys;
-    const unsigned long* pcrc_32_tab;
-    unsigned long crcForCrypting;
+static int crypthead(
+    const char *passwd,         /* password string */
+    unsigned char *buf,         /* where to write header */
+    int bufSize,
+    unsigned long* pkeys,
+    const unsigned long* pcrc_32_tab,
+    unsigned long crcForCrypting)
 {
     int n;                       /* index in random header */
     int t;                       /* temporary */

JGE/src/unzip/ioapi.c

@@ -65,10 +65,10 @@ int ZCALLBACK ferror_file_func OF((
    voidpf stream));
 
 
-voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
-   voidpf opaque;
-   const char* filename;
-   int mode;
+voidpf ZCALLBACK fopen_file_func (
+   voidpf opaque,
+   const char* filename,
+   int mode)
 {
     FILE* file = NULL;
     const char* mode_fopen = NULL;
@@ -87,11 +87,11 @@ voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
 }
 
 
-uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
-   voidpf opaque;
-   voidpf stream;
-   void* buf;
-   uLong size;
+uLong ZCALLBACK fread_file_func (
+   voidpf opaque,
+   voidpf stream,
+   void* buf,
+   uLong size)
 {
     uLong ret;
     ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
@@ -99,31 +99,31 @@ uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
 }
 
 
-uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
-   voidpf opaque;
-   voidpf stream;
-   const void* buf;
-   uLong size;
+uLong ZCALLBACK fwrite_file_func (
+   voidpf opaque,
+   voidpf stream,
+   const void* buf,
+   uLong size)
 {
     uLong ret;
     ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
     return ret;
 }
 
-long ZCALLBACK ftell_file_func (opaque, stream)
-   voidpf opaque;
-   voidpf stream;
+long ZCALLBACK ftell_file_func (
+   voidpf opaque,
+   voidpf stream)
 {
     long ret;
     ret = ftell((FILE *)stream);
     return ret;
 }
 
-long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
-   voidpf opaque;
-   voidpf stream;
-   uLong offset;
-   int origin;
+long ZCALLBACK fseek_file_func (
+   voidpf opaque,
+   voidpf stream,
+   uLong offset,
+   int origin)
 {
     int fseek_origin=0;
     long ret;
@@ -145,26 +145,26 @@ long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
     return ret;
 }
 
-int ZCALLBACK fclose_file_func (opaque, stream)
-   voidpf opaque;
-   voidpf stream;
+int ZCALLBACK fclose_file_func (
+   voidpf opaque,
+   voidpf stream)
 {
     int ret;
     ret = fclose((FILE *)stream);
     return ret;
 }
 
-int ZCALLBACK ferror_file_func (opaque, stream)
-   voidpf opaque;
-   voidpf stream;
+int ZCALLBACK ferror_file_func (
+   voidpf opaque,
+   voidpf stream)
 {
     int ret;
     ret = ferror((FILE *)stream);
     return ret;
 }
 
-void fill_fopen_filefunc (pzlib_filefunc_def)
-  zlib_filefunc_def* pzlib_filefunc_def;
+void fill_fopen_filefunc (
+  zlib_filefunc_def* pzlib_filefunc_def)
 {
     pzlib_filefunc_def->zopen_file = fopen_file_func;
     pzlib_filefunc_def->zread_file = fread_file_func;

JGE/src/unzip/unzip.c

@@ -168,10 +168,7 @@ local int unzlocal_getByte OF((
     voidpf filestream,
     int *pi));
 
-local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    int *pi;
+local int unzlocal_getByte(const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream,int *pi)
 {
     unsigned char c;
     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
@@ -198,10 +195,7 @@ local int unzlocal_getShort OF((
     voidpf filestream,
     uLong *pX));
 
-local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong *pX;
+local int unzlocal_getShort (const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream,uLong *pX)
 {
     uLong x ;
     int i;
@@ -226,10 +220,7 @@ local int unzlocal_getLong OF((
     voidpf filestream,
     uLong *pX));
 
-local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong *pX;
+local int unzlocal_getLong (const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream,uLong *pX)
 {
     uLong x ;
     int i;
@@ -259,9 +250,7 @@ local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
 
 
 /* My own strcmpi / strcasecmp */
-local int strcmpcasenosensitive_internal (fileName1,fileName2)
-    const char* fileName1;
-    const char* fileName2;
+local int strcmpcasenosensitive_internal (const char* fileName1,const char* fileName2)
 {
     for (;;)
     {
@@ -302,10 +291,7 @@ local int strcmpcasenosensitive_internal (fileName1,fileName2)
         (like 1 on Unix, 2 on Windows)
 
 */
-extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
-    const char* fileName1;
-    const char* fileName2;
-    int iCaseSensitivity;
+extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,const char* fileName2,int iCaseSensitivity)
 {
     if (iCaseSensitivity==0)
         iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
@@ -328,9 +314,7 @@ local uLong unzlocal_SearchCentralDir OF((
     const zlib_filefunc_def* pzlib_filefunc_def,
     voidpf filestream));
 
-local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
+local uLong unzlocal_SearchCentralDir(const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream)
 {
     unsigned char* buf;
     uLong uSizeFile;
@@ -394,9 +378,7 @@ local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
      Else, the return value is a unzFile Handle, usable with other function
        of this unzip package.
 */
-extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
-    const char *path;
-    zlib_filefunc_def* pzlib_filefunc_def;
+extern unzFile ZEXPORT unzOpen2 (const char *path, zlib_filefunc_def* pzlib_filefunc_def)
 {
     unz_s us;
     unz_s *s;
@@ -497,8 +479,7 @@ extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
 }
 
 
-extern unzFile ZEXPORT unzOpen (path)
-    const char *path;
+extern unzFile ZEXPORT unzOpen (const char *path)
 {
     return unzOpen2(path, NULL);
 }
@@ -508,8 +489,7 @@ extern unzFile ZEXPORT unzOpen (path)
   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzClose (file)
-    unzFile file;
+extern int ZEXPORT unzClose (unzFile file)
 {
     unz_s* s;
     if (file==NULL)
@@ -529,9 +509,7 @@ extern int ZEXPORT unzClose (file)
   Write info about the ZipFile in the *pglobal_info structure.
   No preparation of the structure is needed
   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
-    unzFile file;
-    unz_global_info *pglobal_info;
+extern int ZEXPORT unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
 {
     unz_s* s;
     if (file==NULL)
@@ -545,9 +523,7 @@ extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
 /*
    Translate date/time from Dos format to tm_unz (readable more easilty)
 */
-local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
-    uLong ulDosDate;
-    tm_unz* ptm;
+local void unzlocal_DosDateToTmuDate (uLong ulDosDate, tm_unz* ptm)
 {
     uLong uDate;
     uDate = (uLong)(ulDosDate>>16);
@@ -574,21 +550,16 @@ local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
                                                   char *szComment,
                                                   uLong commentBufferSize));
 
-local int unzlocal_GetCurrentFileInfoInternal (file,
-                                              pfile_info,
-                                              pfile_info_internal,
-                                              szFileName, fileNameBufferSize,
-                                              extraField, extraFieldBufferSize,
-                                              szComment,  commentBufferSize)
-    unzFile file;
-    unz_file_info *pfile_info;
-    unz_file_info_internal *pfile_info_internal;
-    char *szFileName;
-    uLong fileNameBufferSize;
-    void *extraField;
-    uLong extraFieldBufferSize;
-    char *szComment;
-    uLong commentBufferSize;
+local int unzlocal_GetCurrentFileInfoInternal (
+    unzFile file,
+    unz_file_info *pfile_info,
+    unz_file_info_internal *pfile_info_internal,
+    char *szFileName,
+    uLong fileNameBufferSize,
+    void *extraField,
+    uLong extraFieldBufferSize,
+    char *szComment,
+    uLong commentBufferSize)
 {
     unz_s* s;
     unz_file_info file_info;
@@ -746,19 +717,15 @@ local int unzlocal_GetCurrentFileInfoInternal (file,
   No preparation of the structure is needed
   return UNZ_OK if there is no problem.
 */
-extern int ZEXPORT unzGetCurrentFileInfo (file,
-                                          pfile_info,
-                                          szFileName, fileNameBufferSize,
-                                          extraField, extraFieldBufferSize,
-                                          szComment,  commentBufferSize)
-    unzFile file;
-    unz_file_info *pfile_info;
-    char *szFileName;
-    uLong fileNameBufferSize;
-    void *extraField;
-    uLong extraFieldBufferSize;
-    char *szComment;
-    uLong commentBufferSize;
+extern int ZEXPORT unzGetCurrentFileInfo (
+    unzFile file,
+    unz_file_info *pfile_info,
+    char *szFileName,
+    uLong fileNameBufferSize,
+    void *extraField,
+    uLong extraFieldBufferSize,
+    char *szComment,
+    uLong commentBufferSize)
 {
     return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
                                                 szFileName,fileNameBufferSize,
@@ -770,8 +737,7 @@ extern int ZEXPORT unzGetCurrentFileInfo (file,
   Set the current file of the zipfile to the first file.
   return UNZ_OK if there is no problem
 */
-extern int ZEXPORT unzGoToFirstFile (file)
-    unzFile file;
+extern int ZEXPORT unzGoToFirstFile (unzFile file)
 {
     int err=UNZ_OK;
     unz_s* s;
@@ -792,8 +758,7 @@ extern int ZEXPORT unzGoToFirstFile (file)
   return UNZ_OK if there is no problem
   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
 */
-extern int ZEXPORT unzGoToNextFile (file)
-    unzFile file;
+extern int ZEXPORT unzGoToNextFile (unzFile file)
 {
     unz_s* s;
     int err;
@@ -826,10 +791,7 @@ extern int ZEXPORT unzGoToNextFile (file)
   UNZ_OK if the file is found. It becomes the current file.
   UNZ_END_OF_LIST_OF_FILE if the file is not found
 */
-extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
-    unzFile file;
-    const char *szFileName;
-    int iCaseSensitivity;
+extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
 {
     unz_s* s;
     int err;
@@ -905,9 +867,7 @@ typedef struct unz_file_pos_s
 } unz_file_pos;
 */
 
-extern int ZEXPORT unzGetFilePos(file, file_pos)
-    unzFile file;
-    unz_file_pos* file_pos;
+extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos* file_pos)
 {
     unz_s* s;
 
@@ -923,9 +883,7 @@ extern int ZEXPORT unzGetFilePos(file, file_pos)
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzGoToFilePos(file, file_pos)
-    unzFile file;
-    unz_file_pos* file_pos;
+extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos*file_pos)
 {
     unz_s* s;
     int err;
@@ -959,13 +917,11 @@ extern int ZEXPORT unzGoToFilePos(file, file_pos)
   store in *piSizeVar the size of extra info in local header
         (filename and size of extra field data)
 */
-local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
-                                                    poffset_local_extrafield,
-                                                    psize_local_extrafield)
-    unz_s* s;
-    uInt* piSizeVar;
-    uLong *poffset_local_extrafield;
-    uInt  *psize_local_extrafield;
+local int unzlocal_CheckCurrentFileCoherencyHeader (
+    unz_s* s,
+    uInt* piSizeVar,
+    uLong *poffset_local_extrafield,
+    uInt  *psize_local_extrafield)
 {
     uLong uMagic,uData,uFlags;
     uLong size_filename;
@@ -1050,12 +1006,12 @@ local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
   Open for reading data the current file in the zipfile.
   If there is no error and the file is opened, the return value is UNZ_OK.
 */
-extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
-    unzFile file;
-    int* method;
-    int* level;
-    int raw;
-    const char* password;
+extern int ZEXPORT unzOpenCurrentFile3 (
+    unzFile file,
+    int* method,
+    int* level,
+    int raw,
+    const char* password)
 {
     int err=UNZ_OK;
     uInt iSizeVar;
@@ -1136,7 +1092,7 @@ extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
       pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
       pfile_in_zip_read_info->stream.zfree = (free_func)0;
       pfile_in_zip_read_info->stream.opaque = (voidpf)0;
-      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+      pfile_in_zip_read_info->stream.next_in = (Bytef*)0;
       pfile_in_zip_read_info->stream.avail_in = 0;
 
       err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
@@ -1195,24 +1151,21 @@ extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzOpenCurrentFile (file)
-    unzFile file;
+extern int ZEXPORT unzOpenCurrentFile (unzFile file)
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
 }
 
-extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
-    unzFile file;
-    const char* password;
+extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password)
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
 }
 
-extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
-    unzFile file;
-    int* method;
-    int* level;
-    int raw;
+extern int ZEXPORT unzOpenCurrentFile2 (
+    unzFile file,
+    int* method,
+    int* level,
+    int raw)
 {
     return unzOpenCurrentFile3(file, method, level, raw, NULL);
 }
@@ -1227,10 +1180,10 @@ extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
   return <0 with error code if there is an error
     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
 */
-extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
-    unzFile file;
-    voidp buf;
-    unsigned len;
+extern int ZEXPORT unzReadCurrentFile(
+    unzFile file,
+    voidp buf,
+    unsigned len)
 {
     int err=UNZ_OK;
     uInt iRead = 0;
@@ -1388,8 +1341,7 @@ extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
 /*
   Give the current position in uncompressed data
 */
-extern z_off_t ZEXPORT unztell (file)
-    unzFile file;
+extern z_off_t ZEXPORT unztell (unzFile file)
 {
     unz_s* s;
     file_in_zip_read_info_s* pfile_in_zip_read_info;
@@ -1408,8 +1360,7 @@ extern z_off_t ZEXPORT unztell (file)
 /*
   return 1 if the end of file was reached, 0 elsewhere
 */
-extern int ZEXPORT unzeof (file)
-    unzFile file;
+extern int ZEXPORT unzeof (unzFile file)
 {
     unz_s* s;
     file_in_zip_read_info_s* pfile_in_zip_read_info;
@@ -1441,10 +1392,10 @@ extern int ZEXPORT unzeof (file)
   the return value is the number of bytes copied in buf, or (if <0)
     the error code
 */
-extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
-    unzFile file;
-    voidp buf;
-    unsigned len;
+extern int ZEXPORT unzGetLocalExtrafield (
+    unzFile file,
+    voidp buf,
+    unsigned len)
 {
     unz_s* s;
     file_in_zip_read_info_s* pfile_in_zip_read_info;
@@ -1492,8 +1443,7 @@ extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
   Close the file in zip opened with unzipOpenCurrentFile
   Return UNZ_CRCERROR if all the file was read but the CRC is not good
 */
-extern int ZEXPORT unzCloseCurrentFile (file)
-    unzFile file;
+extern int ZEXPORT unzCloseCurrentFile (unzFile file)
 {
     int err=UNZ_OK;
 
@@ -1535,12 +1485,11 @@ extern int ZEXPORT unzCloseCurrentFile (file)
   uSizeBuf is the size of the szComment buffer.
   return the number of byte copied or an error code <0
 */
-extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
-    unzFile file;
-    char *szComment;
-    uLong uSizeBuf;
+extern int ZEXPORT unzGetGlobalComment (
+    unzFile file,
+    char *szComment,
+    uLong uSizeBuf)
 {
-    int err=UNZ_OK;
     unz_s* s;
     uLong uReadThis ;
     if (file==NULL)
@@ -1567,8 +1516,7 @@ extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
 }
 
 /* Additions by RX '2004 */
-extern uLong ZEXPORT unzGetOffset (file)
-    unzFile file;
+extern uLong ZEXPORT unzGetOffset (unzFile file)
 {
     unz_s* s;
 
@@ -1583,9 +1531,9 @@ extern uLong ZEXPORT unzGetOffset (file)
     return s->pos_in_central_dir;
 }
 
-extern int ZEXPORT unzSetOffset (file, pos)
-        unzFile file;
-        uLong pos;
+extern int ZEXPORT unzSetOffset (
+        unzFile file,
+        uLong pos)
 {
     unz_s* s;
     int err;

JGE/src/unzip/zip.c

@@ -172,8 +172,7 @@ local linkedlist_datablock_internal* allocate_new_datablock()
     return ldi;
 }
 
-local void free_datablock(ldi)
-    linkedlist_datablock_internal* ldi;
+local void free_datablock(linkedlist_datablock_internal* ldi)
 {
     while (ldi!=NULL)
     {
@@ -183,24 +182,24 @@ local void free_datablock(ldi)
     }
 }
 
-local void init_linkedlist(ll)
-    linkedlist_data* ll;
+local void init_linkedlist(
+    linkedlist_data* ll)
 {
     ll->first_block = ll->last_block = NULL;
 }
 
-local void free_linkedlist(ll)
-    linkedlist_data* ll;
+local void free_linkedlist(
+    linkedlist_data* ll)
 {
     free_datablock(ll->first_block);
     ll->first_block = ll->last_block = NULL;
 }
 
 
-local int add_data_in_datablock(ll,buf,len)
-    linkedlist_data* ll;
-    const void* buf;
-    uLong len;
+local int add_data_in_datablock(
+    linkedlist_data* ll,
+    const void* buf,
+    uLong len)
 {
     linkedlist_datablock_internal* ldi;
     const unsigned char* from_copy;
@@ -263,11 +262,11 @@ local int add_data_in_datablock(ll,buf,len)
 
 local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
                                 voidpf filestream, uLong x, int nbByte));
-local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong x;
-    int nbByte;
+local int ziplocal_putValue (
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong x,
+    int nbByte)
 {
     unsigned char buf[4];
     int n;
@@ -291,10 +290,10 @@ local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
 }
 
 local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
-local void ziplocal_putValue_inmemory (dest, x, nbByte)
-    void* dest;
-    uLong x;
-    int nbByte;
+local void ziplocal_putValue_inmemory (
+    void* dest,
+    uLong x,
+    int nbByte)
 {
     unsigned char* buf=(unsigned char*)dest;
     int n;
@@ -315,9 +314,9 @@ local void ziplocal_putValue_inmemory (dest, x, nbByte)
 /****************************************************************************/
 
 
-local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
-    const tm_zip* ptm;
-    uLong dosDate;
+local uLong ziplocal_TmzDateToDosDate(
+    const tm_zip* ptm,
+    uLong dosDate)
 {
     uLong year = (uLong)ptm->tm_year;
     if (year>1980)
@@ -337,10 +336,10 @@ local int ziplocal_getByte OF((
     voidpf filestream,
     int *pi));
 
-local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    int *pi;
+local int ziplocal_getByte(
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    int *pi)
 {
     unsigned char c;
     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
@@ -367,10 +366,10 @@ local int ziplocal_getShort OF((
     voidpf filestream,
     uLong *pX));
 
-local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong *pX;
+local int ziplocal_getShort (
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX)
 {
     uLong x ;
     int i;
@@ -395,10 +394,10 @@ local int ziplocal_getLong OF((
     voidpf filestream,
     uLong *pX));
 
-local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong *pX;
+local int ziplocal_getLong (
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX)
 {
     uLong x ;
     int i;
@@ -437,9 +436,9 @@ local uLong ziplocal_SearchCentralDir OF((
     const zlib_filefunc_def* pzlib_filefunc_def,
     voidpf filestream));
 
-local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
+local uLong ziplocal_SearchCentralDir(
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream)
 {
     unsigned char* buf;
     uLong uSizeFile;
@@ -496,11 +495,11 @@ local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
 #endif /* !NO_ADDFILEINEXISTINGZIP*/
 
 /************************************************************/
-extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
-    const char *pathname;
-    int append;
-    zipcharpc* globalcomment;
-    zlib_filefunc_def* pzlib_filefunc_def;
+extern zipFile ZEXPORT zipOpen2 (
+    const char *pathname,
+    int append,
+    zipcharpc* globalcomment,
+    zlib_filefunc_def* pzlib_filefunc_def)
 {
     zip_internal ziinit;
     zip_internal* zi;
@@ -615,7 +614,7 @@ extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc
 
         if (size_comment>0)
         {
-            ziinit.globalcomment = ALLOC(size_comment+1);
+            ziinit.globalcomment = (char*)ALLOC(size_comment+1);
             if (ziinit.globalcomment)
             {
                size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
@@ -680,35 +679,30 @@ extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc
     }
 }
 
-extern zipFile ZEXPORT zipOpen (pathname, append)
-    const char *pathname;
-    int append;
+extern zipFile ZEXPORT zipOpen (
+    const char *pathname,
+    int append)
 {
     return zipOpen2(pathname,append,NULL,NULL);
 }
 
-extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
-                                         extrafield_local, size_extrafield_local,
-                                         extrafield_global, size_extrafield_global,
-                                         comment, method, level, raw,
-                                         windowBits, memLevel, strategy,
-                                         password, crcForCrypting)
-    zipFile file;
-    const char* filename;
-    const zip_fileinfo* zipfi;
-    const void* extrafield_local;
-    uInt size_extrafield_local;
-    const void* extrafield_global;
-    uInt size_extrafield_global;
-    const char* comment;
-    int method;
-    int level;
-    int raw;
-    int windowBits;
-    int memLevel;
-    int strategy;
-    const char* password;
-    uLong crcForCrypting;
+extern int ZEXPORT zipOpenNewFileInZip3 (
+    zipFile file,
+    const char* filename,
+    const zip_fileinfo* zipfi,
+    const void* extrafield_local,
+    uInt size_extrafield_local,
+    const void* extrafield_global,
+    uInt size_extrafield_global,
+    const char* comment,
+    int method,
+    int level,
+    int raw,
+    int windowBits,
+    int memLevel,
+    int strategy,
+    const char* password,
+    uLong crcForCrypting)
 {
     zip_internal* zi;
     uInt size_filename;
@@ -896,21 +890,18 @@ extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
     return err;
 }
 
-extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
-                                        extrafield_local, size_extrafield_local,
-                                        extrafield_global, size_extrafield_global,
-                                        comment, method, level, raw)
-    zipFile file;
-    const char* filename;
-    const zip_fileinfo* zipfi;
-    const void* extrafield_local;
-    uInt size_extrafield_local;
-    const void* extrafield_global;
-    uInt size_extrafield_global;
-    const char* comment;
-    int method;
-    int level;
-    int raw;
+extern int ZEXPORT zipOpenNewFileInZip2(
+    zipFile file,
+    const char* filename,
+    const zip_fileinfo* zipfi,
+    const void* extrafield_local,
+    uInt size_extrafield_local,
+    const void* extrafield_global,
+    uInt size_extrafield_global,
+    const char* comment,
+    int method,
+    int level,
+    int raw)
 {
     return zipOpenNewFileInZip3 (file, filename, zipfi,
                                  extrafield_local, size_extrafield_local,
@@ -920,20 +911,17 @@ extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
                                  NULL, 0);
 }
 
-extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
-                                        extrafield_local, size_extrafield_local,
-                                        extrafield_global, size_extrafield_global,
-                                        comment, method, level)
-    zipFile file;
-    const char* filename;
-    const zip_fileinfo* zipfi;
-    const void* extrafield_local;
-    uInt size_extrafield_local;
-    const void* extrafield_global;
-    uInt size_extrafield_global;
-    const char* comment;
-    int method;
-    int level;
+extern int ZEXPORT zipOpenNewFileInZip (
+    zipFile file,
+    const char* filename,
+    const zip_fileinfo* zipfi,
+    const void* extrafield_local,
+    uInt size_extrafield_local,
+    const void* extrafield_global,
+    uInt size_extrafield_global,
+    const char* comment,
+    int method,
+    int level)
 {
     return zipOpenNewFileInZip2 (file, filename, zipfi,
                                  extrafield_local, size_extrafield_local,
@@ -941,8 +929,8 @@ extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
                                  comment, method, level, 0);
 }
 
-local int zipFlushWriteBuffer(zi)
-  zip_internal* zi;
+local int zipFlushWriteBuffer(
+  zip_internal* zi)
 {
     int err=ZIP_OK;
 
@@ -963,10 +951,10 @@ local int zipFlushWriteBuffer(zi)
     return err;
 }
 
-extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
-    zipFile file;
-    const void* buf;
-    unsigned len;
+extern int ZEXPORT zipWriteInFileInZip (
+    zipFile file,
+    const void* buf,
+    unsigned len)
 {
     zip_internal* zi;
     int err=ZIP_OK;
@@ -978,9 +966,9 @@ extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
     if (zi->in_opened_file_inzip == 0)
         return ZIP_PARAMERROR;
 
-    zi->ci.stream.next_in = (void*)buf;
+    zi->ci.stream.next_in = (Bytef*)buf;
     zi->ci.stream.avail_in = len;
-    zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
+    zi->ci.crc32 = crc32(zi->ci.crc32,(const Bytef*)buf,len);
 
     while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
     {
@@ -1028,10 +1016,10 @@ extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
     return err;
 }
 
-extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
-    zipFile file;
-    uLong uncompressed_size;
-    uLong crc32;
+extern int ZEXPORT zipCloseFileInZipRaw (
+    zipFile file,
+    uLong uncompressed_size,
+    uLong crc32)
 {
     zip_internal* zi;
     uLong compressed_size;
@@ -1124,15 +1112,15 @@ extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
     return err;
 }
 
-extern int ZEXPORT zipCloseFileInZip (file)
-    zipFile file;
+extern int ZEXPORT zipCloseFileInZip (
+    zipFile file)
 {
     return zipCloseFileInZipRaw (file,0,0);
 }
 
-extern int ZEXPORT zipClose (file, global_comment)
-    zipFile file;
-    const char* global_comment;
+extern int ZEXPORT zipClose (
+    zipFile file,
+    const char* global_comment)
 {
     zip_internal* zi;
     int err = 0;

JGE/src/zipFS/zfsystem.cpp

@@ -42,7 +42,6 @@ filesystem * filesystem::pCurrentFS = NULL;
 std::vector<filesystem::pooledBuffer *> filesystem::m_Buffers;
 
 static const int STORED = 0;
-static const int DEFLATED = 8;
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction

JGE/src/zipFS/zstream.h

@@ -106,6 +106,7 @@ public:
  	virtual int overflow(int c = EOF);
 	virtual int underflow();
 	virtual int	sync();
+    using std::streambuf::setbuf;
 	virtual std::streambuf * setbuf(char * pr, int nLength);
 	virtual std::streampos seekoff(std::streamoff, std::ios::seekdir, std::ios::openmode);
 
@@ -131,6 +132,7 @@ public:
  	virtual int overflow(int c = EOF);
 	virtual int underflow();
 	virtual int sync();
+    using std::streambuf::setbuf;
 	virtual std::streambuf * setbuf(char * pr, int nLength);
 	virtual std::streampos seekoff(std::streamoff, std::ios::seekdir, std::ios::openmode);
 

README.md

@@ -2,6 +2,8 @@
 
 
 [![Build Status](https://travis-ci.org/WagicProject/wagic.png?branch=master)](https://travis-ci.org/WagicProject/wagic)
+[![Build status](https://ci.appveyor.com/api/projects/status/7j4fbr6m62aqej59/branch/master)](https://ci.appveyor.com/project/xawotihs/wagic/branch/master)
+[![Coverage Status](https://coveralls.io/repos/WagicProject/wagic/badge.png?branch=master)](https://coveralls.io/r/WagicProject/wagic?branch=master)
 
 ## Description
 
@@ -16,6 +18,11 @@ Wagic, the Homebrew, is a C++ game engine that allows to play card games against
 It is highly customizable and allows the player to tweak the rules / create their own cards, their own themes, etc... 
 
 
-Info, Downloads, and more at http://wololo.net
+Info, downloads, discussions and more at http://wololo.net/forum/index.php
 
 -![alt text](http://wololo.net/wagic/wp-content/uploads/2009/10/shop.jpg "Screenshot")
+
+
+
+### Sample round play-through video
+[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/WUFSAPZuDIk/0.jpg)](http://www.youtube.com/watch?v=WUFSAPZuDIk)

appveyor.yml

@@ -0,0 +1,76 @@
+# Notes:
+#   - Minimal appveyor.yml file is an empty file. All sections are optional.
+#   - Indent each level of configuration with 2 spaces. Do not use tabs!
+#   - All section names are case-sensitive.
+#   - Section names should be unique on each level.
+
+# branches to build
+branches:
+  # blacklist
+  except:
+    - travis_mac_osx
+# Do not build on tags (GitHub only)
+skip_tags: true
+
+#---------------------------------#
+#    environment configuration    #
+#---------------------------------#
+
+environment:
+  GH_TOKEN:
+    secure: dYnBDQkiY5oVjIlswzBX9BJigNtBGXgGlp1tK3XbHzrDEDrs2vaKD5m+Oz5OSz1C
+
+# scripts that run after cloning repository
+install:
+  - ps: (new-object net.webclient).DownloadFile('https://bootstrap.pypa.io/get-pip.py', 'C:/get-pip.py')
+  - "C:/Python27/python.exe C:/get-pip.py"
+  - "C:/Python27/Scripts/pip.exe install pyjavaproperties"
+  - "C:/Python27/Scripts/pip.exe install github3.py"
+
+#---------------------------------#
+#       build configuration       #
+#---------------------------------#
+
+# build Configuration, i.e. Debug, Release, etc.
+configuration: Release
+
+build:
+  project: projects/mtg/mtg_vs2010.sln      # path to Visual Studio solution or project
+
+#---------------------------------#
+#       tests configuration       #
+#---------------------------------#
+
+# to disable automatic tests
+test: off
+
+
+#---------------------------------#
+#      artifacts configuration    #
+#---------------------------------#
+
+artifacts:
+  # pushing windows package
+  - path: projects\mtg\bin\Wagic-windows*.zip
+
+
+#---------------------------------#
+#     deployment configuration    #
+#---------------------------------#
+
+# scripts to run before deployment
+before_deploy:
+  - cd projects/mtg/bin
+  - "C:/Python27/python.exe createWindowsZip.py"
+  - cd ../../..
+
+# scripts to run after deployment
+after_deploy:
+
+# to run your custom scripts instead of provider deployments
+deploy_script:
+  - "C:/Python27/python.exe tools/upload-binaries.py -t %GH_TOKEN% -s %APPVEYOR_REPO_COMMIT% -l projects/mtg/bin/Wagic-windows.zip -r Wagic-windows.zip -b %APPVEYOR_REPO_BRANCH%"
+
+# to disable deployment
+#deploy: off
+

projects/mtg/Android/AndroidManifest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8" standalone="no"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="0192" android:versionName="@string/app_version" package="net.wagic.app">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="0201" android:versionName="@string/app_version" package="net.wagic.app">
     <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.INTERNET"/>

projects/mtg/Android/jni/Android.mk

@@ -57,7 +57,6 @@ LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.cpp \
         $(MTG_PATH)/src/DeckMetaData.cpp \
         $(MTG_PATH)/src/DeckStats.cpp \
         $(MTG_PATH)/src/DuelLayers.cpp \
-        $(MTG_PATH)/src/Effects.cpp \
         $(MTG_PATH)/src/ExtraCost.cpp \
         $(MTG_PATH)/src/GameApp.cpp \
         $(MTG_PATH)/src/GameLauncher.cpp \

projects/mtg/Android/res/values/strings.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
     <string name="app_name">Wagic</string>
-    <string name="app_version">0.19.2</string>
-    <string name="info_text">Wagic v0.19.2\\nAll Rights Reserved.</string>
+    <string name="app_version">0.20.1</string>
+    <string name="info_text">Wagic v0.20.1\\nAll Rights Reserved.</string>
 </resources>

projects/mtg/Android/src/net/wagic/utils/DeckImporter.java

@@ -0,0 +1,280 @@
+package net.wagic.utils;
+
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.File;
+import java.io.IOException;
+import java.util.Scanner;
+
+import android.util.Log;
+
+public class DeckImporter
+{
+
+    public static String importDeck( File f, String mypath, String activePath )
+    {
+        String message = "";
+        String deck = "";
+        String deckname = "";
+		String prefix = "#SB:";
+        if(f.exists() && !f.isDirectory())
+        { 
+            deckname = f.getName();
+            int pos = deckname.lastIndexOf(".");
+            if (pos > 0) 
+            {
+                deckname = deckname.substring(0, pos);
+            }
+            deck += "#NAME:"+deckname+"\n"; 
+            try
+            {
+                Scanner scanner = new Scanner(new File(mypath));                
+                if (scanner.hasNext()) 
+                {
+                    while (scanner.hasNext()) 
+                    {
+                        String line = scanner.nextLine();
+						line = line.trim();
+						if (!line.equals("")) // don't write out blank lines
+						{
+							String[] slines = line.split("\\s+");
+							String arranged = "";
+							for(int idx = 1; idx < slines.length; idx++)
+							{
+								arranged += slines[idx] + " ";
+							}
+							if ((isNumeric(slines[0])) && arranged != null)
+							{							
+								if (slines[1] != null && slines[1].startsWith("["))
+								{
+									arranged = arranged.substring(5);
+									slines[1] = slines[1].replaceAll("\\[", "").replaceAll("\\]","");
+									deck += arranged + " (" + renameSet(slines[1]) + ") * " + slines[0] + "\n";
+								}
+								else
+								{
+									deck += arranged + "(*) * " + slines[0] + "\n";
+								}
+							}
+						}
+					}
+					File profile = new File(activePath+"/Res/settings/options.txt");
+					if(profile.exists() && !profile.isDirectory())
+					{
+						String profileName = getActiveProfile(profile);
+						if(profileName != "Missing!")
+						{
+							File rootProfiles = new File(activePath+"/Res/profiles/"+profileName);
+							if(rootProfiles.exists() && rootProfiles.isDirectory())
+							{
+								//save deck
+								int countdeck = 1;
+								File[] files = rootProfiles.listFiles();
+								for (int i = 0; i < files.length; i++)
+								{//check if there is available deck...
+									if(files[i].getName().startsWith("deck"))
+                                       countdeck++;
+								}
+								File toSave = new File(rootProfiles+"/deck"+countdeck+".txt");
+								try 
+								{
+									FileOutputStream fop = new FileOutputStream(toSave);
+                                   
+									// if file doesn't exists, then create it
+									if (!toSave.exists()) {
+                                       toSave.createNewFile();
+									}
+										// get the content in bytes
+									byte[] contentInBytes = deck.getBytes();
+									fop.write(contentInBytes);
+									fop.flush();
+									fop.close();
+									message = "Import Deck Success!\n\n"+deck;
+								} 
+								catch (IOException e) 
+								{
+									message = e.getMessage();
+								}
+							}
+							else
+							{
+								message = "Missing Folder!";
+							}
+						}
+					}
+					else
+					{
+						message = "Invalid Profile!";
+					}
+				}
+				else
+				{
+					message = "No errors, and file EMPTY";
+				}
+			}
+			catch(IOException e)
+			{
+				message = e.getMessage();
+			}
+		}
+		return message;
+    }
+      
+    private static boolean isNumeric(String input)
+    {
+        try
+        {
+            Integer.parseInt(input);
+        }
+        catch(NumberFormatException ex)
+        {
+            return false;
+        }
+        return true;
+    }
+    
+    private static String getActiveProfile(File mypath)
+    {
+        String name = "";
+        try
+            {
+                Scanner scanner = new Scanner(new File(mypath.toString()));                
+                if (scanner.hasNext()) 
+                {
+                    String line = scanner.nextLine();
+                    name = line.substring(8);    
+                }
+                else
+                {
+                    return "Missing!";
+                }
+            }
+            catch(IOException e)
+            {
+                return "Missing!";
+            }
+        return name;
+    }
+    
+    private static String renameSet(String set)
+    {
+        if (set == "")
+            return "*";
+        if (set == "AL")
+            return "ALL";
+        if (set == "AQ")
+            return "ATQ";
+        if (set == "AP")
+            return "APC";
+        if (set == "AN")
+            return "ARN";
+        if (set == "AE")
+            return "ARC";
+        if (set == "BR")
+            return "BRB";
+        if (set == "BD")
+            return "BTD";
+        if (set == "CH")
+            return "CHR";
+        if (set == "6E")
+            return "6ED";
+        if (set == "CS")
+            return "CSP";
+        if (set == "DS")
+            return "DST";
+        if (set == "D2")
+            return "DD2";
+        if (set == "8E")
+            return "8ED";
+        if (set == "EX")
+            return "EXO";
+        if (set == "FE")
+            return "FEM";
+        if (set == "FD")
+            return "5DN";
+        if (set == "5E")
+            return "5ED";
+        if (set == "4E")
+            return "4ED";
+        if (set == "GP")
+            return "GPT";
+        if (set == "HL")
+            return "HML";
+        if (set == "IA")
+            return "ICE";
+        if (set == "IN")
+            return "INV";
+        if (set == "JU")
+            return "JUD";
+        if (set == "LG")
+            return "LEG";
+        if (set == "LE")
+            return "LGN";
+        if (set == "A")
+            return "LEA";
+        if (set == "B")
+            return "LEB";
+        if (set == "MM")
+            return "MMQ";
+        if (set == "MI")
+            return "MIR";
+        if (set == "MR")
+            return "MRD";
+        if (set == "NE")
+            return "NEM";
+        if (set == "9E")
+            return "9ED";
+        if (set == "OD")
+            return "ODY";
+        if (set == "ON")
+            return "ONS";
+        if (set == "PS")
+            return "PLS";
+        if (set == "PT")
+            return "POR";
+        if (set == "P2")
+            return "P02";
+        if (set == "P3")
+            return "PTK";
+        if (set == "PR")
+            return "PPR";
+        if (set == "PY")
+            return "PCY";
+        if (set == "R")
+            return "RV";
+        if (set == "SC")
+            return "SCG";
+        if (set == "7E")
+            return "7ED";
+        if (set == "ST")
+            return "S99";
+        if (set == "ST2K")
+            return "S00";
+        if (set == "SH")
+            return "STH";
+        if (set == "TE")
+            return "TMP";
+        if (set == "DK")
+            return "DRK";
+        if (set == "TO")
+            return "TOR";
+        if (set == "UG")
+            return "UGL";
+        if (set == "U")
+            return "2ED";
+        if (set == "UD")
+            return "UDS";
+        if (set == "UL")
+            return "ULG";
+        if (set == "US")
+            return "USG";
+        if (set == "VI")
+            return "VIS";
+        if (set == "WL")
+            return "WTH";
+        else
+            return set;
+    }
+    
+}

projects/mtg/Android/src/net/wagic/utils/StorageOptions.java

@@ -5,6 +5,10 @@ import java.io.FileNotFoundException;
 import java.util.ArrayList;
 import java.util.Scanner;
 
+import java.util.HashSet;
+import java.util.Set;
+import android.os.Build;
+
 import android.os.Environment;
 import android.util.Log;
 
@@ -21,8 +25,14 @@ public class StorageOptions
     public static void determineStorageOptions()
     {
         initializeMountPoints();
+        if (findForcemount()){
+            readMountsFileTest();
+        }
         readMountsFile();
         readVoldFile();
+        if (findForcemount()){
+            removeDuplicates(mMounts);
+        }
         compareMountsWithVold();
         testAndCleanMountsList();
         setProperties();
@@ -40,6 +50,42 @@ public class StorageOptions
         }
     }
 
+    private static void readMountsFileTest()
+    {
+        /*
+         * Test mountpoints storage -kevlahnota
+         */
+
+        try
+        {
+            Scanner scanner = new Scanner(new File("/proc/mounts"));
+            while (scanner.hasNext())
+            {
+                String line = scanner.nextLine();
+                if (line.startsWith("/"))
+                {
+                    String[] lineElements = line.split("\\s+");
+                    if ("vfat".equals(lineElements[2]) || "fuse".equals(lineElements[2]) || "sdcardfs".equals(lineElements[2])) 
+                    {
+                        File mountPoint = new File(lineElements[1]);
+                        if (!lineElements[1].equals(defaultMountPoint))
+                            if (mountPoint.isDirectory() && mountPoint.canRead())
+                                mMounts.add(lineElements[1]);
+                    }
+                }
+            }
+        } catch (FileNotFoundException fnfex)
+        {
+            // if proc/mount doesn't exist we just use
+            Log.i(StorageOptions.class.getCanonicalName(), fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
+            mMounts.add(defaultMountPoint);
+        } catch (Exception e)
+        {
+            Log.e(StorageOptions.class.getCanonicalName(), e.getMessage() + ": unknown exception while reading mounts file");
+            mMounts.add(defaultMountPoint);
+        }
+    }
+
     private static void readMountsFile()
     {
         /*
@@ -106,6 +152,23 @@ public class StorageOptions
             mMounts.add(defaultMountPoint);
         }
     }
+    
+    private static ArrayList<String> removeDuplicates(ArrayList<String> list) 
+    {
+        ArrayList<String> result = new ArrayList<String>();
+
+        HashSet<String> set = new HashSet<String>();
+
+        for (String item : list) 
+        {
+            if (!set.contains(item)) 
+            {
+                result.add(item);
+                set.add(item);
+            }
+        }
+        return result;
+    }
 
     private static void compareMountsWithVold()
     {
@@ -132,14 +195,54 @@ public class StorageOptions
         /*
          * Now that we have a cleaned list of mount paths Test each one to make sure it's a valid and available path. If it is not, remove it from the list.
          */
-
+        int t = 0;
         for (int i = 0; i < mMounts.size(); i++)
         {
+            t++;
             String mount = mMounts.get(i);
             File root = new File(mount);
             if (!root.exists() || !root.isDirectory() || !root.canWrite())
                 mMounts.remove(i--);
         }
+        
+        if (t == 0 && Build.VERSION.SDK_INT >= 16 && findForcemount())
+        {//if none is found lets force it for Jellybean and above...
+            if (System.getenv("EXTERNAL_STORAGE") != null)
+            {
+                File root = new File(System.getenv("EXTERNAL_STORAGE"));
+                if (root.exists() && root.isDirectory() && root.canWrite())
+                {
+                    if(!isRooted())
+                    {
+                        File folder = new File(System.getenv("EXTERNAL_STORAGE")+"/Android/data/net.wagic.app/files");
+                        folder.mkdirs();
+                        mMounts.add(folder.toString());
+                    }
+                    else
+                    {
+                        mMounts.add(System.getenv("EXTERNAL_STORAGE"));
+                    }
+                }
+            }
+            
+            if (System.getenv("SECONDARY_STORAGE") != null)
+            {
+                File root = new File(System.getenv("SECONDARY_STORAGE"));
+                if (root.exists() && root.isDirectory() && root.canWrite())
+                {
+                    if(!isRooted())
+                    {
+                        File folder = new File(System.getenv("SECONDARY_STORAGE")+"/Android/data/net.wagic.app/files");
+                        folder.mkdirs();
+                        mMounts.add(folder.toString());
+                    }
+                    else
+                    {
+                        mMounts.add(System.getenv("SECONDARY_STORAGE"));
+                    }
+                }
+            }
+        }
     }
 
     private static void setProperties()
@@ -151,14 +254,28 @@ public class StorageOptions
         ArrayList<String> mLabels = new ArrayList<String>();
 
         int i = 1;
-        for (String path : mMounts)
-        { // TODO: /mnt/sdcard is assumed to always mean internal storage. Use this comparison until there is a better way to do this
-            if ("/mnt/sdcard".equalsIgnoreCase(path))
-                mLabels.add("Built-in Storage");
-            else
-                mLabels.add("External SD Card " + i++);
+        if(findForcemount()){
+            for (String path : mMounts)
+            {//with forcemount menu
+                if ("/mnt/sdcard".equalsIgnoreCase(path) || "/storage/sdcard0".equalsIgnoreCase(path))
+                    mLabels.add("Internal SD " + "[" + path + "]");
+                else if (path.contains("emulated"))
+                    mLabels.add("Emulated SD " + " [" + path + "]");
+                else
+                    mLabels.add("External SD " + " [" + path + "]");
+            }
         }
-
+        else
+        {
+            for (String path : mMounts)
+            { // TODO: /mnt/sdcard is assumed to always mean internal storage. Use this comparison until there is a better way to do this
+                if ("/mnt/sdcard".equalsIgnoreCase(path))
+                    mLabels.add("Built-in Storage");
+                else
+                    mLabels.add("External SD Card " + i++);
+            }
+        }
+        
         labels = new String[mLabels.size()];
         mLabels.toArray(labels);
 
@@ -171,4 +288,106 @@ public class StorageOptions
         // use and to prepare it for the next time it's needed.
         mMounts.clear();
     }
-}
+    
+    private static boolean isExternalStorageReadOnly() {
+        String extStorageState = Environment.getExternalStorageState();
+        if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(extStorageState)) {
+            return true;
+        }
+        return false;
+    }
+ 
+    private static boolean isExternalStorageAvailable() {
+        String extStorageState = Environment.getExternalStorageState();
+        if (Environment.MEDIA_MOUNTED.equals(extStorageState)) {
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+    * Checks if the device is rooted.
+    *
+    * @return <code>true</code> if the device is rooted, <code>false</code> otherwise.
+    */
+    public static boolean isRooted() {
+
+    // get from build info
+    String buildTags = android.os.Build.TAGS;
+    if (buildTags != null && buildTags.contains("test-keys")) {
+      return true;
+    }
+
+    // check if /system/app/Superuser.apk is present
+    try {
+      File file = new File("/system/app/Superuser.apk");
+      if (file.exists()) {
+        return true;
+      }
+    } 
+    catch (Exception e1) {
+      // ignore
+    }
+    try {
+      File file = new File("/system/app/Superuser/Superuser.apk");
+      if (file.exists()) {
+        return true;
+      }
+    } 
+    catch (Exception e1) {
+      // ignore
+    }
+    //SuperSU
+    try {
+      File file = new File("/system/app/SuperSU.apk");
+      if (file.exists()) {
+        return true;
+      }
+    } 
+    catch (Exception e1) {
+      // ignore
+    }
+    try {
+      File file = new File("/system/app/SuperSU/SuperSU.apk");
+      if (file.exists()) {
+        return true;
+      }
+    } 
+    catch (Exception e1) {
+      // ignore
+    }
+    // try executing commands
+    return canExecuteCommand("/system/xbin/which su")
+        || canExecuteCommand("/system/bin/which su") || canExecuteCommand("which su");
+    }
+
+    // executes a command on the system
+    private static boolean canExecuteCommand(String command) {
+    boolean executedSuccesfully;
+    try {
+      Runtime.getRuntime().exec(command);
+      executedSuccesfully = true;
+    } 
+    catch (Exception e) {
+      executedSuccesfully = false;
+    }
+
+    return executedSuccesfully;
+    }
+    
+    private static boolean findForcemount(){
+    try 
+    {
+        File file = new File(System.getenv("EXTERNAL_STORAGE")+"/forcemount");
+        if (file.exists()) 
+        {
+            return true;
+        }
+    } 
+    catch (Exception e1) 
+    {
+        return false;
+    }
+    return false;
+    }
+}

projects/mtg/Android/src/org/libsdl/app/SDLActivity.java

@@ -1,12 +1,20 @@
 package org.libsdl.app;
 
+
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
 import java.io.InputStream;
+import java.io.IOException;
 import java.io.OutputStream;
 import java.net.URL;
 import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+
 
 import javax.microedition.khronos.egl.EGL10;
 import javax.microedition.khronos.egl.EGLConfig;
@@ -16,6 +24,7 @@ import javax.microedition.khronos.egl.EGLSurface;
 
 import net.wagic.app.R;
 import net.wagic.utils.StorageOptions;
+import net.wagic.utils.DeckImporter;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.Dialog;
@@ -59,7 +68,10 @@ import android.widget.FrameLayout.LayoutParams;
  */
 public class SDLActivity extends Activity implements OnKeyListener
 {
-
+    //import deck globals
+    public ArrayList<String> myresult = new ArrayList<String>();
+    public String myclickedItem = "";
+        
     // TAG used for debugging in DDMS
     public static String       TAG                                   = Activity.class.getCanonicalName();
 
@@ -80,7 +92,6 @@ public class SDLActivity extends Activity implements OnKeyListener
     public Boolean             mErrorHappened                        = false;
     public final static String RES_FOLDER                            = Environment.getExternalStorageDirectory().getPath() + "/Wagic/Res/";
     public static String       RES_FILENAME                          = "core_0184.zip";
-    public static final String RES_URL                               = "http://wagic.googlecode.com/files/";
 
     public String              systemFolder                          = Environment.getExternalStorageDirectory().getPath() + "/Wagic/Res/";
     private String             userFolder;
@@ -201,7 +212,60 @@ public class SDLActivity extends Activity implements OnKeyListener
 
         setStorage.create().show();
     }
+    
+    private void importDeckOptions()
+    {
+        AlertDialog.Builder importDeck = new AlertDialog.Builder(this);
+        importDeck.setTitle("Choose Deck to Import:");
+        File root = new File(System.getenv("EXTERNAL_STORAGE")+"/Download");
+        File[] files = root.listFiles();
+        for( File f : files) 
+        {
+            if( !myresult.contains(f.toString()) && (f.toString().contains(".txt")||f.toString().contains(".dck")||f.toString().contains(".dec")))
+                myresult.add(f.toString());
+        }
+        
+        //get first item?
+        if(!myresult.isEmpty())
+            myclickedItem = myresult.get(0).toString();
+        
+        importDeck.setSingleChoiceItems(myresult.toArray(new String[myresult.size()]), 0, new DialogInterface.OnClickListener()
+        {
+            public void onClick(DialogInterface dialog, int item)
+            {
+                myclickedItem = myresult.get(item).toString();
+            }
+        });
 
+        importDeck.setPositiveButton("Import Deck", new DialogInterface.OnClickListener()
+        {
+            public void onClick(DialogInterface dialog, int which)
+            {
+                processSelectedDeck( myclickedItem );
+                if (mSurface == null)
+                    mSingleton.initializeGame();
+            }
+        });
+
+        importDeck.create().show();
+    }
+    
+    private void processSelectedDeck(String mypath)
+    {
+        AlertDialog.Builder infoDialog = new AlertDialog.Builder(this);
+        infoDialog.setTitle("Imported Deck:");
+        String activePath = sdcardPath;
+        if(activePath == ""){
+            activePath = internalPath;
+        }
+            
+        File f = new File(mypath);
+        //Call the deck importer....
+        String state = DeckImporter.importDeck(f, mypath, activePath);
+        infoDialog.setMessage(state);
+        infoDialog.show();
+    }
+  
     private void checkStorageLocationPreference()
     {
         SharedPreferences settings = getSharedPreferences(kWagicSharedPreferencesKey, MODE_PRIVATE);
@@ -307,7 +371,7 @@ public class SDLActivity extends Activity implements OnKeyListener
 
     private void startDownload()
     {
-        String url = RES_URL + RES_FILENAME;
+        String url = getResourceUrl();
         if (!checkStorageState())
         {
             Log.e(TAG, "Error in initializing storage space.");
@@ -335,7 +399,8 @@ public class SDLActivity extends Activity implements OnKeyListener
     public boolean onCreateOptionsMenu(Menu menu)
     {
         SubMenu settingsMenu = menu.addSubMenu(Menu.NONE, 1, 1, "Settings");
-        menu.add(Menu.NONE, 2, 2, "About");
+        menu.add(Menu.NONE, 2, 2, "Import");
+        menu.add(Menu.NONE, 3, 3, "About");
         settingsMenu.add(kStorageDataOptionsMenuId, kStorageDataOptionsMenuId, Menu.NONE, "Storage Data Options");
         // buildStorageOptionsMenu(settingsMenu);
 
@@ -351,6 +416,9 @@ public class SDLActivity extends Activity implements OnKeyListener
         {
             displayStorageOptions();
         } else if (itemId == 2)
+        {
+            importDeckOptions();
+        } else if (itemId == 3)
         {
             // display some info about the app
             AlertDialog.Builder infoDialog = new AlertDialog.Builder(this);
@@ -437,7 +505,7 @@ public class SDLActivity extends Activity implements OnKeyListener
         mContext = this.getApplicationContext();
         // get the current version of the app to set the core filename
         String versionCodeString = getApplicationCode();
-        RES_FILENAME = "core_" + versionCodeString + ".zip";
+        RES_FILENAME = getResourceName();
 
         StorageOptions.determineStorageOptions();
         checkStorageLocationPreference();
@@ -525,6 +593,9 @@ public class SDLActivity extends Activity implements OnKeyListener
     }
 
     // C functions we call
+    public static native String getResourceUrl();
+    public static native String getResourceName();
+
     public static native void nativeInit();
 
     public static native void nativeQuit();

projects/mtg/MacOS/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleGetInfoString</key>
+	<string>Created by Qt/QMake</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleExecutable</key>
+        <string>wagic.launcher</string>
+	<key>CFBundleIdentifier</key>
+	<string>wagic.wagic</string>
+	<key>NOTE</key>
+	<string>This file was generated by Qt/QMake.</string>
+</dict>
+</plist>

projects/mtg/MacOS/wagic.launcher

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+cd ${0%/*/*}/Resources
+#cd ../Resources
+exec ../MacOS/wagic -platformpluginpath ../PlugIns >> ../logs/out.log 2> ../logs/err.log

projects/mtg/Makefile

@@ -6,7 +6,7 @@ OBJS	= objs/InteractiveButton.o objs/AbilityParser.o objs/ActionElement.o\
 	objs/Counters.o objs/Credits.o objs/Damage.o objs/DamagerDamaged.o\
 	objs/DeckDataWrapper.o objs/DeckEditorMenu.o objs/DeckMenu.o\
 	objs/DeckMenuItem.o objs/DeckMetaData.o objs/DeckStats.o objs/DuelLayers.o\
-	objs/Effects.o objs/ExtraCost.o objs/GameApp.o objs/GameLauncher.o\
+	objs/ExtraCost.o objs/GameApp.o objs/GameLauncher.o\
 	objs/GameObserver.o objs/GameOptions.o objs/GameState.o\
 	objs/GameStateAwards.o objs/GameStateDeckViewer.o objs/GameStateDuel.o\
 	objs/DeckManager.o objs/GameStateMenu.o objs/GameStateOptions.o\
@@ -128,7 +128,7 @@ clean:
 endif
 
 define compile
-$(CXX) -c $(CXXFLAGS) $< -o $@  
+$(CXX) -c $(CXXFLAGS) $< -o $@
 endef
 
 PrecompiledHeader.h.gch: ../../projects/mtg/include/PrecompiledHeader.h

projects/mtg/bin/Res/ai/baka/deck104.txt

@@ -1,5 +1,11 @@
 #NAME:Kill by Numbers
 #DESC:They just keep multiplying.
+#HINT:castpriority(enchantment,instant,sorcery,artifact,creature)
+#HINT:dontattackwith(Rhys the Redeemed)
+#HINT:dontblockwith(Rhys the Redeemed)
+#HINT:dontattackwith(Kazandu Tuskcaller)
+#HINT:dontblockwith(Kazandu Tuskcaller)
+
 Mox Emerald	 (LEA) *2
 Mox Pearl	 (LEA) *2
 Forest	 (LEA) *15

projects/mtg/bin/Res/createResourceZip.py

@@ -7,10 +7,13 @@ from optparse import OptionParser
 def createResZipFile(filename): 
 
         utilities = ZipUtilities()
+        rename = False
         if not os.path.isfile('settings/options.txt'):
             os.rename('settings/options.orig.txt', 'settings/options.txt')
+            remame = True
         if not os.path.isfile('player/options.txt'):
             os.rename('player/options.orig.txt', 'player/options.txt')
+            rename = True
 
         zip_file = zipfile.ZipFile(filename, 'w', zipfile.ZIP_STORED)
         utilities.addFolderToZip(zip_file, 'themes')
@@ -25,6 +28,10 @@ def createResZipFile(filename):
         utilities.addFolderToZip(zip_file, 'campaigns')
         utilities.addFolderToZip(zip_file, 'ai')
         zip_file.close()
+        
+        if rename:
+            os.rename('settings/options.txt', 'settings/options.orig.txt')
+            os.rename('player/options.txt', 'player/options.orig.txt')
 
 def getFilename():
     p = Properties();
@@ -37,16 +44,18 @@ def getFilename():
 
 
 
-def createStandardResFile():
-    print "Creating Standard Resource File"
-    filename = getFilename() + '.zip'
+def createStandardResFile(filename):
+    print('Creating Standard Resource File')
+    if not filename:
+        filename = getFilename() + '.zip'
     createResZipFile( filename )
     print >> sys.stderr, 'Created Resource Package for Standard Distribution: {0}'.format( filename)
 
-def createIosResFile():
-    print 'Preparing Resource Package for iOS'
+def createIosResFile(filename):
+    print('Preparing Resource Package for iOS')
     utilities = ZipUtilities()
-    filename = getFilename() + '_iOS.zip'
+    if not filename:
+        filename = getFilename() + '_iOS.zip'
     #createResZipFile( filename )
     zip_file = zipfile.ZipFile(filename, 'a', zipfile.ZIP_STORED)
     zip_file.write("../../iOS/Res/rules/modrules.xml", "rules/modrules.xml", zipfile.ZIP_STORED)
@@ -71,10 +80,10 @@ class ZipUtilities:
             if file != '.svn':
                 full_path = os.path.join(folder, file)
                 if os.path.isfile(full_path):
-                        print 'File added: ' + str(full_path)
+                        print('File added: ' + str(full_path))
                         zip_file.write(full_path)
                 elif os.path.isdir(full_path):
-                        print 'Entering folder: ' + str(full_path)
+                        print('Entering folder: ' + str(full_path))
                         self.addFolderToZip(zip_file, full_path)
 
 
@@ -83,16 +92,17 @@ def main():
 
     parser = OptionParser()
     parser.add_option("-p", "--platform", help="PLATFORM: specify custom build. (eg ios, android, etc)", metavar="PLATFORM", dest="platform")
+    parser.add_option("-n", "--name", help="NAME: specify resource file name", metavar="NAME", dest="name")
 
     (options, args) = parser.parse_args()
 	
     if (options.platform):
-		if (options.platform == "ios"): 
-				createIosResFile()
-		else:
-				createStandardResFile()
+        if (options.platform == "ios"):
+            createIosResFile(options.name)
+        else:
+            createStandardResFile(options.name)
     else:
-		createStandardResFile()
+        createStandardResFile(options.name)
 
 if __name__ == "__main__":
 	main()

projects/mtg/bin/Res/graphics/wallpapers.txt

@@ -5,7 +5,6 @@ wallpapers/wagic1.jpg
 wallpapers/kaioshin_garruk.jpg
 wallpapers/kaioshin_jace.jpg
 graphics/shop.jpg
-themes/Classic/backdrop.jpg
 wallpapers/kaioshin_ravager.jpg
 wallpapers/kaioshin_elsXIII.jpg
 wallpapers/kaioshin_sorin.jpg