--- a/.hgignore	Wed Nov 23 20:12:16 2011 +0300
+++ b/.hgignore	Thu Nov 24 16:18:45 2011 +0100
@@ -36,3 +36,15 @@
 glob:*.orig
 glob:*.bak
 glob:*.rej
+glob:project_files/Android-build/SDL-android-project/jni/**
+glob:project_files/Android-build/SDL-android-project/obj
+glob:project_files/Android-build/SDL-android-project/libs
+glob:project_files/Android-build/SDL-android-project/bin
+glob:project_files/Android-build/SDL-android-project/gen
+glob:project_files/Android-build/SDL-android-project/local.properties
+glob:project_files/Android-build/SDL-android-project/default.properties
+glob:project_files/Android-build/SDL-android-project/.*
+glob:project_files/Android-build/complete_build.sh
+glob:project_files/Android-build/pushToDevice.sh
+glob:project_files/Android-build/Makefile.android
+glob:project_files/Android-build/out

--- a/CMakeLists.txt	Wed Nov 23 20:12:16 2011 +0300
+++ b/CMakeLists.txt	Thu Nov 24 16:18:45 2011 +0100
@@ -192,6 +192,11 @@
 add_subdirectory(misc/liblua)
 add_subdirectory(hedgewars)
 
+#run cmake -DBUILD_ANDROID_PORT=1 to enable this
+if(BUILD_ANDROID_PORT)
+	add_subdirectory(project_files/Android-build)
+endif()
+
 if(NOT BUILD_ENGINE_LIBRARY)
 	add_subdirectory(bin)
 	add_subdirectory(misc/quazip)
@@ -264,7 +269,7 @@
 	"CMakeCache\\\\.txt$"
 #	"^${CMAKE_CURRENT_SOURCE_DIR}/misc/libopenalbridge"
 #	"^${CMAKE_CURRENT_SOURCE_DIR}/misc/libfreetype"
-#	"^${CMAKE_CURRENT_SOURCE_DIR}/misc/liblua"
+	"^${CMAKE_CURRENT_SOURCE_DIR}/misc/liblua"
 #	"^${CMAKE_CURRENT_SOURCE_DIR}/misc/libtremor"
 	"^${CMAKE_CURRENT_SOURCE_DIR}/project_files/HedgewarsMobile/"
 	"^${CMAKE_CURRENT_SOURCE_DIR}/bin/[a-z]"

--- a/hedgewars/CMakeLists.txt	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/CMakeLists.txt	Thu Nov 24 16:18:45 2011 +0100
@@ -184,8 +184,8 @@
 
 add_custom_target(${engine_output_name} ALL DEPENDS "${EXECUTABLE_OUTPUT_PATH}/${engine_output_name}${CMAKE_EXECUTABLE_SUFFIX}")
 IF(NOT APPLE)
-add_custom_target(ENGINECLEAN COMMAND ${CMAKE_BUILD_TOOL} "clean" "${PROJECT_BINARY_DIR}" "${hedgewars_SOURCE_DIR}/hedgewars")
-add_dependencies(${engine_output_name} ENGINECLEAN)
+    add_custom_target(ENGINECLEAN COMMAND ${CMAKE_BUILD_TOOL} "clean" "${PROJECT_BINARY_DIR}" "${hedgewars_SOURCE_DIR}/hedgewars")
+    add_dependencies(${engine_output_name} ENGINECLEAN)
 ENDIF()
 
 install(PROGRAMS "${EXECUTABLE_OUTPUT_PATH}/${engine_output_name}${CMAKE_EXECUTABLE_SUFFIX}" DESTINATION ${target_dir})

--- a/hedgewars/PascalExports.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/PascalExports.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -32,6 +32,10 @@
 
 {$INCLUDE "config.inc"}
 procedure HW_versionInfo(netProto: PLongInt; versionStr: PPChar); cdecl; export;
+function HW_getNumberOfWeapons:LongInt; cdecl; export;
+function HW_getMaxNumberOfTeams:LongInt; cdecl; export;
+function HW_getMaxNumberOfHogs:LongInt; cdecl; export;
+procedure HW_terminate(closeFrontend: Boolean); cdecl; export;
 
 implementation
 {$IFDEF HWLIBRARY}

--- a/hedgewars/SDLh.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/SDLh.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -41,7 +41,9 @@
   {$IFDEF HAIKU}
     {$linklib root}
   {$ELSE}
-    {$linklib pthread}
+    {$IFNDEF ANDROID}
+      {$linklib pthread}
+    {$ENDIF}
   {$ENDIF}
 {$ENDIF}
 
@@ -858,7 +860,9 @@
 procedure SDL_StartTextInput; cdecl; external SDLLibName;
 
 function  SDL_PeepEvents(event: PSDL_Event; numevents: LongInt; action: SDL_eventaction; minType, maxType: LongWord): LongInt; cdecl; external SDLLibName;
+function  SDL_CreateThread(fn: Pointer; name: PChar; data: Pointer): PSDL_Thread; cdecl; external SDLLibName;
 {$ELSE}
+function  SDL_CreateThread(fn: Pointer; data: Pointer): PSDL_Thread; cdecl; external SDLLibName;
 function  SDL_PeepEvents(event: PSDL_Event; numevents: LongInt; action: SDL_eventaction; mask: LongWord): LongInt; cdecl; external SDLLibName;
 {$ENDIF}
 
@@ -876,6 +880,7 @@
 procedure SDL_WM_SetCaption(title: PChar; icon: PChar); cdecl; external SDLLibName;
 function  SDL_WM_ToggleFullScreen(surface: PSDL_Surface): LongInt; cdecl; external SDLLibName;
 
+procedure SDL_WaitThread(thread: PSDL_Thread; status: PLongInt); cdecl; external SDLLibName;
 function  SDL_CreateMutex: PSDL_mutex; cdecl; external SDLLibName;
 procedure SDL_DestroyMutex(mutex: PSDL_mutex); cdecl; external SDLLibName;
 function  SDL_LockMutex(mutex: PSDL_mutex): LongInt; cdecl; external SDLLibName name 'SDL_mutexP';

--- a/hedgewars/hwLibrary.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/hwLibrary.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -17,15 +17,43 @@
  *)
 
 Library hwLibrary;
+{$INCLUDE "options.inc"}
 
-// Add all your Pascal units to the "uses" clause below to add them to the program.
+// Add all your Pascal units to the 'uses' clause below to add them to the program.
 // Mark all Pascal procedures/functions that you wish to call from C/C++/Objective-C code using
-// "cdecl; export;" (see the fpclogo.pas unit for an example), and then add C-declarations for
-// these procedures/functions to the PascalImports.h file (also in the "Pascal Sources" group)
+// 'cdecl; export;' (see the fpclogo.pas unit for an example), and then add C-declarations for
+// these procedures/functions to the PascalImports.h file (also in the 'Pascal Sources' group)
 // to make these functions available in the C/C++/Objective-C source files
-// (add "#include PascalImports.h" near the top of these files if it's not there yet)
-uses PascalExports, hwengine;
+// (add '#include PascalImports.h' near the top of these files if it is not there yet)
+uses PascalExports, hwengine{$IFDEF ANDROID}, jni{$ENDIF};
 exports Game, HW_versionInfo;
+
+{$IFDEF ANDROID}
+function JNI_HW_versionInfoNet(env: PJNIEnv; obj: JObject):JInt;cdecl;
+begin
+    env:= env; // avoid hint
+    obj:= obj; // avoid hint
+    JNI_HW_versionInfoNet:= cNetProtoVersion;
+end;
+
+function JNI_HW_versionInfoVersion(env: PJNIEnv; obj: JObject):JString; cdecl;
+var envderef : JNIEnv;
+begin
+    obj:= obj; // avoid hint
+    envderef:= @env;
+    JNI_HW_versionInfoVersion := envderef^.NewStringUTF(env, PChar(cVersionString));
+end;
+
+exports
+    JNI_HW_versionInfoNet name Java_Prefix+'HWversionInfoNetProto', 
+    JNI_HW_versionInfoVersion name Java_Prefix+'HWversionInfoVersion', 
+    GenLandPreview name Java_Prefix + 'GenLandPreview',
+    HW_getNumberOfweapons name Java_Prefix + 'HWgetNumberOfWeapons',
+    HW_getMaxNumberOfHogs name Java_Prefix + 'HWgetMaxNumberOfHogs',
+    HW_getMaxNumberOfTeams name Java_Prefix + 'HWgetMaxNumberOfTeams',
+    HW_terminate name Java_Prefix + 'HWterminate';
+{$ENDIF}
+
 begin
 
 end.

--- a/hedgewars/hwengine.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/hwengine.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -31,12 +31,14 @@
 
 uses SDLh, uMisc, uConsole, uGame, uConsts, uLand, uAmmos, uVisualGears, uGears, uStore, uWorld, uKeys, uSound,
      uScript, uTeams, uStats, uIO, uLocale, uChat, uAI, uAIMisc, uRandom, uLandTexture, uCollisions,
-     sysutils, uTypes, uVariables, uCommands, uUtils, uCaptions, uDebug, uCommandHandlers, uLandPainted;
+     sysutils, uTypes, uVariables, uCommands, uUtils, uCaptions, uDebug, uCommandHandlers, uLandPainted
+     {$IFDEF SDL13}, uTouch{$ENDIF}{$IFDEF ANDROID}, GLUnit{$ENDIF};
 
 {$IFDEF HWLIBRARY}
 procedure initEverything(complete:boolean);
 procedure freeEverything(complete:boolean);
 procedure Game(gameArgs: PPChar); cdecl; export;
+procedure GenLandPreview(port: Longint); cdecl; export;
 
 implementation
 {$ELSE}
@@ -187,6 +189,9 @@
                         cScreenResizeDelay:= RealTicks+500;
                         *)
                         end;
+                SDL_FINGERMOTION: onTouchMotion(event.tfinger.x, event.tfinger.y,event.tfinger.dx, event.tfinger.dy, event.tfinger.fingerId);
+                SDL_FINGERDOWN: onTouchDown(event.tfinger.x, event.tfinger.y, event.tfinger.fingerId);
+                SDL_FINGERUP: onTouchUp(event.tfinger.x, event.tfinger.y, event.tfinger.fingerId);
 {$ELSE}
                 SDL_KEYDOWN: if GameState = gsChat then
                     KeyPressChat(event.key.keysym.unicode);
@@ -254,8 +259,6 @@
     cBits:= 32;
     cFullScreen:= false;
     cTimerInterval:= 8;
-    PathPrefix:= 'Data';
-    UserPathPrefix:= '../Documents';
     cShowFPS:= {$IFDEF DEBUGFILE}true{$ELSE}false{$ENDIF};
     val(gameArgs[0], ipcPort);
     val(gameArgs[1], cScreenWidth);
@@ -268,7 +271,8 @@
     isSoundEnabled:= gameArgs[6] = '1';
     isMusicEnabled:= gameArgs[7] = '1';
     cAltDamage:= gameArgs[8] = '1';
-    val(gameArgs[9], rotationQt);
+    PathPrefix:= gameArgs[9];
+    UserPathPrefix:= '../Documents';
     recordFileName:= gameArgs[10];
     cStereoMode:= smNone;
 {$ENDIF}
@@ -278,7 +282,6 @@
     cOrigScreenHeight:= cScreenHeight;
 
     initEverything(true);
-
     WriteLnToConsole('Hedgewars ' + cVersionString + ' engine (network protocol: ' + inttostr(cNetProtoVersion) + ')');
     AddFileLog('Prefix: "' + PathPrefix +'"');
     AddFileLog('UserPrefix: "' + UserPathPrefix +'"');
@@ -384,6 +387,8 @@
 
     if complete then
     begin
+{$IFDEF ANDROID}GLUnit.init;{$ENDIF}
+{$IFDEF SDL13}uTouch.initModule;{$ENDIF}
         uAI.initModule;
         //uAIActions does not need initialization
         //uAIAmmoTests does not need initialization

--- a/hedgewars/options.inc	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/options.inc	Thu Nov 24 16:18:45 2011 +0100
@@ -27,16 +27,28 @@
 
 {$DEFINE GLunit:=GL}
 
+{$IFDEF ANDROID}
+  {$DEFINE SDL13}
+  {$DEFINE HWLIBRARY}
+  {$DEFINE S3D_DISABLED}
+  {$DEFINE GLunit:=gles11}
+  {$DEFINE MOBILE}
+  {$DEFINE Java_Prefix := 'Java_org_hedgewars_hedgeroid_EngineProtocol_PascalExports_'}
+{$ENDIF}
+
 {$IFDEF IPHONEOS}
   {$DEFINE SDL13}
   {$DEFINE HWLIBRARY}
   {$DEFINE S3D_DISABLED}
   {$DEFINE GLunit:=gles11}
-{$ELSE}
+  {$DEFINE MOBILE}
+{$ENDIF}
+
+{$IFNDEF IPHONEOS}
+  // not needed on ios because it is switched from the compiler command line arguments
   {$DEFINE DEBUGFILE}
   //{$DEFINE TRACEAIACTIONS}
   //{$DEFINE COUNTTICKS}
 {$ENDIF}
 
-
 //also available LUA_DISABLED

--- a/hedgewars/uAI.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uAI.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -30,13 +30,13 @@
 
 implementation
 uses uConsts, SDLh, uAIMisc, uAIAmmoTests, uAIActions,
-     uAmmos, SysUtils{$IFDEF UNIX}, cthreads{$ENDIF}, uTypes,
+     uAmmos, SysUtils{$IFDEF UNIX}{$IFNDEF ANDROID}, cthreads{$ENDIF}{$ENDIF}, uTypes,
      uVariables, uCommands, uUtils, uDebug;
 
 var BestActions: TActions;
     CanUseAmmo: array [TAmmoType] of boolean;
     StopThinking: boolean;
-    ThinkThread: TThreadID;
+    ThinkThread: PSDL_Thread = nil;
     hasThread: LongInt;
 
 procedure FreeActionsList;
@@ -117,8 +117,7 @@
        with CurrentHedgehog^ do
             a:= CurAmmoType;
        aa:= a;
-       
-       ThreadSwitch();
+       SDL_delay(0);    //ThreadSwitch was only a hint
        
        repeat
         if (CanUseAmmo[a]) and
@@ -366,7 +365,14 @@
 
 FillBonuses((Me^.State and gstAttacked) <> 0);
 AddFileLog('Enter Think Thread');
-BeginThread(@Think, Me, ThinkThread)
+{$IFDEF IPHONEOS}
+//TODO: sdl_thread works on device but crashes in simulator, most likely because of outdated toolchain
+BeginThread(@Think, Me, ThinkThread);
+{$ELSE}
+ThinkThread := SDL_CreateThread(@Think{$IFDEF SDL13}, nil{$ENDIF}, Me);
+{$ENDIF}
+{$ENDIF}
+AddFileLog('Thread started');
 end;
 
 procedure ProcessBot;
@@ -397,6 +403,7 @@
 procedure initModule;
 begin
     hasThread:= 0;
+    ThinkThread:= ThinkThread;
 end;
 
 procedure freeModule;

--- a/hedgewars/uCaptions.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uCaptions.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -79,7 +79,7 @@
     grp: TCapGroup;
     offset: LongInt;
 begin
-{$IFDEF IPHONEOS}
+{$IFDEF MOBILE}
     offset:= 48;
 {$ELSE}
     offset:= 8;

--- a/hedgewars/uConsole.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uConsole.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -26,9 +26,10 @@
 procedure WriteToConsole(s: shortstring);
 procedure WriteLnToConsole(s: shortstring);
 function  GetLastConsoleLine: shortstring;
+function ShortStringAsPChar(s: shortstring): PChar;
 
 implementation
-uses Types, uVariables, uUtils;
+uses Types, uVariables, uUtils {$IFDEF ANDROID}, log in 'log.pas'{$ENDIF};
 
 const cLineWidth: LongInt = 0;
       cLinesCount = 8;
@@ -53,6 +54,9 @@
 begin
 {$IFNDEF NOCONSOLE}
 AddFileLog('[Con] ' + s);
+{$IFDEF ANDROID}
+  Log.__android_log_write(Log.Android_LOG_DEBUG, 'HW_Engine', ShortStringAsPChar('[Con]' + s));
+{$ELSE}
 Write(stderr, s);
 done:= false;
 
@@ -70,20 +74,29 @@
     done:= (Length(s) = 0);
     end;
 {$ENDIF}
+{$ENDIF}
 end;
 
 procedure WriteLnToConsole(s: shortstring);
 begin
 {$IFNDEF NOCONSOLE}
 WriteToConsole(s);
+{$IFNDEF ANDROID}
 WriteLn(stderr);
 inc(CurrLine);
 if CurrLine = cLinesCount then
     CurrLine:= 0;
 PByte(@ConsoleLines[CurrLine].s)^:= 0
 {$ENDIF}
+{$ENDIF}
 end;
 
+function ShortStringAsPChar(s: ShortString) : PChar;
+begin
+    if Length(s) = High(s) then Dec(s[0]);
+    s[Ord(Length(s))+1] := #0;
+    exit(@s[1]);
+end;
 
 function GetLastConsoleLine: shortstring;
 var valueStr: shortstring;

--- a/hedgewars/uConsts.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uConsts.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -158,7 +158,7 @@
     // do not change this value
     cDefaultZoomLevel = 2.0;
 
-{$IFDEF IPHONEOS}
+{$IFDEF MOBILE}
     cMaxZoomLevel = 0.5;
     cMinZoomLevel = 3.5;
     cZoomDelta = 0.20;
@@ -168,6 +168,8 @@
     cZoomDelta = 0.25;
 {$ENDIF}
 
+    cMinMaxZoomLevelDelta = cMaxZoomLevel - cMinZoomLevel;
+
     cSendEmptyPacketTime = 1000;
     trigTurns = $80000001;
 

--- a/hedgewars/uFloat.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uFloat.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -62,6 +62,7 @@
 
 // The implemented operators
 
+operator = (const z1, z2: hwFloat) z : boolean; inline;
 operator + (const z1, z2: hwFloat) z : hwFloat; inline;
 operator - (const z1, z2: hwFloat) z : hwFloat; inline;
 operator - (const z1: hwFloat) z : hwFloat; inline;
@@ -88,7 +89,7 @@
 function AngleCos(const Angle: Longword): hwFloat;
 function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum.
 function hwSign(r: hwFloat): LongInt; inline; // Returns an integer with value 1 and sign of parameter r.
-
+function isZero(const z: hwFloat): boolean; inline;
 {$IFDEF FPC}
 {$J-}
 {$ENDIF}
@@ -159,10 +160,13 @@
              _40: hwFloat = (isNegative: false; QWordValue:  4294967296 * 40);
              _50: hwFloat = (isNegative: false; QWordValue:  4294967296 * 50);
              _70: hwFloat = (isNegative: false; QWordValue:  4294967296 * 70);
+             _90: hwFloat = (isNegative: false; QWordValue:  4294967296 * 90);
             _128: hwFloat = (isNegative: false; QWordValue:  4294967296 * 128);
+            _180: hwFloat = (isNegative: false; QWordValue:  4294967296 * 180);
             _250: hwFloat = (isNegative: false; QWordValue:  4294967296 * 250);
             _256: hwFloat = (isNegative: false; QWordValue:  4294967296 * 256);
             _300: hwFloat = (isNegative: false; QWordValue:  4294967296 * 300);
+            _360: hwFloat = (isNegative: false; QWordValue:  4294967296 * 360);
             _450: hwFloat = (isNegative: false; QWordValue:  4294967296 * 450);
            _1000: hwFloat = (isNegative: false; QWordValue:  4294967296 * 1000);
            _1024: hwFloat = (isNegative: false; QWordValue:  4294967296 * 1024);
@@ -198,6 +202,12 @@
 if i.isNegative then hwFloat2Float:= -hwFloat2Float;
 end;
 
+operator = (const z1, z2: hwFloat) z : boolean; inline;
+begin
+    z:= (z1.isNegative = z2.isNegative) and (z1.QWordValue = z2.QWordValue);
+end;
+
+
 operator + (const z1, z2: hwFloat) z : hwFloat;
 begin
 if z1.isNegative = z2.isNegative then
@@ -404,6 +414,10 @@
                 else AngleCos.QWordValue:= SinTable[Angle - 1024]
 end;
 
+function isZero(const z: hwFloat): boolean; inline; 
+begin
+    isZero := z.QWordValue = 0;
+end;
 {$ENDIF}
 
 end.

--- a/hedgewars/uGame.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uGame.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -26,7 +26,7 @@
 ////////////////////
    implementation
 ////////////////////
-uses uKeys, uTeams, uIO, uAI, uGears, uSound, uMobile, uVisualGears, uTypes, uVariables;
+uses uKeys, uTeams, uIO, uAI, uGears, uSound, uMobile, uVisualGears, uTypes, uVariables{$IFDEF SDL13}, uTouch{$ENDIF};
 
 procedure DoGameTick(Lag: LongInt);
 var i: LongInt;
@@ -52,7 +52,8 @@
     if not CurrentTeam^.ExtDriven then
        begin
        if CurrentHedgehog^.BotLevel <> 0 then ProcessBot;
-       ProcessGears
+       ProcessGears;
+       {$IFDEF SDL13}ProcessTouch;{$ENDIF}
        end else
        begin
        NetGetNextCmd;

--- a/hedgewars/uGearsRender.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uGearsRender.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -188,7 +188,7 @@
 procedure DrawHH(Gear: PGear; ox, oy: LongInt);
 var i, t: LongInt;
     amt: TAmmoType;
-    sign, hx, hy, cx, cy, tx, ty, sx, sy, m: LongInt;  // hedgehog, crosshair, temp, sprite, direction
+    sign, hx, hy, tx, ty, sx, sy, m: LongInt;  // hedgehog, crosshair, temp, sprite, direction
     dx, dy, ax, ay, aAngle, dAngle, hAngle, lx, ly: real;  // laser, change
     defaultPos, HatVisible: boolean;
     HH: PHedgehog;
@@ -319,10 +319,12 @@
                     end;
                 end;
             // draw crosshair
-            cx:= Round(hwRound(Gear^.X) + dx * 80 + GetLaunchX(HH^.CurAmmoType, sign * m, Gear^.Angle));
-            cy:= Round(hwRound(Gear^.Y) + dy * 80 + GetLaunchY(HH^.CurAmmoType, Gear^.Angle));
+            CrosshairX := Round(hwRound(Gear^.X) + dx * 80 + GetLaunchX(HH^.CurAmmoType, sign * m, Gear^.Angle));
+            CrosshairY := Round(hwRound(Gear^.Y) + dy * 80 + GetLaunchY(HH^.CurAmmoType, Gear^.Angle));
+ 
+            
             DrawRotatedTex(HH^.Team^.CrosshairTex,
-                    12, 12, cx + WorldDx, cy + WorldDy, 0,
+                    12, 12, CrosshairX + WorldDx, CrosshairY + WorldDy, 0,
                     sign * (Gear^.Angle * 180.0) / cMaxAngle);
             end;
         hx:= ox + 8 * sign;

--- a/hedgewars/uScript.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uScript.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -45,6 +45,9 @@
 function ScriptCall(fname : shortstring; par1, par2, par3, par4 : LongInt) : LongInt;
 function ScriptExists(fname : shortstring) : boolean;
 
+
+function ParseCommandOverride(key, value : shortstring) : shortstring;
+
 procedure initModule;
 procedure freeModule;
 
@@ -1724,6 +1727,25 @@
 GetGlobals;
 end;
 
+function ParseCommandOverride(key, value : shortstring) : shortstring;
+begin
+ParseCommandOverride:= value;
+if not ScriptExists('ParseCommandOverride') then exit;
+lua_getglobal(luaState, Str2PChar('ParseCommandOverride'));
+lua_pushstring(luaState, Str2PChar(key));
+lua_pushstring(luaState, Str2PChar(value));
+if lua_pcall(luaState, 2, 1, 0) <> 0 then
+    begin
+    LuaError('Lua: Error while calling ParseCommandOverride: ' + lua_tostring(luaState, -1));
+    lua_pop(luaState, 1)
+    end
+else
+    begin
+    ParseCommandOverride:= lua_tostring(luaState, -1);
+    lua_pop(luaState, 1)
+    end;
+end;
+
 function ScriptCall(fname : shortstring; par1: LongInt) : LongInt;
 begin
 ScriptCall:= ScriptCall(fname, par1, 0, 0, 0)
@@ -2077,6 +2099,11 @@
 ScriptExists:= false
 end;
 
+function ParseCommandOverride(key, value : shortstring) : shortstring;
+begin
+ParseCommandOverride:= value
+end;
+
 procedure initModule;
 begin
 end;

--- a/hedgewars/uSound.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uSound.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -148,7 +148,7 @@
     WriteToConsole('Init sound...');
     isSoundEnabled:= SDL_InitSubSystem(SDL_INIT_AUDIO) >= 0;
 
-{$IFDEF IPHONEOS}
+{$IFDEF MOBILE}
     channels:= 1;
 {$ELSE}
     channels:= 2;

--- a/hedgewars/uStore.pas	Wed Nov 23 20:12:16 2011 +0300
+++ b/hedgewars/uStore.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -291,7 +291,7 @@
            ((vobCount > 0) or (ii <> sprFlake)) then
         begin
             if AltPath = ptNone then
-                if ii in [sprHorizont, sprHorizontL, sprHorizontR, sprSky, sprSkyL, sprSkyR, sprChunk] then // FIXME: hack
+                if ii in [sprHorizont, sprHorizontL, sprHorizontR, sprSky, sprSkyL, sprSkyR, sprChunk, sprFireButton] then // FIXME: hack
                     begin
                     if not reload then
                         begin
@@ -1008,7 +1008,7 @@
     y:= SDL_WINDOWPOS_CENTERED_MASK;
     flags:= SDL_WINDOW_OPENGL or SDL_WINDOW_SHOWN;
 
-{$IFDEF IPHONEOS}
+{$IFDEF MOBILE}
     // make the sdl window appear on the second monitor when present
     x:= x or (SDL_GetNumVideoDisplays() - 1);
     y:= y or (SDL_GetNumVideoDisplays() - 1);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hedgewars/uTouch.pas	Thu Nov 24 16:18:45 2011 +0100
@@ -0,0 +1,517 @@
+(*
+ * Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ *)
+
+{$INCLUDE "options.inc"}
+
+unit uTouch;
+
+interface
+
+uses sysutils, math, uConsole, uVariables, SDLh, uTypes, uFloat, uConsts, uIO, uCommands, GLUnit;
+
+// TODO: this type should be Int64
+// TODO: this type should be named TSDL_FingerId
+type SDL_FingerId = LongInt;
+
+type
+    PTouch_Finger = ^Touch_Finger;
+    Touch_Finger = record
+        id                       : SDL_FingerId;
+        x,y                      : LongInt;
+        historicalX, historicalY : LongInt;
+        timeSinceDown            : Longword;
+        end;
+
+procedure initModule;
+
+procedure ProcessTouch;
+procedure onTouchDown(x,y: Longword; pointerId: SDL_FingerId);
+procedure onTouchMotion(x,y: Longword; dx,dy: LongInt; pointerId: SDL_FingerId);
+procedure onTouchUp(x,y: Longword; pointerId: SDL_FingerId);
+function convertToCursor(scale: LongInt; xy: LongInt): LongInt;
+function addFinger(x,y: Longword; id: SDL_FingerId): PTouch_Finger;
+procedure deleteFinger(id: SDL_FingerId);
+procedure onTouchClick(finger: Touch_Finger);
+procedure onTouchDoubleClick(finger: Touch_Finger);
+
+function findFinger(id: SDL_FingerId): PTouch_Finger;
+procedure aim(finger: Touch_Finger);
+function isOnCrosshair(finger: Touch_Finger): boolean;
+function isOnCurrentHog(finger: Touch_Finger): boolean;
+function isOnFireButton(finger: Touch_Finger): boolean;
+procedure convertToWorldCoord(var x,y: hwFloat; finger: Touch_Finger);
+procedure convertToFingerCoord(var x,y: hwFloat; oldX, oldY: hwFloat);
+function fingerHasMoved(finger: Touch_Finger): boolean;
+function calculateDelta(finger1, finger2: Touch_Finger): hwFloat;
+function getSecondFinger(finger: Touch_Finger): PTouch_Finger;
+procedure printFinger(finger: Touch_Finger);
+implementation
+
+const
+    clicktime = 200;
+    nilFingerId = High(SDL_FingerId);
+
+var
+    fireButtonLeft, fireButtonRight, fireButtonTop, fireButtonBottom : LongInt;
+        
+
+
+    leftButtonBoundary  : LongInt;
+    rightButtonBoundary : LongInt;
+    topButtonBoundary   : LongInt;
+    
+    pointerCount : Longword;
+    fingers: array of Touch_Finger;
+    moveCursor : boolean;
+    invertCursor : boolean;
+
+    xTouchClick,yTouchClick : LongInt;
+    timeSinceClick : Longword;
+
+    //Pinch to zoom 
+    pinchSize : hwFloat;
+    baseZoomValue: GLFloat;
+
+
+    //aiming
+    aiming, movingCrosshair: boolean; 
+    crosshairCommand: ShortString;
+    targetAngle: LongInt;
+    stopFiring: boolean;
+
+    //moving
+    stopLeft, stopRight, walkingLeft, walkingRight :  boolean;
+
+
+procedure onTouchDown(x,y: Longword; pointerId: SDL_FingerId);
+var 
+    finger: PTouch_Finger;
+begin
+    finger := addFinger(x,y,pointerId);
+    case pointerCount of
+        1:
+        begin
+            moveCursor:= false;
+            if bShowAmmoMenu then
+            begin
+                moveCursor := true;
+                exit;
+            end;
+
+            if isOnCrosshair(finger^) then
+            begin
+                aiming:= true;
+                exit;
+            end;
+
+            if isOnFireButton(finger^) then
+            begin
+                stopFiring:= false;
+                ParseCommand('+attack', true);
+                exit;
+            end;
+            if (finger^.x < leftButtonBoundary) and (finger^.y < 390) then
+            begin
+                ParseCommand('+left', true);
+                walkingLeft := true;
+                exit;
+            end;
+            if finger^.x > rightButtonBoundary then
+            begin
+                ParseCommand('+right', true);
+                walkingRight:= true;
+                exit;
+            end;
+            if finger^.y < topButtonBoundary then
+            begin
+                ParseCommand('hjump', true);
+                exit;
+            end;
+            moveCursor:= true; 
+        end;
+        2:
+        begin
+            aiming:= false;
+            stopFiring:= true;
+            moveCursor:= false;
+            pinchSize := calculateDelta(finger^, getSecondFinger(finger^)^);
+            baseZoomValue := ZoomValue
+        end;
+    end;//end case pointerCount of
+end;
+
+procedure onTouchMotion(x,y: Longword;dx,dy: LongInt; pointerId: SDL_FingerId);
+var
+    finger, secondFinger: PTouch_Finger;
+    currentPinchDelta, zoom : hwFloat;
+    tmpX, tmpY: LongInt;
+begin
+    x := x;
+    y := y;
+    dx := dx;
+    dy := dy;
+    finger:= findFinger(pointerId);
+    tmpX := convertToCursor(cScreenWidth, x);
+    tmpY := convertToCursor(cScreenHeight, y);
+
+    if moveCursor then
+    begin
+        if invertCursor then
+        begin
+            CursorPoint.X := CursorPoint.X + (finger^.x - tmpX);
+            CursorPoint.Y := CursorPoint.Y - (finger^.y - tmpY);
+        end
+        else
+        begin
+            CursorPoint.X := CursorPoint.X - (finger^.x - tmpX);
+            CursorPoint.Y := CursorPoint.Y + (finger^.y - tmpY);
+        end;
+        finger^.x := tmpX;
+        finger^.y := tmpY;
+        exit //todo change into switch rather than ugly ifs
+    end;
+    
+    finger^.x := tmpX;
+    finger^.y := tmpY;
+    
+    if aiming then 
+    begin
+        aim(finger^);
+        exit
+    end;
+    if pointerCount = 2 then
+    begin
+       secondFinger := getSecondFinger(finger^);
+       currentPinchDelta := calculateDelta(finger^, secondFinger^) - pinchSize;
+       zoom := currentPinchDelta/cScreenWidth;
+       ZoomValue := baseZoomValue - ((hwFloat2Float(zoom) * cMinMaxZoomLevelDelta));
+       if ZoomValue < cMaxZoomLevel then ZoomValue := cMaxZoomLevel;
+       if ZoomValue > cMinZoomLevel then ZoomValue := cMinZoomLevel;
+    end;
+end;
+
+procedure onTouchUp(x,y: Longword; pointerId: SDL_FingerId);
+begin
+    x := x;
+    y := y;
+    aiming:= false;
+    stopFiring:= true;
+    deleteFinger(pointerId);
+
+    if walkingLeft then
+    begin
+        ParseCommand('-left', true);
+        walkingLeft := false;
+    end;
+
+    if walkingRight then
+    begin
+        ParseCommand('-right', true);
+        walkingRight := false;
+    end;
+end;
+
+procedure onTouchDoubleClick(finger: Touch_Finger);
+begin
+    finger := finger;//avoid compiler hint
+    ParseCommand('ljump', true);
+end;
+
+procedure onTouchClick(finger: Touch_Finger);
+begin
+    if (SDL_GetTicks - timeSinceClick < 300) and (DistanceI(finger.X-xTouchClick, finger.Y-yTouchClick) < _30) then
+    begin
+    onTouchDoubleClick(finger);
+    exit; 
+    end
+    else
+    begin
+        xTouchClick := finger.x;
+        yTouchClick := finger.y;
+        timeSinceClick := SDL_GetTicks;
+    end;
+
+    if bShowAmmoMenu then 
+    begin
+        doPut(CursorPoint.X, CursorPoint.Y, false); 
+        exit
+    end;
+
+    if isOnCurrentHog(finger) then
+    begin
+        bShowAmmoMenu := true;
+        exit;
+    end;
+
+    if finger.y < topButtonBoundary then
+    begin
+        ParseCommand('hjump', true);
+        exit;
+    end;
+end;
+
+function addFinger(x,y: Longword; id: SDL_FingerId): PTouch_Finger;
+var 
+    xCursor, yCursor, index : LongInt;
+begin
+    //Check array sizes
+    if length(fingers) < Integer(pointerCount) then 
+    begin
+        setLength(fingers, length(fingers)*2);
+        for index := length(fingers) div 2 to length(fingers) do fingers[index].id := nilFingerId;
+    end;
+    
+    
+    xCursor := convertToCursor(cScreenWidth, x);
+    yCursor := convertToCursor(cScreenHeight, y);
+    
+    //on removing fingers, all fingers are moved to the left
+    //with dynamic arrays being zero based, the new position of the finger is the old pointerCount
+    fingers[pointerCount].id := id;
+    fingers[pointerCount].historicalX := xCursor;
+    fingers[pointerCount].historicalY := yCursor;
+    fingers[pointerCount].x := xCursor;
+    fingers[pointerCount].y := yCursor;
+    fingers[pointerCount].timeSinceDown:= SDL_GetTicks;
+ 
+    addFinger:= @fingers[pointerCount];
+    inc(pointerCount);
+end;
+
+procedure deleteFinger(id: SDL_FingerId);
+var
+    index : Longword;
+begin
+    
+    dec(pointerCount);
+    for index := 0 to pointerCount do
+    begin
+         if fingers[index].id = id then
+         begin
+             //Check for onTouchClick event
+             if ((SDL_GetTicks - fingers[index].timeSinceDown) < clickTime) AND  
+                 not(fingerHasMoved(fingers[index])) then onTouchClick(fingers[index]);
+
+             //put the last finger into the spot of the finger to be removed, 
+             //so that all fingers are packed to the far left
+             if  pointerCount <> index then
+             begin
+                fingers[index].id := fingers[pointerCount].id;    
+                fingers[index].x := fingers[pointerCount].x;    
+                fingers[index].y := fingers[pointerCount].y;    
+                fingers[index].historicalX := fingers[pointerCount].historicalX;    
+                fingers[index].historicalY := fingers[pointerCount].historicalY;    
+                fingers[index].timeSinceDown := fingers[pointerCount].timeSinceDown;
+
+                fingers[pointerCount].id := nilFingerId;
+             end
+             else fingers[index].id := nilFingerId;
+             break;
+         end;
+    end;
+
+end;
+
+procedure ProcessTouch;
+var
+    deltaAngle: LongInt;
+begin
+    invertCursor := not(bShowAmmoMenu);
+    if aiming then
+    begin
+        if CurrentHedgehog^.Gear <> nil then
+        begin
+            deltaAngle:= CurrentHedgehog^.Gear^.Angle - targetAngle;
+            if (deltaAngle <> 0) and not(movingCrosshair) then 
+            begin
+                ParseCommand('+' + crosshairCommand, true);
+                movingCrosshair := true;
+            end
+            else 
+                if movingCrosshair then 
+                begin
+                    ParseCommand('-' + crosshairCommand, true);
+                    movingCrosshair:= false;
+                end;
+        end;
+    end
+    else if movingCrosshair then 
+    begin
+        ParseCommand('-' + crosshairCommand, true);
+        movingCrosshair := false;
+    end;
+
+    if stopFiring then 
+    begin
+        ParseCommand('-attack', true);
+        stopFiring:= false;
+    end;
+    
+    if stopRight then
+    begin
+        stopRight := false;
+        ParseCommand('-right', true);
+    end;
+ 
+    if stopLeft then
+    begin
+        stopLeft := false;
+        ParseCommand('-left', true);
+    end;
+    
+end;
+
+function findFinger(id: SDL_FingerId): PTouch_Finger;
+var
+    index: LongWord;
+begin
+   for index := 0 to High(fingers) do
+       if fingers[index].id = id then 
+       begin
+           findFinger := @fingers[index];
+           break;
+       end;
+end;
+
+procedure aim(finger: Touch_Finger);
+var 
+    hogX, hogY, touchX, touchY, deltaX, deltaY, tmpAngle: hwFloat;
+    tmp: ShortString;
+begin
+    if CurrentHedgehog^.Gear <> nil then
+    begin
+        touchX := _0;//avoid compiler hint
+        touchY := _0;
+        hogX := CurrentHedgehog^.Gear^.X;
+        hogY := CurrentHedgehog^.Gear^.Y;
+
+        convertToWorldCoord(touchX, touchY, finger);
+        deltaX := hwAbs(TouchX-HogX);
+        deltaY := (TouchY-HogY);
+        
+        tmpAngle:= DeltaY / Distance(deltaX, deltaY) *_2048;
+        targetAngle:= (hwRound(tmpAngle) + 2048) div 2;
+
+        tmp := crosshairCommand;
+        if CurrentHedgehog^.Gear^.Angle - targetAngle < 0 then crosshairCommand := 'down'
+        else crosshairCommand:= 'up';
+        if movingCrosshair and (tmp <> crosshairCommand) then 
+        begin
+            ParseCommand('-' + tmp, true);
+            movingCrosshair := false;
+        end;
+
+    end; //if CurrentHedgehog^.Gear <> nil
+end;
+
+function convertToCursor(scale: LongInt; xy: LongInt): LongInt;
+begin
+    convertToCursor := round(xy/32768*scale)
+end;
+
+function isOnFireButton(finger: Touch_Finger): boolean;
+begin
+    isOnFireButton:= (finger.x <= fireButtonRight) and (finger.x >= fireButtonLeft) and (finger.y <= fireButtonBottom) and (finger.y >= fireButtonTop);
+end;
+
+function isOnCrosshair(finger: Touch_Finger): boolean;
+var
+    x,y : hwFloat;
+begin
+    x := _0;//avoid compiler hint
+    y := _0;
+    convertToFingerCoord(x, y, int2hwFloat(CrosshairX), int2hwFloat(CrosshairY));
+    isOnCrosshair:= Distance(int2hwFloat(finger.x)-x, int2hwFloat(finger.y)-y) < _50;
+end;
+
+function isOnCurrentHog(finger: Touch_Finger): boolean;
+var
+    x,y : hwFloat;
+begin
+    x := _0;
+    y := _0;
+    convertToFingerCoord(x, y, CurrentHedgehog^.Gear^.X, CurrentHedgehog^.Gear^.Y);
+    isOnCurrentHog := Distance(int2hwFloat(finger.X)-x, int2hwFloat(finger.Y)-y) < _50;
+end;
+
+procedure convertToFingerCoord(var x,y : hwFloat; oldX, oldY: hwFloat);
+begin
+    x := oldX + int2hwFloat(WorldDx + (cScreenWidth div 2));
+    y := oldY + int2hwFloat(WorldDy);
+end;
+
+procedure convertToWorldCoord(var x,y: hwFloat; finger: Touch_Finger);
+begin
+//if x <> nil then 
+    x := int2hwFloat((finger.x-WorldDx) - (cScreenWidth div 2));
+//if y <> nil then 
+    y := int2hwFloat(finger.y-WorldDy);
+end;
+
+//Method to calculate the distance this finger has moved since the downEvent
+function fingerHasMoved(finger: Touch_Finger): boolean;
+begin
+    fingerHasMoved := trunc(sqrt(Power(finger.X-finger.historicalX,2) + Power(finger.y-finger.historicalY, 2))) > 330;
+end;
+
+function calculateDelta(finger1, finger2: Touch_Finger): hwFloat; inline;
+begin
+    calculateDelta := DistanceI(finger2.x-finger1.x, finger2.y-finger1.y);
+end;
+
+// Under the premise that all pointer ids in pointerIds:SDL_FingerId are packed to the far left.
+// If the pointer to be ignored is not pointerIds[0] the second must be there
+function getSecondFinger(finger: Touch_Finger): PTouch_Finger;
+begin
+    if fingers[0].id = finger.id then getSecondFinger := @fingers[1]
+    else getSecondFinger := @fingers[0];
+end;
+
+procedure printFinger(finger: Touch_Finger);
+begin
+    WriteToConsole(Format('id:%d, (%d,%d), (%d,%d), time: %d', [finger.id, finger.x, finger.y, finger.historicalX, finger.historicalY, finger.timeSinceDown]));
+end;
+
+procedure initModule;
+var
+    index: Longword;
+    //uRenderCoordScaleX, uRenderCoordScaleY: Longword;
+begin
+    movingCrosshair := false;
+    stopFiring:= false;
+    walkingLeft := false;
+    walkingRight := false;
+
+    leftButtonBoundary := cScreenWidth div 4;
+    rightButtonBoundary := cScreenWidth div 4*3;
+    topButtonBoundary := cScreenHeight div 6;
+    
+    setLength(fingers, 4);
+    for index := 0 to High(fingers) do 
+        fingers[index].id := nilFingerId;
+
+
+    //uRenderCoordScaleX := Round(cScreenWidth/0.8 * 2);
+    fireButtonLeft := Round(cScreenWidth*0.01);
+    fireButtonRight := Round(fireButtonLeft + (spritesData[sprFireButton].Width*0.4));
+    fireButtonBottom := Round(cScreenHeight*0.99);
+    fireButtonTop := fireButtonBottom - Round(spritesData[sprFireButton].Height*0.4);
+end;
+
+begin
+end.