Pixel was moved to another package

android/build.gradle

@@ -57,8 +57,8 @@ dependencies {
   implementation "com.badlogicgames.gdx:gdx-backend-android:$gdxVersion"
   implementation "com.github.MrStahlfelge.gdx-websockets:common:$websocketVersion"
   implementation project(':core')
-  implementation "com.pixelgamelibrary:pixel:$pixelVersion"
-  implementation "com.pixelgamelibrary:pixel-backend-libgdx:$pixelVersion"
+  implementation "com.openeggbert.pixel:pixel-framework:$pixelVersion"
+  implementation "com.openeggbert.pixel:pixel-backend-libgdx:$pixelVersion"
   
   natives "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-arm64-v8a"
   natives "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-armeabi-v7a"

android/src/main/java/com/openeggbert/android/AndroidLauncher.java

@@ -5,9 +5,9 @@ import android.os.Bundle;
 import com.badlogic.gdx.backends.android.AndroidApplication;
 import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration;
 import com.openeggbert.core.main.OpenEggbertApplication;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.backend.libgdx.interfaces.PixelBackendLibGDX;
-import com.pixelgamelibrary.backend.libgdx.game.LibGdxGame;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.backend.libgdx.interfaces.PixelBackendLibGDX;
+import com.openeggbert.pixel.backend.libgdx.game.LibGdxGame;
 
 /** Launches the Android application. */
 public class AndroidLauncher extends AndroidApplication {

core/build.gradle

@@ -22,7 +22,9 @@ dependencies {
   compileOnly "org.projectlombok:lombok:$lombokVersion"
   testImplementation "org.junit.jupiter:junit-jupiter-api:5.10.3"
   testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.10.3"
-  api "com.pixelgamelibrary:pixel:$pixelVersion"
+  api "com.openeggbert.pixel:pixel-framework:$pixelVersion"
+  implementation "com.openeggbert.jdotnet:jdotnet:$jdotnetVersion"
+  implementation "com.openeggbert.jxna:jxna:$jxnaVersion"
   
   if(enableGraalNative == 'true') {
     implementation "io.github.berstanio:gdx-svmhelper-annotations:$graalHelperVersion"

core/src/main/java/com/openeggbert/core/configuration/ConfigDef.java

@@ -20,7 +20,7 @@
 package com.openeggbert.core.configuration;
 
 import com.openeggbert.core.main.OpenEggbertException;
-import com.pixelgamelibrary.api.Pixel;
+import com.openeggbert.pixel.framework.Pixel;
 import java.util.HashMap;
 import java.util.Map;
 import lombok.ToString;

core/src/main/java/com/openeggbert/core/configuration/OpenEggbertDisplayMode.java

@@ -19,9 +19,9 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.core.configuration;
 
-import com.pixelgamelibrary.api.Pixel;
+import com.openeggbert.pixel.framework.Pixel;
 import com.openeggbert.core.main.OpenEggbertException;
-import com.pixelgamelibrary.api.ViewMode;
+import com.openeggbert.pixel.framework.ViewMode;
 
 /**
  *

core/src/main/java/com/openeggbert/core/main/OpenEggbertApplication.java

@@ -20,12 +20,12 @@
 package com.openeggbert.core.main;
 
 import com.openeggbert.core.gamespace.GameSpace;
-import com.pixelgamelibrary.api.PixelApplication;
+import com.openeggbert.pixel.framework.PixelApplication;
 import java.util.Map;
-import com.pixelgamelibrary.api.game.Game;
+import com.openeggbert.pixel.framework.game.Game;
 
 /**
- * {@link com.pixelgamelibrary.api.PixelApplication} implementation shared by all
+ * {@link com.openeggbert.pixel.framework.PixelApplication} implementation shared by all
  * platforms.
  */
 public class OpenEggbertApplication extends PixelApplication {

core/src/main/java/com/openeggbert/core/main/OpenEggbertGame.java

@@ -8,17 +8,17 @@ import com.openeggbert.core.mod.ModIdentification;
 import com.openeggbert.core.screen.GameSpaceListScreen;
 import com.openeggbert.core.screen.InitScreen;
 import com.openeggbert.core.utils.OpenEggbertUtils;
-import com.pixelgamelibrary.api.game.GameAdapter;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
-import com.pixelgamelibrary.api.graphics.SpriteBatch;
-import com.pixelgamelibrary.api.graphics.Texture;
+import com.openeggbert.pixel.framework.game.GameAdapter;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.graphics.SpriteBatch;
+import com.openeggbert.pixel.framework.graphics.Texture;
 import java.util.List;
 import java.util.Optional;
 import lombok.Data;
-import com.pixelgamelibrary.api.files.File;
-import com.pixelgamelibrary.api.graphics.ShapeRenderer;
-import com.pixelgamelibrary.api.utils.collections.Map;
+import com.openeggbert.pixel.framework.files.File;
+import com.openeggbert.pixel.framework.graphics.ShapeRenderer;
+import com.openeggbert.pixel.framework.utils.collections.Map;
 import lombok.Getter;
 
 /**
@@ -66,7 +66,7 @@ public class OpenEggbertGame extends GameAdapter {
 //        for(FileHandle f:Gdx.files.internal(".").list()) {
 //            System.out.println("assets contains also: " + f.name());
 //        }
-        com.pixelgamelibrary.api.files.File embeddedModsDirectory = Pixel.files().assets("/embedded_mods");
+        com.openeggbert.pixel.framework.files.File embeddedModsDirectory = Pixel.files().assets("/embedded_mods");
         System.out.println("embeddedModsDirectory.exists=" + embeddedModsDirectory.exists());
         System.out.println("embeddedModsDirectory.list().size()=" + embeddedModsDirectory.list().size());
         embeddedModsDirectory.list().forEach(e -> System.out.println(e.path()));

core/src/main/java/com/openeggbert/core/mod/Mod.java

@@ -19,8 +19,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.core.mod;
 
-import com.pixelgamelibrary.api.interfaces.XmlElement;
-import com.pixelgamelibrary.api.Pixel;
+import com.openeggbert.pixel.framework.interfaces.XmlElement;
+import com.openeggbert.pixel.framework.Pixel;
 import com.openeggbert.core.release.Release;
 import java.util.ArrayList;
 import java.util.List;

core/src/main/java/com/openeggbert/core/mod/ModIdentification.java

@@ -19,7 +19,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.core.mod;
 
-import com.pixelgamelibrary.api.interfaces.XmlElement;
+import com.openeggbert.pixel.framework.interfaces.XmlElement;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 

core/src/main/java/com/openeggbert/core/mod/Store.java

@@ -19,7 +19,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.core.mod;
 
-import com.pixelgamelibrary.api.interfaces.XmlElement;
+import com.openeggbert.pixel.framework.interfaces.XmlElement;
 
 /**
  *

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Accelerometer.java

@@ -0,0 +1,13 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+import com.openeggbert.jdotnet.System.*;
+
+public interface Accelerometer {
+
+    void Start();
+
+    void Stop();
+
+    @Event
+    EventHandler<AccelerometerEventArgs> CurrentValueChanged();
+}

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/AccelerometerDummyImpl.java

@@ -0,0 +1,23 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+import com.openeggbert.jdotnet.System.Event;
+import com.openeggbert.jdotnet.System.EventHandler;
+import com.openeggbert.jdotnet.System.EventHandlerImpl;
+
+
+
+    public class AccelerometerDummyImpl implements Accelerometer
+    {
+        private final EventHandler<AccelerometerEventArgs> CurrentValueChangedInternal = new EventHandlerImpl<AccelerometerEventArgs>();
+        public @Event EventHandler<AccelerometerEventArgs> CurrentValueChanged() {return CurrentValueChangedInternal;}
+
+        public void Start()
+        {
+            //throw new AccelerometerFailedException();
+        }
+
+        public void Stop()
+        {
+            //throw new AccelerometerFailedException();
+        }
+    }

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/AccelerometerEventArgs.java

@@ -0,0 +1,24 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+import com.openeggbert.jdotnet.System.EventArgs;
+
+import lombok.Getter;
+
+public class AccelerometerEventArgs extends EventArgs {
+
+    public float X() {return getX();}
+    public float Y() {return getY();}
+    public float Z() {return getZ();}
+    @Getter
+    private float X;
+    @Getter
+    private float Y;
+    @Getter
+    private float Z;
+
+    public AccelerometerEventArgs(float x, float y, float z) {
+        X = x;
+        Y = y;
+        Z = z;
+    }
+}

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/AccelerometerFactory.java

@@ -0,0 +1,8 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+public class AccelerometerFactory {
+
+    public static Accelerometer Create() {
+        return new AccelerometerDummyImpl();
+    }
+}

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Game1.java

@@ -0,0 +1,987 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Game1
+import com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi.GameData.GamerInfo;
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Content.ContentManager;
+//import com.openeggbert.jxna.Microsoft.Xna.Framework.GamerServices;//todo remove me
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Touch.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Media.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Game;
+//import static com.openeggbert.jdotnet.System.Net.Mime.MediaTypeNames.*;
+import lombok.Getter;
+import lombok.Setter;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.readonly;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class Game1 extends Game
+    {
+        private static @readonly final double[] waitTable = new double[]
+        {
+        0.1, 7.0, 0.2, 20.0, 0.25, 22.0, 0.45, 50.0, 0.6, 53.0,
+        0.65, 58.0, 0.68, 60.0, 0.8, 70.0, 0.84, 75.0, 0.9, 84.0,
+        0.94, 91.0, 1.0, 100.0
+        };
+
+        private static @readonly final Def.ButtonGlygh[] cheatGeste = new Def.ButtonGlygh[]
+        {
+        Def.ButtonGlygh.Cheat12,
+        Def.ButtonGlygh.Cheat22,
+        Def.ButtonGlygh.Cheat32,
+        Def.ButtonGlygh.Cheat12,
+        Def.ButtonGlygh.Cheat11,
+        Def.ButtonGlygh.Cheat21,
+        Def.ButtonGlygh.Cheat22,
+        Def.ButtonGlygh.Cheat21,
+        Def.ButtonGlygh.Cheat31,
+        Def.ButtonGlygh.Cheat32
+        };
+
+        private @readonly final GraphicsDeviceManager graphics;
+
+        private @readonly final Pixmap pixmap;
+
+        private @readonly final Sound sound;
+
+        private @readonly final Decor decor;
+
+        private @readonly final InputPad inputPad;
+
+        private @readonly final GameData gameData;
+
+        private Def.Phase phase;
+
+        private TimeSpan startTime;
+
+        private int missionToStart1;
+
+        private int missionToStart2;
+
+        private int mission;
+
+        private int cheatGesteIndex;
+
+        private int continueMission;
+
+        private Jauge waitJauge;
+
+        private double waitProgress;
+
+        private boolean isTrialMode;
+
+        private boolean simulateTrialMode;
+
+        private boolean playSetup;
+
+        private int phaseTime;
+
+        private Def.Phase fadeOutPhase;
+
+        private int fadeOutMission;
+                        
+        public boolean IsRankingMode() {return false;}
+
+        public boolean IsTrialMode()
+        {
+            
+                if (!simulateTrialMode)
+                {
+                    return isTrialMode;
+                }
+                return true;
+            
+        }
+
+        public Game1()
+        {
+            
+            Exiting().addEventListener((e)-> this.OnExiting(this, new ExitingEventArgs()));
+            if(!TouchPanel.GetCapabilities().IsConnected())
+            {
+                this.setMouseVisible(true);
+                Mouse.SetCursor(MouseCursor.Arrow);
+            }
+            graphics = new GraphicsDeviceManager(this);
+            graphics.setFullScreen(false);
+            super.getContent().setRootDirectory("Content");
+            super.setTargetElapsedTime(TimeSpan.FromTicks(500000L));
+            super.setInactiveSleepTime(TimeSpan.FromSeconds(1.0d));
+            missionToStart1 = -1;
+            missionToStart2 = -1;
+            gameData = new GameData();
+            pixmap = new Pixmap(this, graphics);
+            sound = new Sound(this, gameData);
+            decor = new Decor();
+            decor.Create(sound, pixmap, gameData);
+            TinyPoint pos = new TinyPoint(196,426);
+            waitJauge = new Jauge();
+            waitJauge.Create(pixmap, sound, pos, 3, false);
+            waitJauge.SetHide(false);
+            waitJauge.setZoom(2.0);
+            phase = Def.Phase.None;
+            fadeOutPhase = Def.Phase.None;
+            inputPad = new InputPad(this, decor, pixmap, sound, gameData);
+            SetPhase(Def.Phase.First);
+        }
+
+        @Override
+        protected void Initialize() {
+            super.Initialize();
+        }
+
+        @Override
+        protected void LoadContent() {
+            pixmap.BackgroundCache("wait");
+        }
+
+        @Override
+        protected void UnloadContent() {
+        }
+
+        @Override
+        protected void OnDeactivated(Object sender, EventArgs args)
+        {
+            if (phase == Def.Phase.Play)
+            {
+                decor.CurrentWrite();
+            }
+            else
+            {
+                decor.CurrentDelete();
+            }
+            super.OnDeactivated(sender, args);
+        }
+
+        @Override
+        protected void OnActivated(Object sender, EventArgs args)
+        {
+            continueMission = 1;
+            super.OnActivated(sender, args);
+        }
+
+        protected void OnExiting(Object sender, EventArgs args)
+        {
+            decor.CurrentDelete();
+        }
+
+        @Override
+        protected void Update(GameTime gameTime)
+        {
+            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
+            {
+                if (phase == Def.Phase.Play)
+                {
+                    SetPhase(Def.Phase.Pause);
+                }
+                else if (phase == Def.Phase.PlaySetup)
+                {
+                    SetPhase(Def.Phase.Play, -1);
+                }
+                else if (phase != Def.Phase.Init)
+                {
+                    SetPhase(Def.Phase.Init);
+                }
+                else
+                {
+                    Exit();
+                }
+                return;
+            }
+            phaseTime++;
+            if (fadeOutPhase != Def.Phase.None)
+            {
+                if (phaseTime >= 20)
+                {
+                    SetPhase(fadeOutPhase);
+                }
+                return;
+            }
+            if (missionToStart2 != -1)
+            {
+                SetPhase(Def.Phase.Play, missionToStart2);
+                return;
+            }
+            if (phase == Def.Phase.First)
+            {
+                startTime = gameTime.TotalGameTime;
+                pixmap.LoadContent();
+                sound.LoadContent();
+                gameData.Read();
+                inputPad.PixmapOrigin = pixmap.Origin();
+                SetPhase(Def.Phase.Wait);
+                return;
+            }
+            if (phase == Def.Phase.Wait)
+            {
+                if (continueMission == 2)
+                {
+                    continueMission = 0;
+                    if (decor.CurrentRead())
+                    {
+                        SetPhase(Def.Phase.Resume);
+                        return;
+                    }
+                }
+                long num = gameTime.TotalGameTime.Ticks() - startTime.Ticks();
+                waitProgress = (double)num / 50000000.0;
+                if (waitProgress > 1.0)
+                {
+                    SetPhase(Def.Phase.Init);
+                }
+                return;
+            }
+            inputPad.Update();
+            Def.ButtonGlygh buttonPressed = inputPad.ButtonPressed();
+            if (buttonPressed.ordinal()>= Def.ButtonGlygh.InitGamerA.ordinal() && buttonPressed.ordinal() <= Def.ButtonGlygh.InitGamerC.ordinal())
+            {
+                SetGamer((int)(buttonPressed.ordinal() - 1));
+                return;
+            }
+            switch (buttonPressed)
+            {
+                case InitSetup:
+                    SetPhase(Def.Phase.MainSetup);
+                    return;
+                case PauseSetup:
+                    SetPhase(Def.Phase.PlaySetup);
+                    return;
+                case SetupSounds:
+                    gameData.setSounds(!gameData.Sounds());
+                    gameData.Write();
+                    return;
+                case SetupJump:
+                    gameData.setJumpRight(!gameData.JumpRight());
+                    gameData.Write();
+                    return;
+                case SetupZoom:
+                    gameData.setAutoZoom(!gameData.AutoZoom());
+                    gameData.Write();
+                    return;
+                case SetupAccel:
+                    gameData.setAccelActive(!gameData.AccelActive());
+                    gameData.Write();
+                    return;
+                case SetupReset:
+                    gameData.Reset();
+                    gameData.Write();
+                    return;
+                case SetupReturn:
+                    if (playSetup)
+                    {
+                        SetPhase(Def.Phase.Play, -1);
+                    }
+                    else
+                    {
+                        SetPhase(Def.Phase.Init);
+                    }
+                    return;
+                case InitPlay:
+                    SetPhase(Def.Phase.Play, 1);
+                    return;
+                case PlayPause:
+                    SetPhase(Def.Phase.Pause);
+                    return;
+                case WinLostReturn:
+                case PauseMenu:
+                case ResumeMenu:
+                    SetPhase(Def.Phase.Init);
+                    break;
+            }
+            switch (buttonPressed)
+            {
+                case ResumeContinue:
+                    ContinueMission();
+                    return;
+                case InitBuy:
+                case TrialBuy:
+                    MarketPlace.Show(PlayerIndex.One);
+                    SetPhase(Def.Phase.Init);
+                    return;
+                case InitRanking:
+                    SetPhase(Def.Phase.Ranking);
+                    return;
+                case TrialCancel:
+                case RankingContinue:
+                    SetPhase(Def.Phase.Init);
+                    return;
+                case PauseBack:
+                    MissionBack();
+                    return;
+                case PauseRestart:
+                    SetPhase(Def.Phase.Play, mission);
+                    return;
+                case PauseContinue:
+                    SetPhase(Def.Phase.Play, -1);
+                    return;
+                case Cheat11:
+                case Cheat12:
+                case Cheat21:
+                case Cheat22:
+                case Cheat31:
+                case Cheat32:
+                    if (buttonPressed == cheatGeste[cheatGesteIndex])
+                    {
+                        cheatGesteIndex++;
+                        if (cheatGesteIndex == cheatGeste.length)
+                        {
+                            cheatGesteIndex = 0;
+                            inputPad.setShowCheatMenu(true);
+                        }
+                    }
+                    else
+                    {
+                        cheatGesteIndex = 0;
+                    }
+                    break;
+                default:
+                    if (buttonPressed.ordinal() != 0)
+                    {
+                        cheatGesteIndex = 0;
+                    }
+                    break;
+            }
+            if (buttonPressed.ordinal() >= Def.ButtonGlygh.Cheat1.ordinal() && buttonPressed.ordinal() <= Def.ButtonGlygh.Cheat9.ordinal())
+            {
+                CheatAction(buttonPressed);
+            }
+            if (phase == Def.Phase.Play)
+            {
+                decor.ButtonPressed = buttonPressed;
+                decor.MoveStep();
+                int num2 = decor.IsTerminated();
+                if (num2 == -1)
+                {
+                    MemorizeGamerProgress();
+                    SetPhase(Def.Phase.Lost);
+                }
+                else if (num2 == -2)
+                {
+                    MemorizeGamerProgress();
+                    SetPhase(Def.Phase.Win);
+                }
+                else if (num2 >= 1)
+                {
+                    MemorizeGamerProgress();
+                    StartMission(num2);
+                }
+            }
+            super.Update(gameTime);
+        }
+
+        private void MissionBack()
+        {
+            int num = mission;
+            if (num == 1)
+            {
+                SetPhase(Def.Phase.Init);
+                return;
+            }
+            num = ((num % 10 == 0) ? 1 : (num / 10 * 10));
+            SetPhase(Def.Phase.Play, num);
+        }
+
+        private void StartMission(int mission)
+        {
+            if (mission > 20 && mission % 10 > 1 && IsTrialMode())
+            {
+                SetPhase(Def.Phase.Trial);
+                return;
+            }
+            this.mission = mission;
+            if (this.mission != 1)
+            {
+                gameData.setLastWorld(this.mission / 10);
+            }
+            decor.Read(0, this.mission, false);
+            decor.LoadImages();
+            decor.SetMission(this.mission);
+            decor.SetNbVies(gameData.NbVies());
+            decor.InitializeDoors(gameData);
+            decor.AdaptDoors(false);
+            decor.MainSwitchInitialize(gameData.LastWorld());
+            decor.PlayPrepare(false);
+            decor.StartSound();
+            inputPad.StartMission(this.mission);
+        }
+
+        private void ContinueMission()
+        {
+            SetPhase(Def.Phase.Play, -2);
+            mission = decor.GetMission();
+            if (mission != 1)
+            {
+                gameData.setLastWorld(mission / 10);
+            }
+            decor.LoadImages();
+            decor.StartSound();
+            inputPad.StartMission(mission);
+        }
+
+        private void CheatAction(Def.ButtonGlygh glyph)
+        {
+            switch (glyph)
+            {
+                case Cheat1:
+                    decor.CheatAction(Tables.CheatCodes.OpenDoors);
+                    break;
+                case Cheat2:
+                    decor.CheatAction(Tables.CheatCodes.SuperBlupi);
+                    break;
+                case Cheat3:
+                    decor.CheatAction(Tables.CheatCodes.ShowSecret);
+                    break;
+                case Cheat4:
+                    decor.CheatAction(Tables.CheatCodes.LayEgg);
+                    break;
+                case Cheat5:
+                    gameData.Reset();
+                    break;
+                case Cheat6:
+                    simulateTrialMode = !simulateTrialMode;
+                    break;
+                case Cheat7:
+                    decor.CheatAction(Tables.CheatCodes.CleanAll);
+                    break;
+                case Cheat8:
+                    decor.CheatAction(Tables.CheatCodes.AllTreasure);
+                    break;
+                case Cheat9:
+                    decor.CheatAction(Tables.CheatCodes.EndGoal);
+                    break;
+            }
+        }
+
+        @Override
+        protected void Draw(GameTime gameTime)
+        {
+            if (continueMission == 1)
+            {
+                continueMission = 2;
+            }
+            if (phase == Def.Phase.Wait || phase == Def.Phase.Init || phase == Def.Phase.Pause || phase == Def.Phase.Resume || phase == Def.Phase.Lost || phase == Def.Phase.Win || phase == Def.Phase.MainSetup || phase == Def.Phase.PlaySetup || phase == Def.Phase.Trial || phase == Def.Phase.Ranking)
+            {
+                pixmap.DrawBackground();
+                if (fadeOutPhase == Def.Phase.None && missionToStart1 != -1)
+                {
+                    missionToStart2 = missionToStart1;
+                    missionToStart1 = -1;
+                }
+                else
+                {
+                    DrawBackgroundFade();
+                    if (fadeOutPhase == Def.Phase.None)
+                    {
+                        DrawButtonsBackground();
+                        inputPad.Draw();
+                        DrawButtonsText();
+                    }
+                }
+            }
+            else if (phase == Def.Phase.Play)
+            {
+                decor.Build();
+                inputPad.Draw();
+            }
+            if (phase == Def.Phase.Wait)
+            {
+                DrawWaitProgress();
+            }
+            super.Draw(gameTime);
+        }
+
+        private void DrawBackgroundFade()
+        {
+            if (phase == Def.Phase.Init)
+            {
+                double num = Math_.Min((double)phaseTime / 20.0, 1.0);
+                TinyRect rect;
+                double opacity;
+                if (fadeOutPhase == Def.Phase.MainSetup)
+                {
+                    num = (1.0 - num) * (1.0 - num);
+                     TinyRect tinyRect = default_(new TinyRect());
+                    tinyRect.Left = (int)(720.0 - 640.0 * num);
+                    tinyRect.Right = (int)(1360.0 - 640.0 * num);
+                    tinyRect.Top = 0;
+                    tinyRect.Bottom = 160;
+                    rect = tinyRect;
+                    opacity = num * num;
+                }
+                else
+                {
+                    num = ((fadeOutPhase.ordinal() != 0) ? (1.0 - num * 2.0) : (1.0 - (1.0 - num) * (1.0 - num)));
+                     TinyRect tinyRect2 = default_(new TinyRect());
+                    tinyRect2.Left = 80;
+                    tinyRect2.Right = 720;
+                    tinyRect2.Top = (int)(-160.0 + num * 160.0);
+                    tinyRect2.Bottom = (int)(0.0 + num * 160.0);
+                    rect = tinyRect2;
+                    opacity = 1.0;
+                }
+                pixmap.DrawIcon(15, 0, rect, opacity, false);
+            }
+            if (phase == Def.Phase.Init)
+            {
+                double num = Math_.Min((double)phaseTime / 20.0, 1.0);
+                double opacity;
+                if (fadeOutPhase == Def.Phase.MainSetup)
+                {
+                    opacity = (1.0 - num) * (1.0 - num);
+                    num = 1.0;
+                }
+                else if (fadeOutPhase == Def.Phase.None)
+                {
+
+                    num = 0.5 + num / 2.0;
+                    opacity = Math_.Min(num * num, 1.0);
+                }
+                else
+                {
+                    opacity = 1.0 - num;
+                    num = 1.0 + num * 10.0;
+                }
+                 TinyRect tinyRect3 = default_(new TinyRect());
+                tinyRect3.Left = (int)(468.0 - 205.0 * num);
+                tinyRect3.Right = (int)(468.0 + 205.0 * num);
+                tinyRect3.Top = (int)(280.0 - 190.0 * num);
+                tinyRect3.Bottom = (int)(280.0 + 190.0 * num);
+                TinyRect rect = tinyRect3;
+                pixmap.DrawIcon(16, 0, rect, opacity, 0.0, false);
+            }
+            if (phase == Def.Phase.Pause || phase == Def.Phase.Resume)
+            {
+                if (fadeOutPhase == Def.Phase.Play)
+                {
+                    double num = Math_.Min((double)phaseTime / 20.0, 1.0);
+                    double opacity = 1.0 - num;
+                    num = 1.0 + num * 10.0;
+                     TinyRect tinyRect4 = default_(new TinyRect());
+                    tinyRect4.Left = (int)(418.0 - 205.0 * num);
+                    tinyRect4.Right = (int)(418.0 + 205.0 * num);
+                    tinyRect4.Top = (int)(190.0 - 190.0 * num);
+                    tinyRect4.Bottom = (int)(190.0 + 190.0 * num);
+                    TinyRect rect = tinyRect4;
+                    pixmap.DrawIcon(16, 0, rect, opacity, 0.0, false);
+                }
+                else if (fadeOutPhase == Def.Phase.PlaySetup)
+                {
+                    double num = Math_.Min((double)phaseTime / 20.0, 1.0);
+                    num *= num;
+                     TinyRect tinyRect5 = default_(new TinyRect());
+                    tinyRect5.Left = (int)(213.0 + 800.0 * num);
+                    tinyRect5.Right = (int)(623.0 + 800.0 * num);
+                    tinyRect5.Top = 0;
+                    tinyRect5.Bottom = 0;
+                    TinyRect rect = tinyRect5;
+                    pixmap.DrawIcon(16, 0, rect, 1.0, 0.0, false);
+                }
+                else
+                {
+                    double num;
+                    if (fadeOutPhase == Def.Phase.None)
+                    {
+                        num = Math_.Min((double)phaseTime / 15.0, 1.0);
+                    }
+                    else
+                    {
+                        num = Math_.Min((double)phaseTime / 15.0, 1.0);
+                        num = 1.0 - num;
+                    }
+                     TinyRect tinyRect6 = default_(new TinyRect());
+                    tinyRect6.Left = (int)(418.0 - 205.0 * num);
+                    tinyRect6.Right = (int)(418.0 + 205.0 * num);
+                    tinyRect6.Top = (int)(190.0 - 190.0 * num);
+                    tinyRect6.Bottom = (int)(190.0 + 190.0 * num);
+                    TinyRect rect = tinyRect6;
+                    double rotation = 0.0;
+                    if (num < 1.0)
+                    {
+                        rotation = (1.0 - num) * (1.0 - num) * 360.0 * 1.0;
+                    }
+                    if (rect.Width() > 0 && rect.Height() > 0)
+                    {
+                        pixmap.DrawIcon(16, 0, rect, 1.0, rotation, false);
+                    }
+                }
+            }
+            if (phase == Def.Phase.MainSetup || phase == Def.Phase.PlaySetup)
+            {
+                double num = Math_.Min((double)phaseTime / 20.0, 1.0);
+                num = 1.0 - (1.0 - num) * (1.0 - num);
+                double num2;
+                if (phaseTime < 20)
+                {
+                    num2 = (double)phaseTime / 20.0;
+                    num2 = 1.0 - (1.0 - num2) * (1.0 - num2);
+                }
+                else
+                {
+                    num2 = 1.0 + ((double)phaseTime - 20.0) / 400.0;
+                }
+                if (fadeOutPhase.ordinal() != 0)
+                {
+                    num = 1.0 - num;
+                    num2 = 1.0 - num2;
+                }
+                 TinyRect tinyRect7 = default_(new TinyRect());
+                tinyRect7.Left = (int)(720.0 - 640.0 * num);
+                tinyRect7.Right = (int)(1360.0 - 640.0 * num);
+                tinyRect7.Top = 0;
+                tinyRect7.Bottom = 160;
+                TinyRect rect = tinyRect7;
+                pixmap.DrawIcon(15, 0, rect, num * num, false);
+                 TinyRect tinyRect8 = default_(new TinyRect());
+                tinyRect8.Left = 487;
+                tinyRect8.Right = 713;
+                tinyRect8.Top = 148;
+                tinyRect8.Bottom = 374;
+                TinyRect rect2 = tinyRect8;
+                 TinyRect tinyRect9 = default_(new TinyRect());
+                tinyRect9.Left = 118;
+                tinyRect9.Right = 570;
+                tinyRect9.Top = 268;
+                tinyRect9.Bottom = 720;
+                TinyRect rect3 = tinyRect9;
+                double opacity = 0.5 - num * 0.4;
+                double rotation = (0.0 - num2) * 100.0 * 2.5;
+                pixmap.DrawIcon(17, 0, rect2, opacity, rotation, false);
+                pixmap.DrawIcon(17, 0, rect3, opacity, (0.0 - rotation) * 0.5, false);
+            }
+            if (phase == Def.Phase.Lost)
+            {
+                double num = Math_.Min((double)phaseTime / 100.0, 1.0);
+                 TinyRect tinyRect10 = default_(new TinyRect());
+                tinyRect10.Left = (int)(418.0 - 205.0 * num);
+                tinyRect10.Right = (int)(418.0 + 205.0 * num);
+                tinyRect10.Top = (int)(238.0 - 190.0 * num);
+                tinyRect10.Bottom = (int)(238.0 + 190.0 * num);
+                TinyRect rect = tinyRect10;
+                double rotation = 0.0;
+                if (num < 1.0)
+                {
+                    rotation = (1.0 - num) * (1.0 - num) * 360.0 * 6.0;
+                }
+                if (rect.Width() > 0 && rect.Height() > 0)
+                {
+                    pixmap.DrawIcon(16, 0, rect, 1.0, rotation, false);
+                }
+            }
+            if (phase == Def.Phase.Win)
+            {
+                double num = Math_.Sin((double)phaseTime / 3.0) / 2.0 + 1.0;
+                 TinyRect tinyRect11 = default_(new TinyRect());
+                tinyRect11.Left = (int)(418.0 - 205.0 * num);
+                tinyRect11.Right = (int)(418.0 + 205.0 * num);
+                tinyRect11.Top = (int)(238.0 - 190.0 * num);
+                tinyRect11.Bottom = (int)(238.0 + 190.0 * num);
+                TinyRect rect = tinyRect11;
+                pixmap.DrawIcon(16, 0, rect, 1.0, 0.0, false);
+            }
+        }
+
+        private void DrawButtonsBackground()
+        {
+            if (phase == Def.Phase.Init)
+            {
+                TinyRect drawBounds = pixmap.DrawBounds();
+                int width = drawBounds.Width();
+                int height = drawBounds.Height();
+                 TinyRect tinyRect = default_(new TinyRect());
+                tinyRect.Left = 10;
+                tinyRect.Right = 260;
+                tinyRect.Top = height - 325;
+                tinyRect.Bottom = height - 10;
+                TinyRect rect = tinyRect;
+                pixmap.DrawIcon(14, 15, rect, 0.3, false);
+                 TinyRect tinyRect2 = default_(new TinyRect());
+                tinyRect2.Left = width - 170;
+                tinyRect2.Right = width - 10;
+                tinyRect2.Top = height - ((IsTrialMode() || IsRankingMode()) ? 325 : 195);
+                tinyRect2.Bottom = height - 10;
+                rect = tinyRect2;
+                pixmap.DrawIcon(14, 15, rect, 0.3, false);
+            }
+        }
+
+        private void DrawButtonsText()
+        {
+            if (phase == Def.Phase.Init)
+            {
+                DrawButtonGamerText(Def.ButtonGlygh.InitGamerA, 0);
+                DrawButtonGamerText(Def.ButtonGlygh.InitGamerB, 1);
+                DrawButtonGamerText(Def.ButtonGlygh.InitGamerC, 2);
+                DrawTextUnderButton(Def.ButtonGlygh.InitPlay, MyResource.TX_BUTTON_PLAY);
+                DrawTextRightButton(Def.ButtonGlygh.InitSetup, MyResource.TX_BUTTON_SETUP);
+                if (IsTrialMode())
+                {
+                    DrawTextUnderButton(Def.ButtonGlygh.InitBuy, MyResource.TX_BUTTON_BUY);
+                }
+                if (IsRankingMode())
+                {
+                    DrawTextUnderButton(Def.ButtonGlygh.InitRanking, MyResource.TX_BUTTON_RANKING);
+                }
+            }
+            if (phase == Def.Phase.Pause)
+            {
+                DrawTextUnderButton(Def.ButtonGlygh.PauseMenu, MyResource.TX_BUTTON_MENU);
+                if (mission != 1)
+                {
+                    DrawTextUnderButton(Def.ButtonGlygh.PauseBack, MyResource.TX_BUTTON_BACK);
+                }
+                DrawTextUnderButton(Def.ButtonGlygh.PauseSetup, MyResource.TX_BUTTON_SETUP);
+                if (mission != 1 && mission % 10 != 0)
+                {
+                    DrawTextUnderButton(Def.ButtonGlygh.PauseRestart, MyResource.TX_BUTTON_RESTART);
+                }
+                DrawTextUnderButton(Def.ButtonGlygh.PauseContinue, MyResource.TX_BUTTON_CONTINUE);
+            }
+            if (phase == Def.Phase.Resume)
+            {
+                DrawTextUnderButton(Def.ButtonGlygh.ResumeMenu, MyResource.TX_BUTTON_MENU);
+                DrawTextUnderButton(Def.ButtonGlygh.ResumeContinue, MyResource.TX_BUTTON_CONTINUE);
+            }
+            if (phase == Def.Phase.MainSetup || phase == Def.Phase.PlaySetup)
+            {
+                DrawTextRightButton(Def.ButtonGlygh.SetupSounds, MyResource.TX_BUTTON_SETUP_SOUNDS);
+                DrawTextRightButton(Def.ButtonGlygh.SetupJump, MyResource.TX_BUTTON_SETUP_JUMP);
+                DrawTextRightButton(Def.ButtonGlygh.SetupZoom, MyResource.TX_BUTTON_SETUP_ZOOM);
+                DrawTextRightButton(Def.ButtonGlygh.SetupAccel, MyResource.TX_BUTTON_SETUP_ACCEL);
+                if (phase == Def.Phase.MainSetup)
+                {
+                    String text = string.Format(MyResource.LoadString(MyResource.TX_BUTTON_SETUP_RESET), new string((char)(65 + gameData.SelectedGamer()), 1));
+                    DrawTextRightButton(Def.ButtonGlygh.SetupReset, text);
+                }
+            }
+            if (phase == Def.Phase.Trial)
+            {
+                 TinyPoint tinyPoint = default_(new TinyPoint());
+                tinyPoint.X = 360;
+                tinyPoint.Y = 50;
+                TinyPoint pos = tinyPoint;
+                Text.DrawText(pixmap, pos, MyResource.LoadString(MyResource.TX_TRIAL1), 0.9);
+                pos.Y += 40;
+                Text.DrawText(pixmap, pos, MyResource.LoadString(MyResource.TX_TRIAL2), 0.7);
+                pos.Y += 25;
+                Text.DrawText(pixmap, pos, MyResource.LoadString(MyResource.TX_TRIAL3), 0.7);
+                pos.Y += 25;
+                Text.DrawText(pixmap, pos, MyResource.LoadString(MyResource.TX_TRIAL4), 0.7);
+                pos.Y += 25;
+                Text.DrawText(pixmap, pos, MyResource.LoadString(MyResource.TX_TRIAL5), 0.7);
+                pos.Y += 25;
+                Text.DrawText(pixmap, pos, MyResource.LoadString(MyResource.TX_TRIAL6), 0.7);
+                DrawTextUnderButton(Def.ButtonGlygh.TrialBuy, MyResource.TX_BUTTON_BUY);
+                DrawTextUnderButton(Def.ButtonGlygh.TrialCancel, MyResource.TX_BUTTON_BACK);
+            }
+            if (phase == Def.Phase.Ranking)
+            {
+                DrawTextUnderButton(Def.ButtonGlygh.RankingContinue, MyResource.TX_BUTTON_BACK);
+            }
+        }
+
+        private void DrawButtonGamerText(Def.ButtonGlygh glyph, int gamer)
+        {
+            TinyRect buttonRect = inputPad.GetButtonRect(glyph);
+            
+            GamerInfo gamerInfo = gameData.GetGamerInfo(gamer);
+            int nbVies = gamerInfo.nbVies;
+            int mainDoors = gamerInfo.mainDoors;
+            int secondaryDoors = gamerInfo.secondaryDoors;
+             TinyPoint tinyPoint = default_(new TinyPoint());
+            tinyPoint.X = buttonRect.Right + 5 - pixmap.Origin().X;
+            tinyPoint.Y = buttonRect.Top + 3 - pixmap.Origin().Y;
+            TinyPoint pos = tinyPoint;
+            String text = string.Format(MyResource.LoadString(MyResource.TX_GAMER_TITLE), new string((char)(65 + gamer), 1));
+            Text.DrawText(pixmap, pos, text, 0.7);
+             TinyPoint tinyPoint2 = default_(new TinyPoint());
+            tinyPoint2.X = buttonRect.Right + 5 - pixmap.Origin().X;
+            tinyPoint2.Y = buttonRect.Top + 25 - pixmap.Origin().Y;
+            pos = tinyPoint2;
+            text = string.Format(MyResource.LoadString(MyResource.TX_GAMER_MDOORS), mainDoors);
+            Text.DrawText(pixmap, pos, text, 0.45);
+             TinyPoint tinyPoint3 = default_(new TinyPoint());
+            tinyPoint3.X = buttonRect.Right + 5 - pixmap.Origin().X;
+            tinyPoint3.Y = buttonRect.Top + 39 - pixmap.Origin().Y;
+            pos = tinyPoint3;
+            text = string.Format(MyResource.LoadString(MyResource.TX_GAMER_SDOORS), secondaryDoors);
+            Text.DrawText(pixmap, pos, text, 0.45);
+             TinyPoint tinyPoint4 = default_(new TinyPoint());
+            tinyPoint4.X = buttonRect.Right + 5 - pixmap.Origin().X;
+            tinyPoint4.Y = buttonRect.Top + 53 - pixmap.Origin().Y;
+            pos = tinyPoint4;
+            text = string.Format(MyResource.LoadString(MyResource.TX_GAMER_LIFES), nbVies);
+            Text.DrawText(pixmap, pos, text, 0.45);
+        }
+
+        private void DrawTextRightButton(Def.ButtonGlygh glyph, int res)
+        {
+            DrawTextRightButton(glyph, MyResource.LoadString(res));
+        }
+
+        private void DrawTextRightButton(Def.ButtonGlygh glyph, String text)
+        {
+            TinyRect buttonRect = inputPad.GetButtonRect(glyph);
+            String[] array = text.split("\n");
+            if (array.length == 2)
+            {
+                 TinyPoint tinyPoint = default_(new TinyPoint());
+                tinyPoint.X = buttonRect.Right + 10 - pixmap.Origin().X;
+                tinyPoint.Y = (buttonRect.Top + buttonRect.Bottom) / 2 - 20 - pixmap.Origin().Y;
+                TinyPoint pos = tinyPoint;
+                Text.DrawText(pixmap, pos, array[0], 0.7);
+                pos.Y += 24;
+                Text.DrawText(pixmap, pos, array[1], 0.7);
+            }
+            else
+            {
+                 TinyPoint tinyPoint2 = default_(new TinyPoint());
+                tinyPoint2.X = buttonRect.Right + 10 - pixmap.Origin().X;
+                tinyPoint2.Y = (buttonRect.Top + buttonRect.Bottom) / 2 - 8 - pixmap.Origin().Y;
+                TinyPoint pos2 = tinyPoint2;
+                Text.DrawText(pixmap, pos2, text, 0.7);
+            }
+        }
+
+        private void DrawTextUnderButton(Def.ButtonGlygh glyph, int res)
+        {
+            TinyRect buttonRect = inputPad.GetButtonRect(glyph);
+             TinyPoint tinyPoint = default_(new TinyPoint());
+            tinyPoint.X = (buttonRect.Left + buttonRect.Right) / 2 - pixmap.Origin().X;
+            tinyPoint.Y = buttonRect.Bottom + 2 - pixmap.Origin().Y;
+            TinyPoint pos = tinyPoint;
+            String text = MyResource.LoadString(res);
+            Text.DrawTextCenter(pixmap, pos, text, 0.7);
+        }
+
+        private void DrawWaitProgress()
+        {
+            if (continueMission != 0)
+            {
+                return;
+            }
+            for (int i = 0; i < waitTable.length; i++)
+            {
+                if (waitProgress <= waitTable[i * 2])
+                {
+                    waitJauge.SetLevel((int)waitTable[i * 2 + 1]);
+                    break;
+                }
+            }
+            waitJauge.Draw();
+        }
+
+        private void DrawDebug()
+        {
+             TinyPoint tinyPoint = default_(new TinyPoint());
+            tinyPoint.X = 10;
+            tinyPoint.Y = 20;
+            TinyPoint pos = tinyPoint;
+            Text.DrawText(pixmap, pos, Integer.valueOf(inputPad.TotalTouch()).toString(), 1.0);
+        }
+
+        private void SetGamer(int gamer)
+        {
+            gameData.setSelectedGamer(gamer);
+            gameData.Write();
+        }
+
+        private void SetPhase(Def.Phase phase)
+        {
+            SetPhase(phase, 0);
+        }
+
+        private void SetPhase(Def.Phase phase, int mission)
+        {
+            if (mission != -2)
+            {
+                if (missionToStart2 == -1)
+                {
+                    if ((this.phase == Def.Phase.Init || this.phase == Def.Phase.MainSetup || this.phase == Def.Phase.PlaySetup || this.phase == Def.Phase.Pause || this.phase == Def.Phase.Resume) && fadeOutPhase == Def.Phase.None)
+                    {
+                        fadeOutPhase = phase;
+                        fadeOutMission = mission;
+                        phaseTime = 0;
+                        return;
+                    }
+                    if (phase == Def.Phase.Play)
+                    {
+                        fadeOutPhase = Def.Phase.None;
+                        if (fadeOutMission != -1)
+                        {
+                            missionToStart1 = fadeOutMission;
+                            return;
+                        }
+                        mission = fadeOutMission;
+                        decor.LoadImages();
+                    }
+                }
+                else
+                {
+                    mission = missionToStart2;
+                }
+            }
+            this.phase = phase;
+            fadeOutPhase = Def.Phase.None;
+            inputPad.Phase = this.phase;
+            playSetup = this.phase == Def.Phase.PlaySetup;
+            isTrialMode = TrialMode.IsTrialModeEnabled();
+            phaseTime = 0;
+            missionToStart2 = -1;
+            decor.StopSound();
+            switch (this.phase)
+            {
+                case Init:
+                    pixmap.BackgroundCache("init");
+                    break;
+                case Pause:
+                case Resume:
+                    pixmap.BackgroundCache("pause");
+                    break;
+                case Lost:
+                    pixmap.BackgroundCache("lost");
+                    break;
+                case Win:
+                    pixmap.BackgroundCache("win");
+                    break;
+                case MainSetup:
+                case PlaySetup:
+                    pixmap.BackgroundCache("setup");
+                    break;
+                case Trial:
+                    pixmap.BackgroundCache("trial");
+                    break;
+                case Ranking:
+                    pixmap.BackgroundCache("pause");
+                    break;
+                case Play:
+                    decor.setDrawBounds(pixmap.DrawBounds());
+                    break;
+            }
+            if (this.phase == Def.Phase.Play && mission > 0)
+            {
+                StartMission(mission);
+            }
+        }
+
+        private void MemorizeGamerProgress()
+        {
+            gameData.setNbVies(decor.GetNbVies());
+            decor.MemorizeDoors(gameData);
+            gameData.Write();
+        }
+        //public void SetFullScreen(bool isFullScreen)
+        //{
+        //    this.graphics.IsFullScreen = isFullScreen;
+        //    graphics.ToggleFullScreen();
+        //}
+        public void ToggleFullScreen()
+        {
+            this.graphics.ToggleFullScreen();
+        }
+        public boolean IsFullScreen() { return this.graphics.IsFullScreen(); }
+    }

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/GameData.java

@@ -0,0 +1,225 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.GameData
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.readonly;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class GameData
+    {
+        private static @readonly final int HeaderLength = 10;
+
+        private static @readonly final int DoorsLength = 200;
+
+        private static @readonly final int GamerLength = 10 + DoorsLength;
+
+        private static @readonly final int MaxGamer = 3;
+
+        private static @readonly final int TotalLength = HeaderLength + GamerLength * MaxGamer;
+
+        private @readonly final byte[] data;
+
+        public int SelectedGamer() {
+            return getSelectedGamer();
+        }
+        public int getSelectedGamer() {
+            return data[2];
+        }
+
+        public void setSelectedGamer(int value) {
+            data[2] = (byte) value;
+        }
+
+        
+        public boolean Sounds() {
+            return isSounds();
+        }
+        public boolean isSounds() {
+            return data[3] == 1;
+        }
+
+        public void setSounds(boolean value) {
+            data[3] = (byte) (value ? 1 : 0);
+        }  
+        public boolean JumpRight() {
+            return isJumpRight();
+        }
+        public boolean isJumpRight() {
+            return data[4] == 1;
+        }
+
+        public void setJumpRight(boolean value) {
+            data[4] = (byte) (value ? 1 : 0);
+        }
+
+        public boolean AutoZoom() {
+            return isAutoZoom();
+        }
+        public boolean isAutoZoom() {
+            return data[5] == 1;
+        }
+
+        public void setAutoZoom(boolean value) {
+            data[5] = (byte) (value ? 1 : 0);
+        }
+        public boolean AccelActive() {
+            return isAccelActive();
+        }
+        public boolean isAccelActive() {
+            return data[6] == 1;
+        }
+
+        public void setAccelActive(boolean value) {
+            data[6] = (byte) (value ? 1 : 0);
+        }
+
+        public double AccelSensitivity() {
+            return getAccelSensitivity();
+        }
+        public double getAccelSensitivity() {
+            return (double) (int) data[7] / 100.0;
+        }
+
+        public void setAccelSensitivity(double value) {
+            value = Math_.Max(value, 0.0);
+            value = Math_.Min(value, 1.0);
+            data[7] = (byte) (value * 100.0);
+        }
+
+        public int NbVies() {
+            return getNbVies();
+        }
+        public int getNbVies() {
+            return data[getGamerOffset()];
+        }
+
+        public void setNbVies(int value) {
+            data[getGamerOffset()] = (byte) value;
+        }
+        public int LastWorld() {
+            return getLastWorld();
+        }
+        public int getLastWorld() {
+            return data[getGamerOffset() + 1];
+        }
+
+        public void setLastWorld(int value) {
+            data[getGamerOffset() + 1] = (byte) value;
+        }
+
+        private int getGamerOffset() {
+            return GetGamerOffset(getSelectedGamer());
+        }
+        private int getGamerOffset(int gamer) {
+            return GetGamerOffset(gamer);
+        }
+
+
+        
+        
+        public GameData()
+        {
+            data = new byte[TotalLength];
+            Initialize();
+        }
+
+        public void Read()
+        {
+            Worlds.ReadGameData(data);
+        }
+
+        public void Write()
+        {
+            Worlds.WriteGameData(data);
+        }
+
+        public void Reset()
+        {
+            Initialize(getSelectedGamer());
+        }
+
+        public void GetDoors(int[] doors)
+        {
+            for (int i = 0; i < DoorsLength; i++)
+            {
+                doors[i] = data[getGamerOffset() + 10 + i];
+            }
+        }
+
+        public void SetDoors(int[] doors)
+        {
+            for (int i = 0; i < DoorsLength; i++)
+            {
+                data[getGamerOffset() + 10 + i] = (byte)doors[i];
+            }
+        }
+
+        static class GamerInfo {
+
+            public int nbVies;
+            public int mainDoors;
+            public int secondaryDoors;
+
+            public GamerInfo(int nbVies, int mainDoors, int secondaryDoors) {
+                this.nbVies = nbVies;
+                this.mainDoors = mainDoors;
+                this.secondaryDoors = secondaryDoors;
+            }
+        }
+        public GamerInfo GetGamerInfo(int gamer/*, @Out int nbVies, @Out int mainDoors, @Out int secondaryDoors*/) {
+            int nbVies = data[getGamerOffset(gamer)];
+            int secondaryDoors = 0;
+
+            for (int i = 0; i < 180; i++) {
+                if (data[getGamerOffset(gamer) + 10 + i] == 1) {
+                    secondaryDoors++;
+                }
+            }
+
+            int mainDoors = 0;
+            for (int j = 180; j < 200; j++) {
+                if (data[getGamerOffset(gamer) + 10 + j] == 1) {
+                    mainDoors++;
+                }
+            }
+
+            return new GamerInfo(nbVies, mainDoors, secondaryDoors);
+
+        }
+
+        private void Initialize()
+        {
+            data[0] = 1;
+            data[1] = 1;
+            data[2] = 0;
+            data[3] = 1;
+            data[4] = 1;
+            data[5] = 1;
+            data[6] = 0;
+            data[7] = 50;
+            setSelectedGamer(0);
+            for (int i = 0; i < MaxGamer; i++)
+            {
+                Initialize(i);
+            }
+        }
+
+        private void Initialize(int gamer)
+        {
+            data[GetGamerOffset(gamer)] = 3;
+            data[GetGamerOffset(gamer) + 1] = 1;
+            for (int i = 0; i < DoorsLength; i++)
+            {
+                data[GetGamerOffset(gamer) + 10 + i] = 0;
+            }
+        }
+
+        private int GetGamerOffset(int gamer)
+        {
+            return HeaderLength + GamerLength * gamer;
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/InputPad.java

@@ -0,0 +1,997 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.InputPad
+import com.openeggbert.jdotnet.System.UnauthorizedAccessException;
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jdotnet.System.Collections.Generic.*;
+import com.openeggbert.jdotnet.System.Diagnostics.*;
+import com.openeggbert.jdotnet.System.Linq.*;
+import static com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi.Def.*;
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jdotnet.JDotNet.Microsoft.Devices.Sensors.AccelerometerFailedException;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.ButtonState;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Keyboard;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.KeyboardState;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Keys;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Mouse;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.MouseState;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Touch.TouchCollection;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Touch.TouchLocation;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Touch.TouchLocationState;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Input.Touch.TouchPanel;
+import lombok.Getter;
+import lombok.Setter;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.readonly;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class InputPad
+    {
+        private static @readonly final int padSize = 140;
+
+        private @readonly final Game1 game1;
+
+        private @readonly final Decor decor;
+
+        private @readonly final Pixmap pixmap;
+
+        private @readonly final Sound sound;
+
+        private @readonly final GameData gameData;
+
+        private @readonly final List_<Def.ButtonGlygh> pressedGlyphs;
+
+        private @readonly final Accelerometer accelSensor;
+
+        private @readonly final Slider accelSlider;
+
+        private boolean padPressed;
+
+        private boolean showCheatMenu;
+
+        private TinyPoint padTouchPos;
+
+        private Def.ButtonGlygh lastButtonDown;
+
+        private Def.ButtonGlygh buttonPressed;
+
+        private int touchCount;
+
+        private boolean accelStarted;
+
+        private boolean accelActive;
+
+        private double accelSpeedX;
+
+        private boolean accelLastState;
+
+        private boolean accelWaitZero;
+
+        private int mission;
+
+        @Getter @Setter
+        public Def.Phase Phase;
+        
+        @Getter @Setter
+        public int SelectedGamer;
+
+        @Getter @Setter
+        public TinyPoint PixmapOrigin;
+
+        public int TotalTouch() {
+            return getTotalTouch();
+        }
+
+        public int getTotalTouch() {
+            return touchCount;
+        }
+
+        public Def.ButtonGlygh ButtonPressed() {
+            Def.ButtonGlygh result = buttonPressed;
+            buttonPressed = Def.ButtonGlygh.None;
+            return result;
+        }
+  
+        public boolean ShowCheatMenu() {
+            return isShowCheatMenu();
+        }
+
+        public boolean isShowCheatMenu() {
+            return showCheatMenu;
+        }
+
+        public void setShowCheatMenu(boolean showCheatMenu) {
+            this.showCheatMenu = showCheatMenu;
+        }
+
+        public List_<Def.ButtonGlygh> ButtonGlyphs() {
+                List_<Def.ButtonGlygh> buttonGlyphs = new List_<>();
+            
+                switch (Phase)
+                {
+                    case Init:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitGamerA);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitGamerB);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitGamerC);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitSetup);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitPlay);
+                        if (game1.IsTrialMode())
+                        {
+                            buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitBuy);
+                        }
+                        if (game1.IsRankingMode())
+                        {
+                            buttonGlyphs.YieldReturn(Def.ButtonGlygh.InitRanking);
+                        }
+                        break;
+                    case Play:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.PlayPause);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.PlayAction);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.PlayJump);
+                        if (accelStarted)
+                        {
+                            buttonGlyphs.YieldReturn(Def.ButtonGlygh.PlayDown);
+                        }
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat11);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat12);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat21);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat22);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat31);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat32);
+                        break;
+                    case Pause:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.PauseMenu);
+                        if (mission != 1)
+                        {
+                            buttonGlyphs.YieldReturn(Def.ButtonGlygh.PauseBack);
+                        }
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.PauseSetup);
+                        if (mission != 1 && mission % 10 != 0)
+                        {
+                            buttonGlyphs.YieldReturn(Def.ButtonGlygh.PauseRestart);
+                        }
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.PauseContinue);
+                        break;
+                    case Resume:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.ResumeMenu);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.ResumeContinue);
+                        break;
+                    case Lost:
+                    case Win:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.WinLostReturn);
+                        break;
+                    case Trial:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.TrialBuy);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.TrialCancel);
+                        break;
+                    case MainSetup:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupSounds);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupJump);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupZoom);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupAccel);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupReset);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupReturn);
+                        break;
+                    case PlaySetup:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupSounds);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupJump);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupZoom);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupAccel);
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.SetupReturn);
+                        break;
+                    case Ranking:
+                        buttonGlyphs.YieldReturn(Def.ButtonGlygh.RankingContinue);
+                        break;
+                }
+                if (showCheatMenu)
+                {
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat1);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat2);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat3);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat4);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat5);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat6);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat7);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat8);
+                    buttonGlyphs.YieldReturn(Def.ButtonGlygh.Cheat9);
+                }
+                return buttonGlyphs;
+            
+        }
+
+        private TinyPoint PadCenter()
+        {
+                TinyRect drawBounds = pixmap.DrawBounds();
+                if (gameData.isJumpRight())
+                {
+                     TinyPoint result = default_(new TinyPoint());
+                    result.X = 100;
+                    result.Y = drawBounds.Height() - 100;
+                    return result;
+                }
+                 TinyPoint result2 = default_(new TinyPoint());
+                result2.X = drawBounds.Width() - 100;
+                result2.Y = drawBounds.Height() - 100;
+                return result2;
+            
+        }
+
+        public InputPad(Game1 game1, Decor decor, Pixmap pixmap, Sound sound, GameData gameData)
+        {
+            //IL_0037: Unknown result type (might be due to invalid IL or missing references)
+            //IL_0041: Expected O, but got Unknown
+            this.game1 = game1;
+            this.decor = decor;
+            this.pixmap = pixmap;
+            this.sound = sound;
+            this.gameData = gameData;
+            pressedGlyphs = new List_<>();
+            accelSensor = AccelerometerFactory.Create();
+            accelSensor.CurrentValueChanged().addEventListener((e) -> HandleAccelSensorCurrentValueChanged(null, e));
+            accelSlider = new Slider(
+                new TinyPoint(320,400),
+                this.gameData.AccelSensitivity()
+            );
+            lastButtonDown = Def.ButtonGlygh.None;
+            buttonPressed = Def.ButtonGlygh.None;
+        }
+
+        public void StartMission(int mission)
+        {
+            this.mission = mission;
+            accelWaitZero = true;
+        }
+
+        private TinyPoint createTinyPoint(int x, int y)
+        {
+            TinyPoint tinyPoint = new TinyPoint();
+            tinyPoint.X = x;
+            tinyPoint.Y = y;
+            return tinyPoint;
+        }
+        public void Update()
+        {
+            pressedGlyphs.Clear();
+            if (accelActive != gameData.AccelActive())
+            {
+                accelActive = gameData.AccelActive();
+                if (accelActive)
+                {
+                    StartAccel();
+                }
+                else
+                {
+                    StopAccel();
+                }
+            }
+            double horizontalChange = 0.0;
+            double verticalChange = 0.0;
+            int num3 = 0;
+            padPressed = false;
+            Def.ButtonGlygh buttonGlygh = Def.ButtonGlygh.None;
+            TouchCollection touches = TouchPanel.GetState();
+            touchCount = touches.Count;
+            List_<TinyPoint> touchesOrClicks = new List_<>();
+            for (TouchLocation item : touches)
+            {
+                if (item.State == TouchLocationState.Pressed || item.State == TouchLocationState.Moved)
+                {
+                     TinyPoint tinyPoint = default_(new TinyPoint());
+                    tinyPoint.X = (int)item.Position.X;
+                    tinyPoint.Y = (int)item.Position.Y;
+                    touchesOrClicks.Add(tinyPoint);
+                }
+            }
+
+            MouseState mouseState = Mouse.GetState();
+            if (mouseState.LeftButton() == ButtonState.Pressed)
+            {
+                touchCount++;
+                TinyPoint click = new TinyPoint();
+                click.X = mouseState.X();
+                click.Y = mouseState.Y();
+                touchesOrClicks.Add(click);
+            }
+
+            KeyboardState newState = Keyboard.GetState();
+            {
+                if (newState.IsKeyDown(Keys.LeftControl)) touchesOrClicks.Add(createTinyPoint(-1, Misc.keyboardPressToInt(KeyboardPress.LeftControl)));
+                if (newState.IsKeyDown(Keys.Up)) touchesOrClicks.Add(createTinyPoint(-1, Misc.keyboardPressToInt(KeyboardPress.Up)));
+                if (newState.IsKeyDown(Keys.Right)) touchesOrClicks.Add(createTinyPoint(-1, Misc.keyboardPressToInt(KeyboardPress.Right)));
+                if (newState.IsKeyDown(Keys.Down)) touchesOrClicks.Add(createTinyPoint(-1, Misc.keyboardPressToInt(KeyboardPress.Down)));
+                if (newState.IsKeyDown(Keys.Left)) touchesOrClicks.Add(createTinyPoint(-1, Misc.keyboardPressToInt(KeyboardPress.Left)));
+                if (newState.IsKeyDown(Keys.Space)) touchesOrClicks.Add(createTinyPoint(-1, Misc.keyboardPressToInt(KeyboardPress.Space)));
+            }
+            if (newState.IsKeyDown(Keys.F11))
+            {
+                game1.ToggleFullScreen ();
+                Debug.WriteLine("F11 was pressed.");
+            }
+
+            Boolean keyPressedUp = false;
+            Boolean keyPressedDown = false;
+            Boolean keyPressedLeft = false;
+            Boolean keyPressedRight = false;
+            for (TinyPoint touchOrClick : touchesOrClicks)
+            {
+                Boolean keyboardPressed = false;
+                if (touchOrClick.X == -1)
+                {
+                    keyboardPressed = true;
+                }
+                KeyboardPress keyboardPress = keyboardPressed ? Misc.intToKeyboardPress(touchOrClick.Y) : KeyboardPress.None;
+                keyPressedUp = keyboardPress == KeyboardPress.Up ? true : keyPressedUp;
+                keyPressedDown = keyboardPress == KeyboardPress.Down ? true : keyPressedDown;
+                keyPressedLeft = keyboardPress == KeyboardPress.Left ? true : keyPressedLeft;
+                keyPressedRight = keyboardPress == KeyboardPress.Right ? true : keyPressedRight;
+
+                {
+                    TinyPoint tinyPoint2 = keyboardPressed ? createTinyPoint(1, 1) : touchOrClick;
+                    if (!accelStarted && Misc.IsInside(GetPadBounds(PadCenter(), padSize), tinyPoint2))
+                    {
+                        padPressed = true;
+                        padTouchPos = tinyPoint2;
+                    }
+                    if (keyboardPress == KeyboardPress.Up || keyboardPress == KeyboardPress.Right || keyboardPress == KeyboardPress.Down || keyboardPress == KeyboardPress.Left)
+                    {
+                        padPressed = true;
+                    }
+                    Debug.WriteLine("padPressed=" + padPressed);
+                    Def.ButtonGlygh buttonGlygh2 = ButtonDetect(tinyPoint2);
+                    Debug.WriteLine("buttonGlyph2 =" + buttonGlygh2);
+                    if (buttonGlygh2.ordinal() != 0)
+                    {
+                        pressedGlyphs.Add(buttonGlygh2);
+                    }
+                    if (keyboardPressed)
+                    {
+                        switch (keyboardPress)
+                        {
+                            case LeftControl: buttonGlygh2 = Def.ButtonGlygh.PlayJump; pressedGlyphs.Add(buttonGlygh2); break;
+                            case Space: buttonGlygh2 = Def.ButtonGlygh.PlayAction; pressedGlyphs.Add(buttonGlygh2); break;
+                        }
+                    }
+
+                    if ((Phase == Def.Phase.MainSetup || Phase == Def.Phase.PlaySetup) && accelSlider.Move(tinyPoint2))
+                    {
+                        gameData.setAccelSensitivity(accelSlider.Value);
+                    }
+                    switch (buttonGlygh2)
+                    {
+                        case PlayJump:
+                            Debug.WriteLine("Jumping detected");
+                            accelWaitZero = false;
+                            num3 |= 1;
+                            break;
+                        case PlayDown:
+                            accelWaitZero = false;
+                            num3 |= 4;
+                            break;
+                        case InitGamerA:
+                        case InitGamerB:
+                        case InitGamerC:
+                        case InitSetup:
+                        case InitPlay:
+                        case InitBuy:
+                        case InitRanking:
+                        case WinLostReturn:
+                        case TrialBuy:
+                        case TrialCancel:
+                        case SetupSounds:
+                        case SetupJump:
+                        case SetupZoom:
+                        case SetupAccel:
+                        case SetupReset:
+                        case SetupReturn:
+                        case PauseMenu:
+                        case PauseBack:
+                        case PauseSetup:
+                        case PauseRestart:
+                        case PauseContinue:
+                        case PlayPause:
+                        case PlayAction:
+                        case ResumeMenu:
+                        case ResumeContinue:
+                        case RankingContinue:
+                        case Cheat11:
+                        case Cheat12:
+                        case Cheat21:
+                        case Cheat22:
+                        case Cheat31:
+                        case Cheat32:
+                        case Cheat1:
+                        case Cheat2:
+                        case Cheat3:
+                        case Cheat4:
+                        case Cheat5:
+                        case Cheat6:
+                        case Cheat7:
+                        case Cheat8:
+                        case Cheat9:
+                            accelWaitZero = false;
+                            buttonGlygh = buttonGlygh2;
+                            showCheatMenu = false;
+                            break;
+                    }
+                }
+            }
+            if (buttonGlygh.ordinal() != 0 && buttonGlygh != Def.ButtonGlygh.PlayAction && buttonGlygh != Def.ButtonGlygh.Cheat11 && buttonGlygh != Def.ButtonGlygh.Cheat12 && buttonGlygh != Def.ButtonGlygh.Cheat21 && buttonGlygh != Def.ButtonGlygh.Cheat22 && buttonGlygh != Def.ButtonGlygh.Cheat31 && buttonGlygh != Def.ButtonGlygh.Cheat32 && lastButtonDown == Def.ButtonGlygh.None)
+            {
+                 TinyPoint tinyPoint3 = default_(new TinyPoint());
+                tinyPoint3.X = 320;
+                tinyPoint3.Y = 240;
+                TinyPoint pos = tinyPoint3;
+                sound.PlayImage(0, pos);
+            }
+            if (buttonGlygh == Def.ButtonGlygh.None && lastButtonDown.ordinal() != 0)
+            {
+                buttonPressed = lastButtonDown;
+            }
+            lastButtonDown = buttonGlygh;
+            if (padPressed)
+            {
+                Debug.WriteLine("PadCenter.X=" + PadCenter().X);
+                Debug.WriteLine("PadCenter.Y=" + PadCenter().Y);
+                Debug.WriteLine("padTouchPos.X=" + padTouchPos.X);
+                Debug.WriteLine("padTouchPos.Y=" + padTouchPos.Y);
+                Debug.WriteLine("keyPressedUp=" + keyPressedUp);
+                Debug.WriteLine("keyPressedDown=" + keyPressedDown);
+                Debug.WriteLine("keyPressedLeft=" + keyPressedLeft);
+                Debug.WriteLine(" keyPressedRight=" + keyPressedRight);
+                {
+                    if (keyPressedUp)
+                    {
+                        padTouchPos.Y = PadCenter().Y - 30;
+                        padTouchPos.X = PadCenter().X;
+                        if (keyPressedLeft) padTouchPos.X = PadCenter().X - 30;
+                        if (keyPressedRight) padTouchPos.X = PadCenter().X + 30;
+                    }
+                    if (keyPressedDown) { 
+                        padTouchPos.Y = PadCenter().Y + 30;
+                        padTouchPos.X = PadCenter().X;
+                        if (keyPressedLeft) padTouchPos.X = PadCenter().X - 30;
+                        if (keyPressedRight) padTouchPos.X = PadCenter().X + 30;
+                    }
+                    if (keyPressedLeft) { 
+                        padTouchPos.X = PadCenter().X - 30;
+                        padTouchPos.Y = PadCenter().Y;
+                        if (keyPressedUp) padTouchPos.Y = PadCenter().Y - 30;
+                        if (keyPressedDown) padTouchPos.Y = PadCenter().Y + 30;
+                    }
+                    if (keyPressedRight) { 
+                        padTouchPos.X = PadCenter().X + 30;
+                        padTouchPos.Y = PadCenter().Y;
+                        if (keyPressedUp) padTouchPos.Y = PadCenter().Y - 30;
+                        if (keyPressedDown) padTouchPos.Y = PadCenter().Y + 30;
+                    }
+                }
+                double horizontalPosition = padTouchPos.X - PadCenter().X;
+                double verticalPosition = padTouchPos.Y - PadCenter().Y;
+
+                if (horizontalPosition > 20.0)
+                {
+                    horizontalChange += 1.0;
+                    Debug.WriteLine(" horizontalChange += 1.0;");
+                }
+                if (horizontalPosition < -20.0)
+                {
+                    horizontalChange -= 1.0;
+                    Debug.WriteLine(" horizontalChange -= 1.0;");
+
+                }
+                if (verticalPosition > 20.0)
+                {
+                    verticalChange += 1.0;
+                    Debug.WriteLine(" verticalPosition += 1.0;");
+
+                }
+                if (verticalPosition < -20.0)
+                {
+                    verticalChange -= 1.0;
+                    Debug.WriteLine(" verticalPosition -= 1.0;");
+                }
+
+            }
+            if (accelStarted)
+            {
+                horizontalChange = accelSpeedX;
+                verticalChange = 0.0;
+                if ((num3 & 4) != 0)
+                {
+                    verticalChange = 1.0;
+                }
+            }
+            decor.SetSpeedX(horizontalChange);
+            decor.SetSpeedY(verticalChange);
+            decor.KeyChange(num3);
+        }
+
+        private Def.ButtonGlygh ButtonDetect(TinyPoint pos)
+        {
+            for (Def.ButtonGlygh item : ButtonGlyphs().Reverse())
+            {
+                int value = 0;
+                if (item == Def.ButtonGlygh.PlayJump || item == Def.ButtonGlygh.PlayAction || item == Def.ButtonGlygh.PlayDown || item == Def.ButtonGlygh.PlayPause)
+                {
+                    value = 20;
+                }
+                TinyRect rect = Misc.Inflate(GetButtonRect(item), value);
+                if (Misc.IsInside(rect, pos))
+                {
+                    return item;
+                }
+            }
+            return Def.ButtonGlygh.None;
+        }
+
+        public void Draw()
+        {
+            if (!accelStarted && Phase == Def.Phase.Play)
+            {
+                pixmap.DrawIcon(14, 0, GetPadBounds(PadCenter(), padSize / 2), 1.0, false);
+                TinyPoint center = (padPressed ? padTouchPos : PadCenter());
+                pixmap.DrawIcon(14, 1, GetPadBounds(center, padSize / 2), 1.0, false);
+            }
+            for (Def.ButtonGlygh buttonGlyph : ButtonGlyphs())
+            {
+                boolean pressed = pressedGlyphs.Contains(buttonGlyph);
+                boolean selected = false;
+                if (buttonGlyph.ordinal() >= Def.ButtonGlygh.InitGamerA.ordinal() && buttonGlyph.ordinal() <= Def.ButtonGlygh.InitGamerC.ordinal())
+                {
+                    int num = (int)(buttonGlyph.ordinal() - 1);
+                    selected = num == gameData.SelectedGamer();
+                }
+                if (buttonGlyph == Def.ButtonGlygh.SetupSounds)
+                {
+                    selected = gameData.Sounds();
+                }
+                if (buttonGlyph == Def.ButtonGlygh.SetupJump)
+                {
+                    selected = gameData.JumpRight();
+                }
+                if (buttonGlyph == Def.ButtonGlygh.SetupZoom)
+                {
+                    selected = gameData.AutoZoom();
+                }
+                if (buttonGlyph == Def.ButtonGlygh.SetupAccel)
+                {
+                    selected = gameData.AccelActive();
+                }
+                pixmap.DrawInputButton(GetButtonRect(buttonGlyph), buttonGlyph, pressed, selected);
+            }
+            if ((Phase == Def.Phase.MainSetup || Phase == Def.Phase.PlaySetup) && gameData.AccelActive())
+            {
+                accelSlider.Draw(pixmap);
+            }
+        }
+
+        private TinyRect GetPadBounds(TinyPoint center, int radius)
+        {
+             TinyRect result = default_(new TinyRect());
+            result.Left = center.X - radius;
+            result.Right = center.X + radius;
+            result.Top = center.Y - radius;
+            result.Bottom = center.Y + radius;
+            return result;
+        }
+
+        public TinyRect GetButtonRect(Def.ButtonGlygh glyph)
+        {
+            TinyRect drawBounds = pixmap.DrawBounds();
+            double num = drawBounds.Width();
+            double num2 = drawBounds.Height();
+            double num3 = num2 / 5.0;
+            double num4 = num2 * 140.0 / 480.0;
+            double num5 = num2 / 3.5;
+            if (glyph.ordinal() >= Def.ButtonGlygh.Cheat1.ordinal()&& glyph.ordinal() <= Def.ButtonGlygh.Cheat9.ordinal())
+            {
+                int num6 = (int)(glyph.ordinal() - 35);
+                TinyRect result = default_(new TinyRect());
+                result.Left = 80 * num6;
+                result.Right = 80 * (num6 + 1);
+                result.Top = 0;
+                result.Bottom = 80;
+                return result;
+            }
+            switch (glyph)
+            {
+                case InitGamerA:
+                    {
+                         TinyRect result19 = default_(new TinyRect());
+                        result19.Left = (int)(20.0 + num4 * 0.0);
+                        result19.Right = (int)(20.0 + num4 * 0.5);
+                        result19.Top = (int)(num2 - 20.0 - num4 * 2.1);
+                        result19.Bottom = (int)(num2 - 20.0 - num4 * 1.6);
+                        return result19;
+                    }
+                case InitGamerB:
+                    {
+                         TinyRect result18 = default_(new TinyRect());
+                        result18.Left = (int)(20.0 + num4 * 0.0);
+                        result18.Right = (int)(20.0 + num4 * 0.5);
+                        result18.Top = (int)(num2 - 20.0 - num4 * 1.6);
+                        result18.Bottom = (int)(num2 - 20.0 - num4 * 1.1);
+                        return result18;
+                    }
+                case InitGamerC:
+                    {
+                         TinyRect result15 = default_(new TinyRect());
+                        result15.Left = (int)(20.0 + num4 * 0.0);
+                        result15.Right = (int)(20.0 + num4 * 0.5);
+                        result15.Top = (int)(num2 - 20.0 - num4 * 1.1);
+                        result15.Bottom = (int)(num2 - 20.0 - num4 * 0.6);
+                        return result15;
+                    }
+                case InitSetup:
+                    {
+                         TinyRect result14 = default_(new TinyRect());
+                        result14.Left = (int)(20.0 + num4 * 0.0);
+                        result14.Right = (int)(20.0 + num4 * 0.5);
+                        result14.Top = (int)(num2 - 20.0 - num4 * 0.5);
+                        result14.Bottom = (int)(num2 - 20.0 - num4 * 0.0);
+                        return result14;
+                    }
+                case InitPlay:
+                    {
+                         TinyRect result11 = default_(new TinyRect());
+                        result11.Left = (int)(num - 20.0 - num4 * 1.0);
+                        result11.Right = (int)(num - 20.0 - num4 * 0.0);
+                        result11.Top = (int)(num2 - 40.0 - num4 * 1.0);
+                        result11.Bottom = (int)(num2 - 40.0 - num4 * 0.0);
+                        return result11;
+                    }
+                case InitBuy:
+                case InitRanking:
+                    {
+                         TinyRect result10 = default_(new TinyRect());
+                        result10.Left = (int)(num - 20.0 - num4 * 0.75);
+                        result10.Right = (int)(num - 20.0 - num4 * 0.25);
+                        result10.Top = (int)(num2 - 20.0 - num4 * 2.1);
+                        result10.Bottom = (int)(num2 - 20.0 - num4 * 1.6);
+                        return result10;
+                    }
+                case PauseMenu:
+                    {
+                         TinyRect result37 = default_(new TinyRect());
+                        result37.Left = (int)((double)PixmapOrigin.X + num4 * -0.21);
+                        result37.Right = (int)((double)PixmapOrigin.X + num4 * 0.79);
+                        result37.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result37.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result37;
+                    }
+                case PauseBack:
+                    {
+                         TinyRect result36 = default_(new TinyRect());
+                        result36.Left = (int)((double)PixmapOrigin.X + num4 * 0.79);
+                        result36.Right = (int)((double)PixmapOrigin.X + num4 * 1.79);
+                        result36.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result36.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result36;
+                    }
+                case PauseSetup:
+                    {
+                         TinyRect result35 = default_(new TinyRect());
+                        result35.Left = (int)((double)PixmapOrigin.X + num4 * 1.79);
+                        result35.Right = (int)((double)PixmapOrigin.X + num4 * 2.79);
+                        result35.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result35.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result35;
+                    }
+                case PauseRestart:
+                    {
+                         TinyRect result34 = default_(new TinyRect());
+                        result34.Left = (int)((double)PixmapOrigin.X + num4 * 2.79);
+                        result34.Right = (int)((double)PixmapOrigin.X + num4 * 3.79);
+                        result34.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result34.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result34;
+                    }
+                case PauseContinue:
+                    {
+                         TinyRect result33 = default_(new TinyRect());
+                        result33.Left = (int)((double)PixmapOrigin.X + num4 * 3.79);
+                        result33.Right = (int)((double)PixmapOrigin.X + num4 * 4.79);
+                        result33.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result33.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result33;
+                    }
+                case ResumeMenu:
+                    {
+                         TinyRect result32 = default_(new TinyRect());
+                        result32.Left = (int)((double)PixmapOrigin.X + num4 * 1.29);
+                        result32.Right = (int)((double)PixmapOrigin.X + num4 * 2.29);
+                        result32.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result32.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result32;
+                    }
+                case ResumeContinue:
+                    {
+                         TinyRect result31 = default_(new TinyRect());
+                        result31.Left = (int)((double)PixmapOrigin.X + num4 * 2.29);
+                        result31.Right = (int)((double)PixmapOrigin.X + num4 * 3.29);
+                        result31.Top = (int)((double)PixmapOrigin.Y + num4 * 2.2);
+                        result31.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.2);
+                        return result31;
+                    }
+                case WinLostReturn:
+                    {
+                         TinyRect result30 = default_(new TinyRect());
+                        result30.Left = (int)((double)PixmapOrigin.X + num - num3 * 2.2);
+                        result30.Right = (int)((double)PixmapOrigin.X + num - num3 * 1.2);
+                        result30.Top = (int)((double)PixmapOrigin.Y + num3 * 0.2);
+                        result30.Bottom = (int)((double)PixmapOrigin.Y + num3 * 1.2);
+                        return result30;
+                    }
+                case TrialBuy:
+                    {
+                         TinyRect result29 = default_(new TinyRect());
+                        result29.Left = (int)((double)PixmapOrigin.X + num4 * 2.5);
+                        result29.Right = (int)((double)PixmapOrigin.X + num4 * 3.5);
+                        result29.Top = (int)((double)PixmapOrigin.Y + num4 * 2.1);
+                        result29.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.1);
+                        return result29;
+                    }
+                case TrialCancel:
+                    {
+                         TinyRect result28 = default_(new TinyRect());
+                        result28.Left = (int)((double)PixmapOrigin.X + num4 * 3.5);
+                        result28.Right = (int)((double)PixmapOrigin.X + num4 * 4.5);
+                        result28.Top = (int)((double)PixmapOrigin.Y + num4 * 2.1);
+                        result28.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.1);
+                        return result28;
+                    }
+                case RankingContinue:
+                    {
+                         TinyRect result27 = default_(new TinyRect());
+                        result27.Left = (int)((double)PixmapOrigin.X + num4 * 3.5);
+                        result27.Right = (int)((double)PixmapOrigin.X + num4 * 4.5);
+                        result27.Top = (int)((double)PixmapOrigin.Y + num4 * 2.1);
+                        result27.Bottom = (int)((double)PixmapOrigin.Y + num4 * 3.1);
+                        return result27;
+                    }
+                case SetupSounds:
+                    {
+                         TinyRect result26 = default_(new TinyRect());
+                        result26.Left = (int)(20.0 + num4 * 0.0);
+                        result26.Right = (int)(20.0 + num4 * 0.5);
+                        result26.Top = (int)(num2 - 20.0 - num4 * 2.0);
+                        result26.Bottom = (int)(num2 - 20.0 - num4 * 1.5);
+                        return result26;
+                    }
+                case SetupJump:
+                    {
+                         TinyRect result25 = default_(new TinyRect());
+                        result25.Left = (int)(20.0 + num4 * 0.0);
+                        result25.Right = (int)(20.0 + num4 * 0.5);
+                        result25.Top = (int)(num2 - 20.0 - num4 * 1.5);
+                        result25.Bottom = (int)(num2 - 20.0 - num4 * 1.0);
+                        return result25;
+                    }
+                case SetupZoom:
+                    {
+                         TinyRect result24 = default_(new TinyRect());
+                        result24.Left = (int)(20.0 + num4 * 0.0);
+                        result24.Right = (int)(20.0 + num4 * 0.5);
+                        result24.Top = (int)(num2 - 20.0 - num4 * 1.0);
+                        result24.Bottom = (int)(num2 - 20.0 - num4 * 0.5);
+                        return result24;
+                    }
+                case SetupAccel:
+                    {
+                         TinyRect result23 = default_(new TinyRect());
+                        result23.Left = (int)(20.0 + num4 * 0.0);
+                        result23.Right = (int)(20.0 + num4 * 0.5);
+                        result23.Top = (int)(num2 - 20.0 - num4 * 0.5);
+                        result23.Bottom = (int)(num2 - 20.0 - num4 * 0.0);
+                        return result23;
+                    }
+                case SetupReset:
+                    {
+                         TinyRect result22 = default_(new TinyRect());
+                        result22.Left = (int)(450.0 + num4 * 0.0);
+                        result22.Right = (int)(450.0 + num4 * 0.5);
+                        result22.Top = (int)(num2 - 20.0 - num4 * 2.0);
+                        result22.Bottom = (int)(num2 - 20.0 - num4 * 1.5);
+                        return result22;
+                    }
+                case SetupReturn:
+                    {
+                         TinyRect result21 = default_(new TinyRect());
+                        result21.Left = (int)(num - 20.0 - num4 * 0.8);
+                        result21.Right = (int)(num - 20.0 - num4 * 0.0);
+                        result21.Top = (int)(num2 - 20.0 - num4 * 0.8);
+                        result21.Bottom = (int)(num2 - 20.0 - num4 * 0.0);
+                        return result21;
+                    }
+                case PlayPause:
+                    {
+                         TinyRect result20 = default_(new TinyRect());
+                        result20.Left = (int)(num - num3 * 0.7);
+                        result20.Right = (int)(num - num3 * 0.2);
+                        result20.Top = (int)(num3 * 0.2);
+                        result20.Bottom = (int)(num3 * 0.7);
+                        return result20;
+                    }
+                case PlayAction:
+                    {
+                        if (gameData.JumpRight())
+                        {
+                             TinyRect result16 = default_(new TinyRect());
+                            result16.Left = (int)((double)drawBounds.Width() - num3 * 1.2);
+                            result16.Right = (int)((double)drawBounds.Width() - num3 * 0.2);
+                            result16.Top = (int)(num2 - num3 * 2.6);
+                            result16.Bottom = (int)(num2 - num3 * 1.6);
+                            return result16;
+                        }
+                         TinyRect result17 = default_(new TinyRect());
+                        result17.Left = (int)(num3 * 0.2);
+                        result17.Right = (int)(num3 * 1.2);
+                        result17.Top = (int)(num2 - num3 * 2.6);
+                        result17.Bottom = (int)(num2 - num3 * 1.6);
+                        return result17;
+                    }
+                case PlayJump:
+                    {
+                        if (gameData.JumpRight())
+                        {
+                             TinyRect result12 = default_(new TinyRect());
+                            result12.Left = (int)((double)drawBounds.Width() - num3 * 1.2);
+                            result12.Right = (int)((double)drawBounds.Width() - num3 * 0.2);
+                            result12.Top = (int)(num2 - num3 * 1.2);
+                            result12.Bottom = (int)(num2 - num3 * 0.2);
+                            return result12;
+                        }
+                         TinyRect result13 = default_(new TinyRect());
+                        result13.Left = (int)(num3 * 0.2);
+                        result13.Right = (int)(num3 * 1.2);
+                        result13.Top = (int)(num2 - num3 * 1.2);
+                        result13.Bottom = (int)(num2 - num3 * 0.2);
+                        return result13;
+                    }
+                case PlayDown:
+                    {
+                        if (gameData.JumpRight())
+                        {
+                             TinyRect result8 = default_(new TinyRect());
+                            result8.Left = (int)(num3 * 0.2);
+                            result8.Right = (int)(num3 * 1.2);
+                            result8.Top = (int)(num2 - num3 * 1.2);
+                            result8.Bottom = (int)(num2 - num3 * 0.2);
+                            return result8;
+                        }
+                         TinyRect result9 = default_(new TinyRect());
+                        result9.Left = (int)((double)drawBounds.Width() - num3 * 1.2);
+                        result9.Right = (int)((double)drawBounds.Width() - num3 * 0.2);
+                        result9.Top = (int)(num2 - num3 * 1.2);
+                        result9.Bottom = (int)(num2 - num3 * 0.2);
+                        return result9;
+                    }
+                case Cheat11:
+                    {
+                         TinyRect result7 = default_(new TinyRect());
+                        result7.Left = (int)(num5 * 0.0);
+                        result7.Right = (int)(num5 * 1.0);
+                        result7.Top = (int)(num5 * 0.0);
+                        result7.Bottom = (int)(num5 * 1.0);
+                        return result7;
+                    }
+                case Cheat12:
+                    {
+                         TinyRect result6 = default_(new TinyRect());
+                        result6.Left = (int)(num5 * 0.0);
+                        result6.Right = (int)(num5 * 1.0);
+                        result6.Top = (int)(num5 * 1.0);
+                        result6.Bottom = (int)(num5 * 2.0);
+                        return result6;
+                    }
+                case Cheat21:
+                    {
+                         TinyRect result5 = default_(new TinyRect());
+                        result5.Left = (int)(num5 * 1.0);
+                        result5.Right = (int)(num5 * 2.0);
+                        result5.Top = (int)(num5 * 0.0);
+                        result5.Bottom = (int)(num5 * 1.0);
+                        return result5;
+                    }
+                case Cheat22:
+                    {
+                         TinyRect result4 = default_(new TinyRect());
+                        result4.Left = (int)(num5 * 1.0);
+                        result4.Right = (int)(num5 * 2.0);
+                        result4.Top = (int)(num5 * 1.0);
+                        result4.Bottom = (int)(num5 * 2.0);
+                        return result4;
+                    }
+                case Cheat31:
+                    {
+                         TinyRect result3 = default_(new TinyRect());
+                        result3.Left = (int)(num5 * 2.0);
+                        result3.Right = (int)(num5 * 3.0);
+                        result3.Top = (int)(num5 * 0.0);
+                        result3.Bottom = (int)(num5 * 1.0);
+                        return result3;
+                    }
+                case Cheat32:
+                    {
+                         TinyRect result2 = default_(new TinyRect());
+                        result2.Left = (int)(num5 * 2.0);
+                        result2.Right = (int)(num5 * 3.0);
+                        result2.Top = (int)(num5 * 1.0);
+                        result2.Bottom = (int)(num5 * 2.0);
+                        return result2;
+                    }
+                default:
+                    return default_(new TinyRect());
+            }
+        }
+
+        private void StartAccel()
+        {
+            try
+            {
+                accelSensor.Start();
+                accelStarted = true;
+            }
+            catch (AccelerometerFailedException e)
+            {
+                accelStarted = false;
+            }
+            catch (UnauthorizedAccessException e)
+            {
+                accelStarted = false;
+            }
+        }
+
+        private void StopAccel()
+        {
+            if (accelStarted)
+            {
+                try
+                {
+                    accelSensor.Stop();
+                }
+                catch (AccelerometerFailedException e)
+                {
+                }
+                accelStarted = false;
+            }
+        }
+
+
+        private void HandleAccelSensorCurrentValueChanged(Object sender, AccelerometerEventArgs e)
+        {
+            //IL_0001: Unknown result type (might be due to invalid IL or missing references)
+            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
+
+            float y = e.Y();
+            float num = (1f - (float)gameData.AccelSensitivity()) * 0.06f + 0.04f;
+            float num2 = (accelLastState ? (num * 0.6f) : num);
+            if (y > num2)
+            {
+                accelSpeedX = 0.0 - Math_.Min((double)y * 0.25 / (double)num + 0.25, 1.0);
+            }
+            else if (y < 0f - num2)
+            {
+                accelSpeedX = Math_.Min((double)(0f - y) * 0.25 / (double)num + 0.25, 1.0);
+            }
+            else
+            {
+                accelSpeedX = 0.0;
+            }
+            accelLastState = accelSpeedX != 0.0;
+            if (accelWaitZero)
+            {
+                if (accelSpeedX == 0.0)
+                {
+                    accelWaitZero = false;
+                }
+                else
+                {
+                    accelSpeedX = 0.0;
+                }
+            }
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Jauge.java

@@ -0,0 +1,160 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Jauge
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Media.*;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class Jauge
+    {
+        private Pixmap m_pixmap;
+
+        private Sound m_sound;
+
+        private boolean m_bHide;
+
+        private TinyPoint m_pos;
+
+        private TinyPoint m_dim;
+
+        private int m_mode;
+
+        private int m_level;
+
+        private boolean m_bMinimizeRedraw;
+
+        private boolean m_bRedraw;
+
+        private double m_zoom;
+
+        public double getZoom() {
+            return m_zoom;
+        }
+
+        public void setZoom(double value) {
+            m_zoom = value;
+        }
+
+
+        public Jauge()
+        {
+            m_mode = 0;
+            m_bHide = true;
+            m_bMinimizeRedraw = false;
+            m_bRedraw = false;
+            m_zoom = 1.0;
+        }
+
+        public boolean Create(Pixmap pixmap, Sound sound, TinyPoint pos, int mode, boolean bMinimizeRedraw)
+        {
+            m_pixmap = pixmap;
+            m_sound = sound;
+            m_mode = mode;
+            m_bMinimizeRedraw = bMinimizeRedraw;
+            m_bHide = true;
+            m_pos = pos;
+            m_dim.X = 124;
+            m_dim.Y = 22;
+            m_level = 0;
+            m_bRedraw = true;
+            return true;
+        }
+
+        public void Draw()
+        {
+             TinyRect rect = default_(new TinyRect());
+            if (m_bMinimizeRedraw && !m_bRedraw)
+            {
+                return;
+            }
+            m_bRedraw = false;
+            if (!m_bHide)
+            {
+                int num = m_level * 114 / 100;
+                rect.Left = 0;
+                rect.Right = 124;
+                rect.Top = 0;
+                rect.Bottom = 22;
+                m_pixmap.DrawPart(5, m_pos, rect, m_zoom);
+                if (num > 0)
+                {
+                    rect.Left = 0;
+                    rect.Right = 6 + num;
+                    rect.Top = 22 * m_mode;
+                    rect.Bottom = 22 * (m_mode + 1);
+                    m_pixmap.DrawPart(5, m_pos, rect, m_zoom);
+                }
+            }
+        }
+
+        public void Redraw()
+        {
+            m_bRedraw = true;
+        }
+
+        public int GetLevel()
+        {
+            return m_level;
+        }
+
+        public void SetLevel(int level)
+        {
+            if (level < 0)
+            {
+                level = 0;
+            }
+            if (level > 100)
+            {
+                level = 100;
+            }
+            if (m_level != level)
+            {
+                m_bRedraw = true;
+            }
+            m_level = level;
+        }
+
+        public int GetMode()
+        {
+            return m_mode;
+        }
+
+        public void SetMode(int mode)
+        {
+            if (m_mode != mode)
+            {
+                m_bRedraw = true;
+            }
+            m_mode = mode;
+        }
+
+        public boolean GetHide()
+        {
+            return m_bHide;
+        }
+
+        public void SetHide(boolean bHide)
+        {
+            if (m_bHide != bHide)
+            {
+                m_bRedraw = true;
+            }
+            m_bHide = bHide;
+        }
+
+        public TinyPoint GetPos()
+        {
+            return m_pos;
+        }
+
+        public void SetRedraw()
+        {
+            m_bRedraw = true;
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/MarketPlace.java

@@ -0,0 +1,13 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+import com.openeggbert.jdotnet.System.Diagnostics.Debug;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.PlayerIndex;
+
+    public class MarketPlace
+    {
+        public static void Show(PlayerIndex playerIndex)
+        {
+            //Guide.ShowMarketplace(PlayerIndex.One);
+            Debug.Write("The Market Place should be shown.");
+        }
+    }

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Misc.java

@@ -0,0 +1,165 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Misc
+import com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi.Def.KeyboardPress;
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Rectangle;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.out;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.static_;
+
+
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+@static_
+    public class Misc
+    {
+    private Misc() {
+        //Not meant to be instantiated.
+    }
+        public static Rectangle RotateAdjust(Rectangle rect, double angle)
+        {
+             TinyPoint tinyPoint = default_(new TinyPoint());
+            tinyPoint.X = rect.Width / 2;
+            tinyPoint.Y = rect.Height / 2;
+            TinyPoint p = tinyPoint;
+            TinyPoint tinyPoint2 = RotatePointRad(angle, p);
+            int num = tinyPoint2.X - p.X;
+            int num2 = tinyPoint2.Y - p.Y;
+            return new Rectangle(rect.Left() - num, rect.Top() - num2, rect.Width, rect.Height);
+        }
+
+        public static TinyPoint RotatePointRad(double angle, TinyPoint p)
+        {
+            return RotatePointRad(default_(new TinyPoint()), angle, p);
+        }
+
+        public static TinyPoint RotatePointRad(TinyPoint center, double angle, TinyPoint p)
+        {
+             TinyPoint tinyPoint = default_(new TinyPoint());
+             TinyPoint result = default_(new TinyPoint());
+            tinyPoint.X = p.X - center.X;
+            tinyPoint.Y = p.Y - center.Y;
+            double num = Math_.Sin(angle);
+            double num2 = Math_.Cos(angle);
+            result.X = (int)((double)tinyPoint.X * num2 - (double)tinyPoint.Y * num);
+            result.Y = (int)((double)tinyPoint.X * num + (double)tinyPoint.Y * num2);
+            result.X += center.X;
+            result.Y += center.Y;
+            return result;
+        }
+
+        public static double DegToRad(double angle)
+        {
+            return angle * Math_.PI / 180.0;
+        }
+
+        public static int Approch(int actual, int finalValue, int step)
+        {
+            if (actual < finalValue)
+            {
+                actual = Math_.Min(actual + step, finalValue);
+            }
+            else if (actual > finalValue)
+            {
+                actual = Math_.Max(actual - step, finalValue);
+            }
+            return actual;
+        }
+
+        public static int Speed(double speed, int max)
+        {
+            if (speed > 0.0)
+            {
+                return Math_.Max((int)(speed * (double)max), 1);
+            }
+            if (speed < 0.0)
+            {
+                return Math_.Min((int)(speed * (double)max), -1);
+            }
+            return 0;
+        }
+
+        public static TinyRect Inflate(TinyRect rect, int value)
+        {
+             TinyRect result = default_(new TinyRect());
+            result.Left = rect.Left - value;
+            result.Right = rect.Right + value;
+            result.Top = rect.Top - value;
+            result.Bottom = rect.Bottom + value;
+            return result;
+        }
+
+        public static boolean IsInside(TinyRect rect, TinyPoint p)
+        {
+            if (p.X >= rect.Left && p.X <= rect.Right && p.Y >= rect.Top)
+            {
+                return p.Y <= rect.Bottom;
+            }
+            return false;
+        }
+
+        public static boolean IntersectRect(@out TinyRect dst, TinyRect src1, TinyRect src2)
+        {
+            dst = default_(dst);
+            dst.Left = Math_.Max(src1.Left, src2.Left);
+            dst.Right = Math_.Min(src1.Right, src2.Right);
+            dst.Top = Math_.Max(src1.Top, src2.Top);
+            dst.Bottom = Math_.Min(src1.Bottom, src2.Bottom);
+            return !IsRectEmpty(dst);
+        }
+
+        public static boolean UnionRect(@out TinyRect dst, TinyRect src1, TinyRect src2)
+        {
+            
+            dst = default_(dst);
+            dst.Left = Math_.Min(src1.Left, src2.Left);
+            dst.Right = Math_.Max(src1.Right, src2.Right);
+            dst.Top = Math_.Min(src1.Top, src2.Top);
+            dst.Bottom = Math_.Max(src1.Bottom, src2.Bottom);
+            return !IsRectEmpty(dst);
+        }
+
+        private static boolean IsRectEmpty(TinyRect rect)
+        {
+            if (rect.Left < rect.Right)
+            {
+                return rect.Top >= rect.Bottom;
+            }
+            return true;
+        }
+
+        public static KeyboardPress intToKeyboardPress(int i) {
+            switch (i)
+            {
+                case 0: return KeyboardPress.None;
+                case 1: return KeyboardPress.Up;
+                case 2: return KeyboardPress.Right;
+                case 3: return KeyboardPress.Down;
+                case 4: return KeyboardPress.Left;
+                case 5: return KeyboardPress.LeftControl;
+                case 6: return KeyboardPress.Space;
+                case 7: return KeyboardPress.Escape;
+                case 8: return KeyboardPress.Pause;
+                default: throw new Exception_("Unsupported number for KeyboardPress: " + i);
+            }
+        }
+        public static int keyboardPressToInt(KeyboardPress kp)
+        {
+            switch (kp)
+            {
+                case None: return 0;
+                case Up: return 1;
+                case Right: return 2;
+                case Down: return 3;
+                case Left: return 4;
+                case LeftControl: return 5;
+                case Space: return 6;
+                case Escape: return 7;
+                case Pause: return 8;
+                default: throw new Exception_("Unsupported KeyboardPress: " + kp);
+            }
+        }
+    }

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/MyResource.java

@@ -0,0 +1,784 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.MyResource
+import com.openeggbert.jdotnet.System.Collections.Generic.*;
+import com.openeggbert.jdotnet.System.Globalization.*;
+import java.util.HashMap;
+import java.util.Map;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.readonly;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.static_;
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+@static_
+    public class MyResource
+    {
+    private MyResource() {
+        //Not meant to be instantiated.
+    }
+        public static @readonly final int TX_BUTTON_PLAY;
+
+        public static @readonly final int TX_BUTTON_MENU;
+
+        public static @readonly final int TX_BUTTON_BACK;
+
+        public static @readonly final int TX_BUTTON_RESTART;
+
+        public static @readonly final int TX_BUTTON_CONTINUE;
+
+        public static @readonly final int TX_BUTTON_BUY;
+
+        public static @readonly final int TX_BUTTON_SETUP;
+
+        public static @readonly final int TX_BUTTON_SETUP_SOUNDS;
+
+        public static @readonly final int TX_BUTTON_SETUP_JUMP;
+
+        public static @readonly final int TX_BUTTON_SETUP_ZOOM;
+
+        public static @readonly final int TX_BUTTON_SETUP_ACCEL;
+
+        public static @readonly final int TX_BUTTON_SETUP_RESET;
+
+        public static @readonly final int TX_BUTTON_RANKING;
+
+        public static @readonly final int TX_GAMER_TITLE;
+
+        public static @readonly final int TX_GAMER_MDOORS;
+
+        public static @readonly final int TX_GAMER_SDOORS;
+
+        public static @readonly final int TX_GAMER_LIFES;
+
+        public static @readonly final int TX_TRIAL1;
+
+        public static @readonly final int TX_TRIAL2;
+
+        public static @readonly final int TX_TRIAL3;
+
+        public static @readonly final int TX_TRIAL4;
+
+        public static @readonly final int TX_TRIAL5;
+
+        public static @readonly final int TX_TRIAL6;
+
+        public static @readonly final int TX_TRAINING101;
+
+        public static @readonly final int TX_TRAINING102;
+
+        public static @readonly final int TX_TRAINING103;
+
+        public static @readonly final int TX_TRAINING104;
+
+        public static @readonly final int TX_TRAINING105;
+
+        public static @readonly final int TX_TRAINING106;
+
+        public static @readonly final int TX_TRAINING107;
+
+        public static @readonly final int TX_TRAINING108;
+
+        public static @readonly final int TX_TRAINING109;
+
+        public static @readonly final int TX_TRAINING110;
+
+        public static @readonly final int TX_TRAINING111;
+
+        public static @readonly final int TX_TRAINING112;
+
+        public static @readonly final int TX_TRAINING113;
+
+        public static @readonly final int TX_TRAINING114;
+
+        public static @readonly final int TX_TRAINING115;
+
+        public static @readonly final int TX_TRAINING116;
+
+        public static @readonly final int TX_TRAINING117;
+
+        public static @readonly final int TX_TRAINING118;
+
+        public static @readonly final int TX_TRAINING119;
+
+        public static @readonly final int TX_TRAINING120;
+
+        public static @readonly final int TX_TRAINING121;
+
+        public static @readonly final int TX_TRAINING122;
+
+        public static @readonly final int TX_TRAINING123;
+
+        public static @readonly final int TX_TRAINING201;
+
+        public static @readonly final int TX_TRAINING202;
+
+        public static @readonly final int TX_TRAINING203;
+
+        public static @readonly final int TX_TRAINING204;
+
+        public static @readonly final int TX_TRAINING205;
+
+        public static @readonly final int TX_TRAINING206;
+
+        public static @readonly final int TX_TRAINING207;
+
+        public static @readonly final int TX_TRAINING208;
+
+        public static @readonly final int TX_TRAINING209;
+
+        public static @readonly final int TX_TRAINING210;
+
+        public static @readonly final int TX_TRAINING301;
+
+        public static @readonly final int TX_TRAINING302;
+
+        public static @readonly final int TX_TRAINING303;
+
+        public static @readonly final int TX_TRAINING304;
+
+        public static @readonly final int TX_TRAINING305;
+
+        public static @readonly final int TX_TRAINING306;
+
+        public static @readonly final int TX_TRAINING307;
+
+        public static @readonly final int TX_TRAINING308;
+
+        public static @readonly final int TX_TRAINING309;
+
+        public static @readonly final int TX_TRAINING310;
+
+        public static @readonly final int TX_TRAINING311;
+
+        public static @readonly final int TX_TRAINING401;
+
+        public static @readonly final int TX_TRAINING402;
+
+        public static @readonly final int TX_TRAINING403;
+
+        public static @readonly final int TX_TRAINING404;
+
+        public static @readonly final int TX_TRAINING405;
+
+        public static @readonly final int TX_TRAINING406;
+
+        public static @readonly final int TX_TRAINING407;
+
+        public static @readonly final int TX_TRAINING408;
+
+        public static @readonly final int TX_TRAINING409;
+
+        public static @readonly final int TX_TRAINING410;
+
+        public static @readonly final int TX_TRAINING101a;
+
+        public static @readonly final int TX_TRAINING102a;
+
+        public static @readonly final int TX_TRAINING103a;
+
+        public static @readonly final int TX_TRAINING104a;
+
+        public static @readonly final int TX_TRAINING105a;
+
+        public static @readonly final int TX_TRAINING106a;
+
+        public static @readonly final int TX_TRAINING107a;
+
+        public static @readonly final int TX_TRAINING108a;
+
+        public static @readonly final int TX_TRAINING109a;
+
+        public static @readonly final int TX_TRAINING110a;
+
+        public static @readonly final int TX_TRAINING111a;
+
+        public static @readonly final int TX_TRAINING112a;
+
+        public static @readonly final int TX_TRAINING113a;
+
+        public static @readonly final int TX_TRAINING114a;
+
+        public static @readonly final int TX_TRAINING115a;
+
+        public static @readonly final int TX_TRAINING116a;
+
+        public static @readonly final int TX_TRAINING117a;
+
+        public static @readonly final int TX_TRAINING118a;
+
+        public static @readonly final int TX_TRAINING119a;
+
+        public static @readonly final int TX_TRAINING120a;
+
+        public static @readonly final int TX_TRAINING121a;
+
+        public static @readonly final int TX_TRAINING122a;
+
+        public static @readonly final int TX_TRAINING123a;
+
+        public static @readonly final int TX_TRAINING201a;
+
+        public static @readonly final int TX_TRAINING202a;
+
+        public static @readonly final int TX_TRAINING203a;
+
+        public static @readonly final int TX_TRAINING204a;
+
+        public static @readonly final int TX_TRAINING205a;
+
+        public static @readonly final int TX_TRAINING206a;
+
+        public static @readonly final int TX_TRAINING207a;
+
+        public static @readonly final int TX_TRAINING208a;
+
+        public static @readonly final int TX_TRAINING209a;
+
+        public static @readonly final int TX_TRAINING210a;
+
+        public static @readonly final int TX_TRAINING301a;
+
+        public static @readonly final int TX_TRAINING302a;
+
+        public static @readonly final int TX_TRAINING303a;
+
+        public static @readonly final int TX_TRAINING304a;
+
+        public static @readonly final int TX_TRAINING305a;
+
+        public static @readonly final int TX_TRAINING306a;
+
+        public static @readonly final int TX_TRAINING307a;
+
+        public static @readonly final int TX_TRAINING308a;
+
+        public static @readonly final int TX_TRAINING309a;
+
+        public static @readonly final int TX_TRAINING310a;
+
+        public static @readonly final int TX_TRAINING311a;
+
+        public static @readonly final int TX_TRAINING401a;
+
+        public static @readonly final int TX_TRAINING402a;
+
+        public static @readonly final int TX_TRAINING403a;
+
+        public static @readonly final int TX_TRAINING404a;
+
+        public static @readonly final int TX_TRAINING405a;
+
+        public static @readonly final int TX_TRAINING406a;
+
+        public static @readonly final int TX_TRAINING407a;
+
+        public static @readonly final int TX_TRAINING408a;
+
+        public static @readonly final int TX_TRAINING409a;
+
+        public static @readonly final int TX_TRAINING410a;
+
+        private static Map<Integer, String> resources;
+
+        public static String LoadString(int res)
+        {
+            String value = resources.get(res);
+            if (value != null) {
+                return value;
+            }
+            return "???";
+
+        }
+
+        static
+        {
+            TX_BUTTON_PLAY = 100;
+            TX_BUTTON_MENU = 101;
+            TX_BUTTON_BACK = 102;
+            TX_BUTTON_RESTART = 103;
+            TX_BUTTON_CONTINUE = 104;
+            TX_BUTTON_BUY = 105;
+            TX_BUTTON_SETUP = 107;
+            TX_BUTTON_SETUP_SOUNDS = 108;
+            TX_BUTTON_SETUP_JUMP = 109;
+            TX_BUTTON_SETUP_ZOOM = 110;
+            TX_BUTTON_SETUP_ACCEL = 111;
+            TX_BUTTON_SETUP_RESET = 112;
+            TX_BUTTON_RANKING = 113;
+            TX_GAMER_TITLE = 200;
+            TX_GAMER_MDOORS = 201;
+            TX_GAMER_SDOORS = 202;
+            TX_GAMER_LIFES = 203;
+            TX_TRIAL1 = 300;
+            TX_TRIAL2 = 301;
+            TX_TRIAL3 = 302;
+            TX_TRIAL4 = 303;
+            TX_TRIAL5 = 304;
+            TX_TRIAL6 = 305;
+            TX_TRAINING101 = 1000;
+            TX_TRAINING102 = 1001;
+            TX_TRAINING103 = 1002;
+            TX_TRAINING104 = 1003;
+            TX_TRAINING105 = 1004;
+            TX_TRAINING106 = 1005;
+            TX_TRAINING107 = 1006;
+            TX_TRAINING108 = 1007;
+            TX_TRAINING109 = 1008;
+            TX_TRAINING110 = 1009;
+            TX_TRAINING111 = 1010;
+            TX_TRAINING112 = 1011;
+            TX_TRAINING113 = 1012;
+            TX_TRAINING114 = 1013;
+            TX_TRAINING115 = 1014;
+            TX_TRAINING116 = 1015;
+            TX_TRAINING117 = 1016;
+            TX_TRAINING118 = 1017;
+            TX_TRAINING119 = 1018;
+            TX_TRAINING120 = 1019;
+            TX_TRAINING121 = 1020;
+            TX_TRAINING122 = 1021;
+            TX_TRAINING123 = 1022;
+            TX_TRAINING201 = 2000;
+            TX_TRAINING202 = 2001;
+            TX_TRAINING203 = 2002;
+            TX_TRAINING204 = 2003;
+            TX_TRAINING205 = 2004;
+            TX_TRAINING206 = 2005;
+            TX_TRAINING207 = 2006;
+            TX_TRAINING208 = 2007;
+            TX_TRAINING209 = 2008;
+            TX_TRAINING210 = 2009;
+            TX_TRAINING301 = 3000;
+            TX_TRAINING302 = 3001;
+            TX_TRAINING303 = 3002;
+            TX_TRAINING304 = 3003;
+            TX_TRAINING305 = 3004;
+            TX_TRAINING306 = 3005;
+            TX_TRAINING307 = 3006;
+            TX_TRAINING308 = 3007;
+            TX_TRAINING309 = 3008;
+            TX_TRAINING310 = 3009;
+            TX_TRAINING311 = 3010;
+            TX_TRAINING401 = 4000;
+            TX_TRAINING402 = 4001;
+            TX_TRAINING403 = 4002;
+            TX_TRAINING404 = 4003;
+            TX_TRAINING405 = 4004;
+            TX_TRAINING406 = 4005;
+            TX_TRAINING407 = 4006;
+            TX_TRAINING408 = 4007;
+            TX_TRAINING409 = 4008;
+            TX_TRAINING410 = 4009;
+            TX_TRAINING101a = 11000;
+            TX_TRAINING102a = 11001;
+            TX_TRAINING103a = 11002;
+            TX_TRAINING104a = 11003;
+            TX_TRAINING105a = 11004;
+            TX_TRAINING106a = 11005;
+            TX_TRAINING107a = 11006;
+            TX_TRAINING108a = 11007;
+            TX_TRAINING109a = 11008;
+            TX_TRAINING110a = 11009;
+            TX_TRAINING111a = 11010;
+            TX_TRAINING112a = 11011;
+            TX_TRAINING113a = 11012;
+            TX_TRAINING114a = 11013;
+            TX_TRAINING115a = 11014;
+            TX_TRAINING116a = 11015;
+            TX_TRAINING117a = 11016;
+            TX_TRAINING118a = 11017;
+            TX_TRAINING119a = 11018;
+            TX_TRAINING120a = 11019;
+            TX_TRAINING121a = 11020;
+            TX_TRAINING122a = 11021;
+            TX_TRAINING123a = 11022;
+            TX_TRAINING201a = 12000;
+            TX_TRAINING202a = 12001;
+            TX_TRAINING203a = 12002;
+            TX_TRAINING204a = 12003;
+            TX_TRAINING205a = 12004;
+            TX_TRAINING206a = 12005;
+            TX_TRAINING207a = 12006;
+            TX_TRAINING208a = 12007;
+            TX_TRAINING209a = 12008;
+            TX_TRAINING210a = 12009;
+            TX_TRAINING301a = 13000;
+            TX_TRAINING302a = 13001;
+            TX_TRAINING303a = 13002;
+            TX_TRAINING304a = 13003;
+            TX_TRAINING305a = 13004;
+            TX_TRAINING306a = 13005;
+            TX_TRAINING307a = 13006;
+            TX_TRAINING308a = 13007;
+            TX_TRAINING309a = 13008;
+            TX_TRAINING310a = 13009;
+            TX_TRAINING311a = 13010;
+            TX_TRAINING401a = 14000;
+            TX_TRAINING402a = 14001;
+            TX_TRAINING403a = 14002;
+            TX_TRAINING404a = 14003;
+            TX_TRAINING405a = 14004;
+            TX_TRAINING406a = 14005;
+            TX_TRAINING407a = 14006;
+            TX_TRAINING408a = 14007;
+            TX_TRAINING409a = 14008;
+            TX_TRAINING410a = 14009;
+            resources = new HashMap<>();
+            String text = CultureInfo.getCurrentCulture().getTwoLetterISOLanguageName().toLowerCase();
+            String text2;
+            if ((text2 = text) != null && text2 == "fr")
+            {
+                InitializeFR();
+            }
+            else
+            {
+                InitializeEN();
+            }
+        }
+
+        private static void InitializeFR()
+        {
+            resources.put(TX_BUTTON_PLAY, "Jouer");
+            resources.put(TX_BUTTON_MENU, "Menu");
+            resources.put(TX_BUTTON_BACK, "Retour");
+            resources.put(TX_BUTTON_RESTART, "Recommencer");
+            resources.put(TX_BUTTON_CONTINUE, "Continuer");
+            resources.put(TX_BUTTON_BUY, "Acheter");
+            resources.put(TX_BUTTON_RANKING, "Classement");
+            resources.put(TX_BUTTON_SETUP, "Réglages");
+            resources.put(TX_BUTTON_SETUP_SOUNDS, "Bruitages");
+            resources.put(TX_BUTTON_SETUP_JUMP, "Bouton de saut à droite");
+            resources.put(TX_BUTTON_SETUP_ZOOM, "Zoom automatique sur l'action");
+            resources.put(TX_BUTTON_SETUP_ACCEL, "Accéléromètre");
+            resources.put(TX_BUTTON_SETUP_RESET, "Joueur {0} :\nEffacer la progression");
+            resources.put(TX_GAMER_TITLE, "Joueur {0}");
+            resources.put(TX_GAMER_MDOORS, "Portes principales : {0}/12");
+            resources.put(TX_GAMER_SDOORS, "Portes secondaires : {0}/52");
+            resources.put(TX_GAMER_LIFES, "Blupi : {0}");
+            resources.put(TX_TRIAL1, "Achetez la version complète");
+            resources.put(TX_TRIAL2, "\u000e 64 niveaux passionnants");
+            resources.put(TX_TRIAL3, "\u000e Des décors variés");
+            resources.put(TX_TRIAL4, "\u000e Une difficulté progressive");
+            resources.put(TX_TRIAL5, "\u000e De nouveaux pièges");
+            resources.put(TX_TRIAL6, "\u000e Un challenge fun");
+            resources.put(TX_TRAINING101, "Utilise la roue directionnelle \0.");
+            resources.put(TX_TRAINING102, "Appuie maintenant sur Saut \b.");
+            resources.put(TX_TRAINING103, "Appuie à droite sur la roue directionnelle \0 et sur Saut \b.");
+            resources.put(TX_TRAINING104, "Appuie sur Droite \0 et Saut \b.");
+            resources.put(TX_TRAINING105, "Essaie de ne pas te mouiller avec \0 \b !");
+            resources.put(TX_TRAINING106, "");
+            resources.put(TX_TRAINING107, "Prend l'ascenseur calmement, sans sauter \0.");
+            resources.put(TX_TRAINING108, "Saute sur l'ascenseur.");
+            resources.put(TX_TRAINING109, "");
+            resources.put(TX_TRAINING110, "Avance sans sauter et sans t'arrêter \0 !");
+            resources.put(TX_TRAINING111, "");
+            resources.put(TX_TRAINING112, "");
+            resources.put(TX_TRAINING113, "Avance sur la plateforme \0.");
+            resources.put(TX_TRAINING114, "Quitte la plateforme \0.");
+            resources.put(TX_TRAINING115, "Encore une fois, mais plus vite...");
+            resources.put(TX_TRAINING116, "Avance sur la plateforme \0 puis saute \0 \b.");
+            resources.put(TX_TRAINING117, "Saute lorsque tu es sur la plateforme \0 \b.");
+            resources.put(TX_TRAINING118, "Passe par en haut \0 \b.");
+            resources.put(TX_TRAINING119, "Les oeufs te redonnent des vies.");
+            resources.put(TX_TRAINING120, "Arrivé en haut, avance sur l'autre plateforme sans tarder...");
+            resources.put(TX_TRAINING121, "Attrape le deuxième et dernier trésor.");
+            resources.put(TX_TRAINING122, "Pour terminer, va sur la flèche rouge.");
+            resources.put(TX_TRAINING201, "Pousse la caisse sur le point rouge avec \0.");
+            resources.put(TX_TRAINING202, "Pratique, cette caisse, non ?");
+            resources.put(TX_TRAINING203, "Tire la caisse sur le point rouge avec \u0003.");
+            resources.put(TX_TRAINING204, "Empile les 2 caisses sur le point rouge pour passer.");
+            resources.put(TX_TRAINING205, "Empile 3 caisses sur le point rouge pour passer.");
+            resources.put(TX_TRAINING206, "");
+            resources.put(TX_TRAINING207, "");
+            resources.put(TX_TRAINING208, "");
+            resources.put(TX_TRAINING209, "");
+            resources.put(TX_TRAINING210, "");
+            resources.put(TX_TRAINING301, "Prend un hélico avec \t.");
+            resources.put(TX_TRAINING302, "Utilise \u0006 ou \b pour décoller. Dirige avec \u0004 et \0.");
+            resources.put(TX_TRAINING303, "Quitte l'hélico avec \t, il n'aime pas l'eau !");
+            resources.put(TX_TRAINING304, "Plonge. Utilise \u0004 \0 \u0002 \u0006 pour te diriger.");
+            resources.put(TX_TRAINING305, "Prend un hélico \t puis décole avec \u0006 ou \b.");
+            resources.put(TX_TRAINING306, "Attrape les 3 trésors puis monte.");
+            resources.put(TX_TRAINING307, "Pour passer, va chercher un skate en haut à gauche.");
+            resources.put(TX_TRAINING308, "Prend un skate avec \t.");
+            resources.put(TX_TRAINING309, "Tu peux passer sans crainte avec ton skate \0.");
+            resources.put(TX_TRAINING310, "Ton skate n'aime pas l'eau ! Utilise \0 \b.");
+            resources.put(TX_TRAINING311, "Pose ton skate avec \t.");
+            resources.put(TX_TRAINING401, "Prend la dynamite avec \t.");
+            resources.put(TX_TRAINING402, "Ne pose surtout pas la dynamite ici avec \t !");
+            resources.put(TX_TRAINING403, "Va chercher de la dynamite à gauche.");
+            resources.put(TX_TRAINING404, "Pose la dynamite avec \t, puis barre-toi !");
+            resources.put(TX_TRAINING405, "Pose encore de la dynamite pour passer.");
+            resources.put(TX_TRAINING406, "");
+            resources.put(TX_TRAINING407, "");
+            resources.put(TX_TRAINING408, "");
+            resources.put(TX_TRAINING409, "");
+            resources.put(TX_TRAINING410, "");
+            resources.put(TX_TRAINING101a, "Incline le téléphone à droite \u000B.");
+            resources.put(TX_TRAINING102a, "Appuie maintenant sur Saut \b.");
+            resources.put(TX_TRAINING103a, "\u000B et appuie sur Saut \b.");
+            resources.put(TX_TRAINING104a, "\u000B et Saut \b.");
+            resources.put(TX_TRAINING105a, "Essaie de ne pas te mouiller avec \u000B \b !");
+            resources.put(TX_TRAINING106a, "");
+            resources.put(TX_TRAINING107a, "Prend l'ascenseur calmement, sans sauter \u000B.");
+            resources.put(TX_TRAINING108a, "Saute sur l'ascenseur.");
+            resources.put(TX_TRAINING109a, "");
+            resources.put(TX_TRAINING110a, "Avance sans sauter et sans t'arrêter \u000B !");
+            resources.put(TX_TRAINING111a, "");
+            resources.put(TX_TRAINING112a, "");
+            resources.put(TX_TRAINING113a, "Avance sur la plateforme \u000B.");
+            resources.put(TX_TRAINING114a, "Quitte la plateforme \u000B.");
+            resources.put(TX_TRAINING115a, "Encore une fois, mais plus vite...");
+            resources.put(TX_TRAINING116a, "Avance sur la plateforme \u000B puis saute \u000B \b.");
+            resources.put(TX_TRAINING117a, "Saute lorsque tu es sur la plateforme \u000B \b.");
+            resources.put(TX_TRAINING118a, "Passe par en haut \u000B \b.");
+            resources.put(TX_TRAINING119a, "Les oeufs te redonnent des vies.");
+            resources.put(TX_TRAINING120a, "Arrivé en haut, avance sur l'autre plateforme sans tarder...");
+            resources.put(TX_TRAINING121a, "Attrape le deuxième et dernier trésor.");
+            resources.put(TX_TRAINING122a, "Pour terminer, va sur la flèche rouge.");
+            resources.put(TX_TRAINING201a, "Pousse la caisse sur le point rouge avec \u000B.");
+            resources.put(TX_TRAINING202a, "Pratique, cette caisse, non ?");
+            resources.put(TX_TRAINING203a, "Tire la caisse sur le point rouge avec \f et \n.");
+            resources.put(TX_TRAINING204a, "Empile les 2 caisses sur le point rouge pour passer.");
+            resources.put(TX_TRAINING205a, "Empile 3 caisses sur le point rouge pour passer.");
+            resources.put(TX_TRAINING206a, "");
+            resources.put(TX_TRAINING207a, "");
+            resources.put(TX_TRAINING208a, "");
+            resources.put(TX_TRAINING209a, "");
+            resources.put(TX_TRAINING210a, "");
+            resources.put(TX_TRAINING301a, "Prend un hélico avec \t.");
+            resources.put(TX_TRAINING302a, "Utilise \b pour décoller. Dirige avec \f et \u000B.");
+            resources.put(TX_TRAINING303a, "Quitte l'hélico avec \t, il n'aime pas l'eau !");
+            resources.put(TX_TRAINING304a, "Plonge. Utilise \f \u000B \b \n pour te diriger.");
+            resources.put(TX_TRAINING305a, "Prend un hélico \t puis décole avec \b.");
+            resources.put(TX_TRAINING306a, "Attrape les 3 trésors puis monte.");
+            resources.put(TX_TRAINING307a, "Pour passer, va chercher un skate en haut à gauche.");
+            resources.put(TX_TRAINING308a, "Prend un skate avec \t.");
+            resources.put(TX_TRAINING309a, "Tu peux passer sans crainte avec ton skate \u000B.");
+            resources.put(TX_TRAINING310a, "Ton skate n'aime pas l'eau ! Utilise \u000B \b.");
+            resources.put(TX_TRAINING311a, "Pose ton skate avec \t.");
+            resources.put(TX_TRAINING401a, "Prend la dynamite avec \t.");
+            resources.put(TX_TRAINING402a, "Ne pose surtout pas la dynamite ici avec \t !");
+            resources.put(TX_TRAINING403a, "Va chercher de la dynamite à gauche.");
+            resources.put(TX_TRAINING404a, "Pose la dynamite avec \t, puis barre-toi !");
+            resources.put(TX_TRAINING405a, "Pose encore de la dynamite pour passer.");
+            resources.put(TX_TRAINING406a, "");
+            resources.put(TX_TRAINING407a, "");
+            resources.put(TX_TRAINING408a, "");
+            resources.put(TX_TRAINING409a, "");
+            resources.put(TX_TRAINING410a, "");
+        }
+
+        private static void InitializeEN()
+        {
+            resources.put(TX_BUTTON_PLAY, "Play");
+            resources.put(TX_BUTTON_MENU, "Home");
+            resources.put(TX_BUTTON_BACK, "Back");
+            resources.put(TX_BUTTON_RESTART, "Restart");
+            resources.put(TX_BUTTON_CONTINUE, "Continue");
+            resources.put(TX_BUTTON_BUY, "Buy");
+            resources.put(TX_BUTTON_RANKING, "Ranking");
+            resources.put(TX_BUTTON_SETUP, "Setup");
+            resources.put(TX_BUTTON_SETUP_SOUNDS, "Sound effects");
+            resources.put(TX_BUTTON_SETUP_JUMP, "Jump button on the right");
+            resources.put(TX_BUTTON_SETUP_ZOOM, "Automatic zoom on action");
+            resources.put(TX_BUTTON_SETUP_ACCEL, "Accelerometer");
+            resources.put(TX_BUTTON_SETUP_RESET, "Player {0} :\nErase progress");
+            resources.put(TX_GAMER_TITLE, "Player {0}");
+            resources.put(TX_GAMER_MDOORS, "Main gates : {0}/12");
+            resources.put(TX_GAMER_SDOORS, "Secondary gates : {0}/52");
+            resources.put(TX_GAMER_LIFES, "Blupi : {0}");
+            resources.put(TX_TRIAL1, "Buy the full version");
+            resources.put(TX_TRIAL2, "\u000e 64 exciting stages");
+            resources.put(TX_TRIAL3, "\u000e Varied backgrounds");
+            resources.put(TX_TRIAL4, "\u000e An increasing difficulty");
+            resources.put(TX_TRIAL5, "\u000e New traps");
+            resources.put(TX_TRIAL6, "\u000e Challenge and fun");
+            resources.put(TX_TRAINING101, "Use the directional wheel \0.");
+            resources.put(TX_TRAINING102, "Press Jump \b.");
+            resources.put(TX_TRAINING103, "Press Right \0 and Jump \b.");
+            resources.put(TX_TRAINING104, "Press Right \0 and Jump \b.");
+            resources.put(TX_TRAINING105, "Don't fall into the water \0 \b !");
+            resources.put(TX_TRAINING106, "");
+            resources.put(TX_TRAINING107, "Take the elevator quietly, without jumping \0.");
+            resources.put(TX_TRAINING108, "Jump on the elevator.");
+            resources.put(TX_TRAINING109, "");
+            resources.put(TX_TRAINING110, "Move forward without jumping nor stopping \0 !");
+            resources.put(TX_TRAINING111, "");
+            resources.put(TX_TRAINING112, "");
+            resources.put(TX_TRAINING113, "Move forward on the platform \0.");
+            resources.put(TX_TRAINING114, "Leave the platform \0.");
+            resources.put(TX_TRAINING115, "Once again, but faster...");
+            resources.put(TX_TRAINING116, "Move forward on the platform \0, then jump \0 \b.");
+            resources.put(TX_TRAINING117, "Jump when you are on the platform \0 \b.");
+            resources.put(TX_TRAINING118, "Choose the upper path \0 \b.");
+            resources.put(TX_TRAINING119, "Eggs give you extra lives.");
+            resources.put(TX_TRAINING120, "Once on the top, move forward on the other platform without delay...");
+            resources.put(TX_TRAINING121, "Catch the second and last treasure.");
+            resources.put(TX_TRAINING122, "Join the red arrow.");
+            resources.put(TX_TRAINING201, "Push the box forward until the red dot with \0.");
+            resources.put(TX_TRAINING202, "Practical, right?");
+            resources.put(TX_TRAINING203, "Pull the box backward until the red dot with \u0003.");
+            resources.put(TX_TRAINING204, "Stack both boxes up on the red dot to move on.");
+            resources.put(TX_TRAINING205, "Stack the three boxes up on the red dot to move on.");
+            resources.put(TX_TRAINING206, "");
+            resources.put(TX_TRAINING207, "");
+            resources.put(TX_TRAINING208, "");
+            resources.put(TX_TRAINING209, "");
+            resources.put(TX_TRAINING210, "");
+            resources.put(TX_TRAINING301, "Take a helicopter with \t.");
+            resources.put(TX_TRAINING302, "Use \u0006 or \b to take off. Direct with \u0004 and \0.");
+            resources.put(TX_TRAINING303, "Leave the helicopter with \t, it dislikes water!");
+            resources.put(TX_TRAINING304, "Plunge. Use \u0004 \0 \u0002 \u0006 to direct.");
+            resources.put(TX_TRAINING305, "Take a helicopter \t then take off with \u0006 or \b.");
+            resources.put(TX_TRAINING306, "Grab the three treasures, then go up.");
+            resources.put(TX_TRAINING307, "Go and get a skate in the top left corner.");
+            resources.put(TX_TRAINING308, "Take a skate with \t.");
+            resources.put(TX_TRAINING309, "You can move on with your skate without fear \0.");
+            resources.put(TX_TRAINING310, "Your skate dislikes water! Jump!");
+            resources.put(TX_TRAINING311, "Leave your skate with \t.");
+            resources.put(TX_TRAINING401, "Take the dynamite sticks with \t.");
+            resources.put(TX_TRAINING402, "Do not put down the dynamite here!");
+            resources.put(TX_TRAINING403, "Go and get the dynamite sticks on the left.");
+            resources.put(TX_TRAINING404, "Put down the dynamite with \t, then clear off!");
+            resources.put(TX_TRAINING405, "Put down another stick of dynamite here to move on.");
+            resources.put(TX_TRAINING406, "");
+            resources.put(TX_TRAINING407, "");
+            resources.put(TX_TRAINING408, "");
+            resources.put(TX_TRAINING409, "");
+            resources.put(TX_TRAINING410, "");
+            resources.put(TX_TRAINING101a, "Tilt the phone u000B.");
+            resources.put(TX_TRAINING102a, "Press Jump \b.");
+            resources.put(TX_TRAINING103a, "u000B and Jump \b.");
+            resources.put(TX_TRAINING104a, "u000B and Jump \b.");
+            resources.put(TX_TRAINING105a, "Don't fall into the water \u000B \b !");
+            resources.put(TX_TRAINING106a, "");
+            resources.put(TX_TRAINING107a, "Take the elevator quietly, without jumping \0.");
+            resources.put(TX_TRAINING108a, "Jump on the elevator.");
+            resources.put(TX_TRAINING109a, "");
+            resources.put(TX_TRAINING110a, "Move forward without jumping nor stopping u000B !");
+            resources.put(TX_TRAINING111a, "");
+            resources.put(TX_TRAINING112a, "");
+            resources.put(TX_TRAINING113a, "Move forward on the platform u000B.");
+            resources.put(TX_TRAINING114a, "Leave the platform u000B.");
+            resources.put(TX_TRAINING115a, "Once again, but faster...");
+            resources.put(TX_TRAINING116a, "Move forward on the platform u000B, then jump u000B \b.");
+            resources.put(TX_TRAINING117a, "Jump when you are on the platform u000B \b.");
+            resources.put(TX_TRAINING118a, "Choose the upper path u000B \b.");
+            resources.put(TX_TRAINING119a, "Eggs give you extra lives.");
+            resources.put(TX_TRAINING120a, "Once on the top, move forward on the other platform without delay...");
+            resources.put(TX_TRAINING121a, "Catch the second and last treasure.");
+            resources.put(TX_TRAINING122a, "Join the red arrow.");
+            resources.put(TX_TRAINING201a, "Push the box forward until the red dot with u000B.");
+            resources.put(TX_TRAINING202a, "Practical, right?");
+            resources.put(TX_TRAINING203a, "Pull the box backward until the red dot with \f and \n.");
+            resources.put(TX_TRAINING204a, "Stack both boxes up on the red dot to move on.");
+            resources.put(TX_TRAINING205a, "Stack the three boxes up on the red dot to move on.");
+            resources.put(TX_TRAINING206a, "");
+            resources.put(TX_TRAINING207a, "");
+            resources.put(TX_TRAINING208a, "");
+            resources.put(TX_TRAINING209a, "");
+            resources.put(TX_TRAINING210a, "");
+            resources.put(TX_TRAINING301a, "Take a helicopter with \t.");
+            resources.put(TX_TRAINING302a, "Use \b to take off. Direct with \f and u000B.");
+            resources.put(TX_TRAINING303a, "Leave the helicopter with \t, it dislikes water!");
+            resources.put(TX_TRAINING304a, "Plunge. Use \f u000B \b \n to direct.");
+            resources.put(TX_TRAINING305a, "Take a helicopter \t then take off with \b.");
+            resources.put(TX_TRAINING306a, "Grab the three treasures, then go up.");
+            resources.put(TX_TRAINING307a, "Go and get a skate in the top left corner.");
+            resources.put(TX_TRAINING308a, "Take a skate with \t.");
+            resources.put(TX_TRAINING309a, "You can move on with your skate without fear u000B.");
+            resources.put(TX_TRAINING310a, "Your skate dislikes water! Jump!");
+            resources.put(TX_TRAINING311a, "Leave your skate with \t.");
+            resources.put(TX_TRAINING401a, "Take the dynamite sticks with \t.");
+            resources.put(TX_TRAINING402a, "Do not put down the dynamite here!");
+            resources.put(TX_TRAINING403a, "Go and get the dynamite sticks on the left.");
+            resources.put(TX_TRAINING404a, "Put down the dynamite with \t, then clear off!");
+            resources.put(TX_TRAINING405a, "Put down another stick of dynamite here to move on.");
+            resources.put(TX_TRAINING406a, "");
+            resources.put(TX_TRAINING407a, "");
+            resources.put(TX_TRAINING408a, "");
+            resources.put(TX_TRAINING409a, "");
+            resources.put(TX_TRAINING410a, "");
+        }
+
+        private static void InitializeDE()
+        {
+            resources.put(TX_BUTTON_PLAY, "Play");
+            resources.put(TX_BUTTON_MENU, "Home");
+            resources.put(TX_BUTTON_BACK, "Back");
+            resources.put(TX_BUTTON_RESTART, "Restart");
+            resources.put(TX_BUTTON_CONTINUE, "Continue");
+            resources.put(TX_BUTTON_BUY, "Buy");
+            resources.put(TX_BUTTON_RANKING, "Ranking");
+            resources.put(TX_BUTTON_SETUP, "Setup");
+            resources.put(TX_BUTTON_SETUP_SOUNDS, "Sounds");
+            resources.put(TX_BUTTON_SETUP_JUMP, "Jump button to the right");
+            resources.put(TX_BUTTON_SETUP_ZOOM, "Automatically zoom action");
+            resources.put(TX_BUTTON_SETUP_ACCEL, "Accelerometer");
+            resources.put(TX_BUTTON_SETUP_RESET, "Gamer {0} :\nReset progression");
+            resources.put(TX_GAMER_TITLE, "Gamer {0}");
+            resources.put(TX_GAMER_MDOORS, "Main doors : {0}/12");
+            resources.put(TX_GAMER_SDOORS, "Secondary doors : {0}/52");
+            resources.put(TX_GAMER_LIFES, "Blupi : {0}");
+            resources.put(TX_TRIAL1, "Buy the full version");
+            resources.put(TX_TRIAL2, "\u000e 64 niveaux passionnants");
+            resources.put(TX_TRIAL3, "\u000e Des décors variés");
+            resources.put(TX_TRIAL4, "\u000e Une difficulté progressive");
+            resources.put(TX_TRIAL5, "\u000e De nouveaux pièges");
+            resources.put(TX_TRIAL6, "\u000e Un challenge fun");
+            resources.put(TX_TRAINING101, "Utilise la roue directionnelle \0 pour faire avancer Blupi.");
+            resources.put(TX_TRAINING102, "Appuie maintenant sur le bouton de saut \b.");
+            resources.put(TX_TRAINING103, "Appuie à droite sur la roue directionnelle \0 et sur Saut \b.");
+            resources.put(TX_TRAINING104, "Appuie sur Droite \0 et Saut \b.");
+            resources.put(TX_TRAINING105, "Essaie de ne pas te mouiller avec \0 \b !");
+            resources.put(TX_TRAINING106, "");
+            resources.put(TX_TRAINING107, "Prend l'ascenseur calmement, sans sauter \0.");
+            resources.put(TX_TRAINING108, "Saute sur l'ascenseur.");
+            resources.put(TX_TRAINING109, "");
+            resources.put(TX_TRAINING110, "Avance sans sauter et sans t'arrêter \0 !");
+            resources.put(TX_TRAINING111, "");
+            resources.put(TX_TRAINING112, "");
+            resources.put(TX_TRAINING113, "Avance sur la plateforme \0.");
+            resources.put(TX_TRAINING114, "Quitte la plateforme \0.");
+            resources.put(TX_TRAINING115, "Encore une fois, mais plus vite...");
+            resources.put(TX_TRAINING116, "Avance sur la plateforme \0 puis saute \0 \b.");
+            resources.put(TX_TRAINING117, "Saute lorsque tu es sur la plateforme \0 \b.");
+            resources.put(TX_TRAINING118, "Passe par en haut \0 \b.");
+            resources.put(TX_TRAINING119, "Les oeufs te redonnent des vies.");
+            resources.put(TX_TRAINING120, "Arrivé en haut, avance sur l'autre plateforme sans tarder...");
+            resources.put(TX_TRAINING121, "Attrape le deuxième et dernier trésor.");
+            resources.put(TX_TRAINING122, "Pour terminer, va sur la flèche rouge.");
+            resources.put(TX_TRAINING201, "Pousse la caisse sur le point rouge avec \0.");
+            resources.put(TX_TRAINING202, "Utilise la caisse pour passer l'obstacle avec \0 \b.");
+            resources.put(TX_TRAINING203, "Tire la caisse sur le point rouge avec \u0003.");
+            resources.put(TX_TRAINING204, "Empile les 2 caisses sur le point rouge pour passer.");
+            resources.put(TX_TRAINING205, "Empile 3 caisses sur le point rouge pour passer.");
+            resources.put(TX_TRAINING206, "");
+            resources.put(TX_TRAINING207, "");
+            resources.put(TX_TRAINING208, "");
+            resources.put(TX_TRAINING209, "");
+            resources.put(TX_TRAINING210, "");
+            resources.put(TX_TRAINING301, "Prend un hélico avec \t.");
+            resources.put(TX_TRAINING302, "Utilise \u0006 ou \b pour décoler. Dirige avec \u0004 et \0.");
+            resources.put(TX_TRAINING303, "Quitte l'hélico avec \t, il n'aime pas l'eau !");
+            resources.put(TX_TRAINING304, "Plonge. Utilise \u0004 \0 \u0002 \u0006 pour te diriger.");
+            resources.put(TX_TRAINING305, "Prend un hélico \t puis décole avec \u0006 ou \b.");
+            resources.put(TX_TRAINING306, "Attrape les 3 trésors puis monte.");
+            resources.put(TX_TRAINING307, "Pour passer, va chercher un skate en haut à gauche.");
+            resources.put(TX_TRAINING308, "Prend un skate avec \t.");
+            resources.put(TX_TRAINING309, "Tu peux passer sans crainte avec ton skate \0.");
+            resources.put(TX_TRAINING310, "Ton skate n'aime pas l'eau ! Utilise \0 \b.");
+            resources.put(TX_TRAINING311, "Pose ton skate avec \t.");
+            resources.put(TX_TRAINING401, "Prend la dynamite avec \t.");
+            resources.put(TX_TRAINING402, "Ne pose surtout pas la dynamite ici avec \t !");
+            resources.put(TX_TRAINING403, "Va chercher de la dynamite à gauche.");
+            resources.put(TX_TRAINING404, "Pose la dynamite avec \t, puis barre-toi !");
+            resources.put(TX_TRAINING405, "Pose encore de la dynamite pour passer.");
+            resources.put(TX_TRAINING406, "");
+            resources.put(TX_TRAINING407, "");
+            resources.put(TX_TRAINING408, "");
+            resources.put(TX_TRAINING409, "");
+            resources.put(TX_TRAINING410, "");
+        }
+    }

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Pixmap.java

@@ -0,0 +1,569 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Pixmap
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Color;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.GraphicsDeviceManager;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Graphics.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Rectangle;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Vector2;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+//import static com.openeggbert.jdotnet.System.Net.Mime.MediaTypeNames.*;
+
+
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class Pixmap
+    {
+        private final Game1 game1;
+
+        private final GraphicsDeviceManager graphics;
+
+        private double zoom;
+
+        private double originX;
+
+        private double originY;
+
+        private double hotSpotZoom;
+
+        private double hotSpotX;
+
+        private double hotSpotY;
+
+        private SpriteBatch spriteBatch;
+
+        private Texture2D bitmapText;
+
+        private Texture2D bitmapButton;
+
+        private Texture2D bitmapJauge;
+
+        private Texture2D bitmapBlupi;
+
+        private Texture2D bitmapBlupi1;
+
+        private Texture2D bitmapObject;
+
+        private Texture2D bitmapElement;
+
+        private Texture2D bitmapExplo;
+
+        private Texture2D bitmapPad;
+
+        private Texture2D bitmapSpeedyBlupi;
+
+        private Texture2D bitmapBlupiYoupie;
+
+        private Texture2D bitmapGear;
+
+        private Texture2D bitmapBackground;
+
+        private Vector2 origin;
+
+        private SpriteEffects effect;
+
+        public TinyRect DrawBounds() {return getDrawBounds();}
+        public TinyRect getDrawBounds()
+        {
+            
+            {
+                TinyRect result = default_(new TinyRect());
+                double num = graphics.GraphicsDevice().Viewport().Width();
+                double num2 = graphics.GraphicsDevice().Viewport().Height();
+                if (num != 0.0 && num2 != 0.0)
+                {
+                    double num3;
+                    double num4;
+                    if (num / num2 < 1.3333333333333333)
+                    {
+                        num3 = 640.0;
+                        num4 = 640.0 * (num2 / num);
+                    }
+                    else
+                    {
+                        num3 = 480.0 * (num / num2);
+                        num4 = 480.0;
+                    }
+                    result.Left = 0;
+                    result.Right = (int)num3;
+                    result.Top = 0;
+                    result.Bottom = (int)num4;
+                }
+                return result;
+            }
+        }
+
+        public TinyPoint Origin()
+        {
+            
+            {
+                TinyPoint result = default_(new TinyPoint());
+                result.X = (int)originX;
+                result.Y = (int)originY;
+                return result;
+            }
+        }
+
+        public Pixmap(Game1 game1, GraphicsDeviceManager graphics)
+        {
+            this.game1 = game1;
+            this.graphics = graphics;
+            origin = new Vector2(0f, 0f);
+            effect = SpriteEffects.None;
+        }
+
+        public TinyPoint HotSpotToHud(TinyPoint pos)
+        {
+            TinyPoint result = default_(new TinyPoint());
+            result.X = (int)((double)(pos.X - (int)hotSpotX) / hotSpotZoom) + (int)hotSpotX - (int)originX;
+            result.Y = (int)((double)(pos.Y - (int)hotSpotY) / hotSpotZoom) + (int)hotSpotY - (int)originY;
+            return result;
+        }
+
+        public void SetHotSpot(double zoom, double x, double y)
+        {
+            hotSpotZoom = zoom;
+            hotSpotX = x;
+            hotSpotY = y;
+        }
+
+        public void DrawInputButton(TinyRect rect, Def.ButtonGlygh glyph, boolean pressed, boolean selected)
+        {
+            switch (glyph)
+            {
+                case InitGamerA:
+                    DrawIcon(14, selected ? 16 : 4, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case InitGamerB:
+                    DrawIcon(14, selected ? 17 : 5, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case InitGamerC:
+                    DrawIcon(14, selected ? 18 : 6, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case InitSetup:
+                case PauseSetup:
+                    DrawIcon(14, 19, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case InitPlay:
+                    DrawIcon(14, 7, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case PauseMenu:
+                case ResumeMenu:
+                    DrawIcon(14, 11, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case PauseBack:
+                    DrawIcon(14, 8, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case PauseRestart:
+                    DrawIcon(14, 9, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case PauseContinue:
+                case ResumeContinue:
+                    DrawIcon(14, 10, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case WinLostReturn:
+                    DrawIcon(14, 3, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case InitBuy:
+                case TrialBuy:
+                    DrawIcon(14, 22, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case InitRanking:
+                    DrawIcon(14, 12, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case TrialCancel:
+                case RankingContinue:
+                    DrawIcon(14, 8, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case SetupSounds:
+                case SetupJump:
+                case SetupZoom:
+                case SetupAccel:
+                    DrawIcon(14, selected ? 13 : 21, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case SetupReset:
+                    DrawIcon(14, 20, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case SetupReturn:
+                    DrawIcon(14, 8, rect, pressed ? 0.8 : 1.0, false);
+                    break;
+                case PlayJump:
+                    DrawIcon(14, 2, rect, pressed ? 0.6 : 1.0, false);
+                    break;
+                case PlayAction:
+                    DrawIcon(14, 12, rect, pressed ? 0.6 : 1.0, false);
+                    break;
+                case PlayDown:
+                    DrawIcon(14, 23, rect, pressed ? 0.6 : 1.0, false);
+                    break;
+                case PlayPause:
+                    DrawIcon(14, 3, rect, pressed ? 0.6 : 1.0, false);
+                    break;
+                case Cheat1:
+                case Cheat2:
+                case Cheat3:
+                case Cheat4:
+                case Cheat5:
+                case Cheat6:
+                case Cheat7:
+                case Cheat8:
+                case Cheat9:
+                    {
+                        DrawIcon(14, 0, rect, pressed ? 0.6 : 1.0, false);
+                        TinyPoint tinyPoint = default_(new TinyPoint());
+                        tinyPoint.X = rect.Left + rect.Width() / 2 - (int)originX;
+                        tinyPoint.Y = rect.Top + 28;
+                        TinyPoint pos = tinyPoint;
+                        Text.DrawTextCenter(this, pos, Decor.GetCheatTinyText(glyph), 1.0);
+                        break;
+                    }
+                case Cheat11:
+                case Cheat12:
+                case Cheat21:
+                case Cheat22:
+                case Cheat31:
+                case Cheat32:
+                    break;
+            }
+        }
+
+        public void LoadContent()
+        {
+            spriteBatch = new SpriteBatch(game1.GraphicsDevice());
+            bitmapText = game1.Content.Load("icons/text", Texture2D.class);
+            bitmapButton = game1.Content.Load("icons/button", Texture2D.class);
+            bitmapJauge = game1.Content.Load("icons/jauge", Texture2D.class);
+            bitmapBlupi = game1.Content.Load("icons/blupi", Texture2D.class);
+            bitmapBlupi1 = game1.Content.Load("icons/blupi1", Texture2D.class);
+            bitmapObject = game1.Content.Load("icons/object-m", Texture2D.class);
+            bitmapElement = game1.Content.Load("icons/element", Texture2D.class);
+            bitmapExplo = game1.Content.Load("icons/explo", Texture2D.class);
+            bitmapPad = game1.Content.Load("icons/pad", Texture2D.class);
+            bitmapSpeedyBlupi = game1.Content.Load("backgrounds/speedyblupi", Texture2D.class);
+            bitmapBlupiYoupie = game1.Content.Load("backgrounds/blupiyoupie", Texture2D.class);
+            bitmapGear = game1.Content.Load("backgrounds/gear", Texture2D.class);
+            UpdateGeometry();
+        }
+
+        private void UpdateGeometry()
+        {
+            double num = graphics.GraphicsDevice().Viewport().Width();
+            double num2 = graphics.GraphicsDevice().Viewport().Height();
+            double val = num / 640.0;
+            double val2 = num2 / 480.0;
+            zoom = Math_.Min(val, val2);
+            originX = (num - 640.0 * zoom) / 2.0;
+            originY = (num2 - 480.0 * zoom) / 2.0;
+        }
+
+        public void BackgroundCache(String name)
+        {
+            bitmapBackground = game1.Content.Load("backgrounds/" + name, Texture2D.class);
+        }
+
+        public boolean Start()
+        {
+            graphics.GraphicsDevice().Clear(Color.CornflowerBlue);
+            return true;
+        }
+
+        public boolean Finish()
+        {
+            return true;
+        }
+
+        public void DrawBackground()
+        {
+            double num = graphics.GraphicsDevice().Viewport().Width();
+            double num2 = graphics.GraphicsDevice().Viewport().Height();
+            Texture2D bitmap = GetBitmap(3);
+            Rectangle srcRectangle = GetSrcRectangle(bitmap, 10, 10, 10, 10, 0, 0);
+            Rectangle destinationRectangle = new Rectangle(0, 0, (int)num, (int)num2);
+            spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
+            spriteBatch.Draw(bitmap, destinationRectangle, srcRectangle, Color.White);
+            spriteBatch.End();
+            TinyPoint tinyPoint = default_(new TinyPoint());
+            tinyPoint.X = (int)originX;
+            tinyPoint.Y = (int)originY;
+            TinyPoint dest = tinyPoint;
+            TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = 0;
+            tinyRect.Top = 0;
+            tinyRect.Right = 640;
+            tinyRect.Bottom = 480;
+            TinyRect rect = tinyRect;
+            DrawPart(3, dest, rect);
+        }
+
+        public void DrawChar(int rank, TinyPoint pos, double size)
+        {
+            pos.X = (int)((double)pos.X + originX);
+            pos.Y = (int)((double)pos.Y + originY);
+            TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = pos.X;
+            tinyRect.Top = pos.Y;
+            tinyRect.Right = pos.X + (int)(32.0 * size);
+            tinyRect.Bottom = pos.Y + (int)(32.0 * size);
+            TinyRect rect = tinyRect;
+            DrawIcon(6, rank, rect, 1.0, false);
+        }
+
+        public void HudIcon(int channel, int rank, TinyPoint pos)
+        {
+            pos.X = (int)((double)pos.X + originX);
+            pos.Y = (int)((double)pos.Y + originY);
+            TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = pos.X;
+            tinyRect.Top = pos.Y;
+            tinyRect.Right = pos.X;
+            tinyRect.Bottom = pos.Y;
+            TinyRect rect = tinyRect;
+            DrawIcon(channel, rank, rect, 1.0, false);
+        }
+
+        public void QuickIcon(int channel, int rank, TinyPoint pos)
+        {
+            TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = pos.X;
+            tinyRect.Top = pos.Y;
+            tinyRect.Right = pos.X;
+            tinyRect.Bottom = pos.Y;
+            TinyRect rect = tinyRect;
+            DrawIcon(channel, rank, rect, 1.0, true);
+        }
+
+        public void QuickIcon(int channel, int rank, TinyPoint pos, double opacity, double rotation)
+        {
+            TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = pos.X;
+            tinyRect.Top = pos.Y;
+            tinyRect.Right = pos.X;
+            tinyRect.Bottom = pos.Y;
+            TinyRect rect = tinyRect;
+            DrawIcon(channel, rank, rect, opacity, rotation, true);
+        }
+
+        public boolean DrawPart(int channel, TinyPoint dest, TinyRect rect)
+        {
+            return DrawPart(channel, dest, rect, 1.0);
+        }
+
+        public boolean DrawPart(int channel, TinyPoint dest, TinyRect rect, double zoom)
+        {
+            Texture2D bitmap = GetBitmap(channel);
+            if (bitmap == null)
+            {
+                return false;
+            }
+            if (channel == 5)
+            {
+                dest.X = (int)((double)dest.X + originX);
+                dest.Y = (int)((double)dest.Y + originY);
+            }
+            Rectangle value = new Rectangle(rect.Left, rect.Top, rect.Width(), rect.Height());
+            Rectangle destinationRectangle = new Rectangle(dest.X, dest.Y, (int)((double)rect.Width() * zoom), (int)((double)rect.Height() * zoom));
+            spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
+            spriteBatch.Draw(bitmap, destinationRectangle, value, Color.White);
+            spriteBatch.End();
+            return true;
+        }
+
+        public void DrawIcon(int channel, int icon, TinyRect rect, double opacity, boolean useHotSpot)
+        {
+            DrawIcon(channel, icon, rect, opacity, 0.0, useHotSpot);
+        }
+
+        public void DrawIcon(int channel, int icon, TinyRect rect, double opacity, double rotation, boolean useHotSpot)
+        {
+            if (icon == -1)
+            {
+                return;
+            }
+            Texture2D bitmap = GetBitmap(channel);
+            if (bitmap == null)
+            {
+                return;
+            }
+            int num;
+            int bitmapGridY;
+            int iconWidth;
+            int num2;
+            int gap;
+            switch (channel)
+            {
+                case 2:
+                case 11:
+                case 12:
+                case 13:
+                    num = 60;
+                    bitmapGridY = 60;
+                    iconWidth = 60;
+                    num2 = 60;
+                    gap = 0;
+                    break;
+                case 1:
+                    num = 64;
+                    bitmapGridY = 64;
+                    iconWidth = 64;
+                    num2 = 64;
+                    gap = 1;
+                    break;
+                case 10:
+                    num = 60;
+                    bitmapGridY = 60;
+                    iconWidth = 60;
+                    num2 = 60;
+                    gap = 0;
+                    break;
+                case 9:
+                    num = 144;
+                    bitmapGridY = 144;
+                    num2 = Tables.table_explo_size[icon];
+                    iconWidth = Math_.Max(num2, 128);
+                    gap = 0;
+                    break;
+                case 6:
+                    num = 32;
+                    bitmapGridY = 32;
+                    iconWidth = 32;
+                    num2 = 32;
+                    gap = 0;
+                    break;
+                case 4:
+                    num = 40;
+                    bitmapGridY = 40;
+                    iconWidth = 40;
+                    num2 = 40;
+                    gap = 0;
+                    break;
+                case 14:
+                    num = 140;
+                    bitmapGridY = 140;
+                    iconWidth = 140;
+                    num2 = 140;
+                    gap = 0;
+                    break;
+                case 15:
+                    num = 640;
+                    bitmapGridY = 160;
+                    iconWidth = 640;
+                    num2 = 160;
+                    gap = 0;
+                    break;
+                case 16:
+                    num = 410;
+                    bitmapGridY = 380;
+                    iconWidth = 410;
+                    num2 = 380;
+                    gap = 0;
+                    break;
+                case 17:
+                    num = 226;
+                    bitmapGridY = 226;
+                    iconWidth = 226;
+                    num2 = 226;
+                    gap = 0;
+                    break;
+                default:
+                    num = 0;
+                    bitmapGridY = 0;
+                    iconWidth = 0;
+                    num2 = 0;
+                    gap = 0;
+                    break;
+            }
+            if (num != 0)
+            {
+                Rectangle srcRectangle = GetSrcRectangle(bitmap, num, bitmapGridY, iconWidth, num2, gap, icon);
+                Rectangle rectangle = GetDstRectangle(rect, iconWidth, num2, useHotSpot);
+                float num3 = 0f;
+                if (rotation != 0.0)
+                {
+                    num3 = (float)Misc.DegToRad(rotation);
+                    rectangle = Misc.RotateAdjust(rectangle, num3);
+                }
+                spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
+                spriteBatch.Draw(bitmap, rectangle, srcRectangle, Color.FromNonPremultiplied(255, 255, 255, (int)(255.0 * opacity)), num3, origin, effect, 0f);
+                spriteBatch.End();
+            }
+        }
+
+        private Rectangle GetSrcRectangle(Texture2D bitmap, int bitmapGridX, int bitmapGridY, int iconWidth, int iconHeight, int gap, int icon)
+        {
+            int width = bitmap.Bounds().Width;
+            int height = bitmap.Bounds().Height;
+            int num = icon % (width / bitmapGridX);
+            int num2 = icon / (width / bitmapGridX);
+            bitmapGridX += gap;
+            bitmapGridY += gap;
+            return new Rectangle(gap + num * bitmapGridX, gap + num2 * bitmapGridY, iconWidth, iconHeight);
+        }
+
+        private Rectangle GetDstRectangle(TinyRect rect, int iconWidth, int iconHeight, boolean useHotSpot)
+        {
+            int num = ((rect.Width() == 0) ? iconWidth : rect.Width());
+            int num2 = ((rect.Height() == 0) ? iconHeight : rect.Height());
+            int num3 = (int)((double)rect.Left * zoom);
+            int num4 = (int)((double)rect.Top * zoom);
+            int num5 = (int)((double)num3 + (double)num * zoom);
+            int num6 = (int)((double)num4 + (double)num2 * zoom);
+            if (useHotSpot && hotSpotZoom > 1.0)
+            {
+                num3 -= (int)hotSpotX;
+                num4 -= (int)hotSpotY;
+                num5 -= (int)hotSpotX;
+                num6 -= (int)hotSpotY;
+                num3 = (int)((double)num3 * hotSpotZoom);
+                num4 = (int)((double)num4 * hotSpotZoom);
+                num5 = (int)((double)num5 * hotSpotZoom);
+                num6 = (int)((double)num6 * hotSpotZoom);
+                num3 += (int)hotSpotX;
+                num4 += (int)hotSpotY;
+                num5 += (int)hotSpotX;
+                num6 += (int)hotSpotY;
+            }
+            return new Rectangle(num3, num4, num5 - num3, num6 - num4);
+        }
+
+        private Texture2D GetBitmap(int channel)
+        {
+            switch (channel)
+            {
+                case 2:
+                    return bitmapBlupi;
+                case 11:
+                case 12:
+                case 13:
+                    return bitmapBlupi1;
+                case 1:
+                    return bitmapObject;
+                case 10:
+                    return bitmapElement;
+                case 9:
+                    return bitmapExplo;
+                case 6:
+                    return bitmapText;
+                case 4:
+                    return bitmapButton;
+                case 5:
+                    return bitmapJauge;
+                case 14:
+                    return bitmapPad;
+                case 15:
+                    return bitmapSpeedyBlupi;
+                case 16:
+                    return bitmapBlupiYoupie;
+                case 17:
+                    return bitmapGear;
+                case 3:
+                    return bitmapBackground;
+                default:
+                    return null;
+            }
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Program.java

@@ -0,0 +1,17 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+import com.openeggbert.jxna.Microsoft.Xna.Framework.*;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+
+
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class Program {
+    public static void main(String[] args) {
+        Game game = new com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi.Game1();
+        game.Run();        
+    }
+
+
+}

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Properties/AssemblyInfo.java

@@ -0,0 +1,46 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi.Properties;
+
+public class AssemblyInfo {
+}
+
+//using System.Reflection;
+//using System.Runtime.CompilerServices;
+//using System.Runtime.InteropServices;
+//using System.Resources;
+//
+//// General Information about an assembly is controlled through the following 
+//// set of attributes. Change these attribute values to modify the information
+//// associated with an assembly.
+////[assembly: AssemblyTitle("Speedy Blupi")]
+////[assembly: AssemblyProduct("Speedy Blupi")]
+//[assembly: AssemblyDescription("")]
+//[assembly: AssemblyCompany("Dada Games")]
+//[assembly: AssemblyCopyright("Copyright © 2013")]
+//[assembly: AssemblyTrademark("")]
+//[assembly: AssemblyCulture("")]
+//[assembly: NeutralResourcesLanguage("en-US")]
+//
+//// Configuration
+////[assembly: AssemblyConfiguration("")]
+//[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
+//[assembly: CompilationRelaxations(8)]
+//
+//// Setting ComVisible to false makes the types in this assembly not visible 
+//// to COM components.  If you need to access a type in this assembly from 
+//// COM, set the ComVisible attribute to true on that type.
+//[assembly: ComVisible(false)]
+//
+//// The following GUID is for the ID of the typelib if this project is exposed to COM
+//[assembly: Guid("4b6c546f-6967-447a-8eda-c3236043dcf7")]
+//
+//// Version information for an assembly consists of the following four values:
+////
+////      Major Version
+////      Minor Version 
+////      Build Number
+////      Revision
+////
+//// You can specify all the values or you can default the Revision and Build Numbers 
+//// by using the '*' as shown below:
+//[assembly: AssemblyVersion("1.0.0.5")]
+//[assembly: AssemblyFileVersion("1.0.0.0")]

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Resource.java

@@ -0,0 +1,66 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Resource
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.internal;
+//import com.openeggbert.jdotnet.System.CodeDom.Compiler.*;
+//import com.openeggbert.jdotnet.System.ComponentModel.*;
+import com.openeggbert.jdotnet.System.Diagnostics.*;
+import com.openeggbert.jdotnet.System.Globalization.*;
+import com.openeggbert.jdotnet.System.Resources.*;
+//import com.openeggbert.jdotnet.System.Runtime.CompilerServices.*;
+import static com.openeggbert.jdotnet.System.Type.typeof;
+import com.openeggbert.jdotnet.System.object;
+
+//[DebuggerNonUserCode]
+//[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+//[CompilerGenerated]
+
+
+
+    @internal class Resource
+    {
+        private static ResourceManager resourceMan;
+
+        private static CultureInfo resourceCulture;
+
+        //[EditorBrowsable(EditorBrowsableState.Advanced)]
+        @internal static ResourceManager ResourceManager()
+        {
+            
+            {
+                if (object.ReferenceEquals(resourceMan, null))
+                {
+                    ResourceManager resourceManager = new ResourceManager("WindowsPhoneSpeedyBlupi.Resource", typeof(Resource.class).Assembly());
+                    resourceMan = resourceManager;
+                }
+                return resourceMan;
+            }
+        }
+
+        //[EditorBrowsable(EditorBrowsableState.Advanced)]
+        @internal static CultureInfo Culture()
+        {
+            
+            {
+                return resourceCulture;
+            }
+        }
+        @internal
+        static void setCultureInfo(CultureInfo value) {
+            resourceCulture = value;
+        }
+
+        @internal static String Title()
+        {
+            
+            {
+                return ResourceManager.GetString("Title", resourceCulture);
+            }
+        }
+
+        @internal private Resource()
+        {
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Slider.java

@@ -0,0 +1,105 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Slider
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jdotnet.System.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+    @AllArgsConstructor
+    public class Slider
+    {
+        public TinyPoint TopLeftCorner() {
+            return getTopLeftCorner();
+        }
+        @Getter @Setter
+        public TinyPoint TopLeftCorner;
+
+        public double Value() {
+            return getValue();
+        }
+        
+        @Getter @Setter
+        public double Value;
+
+        private int PosLeft() {
+            return getPosLeft();
+        }
+        private int getPosLeft()
+        {
+            return TopLeftCorner.X + 22;
+        }
+        private int PosRight() {
+            return getPosRight();
+        }
+        private int getPosRight()
+        {
+            return TopLeftCorner.X + 248 - 22;
+        }
+
+        public void Draw(Pixmap pixmap)
+        {
+             TinyPoint tinyPoint = default_(new TinyPoint());
+            tinyPoint.X = TopLeftCorner.X - pixmap.Origin().X;
+            tinyPoint.Y = TopLeftCorner.Y - pixmap.Origin().Y;
+            TinyPoint dest = tinyPoint;
+             TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = 0;
+            tinyRect.Right = 124;
+            tinyRect.Top = 0;
+            tinyRect.Bottom = 22;
+            TinyRect rect = tinyRect;
+            pixmap.DrawPart(5, dest, rect, 2.0);
+            int num = (int)((double)(PosRight() - PosLeft()) * Value);
+            int num2 = TopLeftCorner.Y + 22;
+            int num3 = 94;
+             TinyRect tinyRect2 = default_(new TinyRect());
+            tinyRect2.Left = PosLeft() + num - num3 / 2;
+            tinyRect2.Right = PosLeft() + num + num3 / 2;
+            tinyRect2.Top = num2 - num3 / 2;
+            tinyRect2.Bottom = num2 + num3 / 2;
+            rect = tinyRect2;
+            pixmap.DrawIcon(14, 1, rect, 1.0, false);
+             TinyRect tinyRect3 = default_(new TinyRect());
+            tinyRect3.Left = TopLeftCorner.X - 65;
+            tinyRect3.Right = TopLeftCorner.X - 65 + 60;
+            tinyRect3.Top = TopLeftCorner.Y - 10;
+            tinyRect3.Bottom = TopLeftCorner.Y - 10 + 60;
+            rect = tinyRect3;
+            pixmap.DrawIcon(10, 37, rect, 1.0, false);
+             TinyRect tinyRect4 = default_(new TinyRect());
+            tinyRect4.Left = TopLeftCorner.X + 248 + 5;
+            tinyRect4.Right = TopLeftCorner.X + 248 + 5 + 60;
+            tinyRect4.Top = TopLeftCorner.Y - 10;
+            tinyRect4.Bottom = TopLeftCorner.Y - 10 + 60;
+            rect = tinyRect4;
+            pixmap.DrawIcon(10, 38, rect, 1.0, false);
+        }
+
+        public boolean Move(TinyPoint pos)
+        {
+             TinyRect tinyRect = default_(new TinyRect());
+            tinyRect.Left = TopLeftCorner.X - 50;
+            tinyRect.Right = TopLeftCorner.X + 248 + 50;
+            tinyRect.Top = TopLeftCorner.Y - 50;
+            tinyRect.Bottom = TopLeftCorner.Y + 44 + 50;
+            TinyRect rect = tinyRect;
+            if (Misc.IsInside(rect, pos))
+            {
+                double val = ((double)pos.X - (double)PosLeft()) / (double)(PosRight() - PosLeft());
+                val = Math_.Max(val, 0.0);
+                val = Math_.Min(val, 1.0);
+                if (Value != val)
+                {
+                    Value = val;
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Sound.java

@@ -0,0 +1,257 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Sound
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jdotnet.System.Collections.Generic.*;
+import com.openeggbert.jdotnet.System.Linq.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.Audio.*;
+import java.util.ArrayList;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.readonly;
+
+
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+
+    public class Sound
+    {
+        private class Play
+        {
+            private final SoundEffectInstance sei;
+
+            private final int channel;
+            
+            public int Channel() { return channel;}
+
+            public boolean IsFree()
+            {
+                return sei.State == SoundState.Stopped;
+            }
+
+            public Play(SoundEffect se, int channel, double volume, double balance, Double pitch, boolean isLooped)
+            {
+                this.channel = channel;
+                int num = channel * 2;
+                if (num >= 0 && num < tableVolumePitch.length)
+                {
+                    volume *= tableVolumePitch[num];
+                    pitch = tableVolumePitch[num + 1];
+                }
+                sei = se.CreateInstance();
+                sei.Volume = (float)volume;
+                sei.Pan = (float)balance;
+                sei.Pitch = (float)(pitch == null ? 0.0d : pitch);
+                sei.IsLooped = isLooped;
+                sei.Play();
+            }
+
+            public void Stop()
+            {
+                sei.Stop();
+            }
+        }
+
+        private static double[] tableVolumePitch = new double[]
+        {
+        1.0, 0.0, 0.5, 1.0, 0.5, 1.0, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.1, 1.0, 0.3, 1.0, 0.2, 1.0, 0.3, 1.0, 0.5,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.1, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 0.7, 0.2, 1.0, 0.1, 1.0, 0.1,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.4, 1.0, 0.0, 1.0, 0.0,
+        1.0, 0.0, 1.0, 0.0, 1.0, 0.2, 1.0, 0.2, 0.7, 0.4,
+        1.0, 0.2, 1.0, 0.4, 1.0, 0.2, 0.5, 1.0, 0.5, 1.0,
+        1.0, 0.4, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 0.6, 0.4, 0.8, 0.1,
+        0.6, 0.5, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.0,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.0,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.0, 1.0, 0.0, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 0.6, 0.4,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2,
+        1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2
+        };
+
+        public static final int MAXVOLUME = 20;
+
+        private final Game1 game1;
+
+        private final GameData gameData;
+
+        private @readonly final List_<SoundEffect> soundEffects;
+
+        private final List_<Play> plays;
+
+        private double volume;
+
+        public Sound(Game1 game1, GameData gameData)
+        {
+            this.game1 = game1;
+            this.gameData = gameData;
+            soundEffects = new List_<>();
+            plays = new List_<>();
+            volume = 1.0;
+            SoundEffect.MasterVolume = 1f;
+        }
+
+        public void LoadContent()
+        {
+            if (Def.HasSound())
+            {
+                for (int i = 0; i <= 92; i++)
+                {
+                    String assetName = string.Format("sounds/sound{0}", int_.of(i).ToString("d3"));
+                    SoundEffect item = game1.Content.Load(assetName, SoundEffect.class);
+                    soundEffects.Add(item);
+                }
+            }
+        }
+
+        public boolean Create()
+        {
+            return true;
+        }
+
+        public void SetState(boolean bState)
+        {
+        }
+
+        public void SetCDAudio(boolean bAudio)
+        {
+        }
+
+        public boolean GetEnable()
+        {
+            return true;
+        }
+
+        public void SetAudioVolume(int volume)
+        {
+            this.volume = (double)volume / (double)MAXVOLUME;
+        }
+
+        public int GetAudioVolume()
+        {
+            return (int)(volume * (double)MAXVOLUME);
+        }
+
+        public void SetMidiVolume(int volume)
+        {
+        }
+
+        public int GetMidiVolume()
+        {
+            return 0;
+        }
+        
+        public void StopAll()
+        {
+            while (plays.Any())
+            {
+                plays.ElementAt(0).Stop();
+                plays.RemoveAt(0);
+            }
+        }
+
+        public boolean PlayImage(int channel, TinyPoint pos)
+        {
+            return PlayImage(channel, pos, -1, false);
+        }
+
+        public boolean PlayImage(int channel, TinyPoint pos, int rank, boolean bLoop)
+        {
+            if (!gameData.Sounds())
+            {
+                return true;
+            }
+            if (channel >= 0 && channel < soundEffects.Count())
+            {
+
+                if (channel != 10 && plays.stream()
+                        .anyMatch(x -> x.Channel() == channel && !x.IsFree())) {
+                    return true;
+                }
+                if (plays.Count() >= 10)
+                {
+                    int num = 0;
+                    while (num < plays.Count())
+                    {
+                        if (plays.ElementAt(num).IsFree())
+                        {
+                            plays.RemoveAt(num);
+                        }
+                        else
+                        {
+                            num++;
+                        }
+                    }
+                }
+                Play item = new Play(soundEffects.ElementAt(channel), channel, (float)GetVolume(pos), (float)GetBalance(pos), null, bLoop);
+                plays.Add(item);
+            }
+            return true;
+        }
+
+        public boolean PosImage(int channel, TinyPoint pos)
+        {
+            return true;
+        }
+
+        public boolean Stop(int channel)
+        {
+            int num = 0;
+            while (num < plays.Count())
+            {
+                if (plays.ElementAt(num).Channel() == channel)
+                {
+                    plays.ElementAt(num).Stop();
+                    plays.RemoveAt(num);
+                }
+                else
+                {
+                    num++;
+                }
+            }
+            return true;
+        }
+
+        private double GetVolume(TinyPoint pos)
+        {
+            double val = 1.0;
+            if (pos.X < 0)
+            {
+                val = 1.0 + (double)(pos.X / 640) * 2.0;
+            }
+            if (pos.X > 640)
+            {
+                pos.X -= 640;
+                val = 1.0 - (double)(pos.X / 640) * 2.0;
+            }
+            val = Math_.Max(val, 0.0);
+            val = Math_.Min(val, 1.0);
+            double val2 = 1.0;
+            if (pos.Y < 0)
+            {
+                val2 = 1.0 + (double)(pos.Y / 480) * 3.0;
+            }
+            if (pos.Y > 480)
+            {
+                pos.Y -= 480;
+                val2 = 1.0 - (double)(pos.Y / 480) * 3.0;
+            }
+            val2 = Math_.Max(val2, 0.0);
+            val2 = Math_.Min(val2, 1.0);
+            return Math_.Min(val, val2) * volume;
+        }
+
+        private double GetBalance(TinyPoint pos)
+        {
+            double val = (double)pos.X * 2.0 / 640.0 - 1.0;
+            val = Math_.Max(val, -1.0);
+            return Math_.Min(val, 1.0);
+        }
+    }

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Tables_table_blupi.java

@@ -0,0 +1,318 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.static_;
+
+// WindowsPhoneSpeedyBlupi.Tables
+
+
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+    @static_
+    class Tables_table_blupi
+    {
+        private Tables_table_blupi() {
+            //Not meant to be instantiated.
+        }
+     
+
+        public static int[] table_blupi = new int[]
+        {
+        35, 9, 0, 276, 277, 278, 279, 280, 281, 282,
+        283, 284, 1, 330, 0, 0, 0, 0, 0, 0,
+        23, 23, 23, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 23, 23, 23, 23, 23, 23, 0, 0,
+        0, 0, 0, 0, 0, 0, 23, 23, 23, 23,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        23, 23, 23, 23, 23, 0, 0, 0, 23, 23,
+        23, 0, 0, 0, 0, 0, 0, 133, 133, 0,
+        0, 0, 133, 133, 0, 0, 0, 0, 0, 0,
+        0, 133, 133, 0, 0, 0, 0, 23, 23, 23,
+        23, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 23, 23, 0, 0, 0, 0, 0, 23,
+        23, 23, 0, 0, 0, 135, 135, 136, 136, 137,
+        137, 137, 137, 137, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 137, 137, 137,
+        136, 136, 135, 135, 135, 0, 0, 0, 0, 0,
+        23, 23, 23, 0, 0, 133, 133, 0, 0, 0,
+        23, 23, 23, 23, 0, 0, 0, 0, 0, 0,
+        0, 23, 23, 0, 0, 0, 0, 0, 0, 0,
+        0, 133, 133, 0, 0, 0, 0, 0, 23, 23,
+        23, 23, 0, 0, 0, 135, 135, 136, 136, 137,
+        137, 137, 137, 137, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 138, 138, 137,
+        137, 137, 138, 138, 137, 137, 137, 137, 137, 137,
+        136, 136, 135, 135, 135, 0, 0, 0, 0, 0,
+        23, 23, 23, 0, 0, 133, 133, 0, 0, 0,
+        23, 23, 23, 23, 0, 0, 0, 0, 0, 0,
+        0, 23, 23, 0, 0, 0, 0, 0, 0, 0,
+        0, 133, 133, 0, 0, 0, 0, 0, 23, 23,
+        23, 23, 0, 0, 0, 2, 6, 0, 5, 6,
+        7, 8, 9, 10, 60, 3, 0, 19, 18, 19,
+        3, 6, 0, 1, 1, 2, 2, 3, 3, 4,
+        3, 0, 17, 18, 19, 5, 5, 4, 169, 26,
+        170, 170, 27, 59, 6, 0, 3, 3, 2, 2,
+        1, 1, 61, 5, 0, 34, 35, 34, 34, 33,
+        62, 2, 0, 35, 34, 6, 3, 2, 33, 34,
+        35, 7, 1, 0, 44, 8, 8, 0, 0, 169,
+        26, 170, 27, 171, 28, 172, 9, 6, 0, 5,
+        6, 7, 8, 9, 10, 10, 6, 0, 5, 6,
+        7, 8, 9, 10, 13, 6, 0, 41, 41, 42,
+        42, 43, 43, 86, 18, 0, 1, 1, 2, 2,
+        41, 41, 42, 42, 43, 43, 42, 42, 41, 41,
+        2, 2, 1, 1, 87, 26, 0, 135, 135, 137,
+        137, 231, 231, 231, 231, 230, 230, 231, 231, 231,
+        231, 230, 230, 231, 231, 231, 231, 230, 230, 137,
+        137, 135, 135, 11, 70, 0, 40, 40, 40, 40,
+        41, 41, 41, 41, 40, 40, 40, 40, 40, 40,
+        40, 41, 41, 41, 40, 40, 40, 40, 40, 40,
+        40, 41, 41, 41, 40, 40, 42, 42, 42, 43,
+        43, 43, 44, 44, 44, 45, 45, 45, 46, 46,
+        47, 47, 46, 46, 47, 47, 46, 46, 47, 47,
+        46, 46, 47, 47, 46, 46, 47, 47, 46, 46,
+        47, 47, 46, 46, 47, 47, 75, 1, 0, -1,
+        76, 70, 0, 40, 40, 40, 40, 41, 41, 41,
+        41, 40, 40, 40, 40, 40, 40, 40, 41, 41,
+        41, 40, 40, 40, 40, 40, 40, 40, 41, 41,
+        41, 40, 40, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, 77, 110, 0, 324, 325, 324, 325,
+        324, 325, 324, 325, 324, 325, 324, 325, 324, 325,
+        324, 325, 324, 325, 324, 325, 324, 324, 325, 325,
+        326, 326, 327, 327, 328, 328, 329, 329, 330, 330,
+        331, 331, 332, 332, 333, 333, 334, 334, 333, 333,
+        332, 332, 331, 331, 330, 330, 329, 329, 329, 330,
+        330, 330, 331, 331, 331, 332, 332, 332, 333, 333,
+        333, 334, 334, 334, 333, 333, 333, 332, 332, 332,
+        331, 331, 331, 330, 330, 330, 329, 329, 329, 329,
+        329, 329, 329, 329, 329, 329, 329, 329, 329, 329,
+        329, 329, 329, 329, 329, 329, 329, 329, 329, 329,
+        329, 329, 329, 329, 329, 329, 78, 1, 0, -1,
+        79, 1, 0, -1, 80, 1, 0, -1, 81, 1,
+        0, -1, 14, 6, 0, 49, 50, 51, 52, 53,
+        54, 29, 6, 0, 126, 125, 124, 123, 122, 121,
+        28, 6, 0, 122, 122, 122, 125, 125, 125, 15,
+        1, 0, 61, 16, 8, 0, 61, 62, 63, 62,
+        61, 64, 65, 64, 17, 10, 0, 71, 71, 72,
+        72, 73, 73, 74, 74, 75, 75, 67, 1, 0,
+        315, 68, 12, 0, 296, 297, 298, 299, 300, 301,
+        302, 301, 300, 299, 298, 297, 69, 7, 0, 296,
+        310, 311, 312, 313, 314, 303, 18, 10, 0, 76,
+        76, 76, 76, 76, 76, 77, 77, 77, 77, 19,
+        14, 0, 76, 76, 77, 77, 78, 78, 79, 79,
+        80, 80, 81, 81, 39, 39, 20, 10, 0, 88,
+        88, 89, 89, 90, 90, 91, 91, 92, 92, 21,
+        12, 0, 93, 93, 94, 94, 95, 95, 96, 96,
+        97, 97, 98, 98, 22, 12, 0, 93, 93, 94,
+        94, 95, 95, 96, 96, 97, 97, 98, 98, 23,
+        10, 0, 105, 105, 106, 106, 107, 107, 108, 108,
+        109, 109, 24, 90, 0, 93, 96, 98, 94, 95,
+        93, 95, 98, 93, 94, 96, 96, 94, 94, 98,
+        98, 93, 93, 97, 97, 94, 94, 94, 96, 96,
+        96, 93, 93, 93, 93, 94, 94, 94, 94, 94,
+        97, 97, 97, 97, 97, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 79, 79, 76, 76, 76,
+        76, 79, 79, 76, 76, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 25, 8, 0, 111, 111,
+        110, 110, 111, 111, 112, 112, 26, 8, 0, 111,
+        111, 110, 110, 111, 111, 112, 112, 27, 7, 0,
+        112, 113, 114, 115, 116, 117, 118, 30, 12, 0,
+        25, 25, 29, 29, 46, 46, 47, 47, 46, 46,
+        29, 29, 31, 328, 0, 156, 156, 156, 156, 157,
+        157, 157, 157, 158, 158, 158, 158, 157, 157, 157,
+        157, 156, 156, 156, 156, 157, 157, 157, 157, 158,
+        158, 158, 158, 157, 157, 157, 157, 156, 156, 156,
+        156, 157, 157, 157, 157, 158, 158, 158, 158, 157,
+        157, 157, 157, 156, 156, 156, 156, 157, 157, 157,
+        157, 158, 158, 158, 158, 157, 157, 157, 157, 156,
+        156, 156, 156, 157, 157, 157, 157, 158, 158, 158,
+        158, 157, 157, 157, 157, 156, 156, 156, 156, 157,
+        157, 157, 157, 158, 158, 158, 158, 157, 157, 157,
+        157, 156, 156, 156, 156, 157, 157, 157, 157, 158,
+        158, 158, 158, 157, 157, 157, 157, 144, 144, 143,
+        143, 151, 151, 162, 162, 163, 163, 164, 164, 163,
+        163, 162, 162, 163, 163, 164, 164, 163, 163, 162,
+        162, 163, 163, 164, 164, 163, 163, 162, 162, 163,
+        163, 164, 164, 163, 163, 162, 162, 151, 151, 143,
+        143, 144, 144, 157, 157, 156, 156, 156, 156, 157,
+        157, 157, 157, 158, 158, 158, 158, 157, 157, 157,
+        157, 156, 156, 156, 156, 157, 157, 157, 157, 158,
+        158, 158, 158, 157, 157, 157, 157, 156, 156, 156,
+        156, 157, 157, 157, 157, 158, 158, 158, 158, 157,
+        157, 157, 157, 156, 156, 156, 156, 157, 157, 157,
+        157, 158, 158, 158, 158, 157, 157, 157, 157, 144,
+        144, 143, 143, 151, 151, 162, 162, 163, 163, 164,
+        164, 163, 163, 162, 162, 163, 163, 164, 164, 163,
+        163, 162, 162, 163, 163, 164, 164, 163, 163, 162,
+        162, 163, 163, 164, 164, 163, 163, 162, 162, 151,
+        151, 143, 143, 151, 151, 162, 162, 163, 163, 164,
+        164, 163, 163, 162, 162, 163, 163, 164, 164, 163,
+        163, 162, 162, 163, 163, 164, 164, 163, 163, 162,
+        162, 163, 163, 164, 164, 163, 163, 162, 162, 163,
+        163, 164, 164, 163, 163, 162, 162, 163, 163, 164,
+        164, 163, 163, 162, 162, 151, 151, 143, 143, 144,
+        144, 157, 157, 32, 12, 0, 144, 144, 145, 145,
+        146, 146, 145, 145, 144, 144, 143, 143, 33, 10,
+        0, 151, 151, 152, 152, 153, 153, 154, 154, 155,
+        155, 34, 10, 0, 157, 157, 165, 165, 165, 165,
+        166, 166, 166, 166, 36, 32, 0, 135, 177, 177,
+        178, 178, 179, 179, 180, 180, 179, 179, 178, 178,
+        179, 179, 180, 180, 179, 179, 178, 178, 179, 179,
+        180, 180, 179, 179, 178, 178, 177, 177, 135, 37,
+        140, 0, 182, 182, 182, 182, 208, 208, 208, 208,
+        208, 182, 182, 182, 182, 182, 182, 208, 208, 208,
+        208, 208, 194, 194, 194, 182, 182, 182, 182, 208,
+        208, 208, 208, 208, 182, 182, 182, 182, 182, 182,
+        208, 208, 208, 208, 182, 182, 182, 182, 182, 182,
+        182, 182, 194, 194, 194, 195, 195, 195, 196, 196,
+        196, 197, 197, 197, 198, 198, 198, 198, 197, 197,
+        197, 196, 196, 196, 195, 195, 195, 194, 194, 194,
+        182, 182, 182, 182, 208, 208, 208, 208, 182, 182,
+        182, 182, 194, 194, 194, 195, 195, 195, 196, 196,
+        196, 197, 197, 197, 198, 198, 198, 198, 197, 197,
+        197, 196, 196, 196, 195, 195, 195, 194, 194, 194,
+        182, 182, 182, 182, 208, 208, 208, 208, 182, 182,
+        182, 182, 210, 210, 211, 211, 211, 211, 211, 211,
+        210, 210, 85, 1, 0, 211, 38, 96, 0, 182,
+        183, 184, 185, 186, 187, 182, 183, 184, 185, 186,
+        187, 182, 183, 184, 185, 186, 187, 182, 182, 182,
+        182, 182, 182, 182, 183, 184, 185, 186, 187, 182,
+        182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
+        182, 182, 183, 184, 185, 186, 187, 182, 182, 182,
+        182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
+        182, 182, 182, 182, 182, 182, 183, 184, 185, 186,
+        187, 182, 182, 182, 182, 182, 182, 182, 182, 182,
+        182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
+        182, 182, 182, 182, 182, 39, 14, 0, 194, 194,
+        195, 195, 196, 196, 197, 197, 198, 198, 199, 199,
+        200, 200, 40, 3, 0, 210, 211, 212, 41, 8,
+        0, 213, 213, 214, 214, 215, 215, 214, 214, 42,
+        20, 0, 17, 17, 18, 18, 19, 19, 1, 1,
+        215, 215, 214, 214, 213, 213, 212, 212, 211, 211,
+        210, 210, 43, 20, 0, 210, 210, 211, 211, 212,
+        212, 213, 213, 214, 214, 215, 215, 1, 1, 19,
+        19, 18, 18, 17, 17, 44, 29, 0, 1, 1,
+        222, 222, 222, 222, 223, 223, 224, 224, 225, 225,
+        225, 225, 225, 224, 223, 222, 222, 222, 223, 223,
+        224, 224, 225, 225, 225, 1, 1, 45, 29, 0,
+        1, 1, 222, 222, 222, 222, 223, 223, 224, 224,
+        225, 225, 225, 225, 225, 224, 223, 222, 222, 222,
+        223, 223, 224, 224, 225, 225, 225, 1, 1, 46,
+        32, 0, 1, 1, 227, 227, 228, 228, 229, 229,
+        228, 228, 227, 227, 226, 226, 227, 227, 228, 228,
+        229, 229, 228, 228, 227, 227, 226, 226, 227, 227,
+        228, 228, 1, 1, 47, 34, 0, 135, 135, 136,
+        136, 137, 137, 231, 231, 231, 231, 230, 230, 231,
+        231, 231, 231, 230, 230, 231, 231, 231, 231, 230,
+        230, 231, 231, 231, 231, 137, 137, 136, 136, 135,
+        135, 48, 40, 0, 0, 0, 135, 135, 136, 136,
+        137, 137, 232, 233, 232, 233, 232, 233, 232, 233,
+        232, 233, 232, 233, 232, 233, 232, 233, 232, 233,
+        232, 233, 232, 233, 232, 233, 137, 137, 136, 136,
+        135, 135, 0, 0, 65, 44, 0, 1, 1, 288,
+        288, 289, 289, 290, 290, 290, 289, 288, 288, 289,
+        289, 290, 290, 290, 289, 288, 288, 289, 289, 290,
+        290, 290, 289, 288, 288, 289, 289, 290, 290, 290,
+        289, 288, 288, 289, 289, 290, 290, 290, 289, 1,
+        1, 49, 32, 0, 234, 234, 235, 235, 236, 236,
+        235, 235, 234, 234, 235, 235, 236, 236, 235, 235,
+        234, 234, 235, 235, 236, 236, 235, 235, 234, 234,
+        235, 235, 236, 236, 235, 235, 50, 64, 0, 238,
+        238, 239, 239, 240, 240, 241, 241, 241, 241, 241,
+        241, 241, 241, 241, 241, 240, 240, 241, 241, 240,
+        240, 241, 241, 241, 241, 241, 241, 241, 241, 241,
+        241, 241, 241, 240, 240, 241, 241, 240, 240, 241,
+        241, 241, 241, 241, 241, 241, 241, 240, 240, 239,
+        239, 238, 238, 238, 238, 238, 238, 237, 237, 238,
+        238, 237, 237, 51, 8, 0, 238, 238, 237, 237,
+        238, 238, 239, 239, 52, 12, 0, 238, 239, 240,
+        241, 242, 243, 244, 245, 246, 247, 248, 249, 53,
+        6, 0, 251, 251, 238, 238, 238, 238, 54, 25,
+        0, 168, 168, 169, 169, 170, 170, 171, 171, 170,
+        170, 169, 169, 168, 168, 169, 169, 169, 168, 168,
+        169, 169, 170, 170, 169, 168, 55, 4, 0, 253,
+        253, 254, 254, 56, 64, 0, 1, 3, 270, 268,
+        1, 3, 270, 268, 1, 3, 270, 268, 1, 3,
+        270, 268, 1, 3, 270, 268, 1, 3, 270, 268,
+        1, 3, 270, 268, 1, 3, 270, 268, 1, 2,
+        3, 4, 270, 269, 268, 0, 1, 2, 3, 4,
+        270, 269, 268, 0, 1, 1, 2, 2, 3, 3,
+        4, 4, 270, 270, 269, 269, 268, 268, 0, 0,
+        57, 90, 0, 266, 267, 266, 267, 266, 267, 266,
+        267, 266, 267, 266, 267, 266, 267, 266, 267, 266,
+        267, 266, 267, 266, 267, 266, 267, 266, 267, 266,
+        267, 266, 267, 40, 40, 40, 40, 41, 41, 41,
+        41, 40, 40, 40, 40, 40, 40, 40, 41, 41,
+        41, 40, 40, 40, 40, 40, 40, 40, 41, 41,
+        41, 40, 40, 42, 42, 42, 43, 43, 43, 44,
+        44, 44, 45, 45, 45, 46, 46, 47, 47, 46,
+        46, 47, 47, 46, 46, 47, 47, 46, 46, 47,
+        47, 46, 46, 82, 10, 0, 0, 268, 268, 269,
+        269, 269, 269, 268, 268, 0, 58, 14, 0, 274,
+        274, 271, 271, 271, 271, 272, 272, 273, 273, 273,
+        273, 274, 274, 66, 16, 0, 291, 291, 292, 292,
+        293, 293, 294, 294, 295, 295, 294, 294, 293, 293,
+        292, 292, 72, 1, 0, 320, 73, 24, 0, 319,
+        319, 318, 318, 317, 317, 318, 318, 319, 319, 320,
+        320, 321, 321, 322, 322, 323, 323, 322, 322, 321,
+        321, 320, 320, 74, 128, 0, 1, 1, 2, 2,
+        3, 3, 4, 4, 270, 270, 269, 269, 268, 268,
+        0, 0, 1, 2, 3, 4, 270, 269, 268, 0,
+        1, 2, 3, 4, 270, 269, 268, 0, 1, 3,
+        270, 268, 2, 4, 269, 0, 1, 3, 270, 268,
+        2, 4, 269, 0, -1, 3, 270, -1, 2, -1,
+        269, 0, 1, -1, -1, 268, -1, -1, 269, -1,
+        -1, -1, -1, 270, -1, -1, 2, -1, -1, -1,
+        -1, -1, -1, 29, 46, 47, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, 63, 92, 0, 263, 264, 265,
+        264, 263, 264, 265, 264, 263, 264, 265, 264, 263,
+        264, 265, 264, 263, 264, 265, 264, 263, 264, 265,
+        264, 263, 264, 265, 264, 263, 264, 265, 264, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 23,
+        23, 23, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 23, 23, 0, 0, 0, 0, 0, 0,
+        0, 133, 133, 0, 0, 0, 133, 133, 0, 0,
+        0, 0, 0, 0, 0, 133, 133, 0, 0, 0,
+        0, 23, 23, 23, 23, 0, 0, 0, 0, 64,
+        104, 0, 1, 1, 2, 2, 3, 3, 285, 286,
+        287, 286, 285, 286, 287, 286, 285, 286, 287, 286,
+        285, 286, 287, 286, 285, 286, 287, 286, 285, 286,
+        287, 286, 285, 286, 287, 286, 285, 286, 287, 286,
+        3, 3, 2, 2, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 23, 23, 23, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 23,
+        23, 0, 0, 0, 0, 0, 0, 0, 133, 133,
+        0, 0, 0, 133, 133, 0, 0, 0, 0, 0,
+        0, 0, 133, 133, 0, 0, 0, 0, 23, 23,
+        23, 23, 0, 0, 0, 0, 83, 60, 0, 1,
+        1, 288, 288, 289, 289, 290, 290, 290, 289, 288,
+        288, 289, 289, 290, 290, 290, 289, 288, 288, 289,
+        289, 290, 290, 290, 289, 288, 288, 289, 289, 290,
+        290, 290, 289, 288, 288, 289, 289, 290, 290, 290,
+        289, 288, 288, 289, 289, 290, 290, 290, 290, 290,
+        290, 290, 290, 290, 290, 290, 290, 1, 1, 84,
+        18, 0, 1, 1, 227, 227, 228, 228, 229, 229,
+        228, 228, 227, 227, 226, 226, 227, 227, 1, 1,
+        0
+        };
+
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Text.java

@@ -0,0 +1,305 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import com.openeggbert.jdotnet.System.string;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.ref;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.static_;
+
+// WindowsPhoneSpeedyBlupi.Text
+
+    @namespace(name = "WindowsPhoneSpeedyBlupi")
+    @static_
+    public class Text
+    {
+        private Text() {
+            //Not meant to be instantiated;
+        }
+        private static short[] table_char = new short[]
+        {
+        0, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 2, 0, 0, -1, 0, 0, 3, 0,
+        0, -1, 0, 0, 4, 0, 0, -1, 0, 0,
+        5, 0, 0, -1, 0, 0, 6, 0, 0, -1,
+        0, 0, 7, 0, 0, -1, 0, 0, 8, 0,
+        0, -1, 0, 0, 9, 0, 0, -1, 0, 0,
+        10, 0, 0, -1, 0, 0, 11, 0, 0, -1,
+        0, 0, 12, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 14, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 32, 0, 0, -1, 0, 0, 33, 0,
+        0, -1, 0, 0, 34, 0, 0, -1, 0, 0,
+        35, 0, 0, -1, 0, 0, 36, 0, 0, -1,
+        0, 0, 37, 0, 0, -1, 0, 0, 38, 0,
+        0, -1, 0, 0, 39, 0, 0, -1, 0, 0,
+        40, 0, 0, -1, 0, 0, 41, 0, 0, -1,
+        0, 0, 42, 0, 0, -1, 0, 0, 43, 0,
+        0, -1, 0, 0, 44, 0, 0, -1, 0, 0,
+        45, 0, 0, -1, 0, 0, 46, 0, 0, -1,
+        0, 0, 47, 0, 0, -1, 0, 0, 48, 0,
+        0, -1, 0, 0, 49, 0, 0, -1, 0, 0,
+        50, 0, 0, -1, 0, 0, 51, 0, 0, -1,
+        0, 0, 52, 0, 0, -1, 0, 0, 53, 0,
+        0, -1, 0, 0, 54, 0, 0, -1, 0, 0,
+        55, 0, 0, -1, 0, 0, 56, 0, 0, -1,
+        0, 0, 57, 0, 0, -1, 0, 0, 58, 0,
+        0, -1, 0, 0, 59, 0, 0, -1, 0, 0,
+        60, 0, 0, -1, 0, 0, 61, 0, 0, -1,
+        0, 0, 62, 0, 0, -1, 0, 0, 63, 0,
+        0, -1, 0, 0, 64, 0, 0, -1, 0, 0,
+        65, 0, 0, -1, 0, 0, 66, 0, 0, -1,
+        0, 0, 67, 0, 0, -1, 0, 0, 68, 0,
+        0, -1, 0, 0, 69, 0, 0, -1, 0, 0,
+        70, 0, 0, -1, 0, 0, 71, 0, 0, -1,
+        0, 0, 72, 0, 0, -1, 0, 0, 73, 0,
+        0, -1, 0, 0, 74, 0, 0, -1, 0, 0,
+        75, 0, 0, -1, 0, 0, 76, 0, 0, -1,
+        0, 0, 77, 0, 0, -1, 0, 0, 78, 0,
+        0, -1, 0, 0, 79, 0, 0, -1, 0, 0,
+        80, 0, 0, -1, 0, 0, 81, 0, 0, -1,
+        0, 0, 82, 0, 0, -1, 0, 0, 83, 0,
+        0, -1, 0, 0, 84, 0, 0, -1, 0, 0,
+        85, 0, 0, -1, 0, 0, 86, 0, 0, -1,
+        0, 0, 87, 0, 0, -1, 0, 0, 88, 0,
+        0, -1, 0, 0, 89, 0, 0, -1, 0, 0,
+        90, 0, 0, -1, 0, 0, 91, 0, 0, -1,
+        0, 0, 92, 0, 0, -1, 0, 0, 93, 0,
+        0, -1, 0, 0, 94, 0, 0, -1, 0, 0,
+        95, 0, 0, -1, 0, 0, 96, 0, 0, -1,
+        0, 0, 97, 0, 0, -1, 0, 0, 98, 0,
+        0, -1, 0, 0, 99, 0, 0, -1, 0, 0,
+        100, 0, 0, -1, 0, 0, 101, 0, 0, -1,
+        0, 0, 102, 0, 0, -1, 0, 0, 103, 0,
+        0, -1, 0, 0, 104, 0, 0, -1, 0, 0,
+        105, 0, 0, -1, 0, 0, 106, 0, 0, -1,
+        0, 0, 107, 0, 0, -1, 0, 0, 108, 0,
+        0, -1, 0, 0, 109, 0, 0, -1, 0, 0,
+        110, 0, 0, -1, 0, 0, 111, 0, 0, -1,
+        0, 0, 112, 0, 0, -1, 0, 0, 113, 0,
+        0, -1, 0, 0, 114, 0, 0, -1, 0, 0,
+        115, 0, 0, -1, 0, 0, 116, 0, 0, -1,
+        0, 0, 117, 0, 0, -1, 0, 0, 118, 0,
+        0, -1, 0, 0, 119, 0, 0, -1, 0, 0,
+        120, 0, 0, -1, 0, 0, 121, 0, 0, -1,
+        0, 0, 122, 0, 0, -1, 0, 0, 123, 0,
+        0, -1, 0, 0, 124, 0, 0, -1, 0, 0,
+        125, 0, 0, -1, 0, 0, 126, 0, 0, -1,
+        0, 0, 127, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 5, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 4, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 16, 0, 0, -1, 0, 0,
+        97, 0, 0, 2, 2, 0, 17, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 27, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 29, 0, 0, -1,
+        0, 0, 19, 0, 0, -1, 0, 0, 18, 0,
+        0, -1, 0, 0, 21, 0, 0, -1, 0, 0,
+        20, 0, 0, -1, 0, 0, 1, 0, 0, -1,
+        0, 0, 105, 0, 0, 2, -1, 0, 23, 0,
+        0, -1, 0, 0, 22, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 110, 0, 0, 126,
+        -1, 0, 1, 0, 0, -1, 0, 0, 111, 0,
+        0, 2, 1, 0, 24, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0, 28, 0, 0, -1,
+        0, 0, 1, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 25, 0, 0, -1, 0, 0,
+        117, 0, 0, 2, 2, 0, 26, 0, 0, -1,
+        0, 0, 15, 0, 0, -1, 0, 0, 1, 0,
+        0, -1, 0, 0, 1, 0, 0, -1, 0, 0,
+        1, 0, 0, -1, 0, 0
+        };
+
+        private static short[] table_accents = new short[]
+        {
+        252, 224, 226, 233, 232, 235, 234, 239, 238, 244,
+        249, 251, 228, 246, 231
+        };
+
+        private static short[] table_width = new short[]
+        {
+        32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+        32, 32, 32, 32, 14, 13, 15, 15, 15, 15,
+        15, 15, 11, 12, 14, 13, 13, 15, 15, 14,
+        0, 0, 9, 5, 10, 25, 17, 22, 18, 5,
+        9, 9, 14, 13, 6, 10, 6, 14, 18, 10,
+        14, 14, 17, 16, 16, 17, 15, 16, 5, 6,
+        9, 12, 10, 14, 25, 18, 16, 17, 18, 16,
+        16, 19, 20, 15, 15, 15, 14, 24, 22, 22,
+        15, 24, 16, 18, 15, 19, 18, 29, 20, 18,
+        19, 8, 13, 8, 12, 20, 7, 15, 15, 13,
+        15, 15, 13, 14, 14, 6, 8, 14, 6, 21,
+        16, 14, 14, 13, 12, 14, 11, 13, 13, 19,
+        16, 15, 14, 10, 5, 11, 16, 0
+        };
+
+        public static void DrawTextLeft(Pixmap pixmap, TinyPoint pos, String text, double size)
+        {
+            if (!string.IsNullOrEmpty(text))
+            {
+                DrawText(pixmap, pos, text, size);
+            }
+        }
+
+        public static void DrawText(Pixmap pixmap, TinyPoint pos, String text, double size)
+        {
+            if (!string.IsNullOrEmpty(text))
+            {
+                for (char car : text.toCharArray())
+                {
+                    DrawChar(pixmap, pos, car, size);
+                }
+            }
+        }
+
+        public static void DrawTextPente(Pixmap pixmap, TinyPoint pos, String text, int pente, double size)
+        {
+            if (!string.IsNullOrEmpty(text))
+            {
+                int y = pos.Y;
+                int num = 0;
+                for (char c : text.toCharArray())
+                {
+                    int charWidth = GetCharWidth(c, size);
+                    DrawChar(pixmap, pos, c, size);
+                    num += charWidth;
+                    pos.Y = y + num / pente;
+                }
+            }
+        }
+
+        public static void DrawTextCenter(Pixmap pixmap, TinyPoint pos, String text, double size)
+        {
+            if (!string.IsNullOrEmpty(text))
+            {
+                 TinyPoint pos2 = default_(new TinyPoint());
+                pos2.X = pos.X - GetTextWidth(text, size) / 2;
+                pos2.Y = pos.Y;
+                DrawText(pixmap, pos2, text, size);
+            }
+        }
+
+        public static int GetTextWidth(String text, double size)
+        {
+            if (string.IsNullOrEmpty(text))
+            {
+                return 0;
+            }
+            int num = 0;
+            for (char c : text.toCharArray())
+            {
+                num += GetCharWidth(c, size);
+            }
+            return num;
+        }
+
+        private static int GetOffset(char c)
+        {
+            for (int i = 0; i < 15; i++)
+            {
+                if ((short)c == table_accents[i])
+                {
+                    return 15 + i;
+                }
+            }
+            if (c < '\0' || c > '\u0080')
+            {
+                return 1;
+            }
+            return c;
+        }
+
+        private static void DrawChar(Pixmap pixmap, @ref TinyPoint pos, char car, double size)
+        {
+             TinyPoint pos2 = default_(new TinyPoint());
+            int num = (short)car * 6;
+            int rank = table_char[num];
+            pos2.X = pos.X + table_char[num + 1];
+            pos2.Y = pos.Y + table_char[num + 2];
+            DrawCharSingle(pixmap, pos2, rank, size);
+            rank = table_char[num + 3];
+            if (rank != -1)
+            {
+                pos2.X = pos.X + table_char[num + 4];
+                pos2.Y = pos.Y + table_char[num + 5];
+                DrawCharSingle(pixmap, pos2, rank, size);
+            }
+            pos.X += GetCharWidth(car, size);
+        }
+
+        private static int GetCharWidth(char c, double size)
+        {
+            return (int)((double)(table_width[table_char[(short)c * 6]] + 1) * size);
+        }
+
+        private static void DrawCharSingle(Pixmap pixmap, TinyPoint pos, int rank, double size)
+        {
+            pixmap.DrawChar(rank, pos, size);
+        }
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/TinyPoint.java

@@ -0,0 +1,35 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+
+// WindowsPhoneSpeedyBlupi.TinyPoint
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+@AllArgsConstructor
+@NoArgsConstructor
+public class TinyPoint extends com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.struct<TinyPoint> {
+
+    public int X;
+
+    public int Y;
+
+    @Override
+    public String toString() {
+        return X + ";" + Y;
+    }
+
+    @Override
+    public TinyPoint copy() {
+        return new TinyPoint(X, Y);
+    }
+    
+
+    @Override
+    public TinyPoint reset() {
+        this.X = 0;
+        this.Y = 0;
+        return this;
+    }
+}

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/TinyRect.java

@@ -0,0 +1,46 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439\
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import lombok.ToString;
+
+// WindowsPhoneSpeedyBlupi.TinyRect
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class TinyRect extends com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.struct<TinyRect> {
+
+    public int Left;
+
+    public int Right;
+
+    public int Top;
+
+    public int Bottom;
+
+    public int Width() {
+        return Right - Left;
+    }
+
+    public int Height() {
+        return Bottom - Top;
+
+    }
+
+    @Override
+    public TinyRect copy() {
+        return new TinyRect(Left, Right, Top, Bottom);
+    }
+
+    @Override
+    public TinyRect reset() {
+        this.Left = 0;
+        this.Right = 0;
+        this.Top = 0;
+        this.Bottom = 0;
+        return this;
+    }
+}

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/TrialMode.java

@@ -0,0 +1,75 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+//import com.openeggbert.jdotnet.System.*;
+//import com.openeggbert.jdotnet.System.IO.*;
+
+
+
+    public class TrialMode
+    {
+
+    static boolean IsTrialModeEnabled() {
+        throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
+    }
+//        private static DateTime trialStartTime;
+//
+//        public static void InitializeTrialMode()
+//        {
+//            // Assuming trial mode starts when the game is launched
+//            trialStartTime = DateTime.Now;
+//        }
+//
+//        public static Boolean IsTrialModeExpired()
+//        {
+//            return IsTrialMode7DaysLimitExpired() || IsTrialMode10MinutesLimitExpired();
+//        }
+//        private static boolean IsTrialMode10MinutesLimitExpired()
+//        {
+//            // Example: Trial expires after 10 minutes
+//            var expired = (DateTime.Now - trialStartTime).TotalMinutes > 10;
+//            return expired;
+//        }
+//        private static boolean IsTrialMode7DaysLimitExpired()
+//        {
+//            // Save trial expiration status to a file or settings
+//            const string TRIAL_END_TIME_TXT = "trialEndTime.txt";
+//            var trialEndTime = File.Exists(TRIAL_END_TIME_TXT) ? DateTime.Parse(File.ReadAllText(TRIAL_END_TIME_TXT)) : DateTime.MinValue;
+//
+//            var expired = trialEndTime != DateTime.MinValue && DateTime.Now > trialEndTime;
+//            if (expired)
+//            {
+//                return true;  // Trial period is over
+//            }
+//
+//            // Example of setting trial end time (e.g., 7 days from now)
+//            if (!File.Exists(TRIAL_END_TIME_TXT))
+//            {
+//                File.WriteAllText(TRIAL_END_TIME_TXT, DateTime.Now.AddDays(7).ToString());
+//            }
+//
+//            return false;  // Trial period still active
+//        }
+//        private static int trialModeEnabled = -1;
+//        public static boolean IsTrialModeEnabled()
+//        {
+//            if(trialModeEnabled == 1)
+//            {
+//                return true;
+//            }
+//
+//            if (trialModeEnabled == 0)
+//            {
+//                return false;
+//            }
+//            
+//            const string TRIAL_MODE_ENABLED_TXT = "trialModeEnabled.txt";
+//            var trialModeEnabledString = File.Exists(TRIAL_MODE_ENABLED_TXT) ? File.ReadAllText(TRIAL_MODE_ENABLED_TXT) : "0";
+//            var trialModeEnabledLocal = trialModeEnabledString.Equals("1");
+//            trialModeEnabled = trialModeEnabledLocal ? 1 : 0;
+//
+//            return trialModeEnabledLocal;
+//        }
+
+
+    }
+

core/src/main/java/com/openeggbert/core/phone/WindowsPhoneSpeedyBlupi/Worlds.java

@@ -0,0 +1,472 @@
+package com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi;
+
+// WindowsPhoneSpeedyBlupi, Version=1.0.0.5, Culture=neutral, PublicKeyToken=6db12cd62dbec439
+// WindowsPhoneSpeedyBlupi.Worlds
+import com.openeggbert.jdotnet.System.*;
+import com.openeggbert.jdotnet.System.Diagnostics.*;
+import com.openeggbert.jdotnet.System.Globalization.*;
+import com.openeggbert.jdotnet.System.IO.*;
+import com.openeggbert.jdotnet.System.IO.IsolatedStorage.*;
+import com.openeggbert.jdotnet.System.Text.*;
+import com.openeggbert.jxna.Microsoft.Xna.Framework.*;
+import com.openeggbert.core.phone.WindowsPhoneSpeedyBlupi.*;
+import static com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.default_.default_;
+import java.util.Locale;
+import lombok.Getter;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.namespace;
+import com.openeggbert.jdotnet.JDotNet.CSharpKeyWords.static_;
+
+
+
+@namespace(name = "WindowsPhoneSpeedyBlupi")
+@static_
+    public class Worlds
+    {
+    private Worlds() {
+        //Not meant to be instantiated.
+    }
+        private static StringBuilder output = new StringBuilder();
+
+        @Getter
+        private static final String GameDataFilename = "SpeedyBlupi";
+
+        @Getter
+        private static final String CurrentGameFilename = "CurrentGame";
+
+        public static String[] ReadWorld(int gamer, int rank)
+        {
+            String worldFilename = GetWorldFilename(gamer, rank);
+            String text = null;
+            try
+            {
+                Stream stream = TitleContainer.OpenStream(worldFilename);
+                StreamReader streamReader = new StreamReader(stream);
+                text = streamReader.ReadToEnd();
+                stream.Close();
+            }
+            catch (Exception_ e)
+            {
+                Debug.Write("Fatal error. Loading world failed: " + worldFilename + "\n");
+                Environment.Exit(1);
+            }
+            if (text == null)
+            {
+                return null;
+            }
+            return text.split("\n");
+        }
+
+        private static String GetWorldFilename(int gamer, int rank)
+        {
+            return string.Format("worlds/world{0}.txt", int_.of(rank).ToString("d3"));
+        }
+
+        public static boolean ReadGameData(byte[] data)
+        {
+            IsolatedStorageFile userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication();
+            if (userStoreForApplication.FileExists(GameDataFilename))
+            {
+                IsolatedStorageFileStream isolatedStorageFileStream = null;
+                try
+                {
+                    isolatedStorageFileStream = userStoreForApplication.OpenFile(GameDataFilename, FileMode.Open);
+                }
+                catch (IsolatedStorageException e)
+                {
+                    return false;
+                }
+                if (isolatedStorageFileStream != null)
+                {
+                    int count = Math_.Min(data.length, (int)isolatedStorageFileStream.Length);
+                    isolatedStorageFileStream.Read(data, 0, count);
+                    isolatedStorageFileStream.Close();
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static void WriteGameData(byte[] data)
+        {
+            IsolatedStorageFile userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication();
+            IsolatedStorageFileStream isolatedStorageFileStream = userStoreForApplication.OpenFile(GameDataFilename, FileMode.Create);
+            if (isolatedStorageFileStream != null)
+            {
+                isolatedStorageFileStream.Write(data, 0, data.length);
+                isolatedStorageFileStream.Close();
+            }
+        }
+
+        public static void DeleteCurrentGame()
+        {
+            IsolatedStorageFile userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication();
+            try
+            {
+                userStoreForApplication.DeleteFile(CurrentGameFilename);
+            }
+            catch (Exception_ e)
+            {
+            }
+        }
+
+        public static String ReadCurrentGame()
+        {
+            IsolatedStorageFile userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication();
+            if (userStoreForApplication.FileExists(CurrentGameFilename))
+            {
+                IsolatedStorageFileStream isolatedStorageFileStream = null;
+                try
+                {
+                    isolatedStorageFileStream = userStoreForApplication.OpenFile(CurrentGameFilename, FileMode.Open);
+                }
+                catch (IsolatedStorageException e)
+                {
+                    return null;
+                }
+                if (isolatedStorageFileStream != null)
+                {
+                    byte[] array = new byte[isolatedStorageFileStream.Length];
+                    isolatedStorageFileStream.Read(array, 0, array.length);
+                    isolatedStorageFileStream.Close();
+                    return Encoding.UTF8.GetString(array, 0, array.length);
+                }
+            }
+            return null;
+        }
+
+        public static void WriteCurrentGame(String data)
+        {
+            IsolatedStorageFile userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication();
+            IsolatedStorageFileStream isolatedStorageFileStream = userStoreForApplication.OpenFile(CurrentGameFilename, FileMode.Create);
+            if (isolatedStorageFileStream != null)
+            {
+                isolatedStorageFileStream.Write(Encoding.UTF8.GetBytes(data), 0, data.length());
+                isolatedStorageFileStream.Close();
+            }
+        }
+
+        public static void GetIntArrayField(String[] lines, String section, int rank, String name, int[] array)
+        {
+            for (String text : lines)
+            {
+                if (!text.startsWith(section + ":") || rank-- != 0)
+                {
+                    continue;
+                }
+                int num = text.indexOf(name + "=");
+                if (num == -1)
+                {
+                    break;
+                }
+                num += name.length() + 1;
+                int num2 = text.indexOf(" ", num);
+                if (num2 == -1)
+                {
+                    break;
+                }
+                String[] array2 = text.substring(num, num2 - num).split(",");
+                for (int j = 0; j < array2.length; j++)
+                {
+                 
+                    try {
+                        int result = Integer.parseInt(array2[j]);
+                        array[j] = result;
+                    } catch (NumberFormatException e) {
+                        array[j] = 0;
+
+                    }
+
+                }
+            }
+        }
+
+        public static boolean GetBoolField(String[] lines, String section, int rank, String name)
+        {
+            for (String text : lines)
+            {
+                if (text.startsWith(section + ":") && rank-- == 0)
+                {
+                    int num = text.indexOf(name + "=");
+                    if (num == -1)
+                    {
+                        return false;
+                    }
+                    num += name.length() + 1;
+                    int num2 = text.indexOf(" ", num);
+                    if (num2 == -1)
+                    {
+                        return false;
+                    }
+                    String value = text.substring(num, num2 - num);
+
+                    boolean result;
+                    try {
+                        result = Boolean.parseBoolean(value);
+                        return result;
+                    } catch (Exception_ e) {
+                        
+                    }
+                    return false;
+
+                }
+            }
+            return false;
+        }
+
+        public static int GetIntField(String[] lines, String section, int rank, String name)
+        {
+            for (String text : lines)
+            {
+                if (text.startsWith(section + ":") && rank-- == 0)
+                {
+                    int num = text.indexOf(name + "=");
+                    if (num == -1)
+                    {
+                        return 0;
+                    }
+                    num += name.length() + 1;
+                    int num2 = text.indexOf(" ", num);
+                    if (num2 == -1)
+                    {
+                        return 0;
+                    }
+                    String s = text.substring(num, num2 - num);
+                    try {
+                        return Integer.parseInt(s);
+                    } catch (NumberFormatException e) {
+                        return 0;
+                    }
+
+                }
+            }
+            return 0;
+        }
+
+        public static double GetDoubleField(String[] lines, String section, int rank, String name)
+        {
+            for (String text : lines)
+            {
+                if (text.startsWith(section + ":") && rank-- == 0)
+                {
+                    int num = text.indexOf(name + "=");
+                    if (num == -1)
+                    {
+                        return 0.0;
+                    }
+                    num += name.length() + 1;
+                    int num2 = text.indexOf(" ", num);
+                    if (num2 == -1)
+                    {
+                        return 0.0;
+                    }
+                    String s = text.substring(num, num2 - num);
+                    try {
+                        return Double.parseDouble(s);
+                    } catch (NumberFormatException e) {
+                        return 0.0;
+                    }
+
+                }
+            }
+            return 0.0;
+        }
+
+        public static TinyPoint GetPointField(String[] lines, String section, int rank, String name)
+        {
+            for (String text : lines)
+            {
+                if (text.startsWith(section + ":") && rank-- == 0)
+                {
+                    int num = text.indexOf(name + "=");
+                    if (num == -1)
+                    {
+                        return default_(new TinyPoint());
+                    }
+                    num += name.length() + 1;
+                    int num2 = text.indexOf(";", num);
+                    if (num2 == -1)
+                    {
+                        return default_(new TinyPoint());
+                    }
+                    int num3 = text.indexOf(" ", num);
+                    if (num3 == -1)
+                    {
+                        return default_(new TinyPoint());
+                    }
+                    String s = text.substring(num, num2 - num);
+                    String s2 = text.substring(num2 + 1, num3 - num2 - 1);
+                    int result;
+                    try {
+                        result = Integer.parseInt(s);
+                    } catch (NumberFormatException e) {
+                        return new TinyPoint();
+                    }
+                    int result2;
+                    try {
+                        result2 = Integer.parseInt(s2);
+                    } catch (NumberFormatException e) {
+                        return new TinyPoint();
+                    }
+
+                     TinyPoint result3 = default_(new TinyPoint());
+                    result3.X = result;
+                    result3.Y = result2;
+                    return result3;
+                }
+            }
+            /**/
+            return default_(new TinyPoint());
+        }
+
+    public static Integer GetDecorField(String[] lines, String section, int x, int y) {
+        for (int i = 0; i < lines.length; i++) {
+            String text = lines[i];
+            if (text.startsWith(section + ":")) {
+                text = lines[i + 1 + x];
+                String[] array = text.split(",");
+                if (string.IsNullOrEmpty(array[y])) {
+                    return -1;
+                }
+                try {
+                    return Integer.parseInt(array[y]);
+                } catch (NumberFormatException e) {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+
+        public static void GetDoorsField(String[] lines, String section, int[] doors)
+        {
+            for (String text : lines)
+            {
+                if (!text.startsWith(section + ":"))
+                {
+                    continue;
+                }
+                String[] array = text.substring(section.length() + 2).split(",");
+                for (int j = 0; j < array.length; j++)
+                {
+                    int result;
+                    if (string.IsNullOrEmpty(array[j]))
+                    {
+                        doors[j] = 1;
+                    }
+                    else {
+                        try {
+                            doors[j] = Integer.parseInt(array[j]);
+                        } catch (NumberFormatException e) {
+                        }
+                    }
+                    
+                }
+            }
+        }
+
+        public static void WriteClear()
+        {
+            output.setLength(0);
+        }
+
+        public static void WriteSection(String section)
+        {
+            output.append(section);
+            output.append(": ");
+        }
+
+        public static void WriteIntArrayField(String name, int[] array)
+        {
+            output.append(name);
+            output.append("=");
+            for (int i = 0; i < array.length; i++)
+            {
+                if (array[i] != 0)
+                {
+                    output.append(string.Format(Locale.US, "%s", array[i]));
+                }
+                if (i < array.length- 1)
+                {
+                    output.append(",");
+                }
+            }
+            output.append(" ");
+        }
+
+        public static void WriteBoolField(String name, boolean n)
+        {
+            output.append(name);
+            output.append("=");
+            output.append(string.Format(Locale.US, "%f", n));
+            output.append(" ");
+        }
+
+        public static void WriteIntField(String name, int n)
+        {
+            output.append(name);
+            output.append("=");
+            output.append(string.Format(Locale.US, "%f", n));
+            output.append(" ");
+        }
+
+        public static void WriteDoubleField(String name, double n)
+        {
+            output.append(name);
+            output.append("=");
+            output.append(string.Format(Locale.US, "%f", n));
+            output.append(" ");
+        }
+
+        public static void WritePointField(String name, TinyPoint p)
+        {
+            output.append(name);
+            output.append("=");
+            output.append(string.Format(Locale.US, "%f", p.X));
+            output.append(";");
+            output.append(string.Format(Locale.US, "%f", p.Y));
+            output.append(" ");
+        }
+
+        public static void WriteDecorField(int[] line)
+        {
+            for (int i = 0; i < line.length; i++)
+            {
+                if (line[i] != -1)
+                {
+                    output.append(string.Format(Locale.US, "%d", line[i]));
+
+                }
+                if (i < line.length - 1)
+                {
+                    output.append(",");
+                }
+            }
+            output.append("\n");
+        }
+
+        public static void WriteDoorsField(int[] doors)
+        {
+            for (int i = 0; i < doors.length; i++)
+            {
+                if (doors[i] != 1)
+                {
+                    output.append(string.Format(Locale.US, "%d", doors[i]));
+                }
+                if (i < doors.length - 1)
+                {
+                    output.append(",");
+                }
+            }
+            output.append("\n");
+        }
+
+        public static void WriteEndSection()
+        {
+            output.append("\n");
+        }
+
+        public static String GetWriteString()
+        {
+            return output.toString();
+        }
+    }

core/src/main/java/com/openeggbert/core/screen/AbstractGameScreen.java

@@ -21,11 +21,11 @@ package com.openeggbert.core.screen;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.InputAdapter;
-import com.pixelgamelibrary.api.graphics.Color;
+import com.openeggbert.pixel.framework.graphics.Color;
 
 import com.badlogic.gdx.utils.ScreenUtils;
 import com.openeggbert.core.main.OpenEggbertGame;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 
 /**
  *

core/src/main/java/com/openeggbert/core/screen/DemoScreen.java

@@ -21,11 +21,11 @@ package com.openeggbert.core.screen;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.InputAdapter;
-import com.pixelgamelibrary.api.graphics.Color;
+import com.openeggbert.pixel.framework.graphics.Color;
 
 import com.badlogic.gdx.utils.ScreenUtils;
 import com.openeggbert.core.main.OpenEggbertGame;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 import java.util.Optional;
 
 /**

core/src/main/java/com/openeggbert/core/screen/GameScreen.java

@@ -21,11 +21,11 @@ package com.openeggbert.core.screen;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.InputAdapter;
-import com.pixelgamelibrary.api.graphics.Color;
+import com.openeggbert.pixel.framework.graphics.Color;
 
 import com.badlogic.gdx.utils.ScreenUtils;
 import com.openeggbert.core.main.OpenEggbertGame;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 import java.util.Optional;
 
 /**

core/src/main/java/com/openeggbert/core/screen/GameSpaceListScreen.java

@@ -24,23 +24,23 @@ import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.Input;
 import com.badlogic.gdx.InputAdapter;
 import com.badlogic.gdx.Preferences;
-import com.pixelgamelibrary.api.graphics.Color;
+import com.openeggbert.pixel.framework.graphics.Color;
 
-import com.pixelgamelibrary.api.graphics.ShapeRenderer;
+import com.openeggbert.pixel.framework.graphics.ShapeRenderer;
 import com.openeggbert.core.gamespace.GameSpace;
 import com.openeggbert.core.main.OpenEggbertGame;
 import com.openeggbert.core.mod.Mod;
 import com.openeggbert.core.mod.ModType;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 import lombok.AllArgsConstructor;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
-import com.pixelgamelibrary.api.files.FileSystem;
-import com.pixelgamelibrary.api.graphics.Texture;
+import com.openeggbert.pixel.framework.files.FileSystem;
+import com.openeggbert.pixel.framework.graphics.Texture;
 
 /**
  *

core/src/main/java/com/openeggbert/core/screen/MainHubScreen.java

@@ -21,11 +21,11 @@ package com.openeggbert.core.screen;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.InputAdapter;
-import com.pixelgamelibrary.api.graphics.Color;
+import com.openeggbert.pixel.framework.graphics.Color;
 
 import com.badlogic.gdx.utils.ScreenUtils;
 import com.openeggbert.core.main.OpenEggbertGame;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 import java.util.Optional;
 
 /**

core/src/main/java/com/openeggbert/core/screen/OpenEggbertScreen.java

@@ -22,15 +22,15 @@ package com.openeggbert.core.screen;
 import com.openeggbert.core.gamespace.GameFileType;
 import com.openeggbert.core.main.OpenEggbertGame;
 import com.openeggbert.core.utils.OpenEggbertUtils;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.api.Platform;
-import com.pixelgamelibrary.api.app.LogLevel;
-import com.pixelgamelibrary.api.graphics.SpriteBatch;
-import com.pixelgamelibrary.api.graphics.Texture;
-import com.pixelgamelibrary.api.screen.ScreenAdapter;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.framework.Platform;
+import com.openeggbert.pixel.framework.app.LogLevel;
+import com.openeggbert.pixel.framework.graphics.SpriteBatch;
+import com.openeggbert.pixel.framework.graphics.Texture;
+import com.openeggbert.pixel.framework.screen.ScreenAdapter;
 import java.util.List;
 import java.util.Optional;
-import com.pixelgamelibrary.api.files.File;
+import com.openeggbert.pixel.framework.files.File;
 
 /**
  *

core/src/main/java/com/openeggbert/core/screen/SubHubScreen.java

@@ -21,11 +21,11 @@ package com.openeggbert.core.screen;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.InputAdapter;
-import com.pixelgamelibrary.api.graphics.Color;
+import com.openeggbert.pixel.framework.graphics.Color;
 
 import com.badlogic.gdx.utils.ScreenUtils;
 import com.openeggbert.core.main.OpenEggbertGame;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 import java.util.Optional;
 
 /**

core/src/main/java/com/openeggbert/core/screen/TestScreen.java

@@ -25,8 +25,8 @@ import com.badlogic.gdx.InputAdapter;
 
 import com.badlogic.gdx.utils.ScreenUtils;
 import com.openeggbert.core.main.OpenEggbertGame;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.api.graphics.BitmapFont;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.framework.graphics.BitmapFont;
 import java.util.function.Function;
 
 /**

gradle.properties

@@ -21,6 +21,8 @@ gdxVersion=1.12.1
 pixelVersion=0.0.0-SNAPSHOT
 gdxTeaVMVersion=1.0.3
 teaVMVersion=0.10.2
-netbeans.hint.jdkPlatform=JDK_17
+netbeans.hint.jdkPlatform=JDK_jdk-17.0.2_from__home_robertvokac_Desktop_jdk-17.0.2
 shapeDrawerVersion=2.6.0
 netbeans.org-netbeans-modules-javascript2-requirejs.enabled=true
+jdotnetVersion=0.0.0-SNAPSHOT
+jxnaVersion=0.0.0-SNAPSHOT

html/build.gradle

@@ -49,9 +49,16 @@ dependencies {
   implementation "de.golfgl.gdxcontrollerutils:gdx-controllerutils-mapping:$controllerMappingVersion:sources"
   
   implementation project(':core')
-  implementation "com.pixelgamelibrary:pixel:$pixelVersion:sources"
-  api "com.pixelgamelibrary:pixel-backend-libgdx:$pixelVersion"
-  implementation "com.pixelgamelibrary:pixel-backend-libgdx:$pixelVersion:sources"
+  implementation "com.openeggbert.pixel:pixel-framework:$pixelVersion:sources"
+  api "com.openeggbert.pixel:pixel-backend-libgdx:$pixelVersion"
+  implementation "com.openeggbert.pixel:pixel-backend-libgdx:$pixelVersion:sources"
+
+  implementation "com.openeggbert.jdotnet:jdotnet:$jdotnetVersion:sources"
+  api "com.openeggbert.jdotnet:jdotnet:$jdotnetVersion"
+
+  implementation "com.openeggbert.jxna:jxna:$jxnaVersion:sources"
+  api "com.openeggbert.jxna:jxna:$jxnaVersion"
+
   implementation("com.badlogicgames.gdx-controllers:gdx-controllers-gwt:$gdxControllersVersion:sources"){exclude group: "com.badlogicgames.gdx", module: "gdx-backend-gwt"}
   implementation("com.badlogicgames.gdx:gdx-box2d-gwt:$gdxVersion:sources") {exclude group: "com.google.gwt", module: "gwt-user"}
   implementation("com.github.crykn.guacamole:gdx-gwt:$guacamoleVersion:sources"){exclude group: "com.badlogicgames.gdx", module: "gdx-backend-gwt"}

html/src/main/java/com/openeggbert/GdxDefinition.gwt.xml

@@ -23,8 +23,10 @@
   <inherits name="com.github.czyzby.websocket.GdxWebSocketGwt" />
   <inherits name="com.github.czyzby.websocket.GdxWebSocketSerialization" />
   <inherits name="com.openeggbert.core.main.OpenEggbertApplication" />
-  <inherits name="com.pixelgamelibrary.pixelapi" />
-  <inherits name="com.pixelgamelibrary.backend.pixelbackendlibgdx" />
+  <inherits name="com.openeggbert.pixel.pixelframework" />
+  <inherits name="com.openeggbert.pixel.backend.pixelbackendlibgdx" />
+  <inherits name="com.openeggbert.jdotnet" />
+  <inherits name="com.openeggbert.jxna" />
   <inherits name="formic" />
   <inherits name="guacamole_gdx_gwt" />
   <inherits name="libgdx-utils" />

html/src/main/java/com/openeggbert/gwt/GwtLauncher.java

@@ -5,9 +5,9 @@ import com.badlogic.gdx.backends.gwt.GwtApplication;
 import com.badlogic.gdx.backends.gwt.GwtApplicationConfiguration;
 import com.openeggbert.core.configuration.VirtualScreenResolution;
 import com.openeggbert.core.main.OpenEggbertApplication;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.backend.libgdx.interfaces.PixelBackendLibGDX;
-import com.pixelgamelibrary.backend.libgdx.game.LibGdxGame;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.backend.libgdx.interfaces.PixelBackendLibGDX;
+import com.openeggbert.pixel.backend.libgdx.game.LibGdxGame;
 
 /** Launches the GWT application. */
 public class GwtLauncher extends GwtApplication {

lwjgl3/build.gradle

@@ -37,8 +37,8 @@ dependencies {
   implementation "games.rednblack.miniaudio:miniaudio:$miniaudioVersion:natives-desktop"
   
   implementation project(':core')
-  implementation "com.pixelgamelibrary:pixel:$pixelVersion"
-  implementation "com.pixelgamelibrary:pixel-backend-libgdx:$pixelVersion"
+  implementation "com.openeggbert.pixel:pixel-framework:$pixelVersion"
+  implementation "com.openeggbert.pixel:pixel-backend-libgdx:$pixelVersion"
   
   if(enableGraalNative == 'true') {
     implementation "io.github.berstanio:gdx-svmhelper-backend-lwjgl3:$graalHelperVersion"

lwjgl3/src/main/java/com/openeggbert/lwjgl3/Lwjgl3Launcher.java

@@ -25,11 +25,11 @@ import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration;
 import com.openeggbert.core.configuration.VirtualScreenResolution;
 import com.openeggbert.core.main.OpenEggbertApplication;
 import com.openeggbert.core.gamespace.GameSpace;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.backend.libgdx.interfaces.PixelBackendLibGDX;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.backend.libgdx.interfaces.PixelBackendLibGDX;
 import java.util.Optional;
-import com.pixelgamelibrary.api.game.Game;
-import com.pixelgamelibrary.backend.libgdx.game.LibGdxGame;
+import com.openeggbert.pixel.framework.game.Game;
+import com.openeggbert.pixel.backend.libgdx.game.LibGdxGame;
 
 /** Launches the desktop (LWJGL3) application. */
 public class Lwjgl3Launcher {

lwjgl3/src/main/java/com/openeggbert/lwjgl3/debugging/DebuggingAssetsTxt.java

@@ -19,9 +19,9 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.lwjgl3.debugging;
 
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.backend.libgdx.interfaces.PixelBackendLibGDX;
-import com.pixelgamelibrary.api.utils.AssetsTxt;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.backend.libgdx.interfaces.PixelBackendLibGDX;
+import com.openeggbert.pixel.framework.utils.AssetsTxt;
 import java.util.List;
 import java.util.Scanner;
 

lwjgl3/src/main/java/com/openeggbert/lwjgl3/debugging/DesktopCommandLineScanner.java

@@ -19,7 +19,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.lwjgl3.debugging;
 
-import com.pixelgamelibrary.api.files.shell.ShellScanner;
+import com.openeggbert.pixel.framework.files.shell.ShellScanner;
 import java.util.Scanner;
 
 /**

lwjgl3/src/main/java/com/openeggbert/lwjgl3/debugging/DesktopStorageCommandLineScanner.java

@@ -19,9 +19,9 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 package com.openeggbert.lwjgl3.debugging;
 
-import com.pixelgamelibrary.api.files.shell.ShellCommandLine;
-import com.pixelgamelibrary.api.files.shell.ShellCommandLineScanner;
-import com.pixelgamelibrary.api.files.map.MemoryFileSystem;
+import com.openeggbert.pixel.framework.files.shell.ShellCommandLine;
+import com.openeggbert.pixel.framework.files.shell.ShellCommandLineScanner;
+import com.openeggbert.pixel.framework.files.map.MemoryFileSystem;
 
 /**
  *

teavm/build.gradle

@@ -27,9 +27,9 @@ dependencies {
   implementation "org.teavm:teavm-jso:$teaVMVersion"
   implementation "org.teavm:teavm-tooling:$teaVMVersion"
   implementation project(':core')
-  implementation "com.pixelgamelibrary:pixel:$pixelVersion:sources"
-  api "com.pixelgamelibrary:pixel-backend-libgdx:$pixelVersion"
-  implementation "com.pixelgamelibrary:pixel-backend-libgdx:$pixelVersion:sources"
+  implementation "com.openeggbert.pixel:pixel-framework:$pixelVersion:sources"
+  api "com.openeggbert.pixel:pixel-backend-libgdx:$pixelVersion"
+  implementation "com.openeggbert.pixel:pixel-backend-libgdx:$pixelVersion:sources"
 
 }
 

teavm/src/main/java/com/openeggbert/teavm/TeaVMLauncher.java

@@ -3,9 +3,9 @@ package com.openeggbert.teavm;
 import com.github.xpenatan.gdx.backends.teavm.TeaApplicationConfiguration;
 import com.github.xpenatan.gdx.backends.teavm.TeaApplication;
 import com.openeggbert.core.main.OpenEggbertApplication;
-import com.pixelgamelibrary.api.Pixel;
-import com.pixelgamelibrary.backend.libgdx.interfaces.PixelBackendLibGDX;
-import com.pixelgamelibrary.backend.libgdx.game.LibGdxGame;
+import com.openeggbert.pixel.framework.Pixel;
+import com.openeggbert.pixel.backend.libgdx.interfaces.PixelBackendLibGDX;
+import com.openeggbert.pixel.backend.libgdx.game.LibGdxGame;
 
 /**
  * Launches the TeaVM/HTML application.