initial

68 files changed, 12669 insertions, 0 deletions

diff --git a/src/org/happysanta/gd/API/API.java b/src/org/happysanta/gd/API/API.java
new file mode 100755
index 0000000..8e1ee0d
--- /dev/null
+++ b/src/org/happysanta/gd/API/API.java
@@ -0,0 +1,101 @@
+package org.happysanta.gd.API;
+
+import org.apache.http.NameValuePair;
+import org.apache.http.message.BasicNameValuePair;
+
+import java.io.*;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.happysanta.gd.Helpers.getDeviceName;
+
+public class API {
+
+	public static final String URL = "http://gdtr.net/api.php";
+	public static final String DEBUG_URL = "http://dev.gdtr.net/api.php";
+	public static final String MRG_URL = "http://gdtr.net/mrg/%d.mrg";
+	public static final int VERSION = 2;
+
+	public static Request getLevels(int offset, int limit, LevelsSortType sort, ResponseHandler handler)
+			throws Exception {
+		List<NameValuePair> params = new LinkedList<NameValuePair>();
+		params.add(new BasicNameValuePair("sort", sort.toString()));
+		params.add(new BasicNameValuePair("offset", String.valueOf(offset)));
+		params.add(new BasicNameValuePair("limit", String.valueOf(limit)));
+
+		return new Request("getLevels", params, handler);
+	}
+
+	public static Request getNotifications(boolean installedFromAPK, ResponseHandler handler) {
+		List<NameValuePair> params = new LinkedList<NameValuePair>();
+		params.add(new BasicNameValuePair("apk", String.valueOf(installedFromAPK ? 1 : 0)));
+		return new Request("getNotifications", params, handler);
+	}
+
+	public static Request sendStats(String statsJSON, String installationID, int useCheats, ResponseHandler handler) {
+		List<NameValuePair> params = new LinkedList<NameValuePair>();
+		params.add(new BasicNameValuePair("stats", statsJSON));
+		params.add(new BasicNameValuePair("id", installationID));
+		params.add(new BasicNameValuePair("use_cheats", String.valueOf(useCheats)));
+		return new Request("sendStats", params, handler);
+	}
+
+	public static Request sendKeyboardLogs(String log, ResponseHandler handler) {
+		List<NameValuePair> params = new LinkedList<NameValuePair>();
+		params.add(new BasicNameValuePair("log", log));
+		params.add(new BasicNameValuePair("device", getDeviceName()));
+		return new Request("sendKeyboardLogs", params, handler, true);
+	}
+
+	public static DownloadFile downloadMrg(long id, FileOutputStream output, DownloadHandler handler) {
+		return new DownloadFile(String.format(MRG_URL, id), output, handler);
+	}
+
+	public static String getMrgURL(long id) {
+		return String.format(MRG_URL, id);
+	}
+
+	public static enum LevelsSortType {
+		POPULAR("popular"), TRACKS("tracks"), RECENT("recent"), OLDEST("oldest");
+
+		private final String text;
+
+		private LevelsSortType(final String text) {
+			this.text = text;
+		}
+
+		@Override
+		public String toString() {
+			return text;
+		}
+	}
+
+	public static LevelsSortType getSortTypeById(int id) {
+		switch (id) {
+			case 0:
+				return LevelsSortType.POPULAR;
+			case 1:
+				return LevelsSortType.RECENT;
+			case 2:
+				return LevelsSortType.OLDEST;
+			case 3:
+				return LevelsSortType.TRACKS;
+		}
+		return null;
+	}
+
+	public static int getIdBySortType(LevelsSortType type) {
+		switch (type) {
+			case POPULAR:
+				return 0;
+			case RECENT:
+				return 1;
+			case OLDEST:
+				return 2;
+			case TRACKS:
+				return 3;
+		}
+		return 0;
+	}
+
+}
diff --git a/src/org/happysanta/gd/API/APIException.java b/src/org/happysanta/gd/API/APIException.java
new file mode 100755
index 0000000..6cf2c14
--- /dev/null
+++ b/src/org/happysanta/gd/API/APIException.java
@@ -0,0 +1,9 @@
+package org.happysanta.gd.API;
+
+public class APIException extends java.lang.Exception {
+
+	public APIException(String message) {
+		super(message);
+	}
+
+}
diff --git a/src/org/happysanta/gd/API/DownloadFile.java b/src/org/happysanta/gd/API/DownloadFile.java
new file mode 100644
index 0000000..2920c27
--- /dev/null
+++ b/src/org/happysanta/gd/API/DownloadFile.java
@@ -0,0 +1,144 @@
+package org.happysanta.gd.API;
+
+import android.content.Context;
+import android.os.AsyncTask;
+import android.os.PowerManager;
+import org.apache.http.HttpException;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class DownloadFile {
+
+	private String urlString;
+	private DownloadHandler handler;
+	private FileOutputStream output;
+	private AsyncDownloadTask task;
+
+	public DownloadFile(String url, FileOutputStream output) {
+		this.urlString = url;
+		this.output = output;
+	}
+
+	public DownloadFile(String url, FileOutputStream output, DownloadHandler handler) {
+		this(url, output);
+		this.handler = handler;
+	}
+
+	public void setDownloadHandler(DownloadHandler handler) {
+		this.handler = handler;
+	}
+
+	public void start() {
+		task = new AsyncDownloadTask();
+		task.execute();
+	}
+
+	public void cancel() {
+		if (task != null) {
+			task.cancel(true);
+			task = null;
+		}
+	}
+
+	protected class AsyncDownloadTask extends AsyncTask<Void, Integer, Throwable> {
+
+		private PowerManager.WakeLock lock;
+
+		@Override
+		protected Throwable doInBackground(Void... params) {
+			// OutputStream output = (FileOutputStream)params[1];
+			InputStream input = null;
+			HttpURLConnection connection = null;
+
+			try {
+				URL url = new URL(urlString);
+				connection = (HttpURLConnection) url.openConnection();
+				connection.connect();
+
+				// expect HTTP 200 OK, so we don't mistakenly save error report
+				// instead of the file
+				if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
+					return new HttpException("Server returned HTTP " + connection.getResponseCode()
+							+ " " + connection.getResponseMessage());
+				}
+
+				// this will be useful to display download percentage
+				// might be -1: server did not report the length
+				int fileLength = connection.getContentLength();
+
+				// download the file
+				input = connection.getInputStream();
+
+				byte data[] = new byte[4096];
+				long total = 0;
+				int count;
+				while ((count = input.read(data)) != -1) {
+					// allow canceling with back button
+					if (isCancelled()) {
+						input.close();
+						return null;
+					}
+
+					total += count;
+
+					// publishing the progress....
+					if (fileLength > 0) // only if total length is known
+						publishProgress((int) (total * 100 / fileLength));
+
+					output.write(data, 0, count);
+				}
+			} catch (Exception e) {
+				return e;
+			} finally {
+				try {
+					if (output != null)
+						output.close();
+					if (input != null)
+						input.close();
+				} catch (IOException ignored) {
+				}
+
+				if (connection != null)
+					connection.disconnect();
+			}
+
+			return null;
+		}
+
+		@Override
+		protected void onPreExecute() {
+			super.onPreExecute();
+
+			// take CPU lock to prevent CPU from going off if the user
+			// presses the power button during download
+			PowerManager pm = (PowerManager) getGDActivity().getSystemService(Context.POWER_SERVICE);
+			lock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
+					getClass().getName());
+			lock.acquire();
+
+			handler.onStart();
+		}
+
+		@Override
+		protected void onProgressUpdate(Integer... progress) {
+			super.onProgressUpdate(progress);
+
+			handler.onProgress(progress[0]);
+		}
+
+		@Override
+		protected void onPostExecute(Throwable error) {
+			lock.release();
+			handler.onFinish(error);
+		}
+
+	}
+
+
+}
diff --git a/src/org/happysanta/gd/API/DownloadHandler.java b/src/org/happysanta/gd/API/DownloadHandler.java
new file mode 100644
index 0000000..ec43651
--- /dev/null
+++ b/src/org/happysanta/gd/API/DownloadHandler.java
@@ -0,0 +1,14 @@
+package org.happysanta.gd.API;
+
+/**
+ * Created by evgeny on 6/10/14.
+ */
+public interface DownloadHandler {
+
+	public abstract void onStart();
+
+	public abstract void onFinish(Throwable error);
+
+	public abstract void onProgress(int progress);
+
+}
\ No newline at end of file
diff --git a/src/org/happysanta/gd/API/LevelsResponse.java b/src/org/happysanta/gd/API/LevelsResponse.java
new file mode 100755
index 0000000..b62a6e6
--- /dev/null
+++ b/src/org/happysanta/gd/API/LevelsResponse.java
@@ -0,0 +1,64 @@
+package org.happysanta.gd.API;
+
+import org.happysanta.gd.Storage.Level;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Vector;
+
+public class LevelsResponse {
+
+	protected Level levels[] = null;
+	protected int totalCount = 0;
+
+	public LevelsResponse(Response response) {
+		parse(response);
+	}
+
+	protected void parse(Response response) {
+		JSONArray json = response.getJSON();
+		try {
+			JSONObject object = json.getJSONObject(1);
+			Vector<Level> levels = new Vector<>();
+			totalCount = object.getInt("count");
+			JSONArray items = object.getJSONArray("items");
+
+			try {
+				JSONObject item;
+				JSONArray tracks;
+				for (int i = 0; i < items.length(); i++) {
+					item = items.getJSONObject(i);
+					tracks = item.getJSONArray("tracks");
+
+					levels.addElement(new Level(
+							0,
+							item.getString("name"),
+							item.getJSONObject("author").getString("name"),
+							tracks.getInt(0),
+							tracks.getInt(1),
+							tracks.getInt(2),
+							item.getInt("added"),
+							item.getInt("size"),
+							item.getInt("id")
+					));
+				}
+			} catch (JSONException e) {
+				e.printStackTrace();
+			} finally {
+				this.levels = levels.toArray(new Level[0]);
+			}
+		} catch (JSONException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public int getTotalCount() {
+		return totalCount;
+	}
+
+	public Level[] getLevels() {
+		return levels;
+	}
+
+}
diff --git a/src/org/happysanta/gd/API/NotificationsResponse.java b/src/org/happysanta/gd/API/NotificationsResponse.java
new file mode 100644
index 0000000..06dca09
--- /dev/null
+++ b/src/org/happysanta/gd/API/NotificationsResponse.java
@@ -0,0 +1,76 @@
+package org.happysanta.gd.API;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class NotificationsResponse {
+
+	private String title;
+	private String message;
+	private String url;
+	private int buttonsCount = 1;
+	private String[] buttons = new String[2];
+	private boolean empty = true;
+	private boolean isURL = false;
+
+	public NotificationsResponse(Response response) {
+		parse(response);
+	}
+
+	protected void parse(Response response) {
+		JSONArray json = response.getJSON();
+		try {
+			JSONArray jsonResponse = json.getJSONArray(1);
+			if (jsonResponse.length() > 0) {
+				JSONObject notification = jsonResponse.getJSONObject(0);
+				title = notification.getString("title");
+				message = notification.getString("message");
+				buttons[0] = notification.getString("button_ok");
+				if (notification.has("button_cancel")) {
+					buttonsCount = 2;
+					buttons[1] = notification.getString("button_cancel");
+				}
+				if (notification.has("open_url")) {
+					url = notification.getString("open_url");
+					isURL = true;
+				}
+				empty = false;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public boolean isEmpty() {
+		return empty;
+	}
+
+	public boolean hasURL() {
+		return isURL;
+	}
+
+	public String getURL() {
+		return url;
+	}
+
+	public String getTitle() {
+		return title;
+	}
+
+	public String getMessage() {
+		return message;
+	}
+
+	public boolean hasTwoButtons() {
+		return buttonsCount == 2;
+	}
+
+	public String getOKButton() {
+		return buttons[0];
+	}
+
+	public String getCancelButton() {
+		return buttons[1];
+	}
+
+}
diff --git a/src/org/happysanta/gd/API/Request.java b/src/org/happysanta/gd/API/Request.java
new file mode 100644
index 0000000..d8bfa6e
--- /dev/null
+++ b/src/org/happysanta/gd/API/Request.java
@@ -0,0 +1,143 @@
+package org.happysanta.gd.API;
+
+import android.os.AsyncTask;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.message.BasicNameValuePair;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.util.List;
+import java.util.Locale;
+
+import static org.happysanta.gd.Helpers.getAppVersion;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class Request {
+
+	// enum Method { GET, POST };
+
+	private List<NameValuePair> params;
+	private ResponseHandler handler;
+	private AsyncRequestTask task;
+	private String apiURL;
+
+	public Request(String method, List<NameValuePair> params, ResponseHandler handler, boolean useDebugURL) {
+		construct(method, params, handler, useDebugURL ? API.DEBUG_URL : API.URL);
+	}
+
+	public Request(String method, List<NameValuePair> params, ResponseHandler handler) {
+		construct(method, params, handler, API.URL);
+	}
+
+	private void construct(String method, List<NameValuePair> params, ResponseHandler handler, String apiURL) {
+		this.apiURL = apiURL;
+
+		params.add(new BasicNameValuePair("v", String.valueOf(API.VERSION)));
+		params.add(new BasicNameValuePair("method", method));
+		params.add(new BasicNameValuePair("app_version", getAppVersion()));
+		params.add(new BasicNameValuePair("app_lang", Locale.getDefault().getDisplayLanguage()));
+
+		this.params = params;
+		this.handler = handler;
+
+		go();
+	}
+
+	private void go() {
+		task = new AsyncRequestTask();
+		task.execute(apiURL);
+	}
+
+	public void cancel() {
+		if (task != null) {
+			task.cancel(true);
+			task = null;
+		}
+	}
+
+	private void onDone(String result) {
+		Response response;
+		logDebug("API.Request.onDone()");
+
+		try {
+			response = new Response(result);
+		} catch (APIException e) {
+			handler.onError(e);
+			return;
+		} catch (Exception e) {
+			// e.printStackTrace();
+			handler.onError(new APIException(result == null ? "Network error" : "JSON parsing error"));
+			return;
+			// exception = new Exception();
+		}
+
+		// handler.onResponse(response);
+
+		if (response != null)
+			handler.onResponse(response);
+		else
+			handler.onError(new APIException("JSON parsing error"));
+	}
+
+	protected class AsyncRequestTask extends AsyncTask<String, Void, String> {
+
+		@Override
+		protected String doInBackground(String... objects) {
+			String url = objects[0];
+
+			DefaultHttpClient client = new DefaultHttpClient();
+			HttpPost post = new HttpPost(url);
+			try {
+				post.setEntity(new UrlEncodedFormEntity(params));
+			} catch (UnsupportedEncodingException e) {
+				e.printStackTrace();
+				return null;
+			}
+			String result = null;
+			InputStream is = null;
+
+			try {
+				HttpResponse response = client.execute(post);
+				HttpEntity entity = response.getEntity();
+				is = entity.getContent();
+
+				BufferedReader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"), 8);
+				StringBuilder sb = new StringBuilder();
+
+				String line;
+				while ((line = reader.readLine()) != null) {
+					if (isCancelled()) break;
+					sb.append(line + "\n");
+				}
+				result = sb.toString();
+			} catch (java.lang.Exception e) {
+				logDebug("API request failed: " + e.getMessage());
+				// e.printStackTrace();
+				return null;
+			} finally {
+				try {
+					if (is != null) is.close();
+				} catch (IOException e) {
+					// e.printStackTrace();
+				}
+			}
+
+			return result;
+		}
+
+		@Override
+		public void onPostExecute(String result) {
+			onDone(result);
+		}
+
+	}
+
+}
diff --git a/src/org/happysanta/gd/API/Response.java b/src/org/happysanta/gd/API/Response.java
new file mode 100644
index 0000000..827fae4
--- /dev/null
+++ b/src/org/happysanta/gd/API/Response.java
@@ -0,0 +1,26 @@
+package org.happysanta.gd.API;
+
+import org.happysanta.gd.API.*;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+public class Response {
+
+	JSONArray jsonArray;
+
+	public Response(String result) throws JSONException, APIException {
+		jsonArray = new JSONArray(result);
+		if (!isOK()) {
+			throw new APIException(jsonArray.getString(1));
+		}
+	}
+
+	public boolean isOK() throws JSONException {
+		return jsonArray.getString(0).equals("ok");
+	}
+
+	public JSONArray getJSON() {
+		return jsonArray;
+	}
+
+}
diff --git a/src/org/happysanta/gd/API/ResponseHandler.java b/src/org/happysanta/gd/API/ResponseHandler.java
new file mode 100755
index 0000000..7b39c99
--- /dev/null
+++ b/src/org/happysanta/gd/API/ResponseHandler.java
@@ -0,0 +1,9 @@
+package org.happysanta.gd.API;
+
+public interface ResponseHandler {
+
+	public void onResponse(Response response);
+
+	public void onError(APIException error);
+
+}
diff --git a/src/org/happysanta/gd/Callback.java b/src/org/happysanta/gd/Callback.java
new file mode 100644
index 0000000..a2a2c3f
--- /dev/null
+++ b/src/org/happysanta/gd/Callback.java
@@ -0,0 +1,7 @@
+package org.happysanta.gd;
+
+public interface Callback {
+
+	public abstract void onDone(Object... objects);
+
+}
diff --git a/src/org/happysanta/gd/Command.java b/src/org/happysanta/gd/Command.java
new file mode 100755
index 0000000..821ddc9
--- /dev/null
+++ b/src/org/happysanta/gd/Command.java
@@ -0,0 +1,11 @@
+package org.happysanta.gd;
+
+public class Command {
+
+	public String title;
+
+	public Command(String title, int unused1, int unused2) {
+		this.title = title;
+	}
+
+}
diff --git a/src/org/happysanta/gd/CommandListener.java b/src/org/happysanta/gd/CommandListener.java
new file mode 100755
index 0000000..7af87e8
--- /dev/null
+++ b/src/org/happysanta/gd/CommandListener.java
@@ -0,0 +1,7 @@
+package org.happysanta.gd;
+
+public interface CommandListener {
+
+	public void commandAction(Command cmd);
+
+}
diff --git a/src/org/happysanta/gd/DoubleCallback.java b/src/org/happysanta/gd/DoubleCallback.java
new file mode 100644
index 0000000..f7d6b7e
--- /dev/null
+++ b/src/org/happysanta/gd/DoubleCallback.java
@@ -0,0 +1,7 @@
+package org.happysanta.gd;
+
+public interface DoubleCallback extends Callback {
+
+	public abstract void onFail();
+
+}
diff --git a/src/org/happysanta/gd/FileDialog.java b/src/org/happysanta/gd/FileDialog.java
new file mode 100644
index 0000000..78b0326
--- /dev/null
+++ b/src/org/happysanta/gd/FileDialog.java
@@ -0,0 +1,209 @@
+package org.happysanta.gd;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Environment;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class FileDialog {
+	private static final String PARENT_DIR = "..";
+	private final String TAG = getClass().getName();
+	private String[] fileList;
+	private File currentPath;
+
+	public interface FileSelectedListener {
+		void fileSelected(File file);
+	}
+
+	public interface DirectorySelectedListener {
+		void directorySelected(File directory);
+	}
+
+	private ListenerList<FileSelectedListener> fileListenerList = new ListenerList<FileDialog.FileSelectedListener>();
+	private ListenerList<DirectorySelectedListener> dirListenerList = new ListenerList<FileDialog.DirectorySelectedListener>();
+	private final Activity activity;
+	private boolean selectDirectoryOption = false;
+	private String fileEndsWith;
+
+	public FileDialog(Activity activity, File path, String fileEndsWith) {
+		this.activity = activity;
+		this.fileEndsWith = fileEndsWith != null ? fileEndsWith.toLowerCase() : fileEndsWith;
+		if (!path.exists()) path = Environment.getExternalStorageDirectory();
+		// logDebug("FileDialog contrustor, path = " + path);
+		loadFileList(path);
+	}
+
+	/**
+	 * @return file dialog
+	 */
+	public Dialog createFileDialog() {
+		Dialog dialog = null;
+		AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+
+		builder.setTitle(currentPath.getPath());
+		if (selectDirectoryOption) {
+			builder.setPositiveButton("Select directory", new DialogInterface.OnClickListener() {
+				public void onClick(DialogInterface dialog, int which) {
+					Helpers.logDebug(currentPath.getParent());
+					// Log.d(TAG, currentPath.getPath());
+					fireDirectorySelectedEvent(currentPath);
+				}
+			});
+		}
+
+		builder.setItems(fileList, new DialogInterface.OnClickListener() {
+			public void onClick(DialogInterface dialog, int which) {
+				String fileChosen = fileList[which];
+				File chosenFile = getChosenFile(fileChosen);
+				if (chosenFile.isDirectory()) {
+					loadFileList(chosenFile);
+					dialog.cancel();
+					dialog.dismiss();
+					showDialog();
+				} else fireFileSelectedEvent(chosenFile);
+			}
+		});
+
+		dialog = builder.show();
+		return dialog;
+	}
+
+
+	public void addFileListener(FileSelectedListener listener) {
+		fileListenerList.add(listener);
+	}
+
+	public void removeFileListener(FileSelectedListener listener) {
+		fileListenerList.remove(listener);
+	}
+
+	public void setSelectDirectoryOption(boolean selectDirectoryOption) {
+		this.selectDirectoryOption = selectDirectoryOption;
+	}
+
+	public void addDirectoryListener(DirectorySelectedListener listener) {
+		dirListenerList.add(listener);
+	}
+
+	public void removeDirectoryListener(DirectorySelectedListener listener) {
+		dirListenerList.remove(listener);
+	}
+
+	/**
+	 * Show file dialog
+	 */
+	public void showDialog() {
+		createFileDialog().show();
+	}
+
+	private void fireFileSelectedEvent(final File file) {
+		fileListenerList.fireEvent(new ListenerList.FireHandler<FileSelectedListener>() {
+			public void fireEvent(FileSelectedListener listener) {
+				listener.fileSelected(file);
+			}
+		});
+	}
+
+	private void fireDirectorySelectedEvent(final File directory) {
+		dirListenerList.fireEvent(new ListenerList.FireHandler<DirectorySelectedListener>() {
+			public void fireEvent(DirectorySelectedListener listener) {
+				listener.directorySelected(directory);
+			}
+		});
+	}
+
+	private void loadFileList(File path) {
+		this.currentPath = path;
+
+		ArrayList<String> dirs = new ArrayList<>();
+		ArrayList<String> files = new ArrayList<>();
+		ArrayList<String> totalList = new ArrayList<>();
+
+		if (path.exists()) {
+			if (path.getParentFile() != null) dirs.add(PARENT_DIR);
+			FilenameFilter filter = new FilenameFilter() {
+				public boolean accept(File dir, String filename) {
+					File sel = new File(dir, filename);
+					if (!sel.canRead()) return false;
+					if (sel.isHidden()) return false;
+					if (selectDirectoryOption) return sel.isDirectory();
+					else {
+						boolean endsWith = fileEndsWith != null ? filename.toLowerCase().endsWith(fileEndsWith) : true;
+						return endsWith || sel.isDirectory();
+					}
+				}
+			};
+
+			File[] list = path.listFiles(filter);
+			try {
+				if (list != null && list.length > 0) {
+					for (File file : list) {
+						if (file.isDirectory())
+							dirs.add(file.getName() + "/");
+						else
+							files.add(file.getName());
+					}
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+
+			Comparator<String> comparator = new Comparator<String>() {
+				@Override
+				public int compare(String lhs, String rhs) {
+					return lhs.compareTo(rhs);
+				}
+			};
+
+			Collections.sort(dirs, comparator);
+			Collections.sort(files, comparator);
+
+			totalList.addAll(dirs);
+			totalList.addAll(files);
+		}
+
+		fileList = totalList.toArray(new String[]{});
+	}
+
+	private File getChosenFile(String fileChosen) {
+		if (fileChosen.equals(PARENT_DIR)) return currentPath.getParentFile();
+		else return new File(currentPath, fileChosen);
+	}
+}
+
+class ListenerList<L> {
+	private List<L> listenerList = new ArrayList<L>();
+
+	public interface FireHandler<L> {
+		void fireEvent(L listener);
+	}
+
+	public void add(L listener) {
+		listenerList.add(listener);
+	}
+
+	public void fireEvent(FireHandler<L> fireHandler) {
+		List<L> copy = new ArrayList<L>(listenerList);
+		for (L l : copy) {
+			fireHandler.fireEvent(l);
+		}
+	}
+
+	public void remove(L listener) {
+		listenerList.remove(listener);
+	}
+
+	public List<L> getListenerList() {
+		return listenerList;
+	}
+}
\ No newline at end of file
diff --git a/src/org/happysanta/gd/GDActivity.java b/src/org/happysanta/gd/GDActivity.java
new file mode 100755
index 0000000..88876a6
--- /dev/null
+++ b/src/org/happysanta/gd/GDActivity.java
@@ -0,0 +1,1177 @@
+package org.happysanta.gd;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.AlertDialog;
+import android.app.PendingIntent;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.graphics.Rect;
+import android.net.Uri;
+import android.os.Bundle;
+import android.text.Html;
+import android.view.*;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import org.happysanta.gd.API.*;
+import org.happysanta.gd.Game.*;
+import org.happysanta.gd.Levels.Loader;
+import org.happysanta.gd.Menu.Views.MenuHelmetView;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+import org.happysanta.gd.Menu.Views.MenuTitleLinearLayout;
+import org.happysanta.gd.Menu.Views.ObservableScrollView;
+import org.happysanta.gd.Storage.LevelsManager;
+import org.acra.util.Installation;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class GDActivity extends Activity implements Runnable {
+
+	public static GDActivity shared = null;
+	public static final int MENU_TITLE_LAYOUT_TOP_PADDING = 25;
+	public static final int MENU_TITLE_LAYOUT_BOTTOM_PADDING = 13;
+	public static final int MENU_TITLE_LAYOUT_X_PADDING = 30;
+	public static final int MENU_TITLE_FONT_SIZE = 30;
+	public static final int GAME_MENU_BUTTON_LAYOUT_WIDTH = 40;
+	public static final int GAME_MENU_BUTTON_LAYOUT_HEIGHT = 56;
+
+	private static final long IMAGES_DELAY = 1000L;
+	private static final long IMAGES_DELAY_DEBUG = 100L;
+
+	public int m_longI = 0;
+
+	private boolean wasPaused = false;
+	private boolean wasStarted = false;
+	private boolean wasDestroyed = false;
+	private boolean restartingStarted = false;
+	public boolean alive = false;
+	public boolean m_cZ = true;
+	private boolean menuShown = false;
+	public boolean fullResetting = false;
+	public boolean exiting = false;
+
+	public GameView gameView = null;
+	// public MenuView menuView = null;
+	public Loader levelLoader;
+	public Physics physEngine;
+	public org.happysanta.gd.Menu.Menu menu;
+	public boolean m_caseZ;
+	public int m_nullI;
+	public long m_forJ;
+	// public long seconds;
+	public long startedTime = 0;
+	public long finishedTime = 0;
+	public long pausedTime = 0;
+	public long pausedTimeStarted = 0;
+	public long m_byteJ;
+	public boolean inited = false;
+	public boolean m_ifZ;
+	private Thread thread;
+	private MenuImageView menuBtn;
+	public MenuTitleLinearLayout titleLayout;
+	public ObservableScrollView scrollView;
+	private FrameLayout frame;
+	private MenuLinearLayout menuLayout;
+	private KeyboardController keyboardController;
+	private boolean isNormalAndroid = true;
+	private boolean buttonCoordsCalculated = false;
+	public TextView menuTitleTextView;
+	private boolean menuReady = false;
+	private ArrayList<Command> commands = new ArrayList<Command>();
+	private MenuLinearLayout keyboardLayout;
+	private MenuTextView portedTextView;
+	private int buttonHeight = 60;
+	public LevelsManager levelsManager;
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		shared = this;
+
+		if (Helpers.isSDK10OrLower()) {
+			isNormalAndroid = false;
+		}
+
+		final GDActivity self = this;
+		Request request = API.getNotifications(Global.INSTALLED_FROM_APK, new ResponseHandler() {
+			@Override
+			public void onResponse(final Response apiResponse) {
+				try {
+					final NotificationsResponse response = new NotificationsResponse(apiResponse);
+					if (!response.isEmpty()) {
+						final Runnable onOk = new Runnable() {
+							@Override
+							public void run() {
+								if (response.hasURL()) {
+									String url = response.getURL();
+									try {
+										Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
+										startActivity(browserIntent);
+									} catch (Exception e) {
+										e.printStackTrace();
+									}
+								}
+							}
+						};
+
+						if (response.hasTwoButtons()) {
+							AlertDialog.Builder alert = new AlertDialog.Builder(self)
+									.setTitle(response.getTitle())
+									.setMessage(response.getMessage())
+									.setPositiveButton(response.getOKButton(), new DialogInterface.OnClickListener() {
+										@Override
+										public void onClick(DialogInterface dialog, int which) {
+											onOk.run();
+										}
+									})
+									.setNegativeButton(response.getCancelButton(), new DialogInterface.OnClickListener() {
+										@Override
+										public void onClick(DialogInterface dialog, int which) {
+										}
+									})
+									.setOnCancelListener(new DialogInterface.OnCancelListener() {
+										@Override
+										public void onCancel(DialogInterface dialog) {
+
+										}
+									});
+							alert.show();
+						} else {
+							AlertDialog alertDialog = new AlertDialog.Builder(self)
+									.setTitle(response.getTitle())
+									.setMessage(response.getMessage())
+									.setPositiveButton(response.getOKButton(), new DialogInterface.OnClickListener() {
+										@Override
+										public void onClick(DialogInterface dialog, int which) {
+											onOk.run();
+										}
+									})
+									.setOnCancelListener(new DialogInterface.OnCancelListener() {
+										@Override
+										public void onCancel(DialogInterface dialog) {
+										}
+									})
+									.create();
+							alertDialog.show();
+						}
+					}
+				} catch (Exception e) {
+					// e.printStackTrace();
+				}
+			}
+
+			@Override
+			public void onError(APIException error) {
+
+			}
+		});
+
+		if (true) {
+			gameView = new GameView(this);
+
+			getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+			scrollView = new ObservableScrollView(this);
+			scrollView.setBackgroundColor(0x00ffffff);
+			scrollView.setFillViewport(true);
+			scrollView.setOnScrollListener(new ObservableScrollView.OnScrollListener() {
+				@Override
+				public void onScroll(ObservableScrollView scrollView, int x, int y, int oldx, int oldy) {
+					if (isMenuShown() && menu != null && menu.currentMenu != null) {
+						int h = scrollView.getChildAt(0).getHeight() - scrollView.getHeight();
+						double p = 100.0 * y / h;
+						if (p > 100f)
+							p = 100f;
+
+						menu.currentMenu.onScroll(p);
+					}
+				}
+			});
+			scrollView.setVisibility(View.GONE);
+
+			frame = new FrameLayout(this);
+			frame.setBackgroundColor(0xffffffff);
+
+			titleLayout = new MenuTitleLinearLayout(this);
+			titleLayout.setBackgroundColor(0x00ffffff);
+			titleLayout.setGravity(Gravity.TOP);
+			titleLayout.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+			titleLayout.setPadding(Helpers.getDp(MENU_TITLE_LAYOUT_X_PADDING), Helpers.getDp(MENU_TITLE_LAYOUT_TOP_PADDING), Helpers.getDp(MENU_TITLE_LAYOUT_X_PADDING), Helpers.getDp(MENU_TITLE_LAYOUT_BOTTOM_PADDING));
+
+			menuTitleTextView = new TextView(this);
+			menuTitleTextView.setText(getString(R.string.main));
+			menuTitleTextView.setTextColor(0xff000000);
+			menuTitleTextView.setTypeface(Global.robotoCondensedTypeface);
+			menuTitleTextView.setTextSize(MENU_TITLE_FONT_SIZE);
+			menuTitleTextView.setLineSpacing(0f, 1.1f);
+			menuTitleTextView.setLayoutParams(new ViewGroup.LayoutParams(
+					ViewGroup.LayoutParams.MATCH_PARENT,
+					ViewGroup.LayoutParams.WRAP_CONTENT
+			));
+			menuTitleTextView.setVisibility(android.view.View.GONE);
+
+			titleLayout.addView(menuTitleTextView);
+
+			scrollView.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT, 1));
+
+			// Keyboard
+			String[] buttonResources = {
+					"btn_br", "btn_br", "btn_b",
+					"btn_br", "btn_br", "btn_b",
+					"btn_r", "btn_r", "btn_n"
+			};
+			if (getString(R.string.screen_type).equals("tablet")) {
+				buttonHeight = 85;
+			} else if (Global.density < 1.5) {
+				buttonHeight = 55;
+			}
+
+			keyboardLayout = new MenuLinearLayout(this, true);
+			keyboardLayout.setOrientation(LinearLayout.VERTICAL);
+
+			keyboardController = new KeyboardController(this);
+
+			for (int i = 0; i < 3; i++) {
+				LinearLayout row = new LinearLayout(this);
+				row.setPadding(Helpers.getDp(KeyboardController.PADDING), i == 0 ? Helpers.getDp(KeyboardController.PADDING) : 0, Helpers.getDp(KeyboardController.PADDING), 0);
+				row.setOrientation(LinearLayout.HORIZONTAL);
+				row.setBackgroundColor(0xc6ffffff);
+				for (int j = 0; j < 3; j++) {
+					LinearLayout btn = new LinearLayout(this);
+					TextView btnText = new TextView(this);
+					btnText.setText(String.valueOf(i * 3 + j + 1));
+					btnText.setTextColor(0xff000000);
+					btnText.setTextSize(17);
+					btn.setBackgroundResource(getResources().getIdentifier(buttonResources[i * 3 + j], "drawable", getPackageName()));
+					btn.addView(btnText, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+					btn.setGravity(Gravity.CENTER);
+					btn.setWeightSum(1);
+
+					row.addView(btn, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, Helpers.getDp(buttonHeight), 1));
+
+					keyboardController.addButton(btn, j, i);
+				}
+
+				keyboardLayout.addView(row);
+			}
+
+			keyboardLayout.setGravity(Gravity.BOTTOM);
+			keyboardLayout.setPadding(0, 0, 0, Helpers.getDp(KeyboardController.PADDING));
+			keyboardLayout.setOnTouchListener(keyboardController);
+			keyboardLayout.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.BOTTOM));
+
+			hideKeyboardLayout();
+
+			menuBtn = new MenuImageView(this);
+			menuBtn.setImageResource(R.drawable.ic_menu);
+			menuBtn.setScaleType(ImageView.ScaleType.CENTER);
+			menuBtn.setLayoutParams(new FrameLayout.LayoutParams(Helpers.getDp(GAME_MENU_BUTTON_LAYOUT_WIDTH), Helpers.getDp(GAME_MENU_BUTTON_LAYOUT_HEIGHT), Gravity.RIGHT | Gravity.TOP));
+			menuBtn.setOnClickListener(new android.view.View.OnClickListener() {
+				@Override
+				public void onClick(android.view.View v) {
+					gameView.showMenu();
+				}
+			});
+			menuBtn.setVisibility(android.view.View.GONE);
+
+			menuLayout = new MenuLinearLayout(this);
+			menuLayout.setOrientation(LinearLayout.VERTICAL);
+			menuLayout.setLayoutParams(new LinearLayout.LayoutParams(
+					LinearLayout.LayoutParams.MATCH_PARENT,
+					LinearLayout.LayoutParams.MATCH_PARENT
+			));
+
+			portedTextView = new MenuTextView(this);
+			portedTextView.setTypeface(Global.robotoCondensedTypeface);
+			portedTextView.setTextSize(15);
+			portedTextView.setLineSpacing(0f, 1.2f);
+			portedTextView.setText(Html.fromHtml(getString(R.string.ported_text)));
+			portedTextView.setGravity(Gravity.CENTER);
+			portedTextView.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.BOTTOM));
+			portedTextView.setPadding(0, 0, 0, Helpers.getDp(10));
+
+			menuLayout.addView(titleLayout);
+			menuLayout.addView(scrollView);
+
+			frame.addView(menuLayout);
+			frame.addView(keyboardLayout);
+			frame.addView(menuBtn);
+			frame.addView(portedTextView);
+
+			gameView.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT, 1));
+			frame.addView(gameView, 0);
+
+			setContentView(frame);
+
+			gameView._doIV(1); // flag for 1st image, as I understand..
+			thread = null;
+			m_caseZ = false;
+			m_nullI = 2;
+			m_forJ = 0;
+			m_byteJ = 0;
+			inited = false;
+			m_ifZ = false;
+			wasDestroyed = false;
+			restartingStarted = false;
+
+			frame.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+				@Override
+				public boolean onPreDraw() {
+					frame.getViewTreeObserver().removeOnPreDrawListener(this);
+					// setButtonsLayoutHeight();
+					doStart();
+					return true;
+				}
+			});
+
+
+
+		/* gameView.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+			@Override
+			public boolean onPreDraw() {
+				gameView.getViewTreeObserver().removeOnPreDrawListener(this);
+				doStart();
+				return true;
+			}
+		}); */
+
+			/* alive = true;
+			m_cZ = false;
+
+			Thread.currentThread().setName("main_thread");
+
+			if (thread == null) {
+				thread = new Thread(this);
+				thread.setName("game_thread");
+			} */
+
+			/*synchronized (thread) {
+				thread.start();
+				try {
+					thread.wait();
+				} catch (Throwable e) {
+					e.printStackTrace();
+				}
+			}
+
+			for (int i = 1; i <= 4; i++) {
+				menu.load(i);
+			}
+
+			wasStarted = true;*/
+		}
+	}
+
+	protected void doStart() {
+		alive = true;
+		m_cZ = false;
+
+		Thread.currentThread().setName("main_thread");
+
+		if (thread == null) {
+			thread = new Thread(this);
+			thread.setName("game_thread");
+			thread.start();
+		}
+
+		wasStarted = true;
+	}
+
+	// protected boolean viewDone = false;
+
+	@Override
+	public void run() {
+		Helpers.logDebug("!!! run()");
+		long l1;
+
+		if (!inited) {
+			Helpers.logDebug("run(): initing");
+			try {
+				// Game view
+				/* gameView = new GameView(shared);
+				gameView.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT, 1));
+				frame.addView(gameView, 0); */
+
+				/* gameView._doIV(1);
+				thread = null;
+				m_caseZ = false;
+				m_nullI = 2;
+				m_forJ = 0L;
+				seconds = 0L;
+				m_byteJ = 0L;
+				inited = false;
+				m_ifZ = false; */
+
+				long imageDelay = Global.DEBUG ? IMAGES_DELAY_DEBUG : IMAGES_DELAY; // delay of first image
+				Thread.yield();
+
+				/*gameView.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+					@Override
+					public boolean onPreDraw() {
+						gameView.getViewTreeObserver().removeOnPreDrawListener(this);
+						viewDone = true;
+						logDebug("gameView is ready");
+						//doStart();
+						return true;
+					}
+				});
+
+				logDebug("before while..");
+				while (!viewDone) {
+					// Thread.sleep(1);
+				}
+				logDebug("after while..");*/
+
+				// do we really need this?!
+				/*while (gameView == null || gameView.getParent() == null) {
+					try {
+						Thread.sleep(100);
+					} catch (Exception x) {}
+				}*/
+
+				MenuHelmetView.clearStaticFields();
+
+				levelsManager = new LevelsManager();
+				try {
+					levelLoader = new Loader(levelsManager.getCurrentLevelsFile());
+				} catch (IOException e) {
+					e.printStackTrace();
+					// logDebug("Reset level id now");
+					levelsManager.resetId();
+					levelsManager.reload();
+
+					levelLoader = new Loader(levelsManager.getCurrentLevelsFile());
+				}
+
+				physEngine = new Physics(levelLoader);
+				gameView.setPhysicsEngine(physEngine);
+
+				// logDebug(levelsManager.getLevelsStat());
+				sendStats();
+
+				/* synchronized (Thread.currentThread()) {
+					Thread.currentThread().notify();
+				} */
+				menu = new org.happysanta.gd.Menu.Menu();
+				// menu = null;
+				// menu.hideKeyboard();
+				for (int i = 1; i <= 4; i++) {
+					menu.load(i);
+				}
+
+				// menu = new Menu();
+				// menu.hideKeyboard();
+
+				/*menu.load(1);
+				menu.load(2);
+				menu.load(3);
+
+				Runnable createMenuRunnable = new Runnable() {
+					@Override
+					public void run() {
+						menu.load(4);
+						synchronized (this) {
+							notify();
+						}
+					}
+				};
+
+				synchronized (createMenuRunnable) {
+					// logDebug("before runOnUiThread()");
+					runOnUiThread(createMenuRunnable);
+					try {
+						// logDebug("before wait()");
+						createMenuRunnable.wait();
+					} catch (InterruptedException e) {
+						e.printStackTrace();
+					}
+				}*/
+
+				portedTextView.setVisibility(View.VISIBLE);
+
+				gameView.setMenu(menu);
+				gameView._doIIV(-50, 150);
+				setMode(1);
+
+				// Show first image
+				Helpers.logDebug("show first image");
+				long l2;
+				for (; imageDelay > 0L; imageDelay -= l2)
+					l2 = _avJ();
+
+				// Show second image
+				portedTextView.setVisibility(View.GONE);
+				Helpers.logDebug("show second image");
+				imageDelay = Global.DEBUG ? IMAGES_DELAY_DEBUG : IMAGES_DELAY;
+				gameView._doIV(2);
+				long l3;
+				for (long l4 = imageDelay; l4 > 0L; l4 -= l3)
+					l3 = _avJ();
+
+				while (m_longI < 10)
+					_avJ();
+
+				gameView._doIV(0);
+				Helpers.logDebug("images DONE");
+				inited = true;
+
+			} catch (Exception _ex) {
+				_ex.printStackTrace();
+				// Log.w("GDTR", _ex);
+				throw new RuntimeException(_ex);
+			}
+		}
+
+		// logDebug("inited, continue");
+
+		restart(false);
+		// logDebug("showMenu() now");
+
+		/*if (menu != null) */
+		menu.showMenu(0);
+		if (/*menu != null && */menu.canStartTrack())
+			restart(true);
+		l1 = 0L;
+
+		// try {
+		Helpers.logDebug("start main loop");
+		while (alive) {
+			/*if (!alive) {
+				logDebug("!alive");
+				break;
+			}*/
+
+			// try {
+			if (physEngine._bytevI() != menu._jvI()) {
+				int j = gameView._intII(menu._jvI());
+				physEngine._doIV(j);
+				menu._intIV(j);
+			}
+
+			if (menuShown) {
+				menu.showMenu(1);
+				if (menu.canStartTrack())
+					restart(true);
+			}
+
+			for (int i1 = m_nullI; i1 > 0 && alive; i1--) {
+			/* if (m_ifZ)
+				seconds += 20L; */
+				if (m_forJ == 0L)
+					m_forJ = System.currentTimeMillis();
+				int k = 0;
+				if (/*physEngine != null && */(k = physEngine._dovI()) == 3 && m_byteJ == 0L) {
+					m_byteJ = System.currentTimeMillis() + 3000L;
+					gameView.showInfoMessage(getString(R.string.crashed), 3000);
+					//m_di.postInvalidate();
+					//m_di.serviceRepaints();
+				}
+				if (m_byteJ != 0L && m_byteJ < System.currentTimeMillis())
+					restart(true);
+				if (k == 5) {
+					finishedTime = System.currentTimeMillis();
+					gameView.showInfoMessage(getString(R.string.crashed), 3000);
+					//m_di.postInvalidate();
+					//m_di.serviceRepaints();
+					try {
+						long l2 = 1000L;
+						if (m_byteJ > 0L)
+							l2 = Math.min(m_byteJ - System.currentTimeMillis(), 1000L);
+						if (l2 > 0L)
+							Thread.sleep(l2);
+					} catch (InterruptedException _ex) {
+					}
+					restart(true);
+				} else if (k == 4) {
+					// logDebug("k == 4");
+					m_forJ = 0;
+					// seconds = 0;
+					startedTime = 0;
+					finishedTime = 0;
+					pausedTime = 0;
+				} else if (k == 1 || k == 2) {
+					finishedTime = System.currentTimeMillis();
+					// logDebug("game-run: k = " + k);
+				/* if (k == 2)
+					seconds -= 10L; */
+					goalLoop();
+					// menu.setLastTrackTime(seconds / 10L);
+					menu.setLastTrackTime((finishedTime - startedTime) / 10);
+					menu.showMenu(2);
+
+					if (menu.canStartTrack())
+						restart(true);
+					if (!alive) {
+						Helpers.logDebug("!alive (2)");
+						break;
+					}
+				}
+				m_ifZ = k != 4;
+				if (m_ifZ && startedTime == 0) {
+					startedTime = System.currentTimeMillis();
+				}
+			}
+
+			if (!alive) {
+				Helpers.logDebug("!alive (3)");
+				break;
+			}
+
+			//try {
+			/*if (physEngine != null)*/
+			physEngine._charvV();
+			long l;
+			if ((l = System.currentTimeMillis()) - l1 < 30L) {
+				try {
+					synchronized (this) {
+						wait(Math.max(30L - (l - l1), 1L));
+					}
+				} catch (InterruptedException interruptedexception) {
+				}
+				l1 = System.currentTimeMillis();
+			} else {
+				l1 = l;
+			}
+			//m_di.postInvalidate();
+		/*} catch (Exception exception) {
+			exception.printStackTrace();
+		}*/
+		}
+		// } catch (Exception e) {
+		//	e.printStackTrace();
+		//}
+
+		Helpers.logDebug("game thread finished, destroyApp(false) next");
+
+		// finish();
+		destroyApp(false);
+		// return;
+	}
+
+	@Override
+	protected void onResume() {
+		Helpers.logDebug("@@@ [GDActivity \"+hashCode()+\"] onResume()");
+		super.onResume();
+		Helpers.logDebug("[GDActivity \"+hashCode()+\"] onResume(), inited = " + inited);
+		if (wasPaused && wasStarted) {
+			// logDebug("onResume(): wasPaused && wasResumed");
+			// start();
+			m_cZ = false;
+			wasPaused = false;
+
+			// Menu.HelmetRotation.start();
+		}
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+
+		Helpers.logDebug("@@@ [GDActivity " + hashCode() + "] onPause()");
+
+		wasPaused = true;
+		m_cZ = true;
+		Helpers.logDebug("inited : " + inited);
+		if (!menuShown && inited)
+			gameToMenu();
+
+		// menu.helmetRotationStop();
+		// Menu.HelmetRotation.stop();
+		// if (menu != null)
+		// 	menu.saveAll();
+		// levelsManager.updateLevelSettings();
+	}
+
+	@Override
+	protected void onDestroy() {
+		super.onDestroy();
+		Helpers.logDebug("@@@ [GDActivity " + hashCode() + "] onDestroy()");
+		destroyApp(false);
+	}
+
+	@Override
+	protected void onStop() {
+		super.onStop();
+		Helpers.logDebug("@@@ [GDActivity " + hashCode() + "] onStop()");
+	}
+
+	@Override
+	protected void onStart() {
+		super.onStart();
+		Helpers.logDebug("@@@ [GDActivity " + hashCode() + "] onStart()");
+	}
+
+	@Override
+	protected void onRestart() {
+		super.onRestart();
+		Helpers.logDebug("@@@ [GDActivity " + hashCode() + "] onRestart()");
+	}
+
+	@Override
+	public void onBackPressed() {
+		if (gameView != null && menu != null && inited) {
+			if (menuShown)
+				menu.back();
+			else
+				gameView.showMenu();
+		}
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(android.view.Menu menu) {
+		menu.clear();
+		int id = 1;
+		for (Command cmd : commands) {
+			MenuItem item = menu.add(0, id, 0, cmd.title);
+			id++;
+		}
+		return true;
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		gameView.commandAction(commands.get(item.getItemId() - 1));
+		return true;
+	}
+
+	public void setMode(int j) {
+		physEngine._byteIV(j);
+	}
+
+	public boolean isMenuShown() {
+		return menuShown;
+	}
+
+	// @UiThread
+	public void setMenu(final LinearLayout layout) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				scrollView.removeAllViews();
+				if (layout.getParent() != null) {
+					((ViewManager) layout.getParent()).removeView(layout);
+				}
+				scrollView.addView(layout);
+			}
+		});
+	}
+
+	public void goalLoop() {
+		if (!alive) {
+			return;
+		}
+
+		long l1 = 0L;
+		if (!physEngine.m_NZ)
+			gameView.showInfoMessage(getString(R.string.wheelie), 1000);
+		else
+			gameView.showInfoMessage(getString(R.string.finished1), 1000);
+		for (long l2 = System.currentTimeMillis() + 1000L; l2 > System.currentTimeMillis(); gameView.postInvalidate()) {
+			if (menuShown) {
+				//m_di.postInvalidate();
+				return;
+			}
+			for (int j = m_nullI; j > 0; j--)
+				if (physEngine._dovI() == 5)
+					try {
+						long l3;
+						if ((l3 = l2 - System.currentTimeMillis()) > 0L)
+							Thread.sleep(l3);
+						return;
+					} catch (InterruptedException _ex) {
+						return;
+					}
+
+			physEngine._charvV();
+			long l;
+			if ((l = System.currentTimeMillis()) - l1 < 30L) {
+				try {
+					synchronized (this) {
+						wait(Math.max(30L - (l - l1), 1L));
+					}
+				} catch (InterruptedException interruptedexception) {
+				}
+				l1 = System.currentTimeMillis();
+			} else {
+				l1 = l;
+			}
+		}
+	}
+
+	public void restart(boolean flag) {
+		// logDebug("[GDActivity] restart()");
+		if (!alive) {
+			return;
+		}
+
+		physEngine._doZV(true);
+		// logDebug("[GDActivity] restart(): 1");
+		m_forJ = 0;
+		// seconds = 0;
+		startedTime = 0;
+		finishedTime = 0;
+		pausedTime = 0;
+		m_byteJ = 0;
+		if (flag)
+			gameView.showInfoMessage(levelLoader.getLevelName(menu.getSelectedLevel(), menu.getSelectedTrack()), 3000);
+		// logDebug("[GDActivity] restart(): 2");
+		gameView._casevV();
+		// logDebug("[GDActivity] restart(): 3");
+	}
+
+	public void destroyApp(final boolean restart) {
+		if (wasDestroyed) {
+			return;
+		}
+
+		wasDestroyed = true;
+		alive = false;
+
+		final GDActivity self = this;
+
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				Helpers.logDebug("[GDActivity " + self.hashCode() + "] destroyApp()");
+				inited = false;
+				m_caseZ = true;
+
+				synchronized (gameView) {
+					destroyResources();
+
+					if (exiting || restart) {
+						finish();
+					}
+
+					if (restart) {
+						doRestartApp();
+					}
+				}
+			}
+		});
+	}
+
+	private void destroyResources() {
+		Helpers.logDebug("[GDActivity " + hashCode() + "]  destroyResources()");
+
+		// if (thread != null) thread.interrupt();
+		if (gameView != null) gameView.destroy();
+
+		menuShown = false;
+		if (menu != null) {
+			if (!fullResetting) menu.saveAll();
+			menu.destroy();
+		}
+
+		if (levelsManager != null) levelsManager.closeDataSource();
+	}
+
+	public int getButtonsLayoutHeight() {
+		return buttonHeight * 3 + KeyboardController.PADDING * 2;
+	}
+
+	// @UiThread
+	public void hideKeyboardLayout() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				keyboardLayout.setVisibility(android.view.View.GONE);
+
+				LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) scrollView.getLayoutParams();
+				params.setMargins(0, 0, 0, 0);
+				scrollView.setLayoutParams(params);
+			}
+		});
+	}
+
+	// @UiThread
+	public void showKeyboardLayout() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				keyboardLayout.setVisibility(android.view.View.VISIBLE);
+
+				LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) scrollView.getLayoutParams();
+				params.setMargins(0, 0, 0, Helpers.getDp(getButtonsLayoutHeight()));
+				scrollView.setLayoutParams(params);
+			}
+		});
+	}
+
+	public void addCommand(Command cmd) {
+		if (!commands.contains(cmd))
+			commands.add(cmd);
+		if (isNormalAndroid)
+			invalidateOptionsMenu();
+	}
+
+	public void removeCommand(Command cmd) {
+		commands.remove(cmd);
+		if (isNormalAndroid)
+			invalidateOptionsMenu();
+	}
+
+	public void gameToMenu() {
+		Helpers.logDebug("gameToMenu()");
+
+		if (gameView == null) {
+			Helpers.logDebug("gameToMenu(): gameView == null");
+			return;
+		}
+
+		pausedTimeStarted = System.currentTimeMillis();
+
+		gameView.removeMenuCommand();
+		menuShown = true;
+		// menu.helmetRotationStart();
+		// Menu.HelmetRotation.start();
+		if (menu != null)
+			menu.addCommands();
+
+		// hideKeyboardLayout();
+		if (!Settings.isKeyboardInMenuEnabled())
+			hideKeyboardLayout();
+		else
+			showKeyboardLayout();
+
+		gameToMenuUpdateUi();
+	}
+
+	// @UiThread
+	protected void gameToMenuUpdateUi() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				menuBtn.setVisibility(android.view.View.GONE);
+				menuTitleTextView.setVisibility(android.view.View.VISIBLE);
+				scrollView.setVisibility(android.view.View.VISIBLE);
+			}
+		});
+	}
+
+	public void menuToGame() {
+		Helpers.logDebug("menuToGame()");
+
+		if (pausedTimeStarted > 0 && startedTime > 0) {
+			pausedTime += (System.currentTimeMillis() - pausedTimeStarted);
+			pausedTimeStarted = 0;
+		}
+
+		if (menu != null) menu.removeCommands();
+		menuShown = false;
+		// menu.helmetRotationStop();
+		// Menu.HelmetRotation.stop();
+		if (gameView != null) gameView.addMenuCommand();
+		showKeyboardLayout();
+		// menu.showKeyboard();
+
+		menuToGameUpdateUi();
+
+		keyboardController.clearLogBuffer();
+	}
+
+	// @UiThread
+	protected void menuToGameUpdateUi() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				menuBtn.setVisibility(android.view.View.VISIBLE);
+				menuTitleTextView.setVisibility(android.view.View.GONE);
+				scrollView.setVisibility(android.view.View.GONE);
+
+				// Clear menu
+				scrollView.removeAllViews();
+				menuTitleTextView.setText("");
+				menu.menuDisabled = true;
+				// menu.currentMenu = null;
+			}
+		});
+	}
+
+	public void scrollTextMenuUp() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				int y = scrollView.getScrollY();
+				scrollView.scrollTo(0, y - Helpers.getDp(20));
+			}
+		});
+	}
+
+	public void scrollTextMenuDown() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				int y = scrollView.getScrollY();
+				scrollView.scrollTo(0, y + Helpers.getDp(20));
+			}
+		});
+	}
+
+	public void scrollToView(final View view) {
+		final GDActivity gd = Helpers.getGDActivity();
+		final ObservableScrollView scrollView = gd.scrollView;
+
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				Rect scrollBounds = new Rect();
+				scrollView.getHitRect(scrollBounds);
+
+				if (!view.getLocalVisibleRect(scrollBounds)
+						|| scrollBounds.height() < view.getHeight()) {
+					int top = view.getTop(),
+							height = view.getHeight(),
+							scrollY = scrollView.getScrollY(),
+							scrollHeight = scrollView.getHeight(),
+							y = top;
+
+					/*logDebug("top = " + top);
+					logDebug("height = " + height);
+					logDebug("scrollY = " + scrollY);
+					logDebug("scrollHeight = " + scrollHeight);*/
+
+					if (top < scrollY) {
+						// scroll to y
+					} else if (top + height > scrollY + scrollHeight) {
+						y = top + height - scrollHeight;
+						if (y < 0)
+							y = 0;
+					}
+
+					// logDebug("View is not visible, scroll to y = " + y);
+					scrollView.scrollTo(0, y);
+				} else {
+					// logDebug("View is visible");
+				}
+			}
+		});
+	}
+
+	private long _avJ() {
+		m_longI++;
+		long l = System.currentTimeMillis();
+		if (m_longI < 1 || m_longI > 10) { // maybe < 1 not needed?
+			m_longI--;
+			try {
+				Thread.sleep(100L);
+			} catch (InterruptedException _ex) {
+			}
+		}
+		return System.currentTimeMillis() - l;
+	}
+
+	public void restartApp() {
+		if (!restartingStarted) {
+			destroyApp(true);
+			restartingStarted = true;
+		}
+	}
+
+	private void doRestartApp() {
+		Intent mStartActivity = new Intent(this, GDActivity.class);
+		int mPendingIntentId = 123456;
+		PendingIntent mPendingIntent = PendingIntent.getActivity(this, mPendingIntentId, mStartActivity, PendingIntent.FLAG_CANCEL_CURRENT);
+		AlarmManager mgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
+		mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent);
+	}
+
+	private void sendStats() {
+		long lastTs = Settings.getLastSendStats();
+		Helpers.logDebug("sendStats: lastTs = " + lastTs);
+		if (lastTs == 0) {
+			Helpers.logDebug("sendStats: set it to current ts and return");
+			Settings.setLastSendStats(Helpers.getTimestamp());
+			return;
+		}
+
+		// if (Helpers.getTimestamp() < lastTs + 3600 * 8) {
+		if (Helpers.getTimestamp() < lastTs + 10) {
+			Helpers.logDebug("sendStats: just return");
+			return;
+		}
+
+		final GDActivity self = this;
+		Thread statsThread = new Thread() {
+			@Override
+			public void run() {
+				try {
+					HashMap<String, Double> stats = levelsManager.getLevelsStat();
+
+					JSONObject statsJSON = new JSONObject(stats);
+					String id = Installation.id(self);
+					int useCheats = org.happysanta.gd.Menu.Menu.isNameCheat(Settings.getName()) ? 1 : 0;
+
+					API.sendStats(statsJSON.toString(), id, useCheats, new ResponseHandler() {
+						@Override
+						public void onResponse(Response response) {
+							Helpers.logDebug("send stats OK");
+							Settings.setLastSendStats(Helpers.getTimestamp());
+						}
+
+						@Override
+						public void onError(APIException error) {
+							Helpers.logDebug("send stats error: " + error.getMessage());
+							// logDebug(error);
+							// error.printStackTrace();
+						}
+					});
+				} catch (Exception e) {
+					Helpers.logDebug("send stats exception: " + e.getMessage());
+					// e.printStackTrace();
+				}
+			}
+		};
+		statsThread.start();
+	}
+
+	public void sendKeyboardLogs() {
+		final ProgressDialog progressDialog = ProgressDialog.show(this, getString(R.string.please_wait), getString(R.string.please_wait), true);
+		API.sendKeyboardLogs(keyboardController.getLog(), new ResponseHandler() {
+			@Override
+			public void onResponse(Response response) {
+				progressDialog.dismiss();
+				keyboardController.clearLogBuffer();
+				Helpers.showAlert(getString(R.string.ok), "Done", null);
+			}
+
+			@Override
+			public void onError(APIException error) {
+				progressDialog.dismiss();
+				Helpers.showAlert(getString(R.string.error), "Unable to send logs. Maybe log is empty?", null);
+			}
+		});
+	}
+
+	private class ButtonCoords {
+
+		public int x = 0;
+		public int y = 0;
+		public int w = 0;
+		public int h = 0;
+
+		public ButtonCoords() {
+		}
+
+		public boolean in(float x, float y) {
+			if (x < this.x || x > this.x + this.w || y < this.y || y > this.y + this.h) {
+				return false;
+			}
+			return true;
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/src/org/happysanta/gd/GDApplication.java b/src/org/happysanta/gd/GDApplication.java
new file mode 100644
index 0000000..120a5a7
--- /dev/null
+++ b/src/org/happysanta/gd/GDApplication.java
@@ -0,0 +1,24 @@
+package org.happysanta.gd;
+
+import android.app.Application;
+import org.acra.*;
+import org.acra.annotation.*;
+
+import static org.acra.ReportField.*;
+
+@ReportsCrashes(
+		formKey = "",
+		formUri = "http://gdtr.net/report.php",
+		customReportContent = {APP_VERSION_NAME, APP_VERSION_CODE, ANDROID_VERSION, PHONE_MODEL, PRODUCT, DISPLAY, STACK_TRACE, LOGCAT, USER_CRASH_DATE, INSTALLATION_ID, CUSTOM_DATA}
+)
+public class GDApplication extends Application {
+
+	@Override
+	public void onCreate() {
+		super.onCreate();
+		if (Global.ACRA_ENABLED) {
+			ACRA.init(this);
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/org/happysanta/gd/Game/Bitmap.java b/src/org/happysanta/gd/Game/Bitmap.java
new file mode 100755
index 0000000..087a865
--- /dev/null
+++ b/src/org/happysanta/gd/Game/Bitmap.java
@@ -0,0 +1,184 @@
+package org.happysanta.gd.Game;
+
+import org.happysanta.gd.Global;
+import org.happysanta.gd.R;
+
+import java.io.IOException;
+
+import static org.happysanta.gd.Helpers.*;
+
+public class Bitmap {
+
+	public final static int HELMET = 0;
+	public final static int CODEBREW_LOGO = 1;
+	public final static int GD_LOGO = 2;
+	public final static int STEERING = 3;
+	public final static int WHEELS = 4;
+	public final static int ARROWS = 5;
+	public final static int FLAGS = 6;
+	public final static int LOCKS = 7;
+	public final static int MEDALS = 8;
+	public final static int LEVELS_WHEELS = 9;
+	public final static int FENDER = 10;
+	public final static int ENGINE = 11;
+	public final static int BIKER = 12;
+
+	public final static int BLUEARM = 100;
+	public final static int BLUELEG = 101;
+	public final static int BLUEBODY = 102;
+
+	public android.graphics.Bitmap bitmap;
+	protected static GDBitmapHolder holders[];
+	protected static Bitmap empty = null;
+
+	Bitmap(android.graphics.Bitmap b) {
+		bitmap = b;
+	}
+
+	static {
+		holders = new GDBitmapHolder[]{
+				// 0
+				new GDBitmapHolder(Bitmap.fromDrawable(R.drawable.s_helmet)),
+
+				// 1
+				new GDBitmapHolder(Bitmap.fromDrawable(R.drawable.codebrew)),
+
+				// 2
+				new GDBitmapHolder(Bitmap.fromDrawable(R.drawable.gd)),
+
+				// 3
+				new GDBitmapHolder(Bitmap.fromDrawable(R.drawable.s_steering)),
+
+				// 4
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.s_wheel1),
+						Bitmap.fromDrawable(R.drawable.s_wheel2)
+				}),
+
+				// 5
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.s_arrow_up),
+						Bitmap.fromDrawable(R.drawable.s_arrow_down)
+				}),
+
+				// 6
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.s_flag_start0),
+						Bitmap.fromDrawable(R.drawable.s_flag_start1),
+						Bitmap.fromDrawable(R.drawable.s_flag_start2),
+						Bitmap.fromDrawable(R.drawable.s_flag_finish0),
+						Bitmap.fromDrawable(R.drawable.s_flag_finish1),
+						Bitmap.fromDrawable(R.drawable.s_flag_finish2)
+				}),
+
+				// 7
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.s_lock0),
+						Bitmap.fromDrawable(R.drawable.s_lock1),
+						Bitmap.fromDrawable(R.drawable.s_lock2)
+				}),
+
+				// 8
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.s_medal_gold),
+						Bitmap.fromDrawable(R.drawable.s_medal_silver),
+						Bitmap.fromDrawable(R.drawable.s_medal_bronze)
+				}),
+
+				// 9
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.levels_wheel0),
+						Bitmap.fromDrawable(R.drawable.levels_wheel1),
+						Bitmap.fromDrawable(R.drawable.levels_wheel2)
+				}),
+
+				// 10
+				new GDBitmapHolder(Bitmap.fromDrawable(R.drawable.s_fender)),
+
+				// 11
+				new GDBitmapHolder(Bitmap.fromDrawable(R.drawable.s_engine)),
+
+				// 12
+				new GDBitmapHolder(new Bitmap[]{
+						Bitmap.fromDrawable(R.drawable.s_bluearm),
+						Bitmap.fromDrawable(R.drawable.s_blueleg),
+						Bitmap.fromDrawable(R.drawable.s_bluebody)
+				})
+		};
+		empty = new Bitmap(android.graphics.Bitmap.createBitmap(1, 1, android.graphics.Bitmap.Config.ARGB_8888));
+	}
+
+	public static Bitmap get(int index) {
+		if (index >= BLUEARM && index <= BLUEBODY) {
+			return get(BIKER, index - 100);
+		}
+
+		if (holders.length >= index - 1) {
+			GDBitmapHolder holder = holders[index];
+
+			if (holder != null && !holder.isArray && holder.bitmap != null) {
+				return holder.bitmap;
+			}
+		}
+
+		return empty;
+	}
+
+	public static Bitmap get(int index, int arrayIndex) {
+		if (holders.length >= index - 1) {
+			GDBitmapHolder holder = holders[index];
+			if (holder != null && holder.isArray && holder.bitmaps != null && holder.bitmaps.length >= arrayIndex - 1) {
+				return holder.bitmaps[arrayIndex];
+			}
+		}
+
+		return empty;
+	}
+
+	public static Bitmap getEmpty() {
+		return empty;
+	}
+
+	public static Bitmap fromDrawable(int id) {
+		return new Bitmap(loadBitmapFromDrawable(id));
+	}
+
+	public static Bitmap fromAsset(String s) throws IOException {
+		return new Bitmap(loadBitmapFromAsset(s));
+	}
+
+	public int getWidth() {
+		return bitmap.getWidth();
+	}
+
+	public int getHeight() {
+		return bitmap.getHeight();
+	}
+
+	public int getWidthDp() {
+		return Math.round(getWidth() / Global.density);
+	}
+
+	public int getHeightDp() {
+		return Math.round(getHeight() / Global.density);
+	}
+
+	private static class GDBitmapHolder {
+
+		public Bitmap bitmap = null;
+		public Bitmap bitmaps[] = null;
+		public boolean isArray = false;
+
+		GDBitmapHolder(Bitmap bitmap) {
+			this.bitmap = bitmap;
+		}
+
+		GDBitmapHolder(Bitmap bitmaps[]) {
+			this.bitmaps = new Bitmap[bitmaps.length];
+			System.arraycopy(bitmaps, 0, this.bitmaps, 0, bitmaps.length);
+			isArray = true;
+		}
+
+	}
+
+}
diff --git a/src/org/happysanta/gd/Game/FPMath.java b/src/org/happysanta/gd/Game/FPMath.java
new file mode 100755
index 0000000..9ddc4ab
--- /dev/null
+++ b/src/org/happysanta/gd/Game/FPMath.java
@@ -0,0 +1,80 @@
+package org.happysanta.gd.Game;
+
+// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
+// Jad home page: http://www.kpdus.com/jad.html
+// Decompiler options: packimports(3) fieldsfirst ansi 
+
+
+public class FPMath {
+
+	//	public static final int UNSIGNED_MASK = 0x7fffffff;
+//	public static final int SIGN_MASK = 0x80000000;
+	//public static final int m_ifI;
+//	public static final int m_aI = 1;
+	public static int HALF_PI = 0x19220; // 1,57080949111162
+	//	public static int DOUBLE_PI = 0x6487f; // 6,283192187380789
+	public static int PI = 0x3243f; // 3,141588464179446
+	//	public static int ONE = 0x10000;
+	private static int m_jI;
+	private static int m_kI;
+//	private static int SIN_TABLE[] = {
+//			0, 1608, 3215, 4821, 6423, 8022, 9616, 11204, 12785, 14359,
+//			15923, 17479, 19024, 20557, 22078, 23586, 25079, 26557, 28020, 29465,
+//			30893, 32302, 33692, 35061, 36409, 37736, 39039, 40319, 41575, 42806,
+//			44011, 45189, 46340, 47464, 48558, 49624, 50660, 51665, 52639, 53581,
+//			54491, 55368, 56212, 57022, 57797, 58538, 59243, 59913, 60547, 61144,
+//			61705, 62228, 62714, 63162, 63571, 63943, 64276, 64571, 64826, 65043,
+//			65220, 65358, 65457, 65516
+//	};
+//	private static int ARCTG_TABLE[] = {
+//			0, 1023, 2047, 3069, 4090, 5109, 6126, 7139, 8149, 9155,
+//			10157, 11155, 12146, 13133, 14113, 15087, 16054, 17015, 17967, 18912,
+//			19849, 20778, 21698, 22610, 23512, 24405, 25289, 26163, 27027, 27882,
+//			28726, 29561, 30385, 31199, 32003, 32796, 33579, 34352, 35114, 35866,
+//			36608, 37339, 38060, 38771, 39471, 40161, 40841, 41512, 42172, 42822,
+//			43463, 44094, 44716, 45328, 45931, 46524, 47109, 47684, 48251, 48809,
+//			49358, 49899, 50431, 50955
+//	};
+
+	public FPMath() {
+	}
+
+	public static int divide(int i, int j) {
+		int res = (int) (((long) i << 32) / (long) j >> 16);
+		return res;
+	}
+
+	public static int sin(int i) {
+		float fi = i / (float) 0xFFFF;
+		return (int) Math.round(Math.sin(fi) * 65536);
+	}
+
+	public static int _doII(int i) {
+		return sin(HALF_PI - i);
+	}
+
+	public static int arctg(int i) {
+		float fi = i / (float) 0xFFFF;
+		return (int) Math.round(Math.atan(fi) * 65536);
+	}
+
+	public static int _ifIII(int i, int j) {
+		if ((j >= 0 ? j : -j) < 3)
+			return (i <= 0 ? -1 : 1) * HALF_PI;
+		int k = arctg(divide(i, j));
+		if (i > 0)
+			if (j > 0)
+				return k;
+			else
+				return PI + k;
+		if (j > 0)
+			return k;
+		else
+			return k - PI;
+	}
+
+	static {
+		m_jI = 64;
+		m_kI = m_jI << 16;
+	}
+}
diff --git a/src/org/happysanta/gd/Game/GameView.java b/src/org/happysanta/gd/Game/GameView.java
new file mode 100755
index 0000000..ad181e0
--- /dev/null
+++ b/src/org/happysanta/gd/Game/GameView.java
@@ -0,0 +1,968 @@
+package org.happysanta.gd.Game;
+
+import android.graphics.*;
+import android.view.View;
+import org.happysanta.gd.Command;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Menu;
+import org.happysanta.gd.Menu.MenuScreen;
+import org.happysanta.gd.Menu.SimpleMenuElement;
+
+import java.io.IOException;
+import java.util.Timer;
+
+import static org.happysanta.gd.Helpers.*;
+
+public class GameView extends View {
+
+	private static int m_VI = 0;
+	private static int m_vcI = 0;
+	private final int[] startFlagIndexes = {
+			2, 0, 1, 0
+	};
+	private final int[] finishFlagIndexes = {
+			4, 3, 5, 3
+	};
+	public int m_abI;
+	public int m_dI;
+	public int m_lI;
+	public boolean drawTimer;
+	public android.graphics.Bitmap m_zaBitmap[];
+	public boolean m_KZ;
+	public long m_rJ;
+	Menu menu;
+	int m_uI;
+	int m_aiI;
+	int m_agI;
+	int m_gI;
+	private Canvas canvas;
+	private int m_XI;
+	private int m_BI;
+	private Physics physEngine;
+	private int m_TI;
+	private int m_QI;
+	private GDActivity activity;
+	private Paint infoFont;
+	private Paint timerFont;
+	private boolean m_ahZ;
+	private int m_oI;
+	private boolean m_AZ;
+	private int m_OI;
+	private android.graphics.Bitmap m_MBitmap;
+	private Canvas m_dcGraphics;
+	private boolean m_ecZ;
+	private String infoMessage;
+	private int gc;
+	private Timer timer;
+	private Command menuCommand;
+	private Paint paint = new Paint();
+	private Object m_ocObject;
+	private byte[][] m_DaaB = {
+			{0, 0},
+			{1, 0},
+			{0, -1},
+			{0, 0},
+			{0, 0},
+			{0, 1},
+			{-1, 0}
+	};
+	private byte[][][] m_maaaB = {
+			{
+					{
+							0, 0
+					},
+					{
+							1, -1
+					},
+					{
+							1, 0
+					},
+					{
+							1, 1
+					},
+					{
+							0, -1
+					},
+					{
+							-1, 0
+					},
+					{
+							0, 1
+					},
+					{
+							-1, -1
+					},
+					{
+							-1, 0
+					},
+					{
+							-1, 1
+					}
+			}, {
+			{
+					0, 0
+			},
+			{
+					1, 0
+			},
+			{
+					0, 0
+			},
+			{
+					0, 0
+			},
+			{
+					-1, 0
+			},
+			{
+					0, -1
+			},
+			{
+					0, 1
+			},
+			{
+					0, 0
+			},
+			{
+					0, 0
+			},
+			{
+					0, 0
+			}
+	},
+			{
+					{
+							0, 0
+					},
+					{
+							0, 0
+					},
+					{
+							0, 0
+					},
+					{
+							1, 0
+					},
+					{
+							0, -1
+					},
+					{
+							0, 1
+					},
+					{
+							-1, 0
+					},
+					{
+							0, 0
+					},
+					{
+							0, 0
+					},
+					{
+							0, 0
+					}
+			}
+	};
+	private int inputOption;
+	private boolean[] m_aeaZ;
+	private boolean[] m_LaZ;
+	// private int defaultHeight;
+	// private int defaultWidth;
+
+	public GameView(GDActivity micro) {
+		super(micro);
+		// clear static
+		m_vcI = 0;
+		m_VI = 0;
+
+		canvas = null;
+		physEngine = null;
+		menu = null;
+		m_TI = 0;
+		m_QI = 0;
+		activity = null;
+		infoFont = null;
+		m_ahZ = false;
+		drawTimer = true;
+		m_oI = 1;
+		m_uI = 0;
+		m_zaBitmap = null;
+
+		m_KZ = false;
+		m_AZ = true;
+		m_MBitmap = null;
+		m_dcGraphics = null;
+		m_ecZ = false;
+		infoMessage = null;
+		gc = 0;
+		timer = new Timer();
+		m_rJ = -1L;
+		m_ocObject = new Object();
+		m_aiI = 0;
+		m_agI = 0;
+		m_gI = -1;
+		inputOption = 2;
+		m_aeaZ = new boolean[7];
+		m_LaZ = new boolean[10];
+		// String s;
+		// String s1;
+		paint.setAntiAlias(true);
+		paint.setStrokeWidth(1);
+
+		invalidate();
+		m_KZ = false;
+		activity = micro;
+		_ifvV();
+
+		infoFont = new Paint();
+		infoFont.setTextSize(20);
+		infoFont.setAntiAlias(true);
+		infoFont.setTypeface(Global.robotoCondensedTypeface);
+
+		timerFont = new Paint();
+		timerFont.setTextSize(18);
+		timerFont.setAntiAlias(true);
+		timerFont.setTypeface(Global.robotoCondensedTypeface);
+
+		m_XI = 0;
+		m_BI = m_dI;
+		menuCommand = new Command("Menu", 1, 1);
+	}
+
+	public void drawBitmap(Bitmap b, float x, float y) {
+		drawBitmap(b, x, y, canvas);
+	}
+
+	public void drawBitmap(Bitmap b, float x, float y, Canvas g) {
+		Paint paint = null;
+		if (!isSDK11OrHigher()) {
+			paint = new Paint();
+			paint.setFlags(Paint.DITHER_FLAG);
+			paint.setFilterBitmap(true);
+		}
+		g.drawBitmap(b.bitmap,
+				new Rect(0, 0, b.getWidth(), b.getHeight()),
+				new RectF(x, y, x + b.getWidthDp(), y + b.getHeightDp()),
+				paint);
+	}
+
+	public static void _dovV() {
+		m_vcI += 655;
+		int j = 32768 + ((FPMath.sin(m_vcI) >= 0 ? FPMath.sin(m_vcI) : -FPMath.sin(m_vcI)) >> 1);
+		m_VI += (int) (6553L * (long) j >> 16);
+	}
+
+	/*
+	TODO
+	суть этого метода в том, что после того, как splash-картинки проигрались, они удаляются из памяти, т.к. они больше нафиг не нужны
+	видимо это было критично на старых телефонах
+	можно и тут в принципе сделать
+	 */
+	public void _doIV(int j) {
+		m_oI = j;
+		if (j == 0) {
+			// Bitmap.get(Bitmap.CODEBREW_LOGO) = null;
+			// Bitmap.get(Bitmap.GD_LOGO) = null;
+		}
+	}
+
+	public void _aZV(boolean flag) {
+		m_AZ = flag;
+		_ifvV();
+	}
+
+	public void _ifvV() {
+		m_abI = getScaledWidth();
+		m_lI = m_dI = getScaledHeight();
+		if (m_KZ && m_AZ)
+			m_dI -= 80;
+		//postInvalidate();
+	}
+
+	public android.graphics.Bitmap[] spritesFromBitmap(android.graphics.Bitmap bitmap, int j, int k) {
+		int l = bitmap.getWidth() / j;
+		int i1 = bitmap.getHeight() / k;
+		android.graphics.Bitmap aBitmap[] = new android.graphics.Bitmap[j * k];
+		for (int j1 = 0; j1 < j * k; j1++) {
+			aBitmap[j1] = android.graphics.Bitmap.createBitmap(l, i1, android.graphics.Bitmap.Config.ARGB_8888);
+			new Canvas(aBitmap[j1]).drawBitmap(bitmap, -l * (j1 % j), -i1 * (j1 / j), null);
+		}
+
+		return aBitmap;
+	}
+
+	public int _intII(int j) {
+		synchronized (m_ocObject) {
+			try {
+				{
+					if ((j & 1) != 0) {
+						/* try {
+							if (Bitmap.get(Bitmap.FENDER) == null) {
+								//Bitmap.get(Bitmap.FENDER) = Bitmap.fromAsset("/fender.png");
+								//Bitmap.get(Bitmap.FENDER).mulWidth = 1.0f/6.0f;
+								//Bitmap.get(Bitmap.FENDER).mulHeight = 1.0f/6.0;
+								Bitmap.get(Bitmap.FENDER) = Bitmap.fromDrawable(R.drawable.s_fender);
+							}
+							if (Bitmap.get(Bitmap.ENGINE) == null) {
+								//Bitmap.get(Bitmap.ENGINE) = Bitmap.fromAsset("/engine.png");
+								//Bitmap.get(Bitmap.ENGINE).mulHeight = 1.0f/6.0f;
+								//Bitmap.get(Bitmap.ENGINE).mulWidth = 1.0f/6.0f;
+								Bitmap.get(Bitmap.ENGINE) = Bitmap.fromDrawable(R.drawable.s_engine);
+							}
+						} catch (Throwable _ex) {
+							Bitmap.get(Bitmap.FENDER) = Bitmap.get(Bitmap.ENGINE) = null;
+							j &= -2;
+						} */
+					} else {
+						// Bitmap.get(Bitmap.ENGINE) = Bitmap.get(Bitmap.FENDER) = null;
+						// System.gc();
+					}
+					if ((j & 2) != 0) {
+						// blueleg
+						/*try {
+							if (bikerSprites[1] == null)
+								bikerSprites[1] = Bitmap.fromDrawable(R.drawable.s_blueleg);
+						} catch (Throwable _ex) {
+							bikerSprites[1] = null;
+							bikerSprites[0] = null;
+							bikerSprites[2] = null;
+							j &= -3;
+							System.out.println("There may be error");
+							return 0;
+						}*/
+
+						// bluearm
+						/*try {
+							bikerSprites[0] = Bitmap.fromDrawable(R.drawable.s_bluearm);
+						} catch (Throwable _ex) {
+							bikerSprites[0] = bikerSprites[1];
+						}
+
+						// bluebody
+						try {
+							bikerSprites[2] = Bitmap.fromDrawable(R.drawable.s_bluebody);
+						} catch (Throwable _ex) {
+							bikerSprites[2] = bikerSprites[1];
+						}*/
+					} else {
+						// bikerSprites[1] = bikerSprites[2] = bikerSprites[0] = null;
+					}
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+				System.out.println("There may be error [1]");
+			}
+		}
+		return j;
+	}
+
+	public android.graphics.Bitmap[] loadSprites(String s, int j, int k) {
+		android.graphics.Bitmap bitmap;
+		try {
+			bitmap = loadBitmapFromAsset(s);
+		} catch (IOException _ex) {
+			android.graphics.Bitmap aBitmap[] = new android.graphics.Bitmap[j * k];
+			for (int l = 0; l < j * k; l++)
+				aBitmap[l] = Bitmap.getEmpty().bitmap;
+
+			return aBitmap;
+		}
+		return spritesFromBitmap(bitmap, j, k);
+	}
+
+	public void _casevV() {
+		physEngine._nullvV();
+		_avV();
+		m_aiI = 0;
+		m_agI = 0;
+	}
+
+	public void setPhysicsEngine(Physics b1) {
+		physEngine = b1;
+		physEngine._caseIV(m_abI >= m_dI ? m_dI : m_abI);
+	}
+
+	public void setMenu(Menu menu) {
+		this.menu = menu;
+	}
+
+	/* public Bitmap _aStringBitmap(String s) {
+		Bitmap bitmap = null;
+		try {
+			bitmap = Global.loadBitmapFromAsset(s);
+		} catch (IOException _ex) {
+		}
+		return bitmap;
+	} */
+
+	public void _doIIV(int j, int k) {
+		m_XI = j;
+		m_BI = k;
+		physEngine._ifIIV(-j, -j + m_abI);
+	}
+
+	public int _charvI() {
+		return m_XI;
+	}
+
+	private float offsetX(float j) {
+		return j + m_XI;
+	}
+
+	private float offsetY(float j) {
+		return -j + m_BI - getGDActivity().getButtonsLayoutHeight() / 2;
+	}
+
+	public void _newvV() {
+		paint.setColor(0xFFFFFFFF);
+		paint.setStyle(Paint.Style.FILL);
+		canvas.drawRect(0, m_dI, m_abI, 80, paint);
+		byte byte0 = 35;
+		int j = m_abI / 2;
+		int k = m_dI + 40;
+		// m_CGraphics.setColor(150, 0, 0);
+		paint.setColor(0xFF960000);
+		int i1;
+		paint.setStyle(Paint.Style.STROKE);
+		if (m_aiI != 0 || m_agI != 0) {
+			i1 = (int) (((long) (int) ((long) m_OI * 0xb40000L >> 16) << 32) / 0x3243fL >> 16) >> 16;
+			int l = i1 - i1 % 45;
+			l -= 90;
+			//m_CGraphics.fillArc(j - byte0, k - byte0, 2 * byte0, 2 * byte0, l - 22, 45);
+			canvas.drawArc(new RectF(j - byte0, k - byte0, 2 * byte0 + j - byte0, 2 * byte0 + k - byte0), l - 22, 45, true, paint);
+		}
+		//m_CGraphics.setColor(0, 0, 0);
+		paint.setColor(0xFF000000);
+		canvas.drawArc(new RectF(j - byte0, k - byte0, 2 * byte0 + j - byte0, 2 * byte0 + k - byte0), 0, 360, true, paint);
+		byte0 = 2;
+		canvas.drawArc(new RectF(j - byte0, k - byte0, 2 * byte0 + j - byte0, 2 * byte0 + k - byte0), 0, 360, true, paint);
+		paint.setStyle(Paint.Style.FILL);
+	}
+
+	public void _aIIIV(int j, int k, int l, int i1) {
+		canvas.drawLine(offsetX(j), offsetY(k), offsetX(l), offsetY(i1), paint);
+	}
+
+	public void drawLine(int j, int k, int l, int i1) {
+		canvas.drawLine(offsetX((j << 2) / (float) 0xFFFF), offsetY((k << 2) / (float) 0xFFFF), offsetX((l << 2) / (float) 0xFFFF), offsetY((i1 << 2) / (float) 0xFFFF), paint);
+	}
+
+	public void _aIIIV(int j, int k, int l, int i1, int j1) {
+		drawBikerPart(j, k, l, i1, j1, 32768);
+	}
+
+	public void drawBikerPart(int j, int k, int l, int i1, int j1, int k1) {
+		float l1 = offsetX((int) ((long) l * (long) k1 >> 16) + (int) ((long) j * (long) (0x10000 - k1) >> 16) >> 16);
+		float i2 = offsetY((int) ((long) i1 * (long) k1 >> 16) + (int) ((long) k * (long) (0x10000 - k1) >> 16) >> 16);
+		int j2 = FPMath._ifIII(l - j, i1 - k);
+		int index = 0;
+		switch (j1) {
+			case 0: // '\0'
+				index = _aIIII(j2, 0, 0x3243f, 16, false);
+				break;
+
+			case 1: // '\001'
+				index = _aIIII(j2, 0, 0x3243f, 16, false);
+				break;
+
+			case 2: // '\002'
+				index = _aIIII(j2, 0, 0x3243f, 16, false);
+				break;
+		}
+		float fAngleDeg = (float) (j2 / (float) 0xFFFF / Math.PI * 180) - 180;
+		index = 0;
+
+		Bitmap bikerSprite = Bitmap.get(Bitmap.BIKER, j1);
+		if (bikerSprite != null) {
+			float x = l1 - bikerSprite.getWidthDp() / 2;
+			float y = i2 - bikerSprite.getHeightDp() / 2;
+
+			canvas.save();
+			canvas.rotate(fAngleDeg, x + bikerSprite.getWidthDp() / 2, y + bikerSprite.getHeightDp() / 2);
+			drawBitmap(bikerSprite, x, y);
+			canvas.restore();
+		}
+	}
+
+	// �������� �����
+	public void _ifIIIV(int j, int k, int l, int i1) {
+		l++;
+		float j1 = offsetX(j - l);
+		float k1 = offsetY(k + l);
+		int l1 = l << 1;
+		if ((i1 = -(int) (((long) (int) ((long) i1 * 0xb40000L >> 16) << 32) / 0x3243fL >> 16)) < 0)
+			i1 += 360;
+		paint.setStyle(Paint.Style.STROKE);
+		canvas.drawArc(new RectF(j1, k1, j1 + l1, k1 + l1), -((i1 >> 16) + 170), -90, false, paint);
+		paint.setStyle(Paint.Style.FILL);
+	}
+
+	// Draws red circle
+	public void drawLineWheel(float j, float k, int l) {
+		float i1 = l / 2;
+		float j1 = offsetX(j - i1);
+		float k1 = offsetY(k + i1);
+
+		paint.setStyle(Paint.Style.STROKE);
+		canvas.drawArc(new RectF(j1, k1, j1 + l, k1 + l), 0, 360, true, paint);
+		paint.setStyle(Paint.Style.FILL);
+	}
+
+	public void _forIIIV(int j, int k, int l, int i1) {
+		float j1 = offsetX(j);
+		float k1 = offsetY(k);
+		canvas.drawRect(j1, k1, j1 + l, k1 + i1, paint);
+	}
+
+	public void drawSteering(int j, int k) {
+		float x = offsetX(j - Bitmap.get(Bitmap.STEERING).getWidthDp() / 2);
+		float y = offsetY(k + Bitmap.get(Bitmap.STEERING).getHeightDp() / 2);
+
+		drawBitmap(Bitmap.get(Bitmap.STEERING), x, y);
+	}
+
+	public void drawHelmet(float j, float k, int l) {
+		float fAngleDeg = (float) (l / (float) 0xFFFF / Math.PI * 180) - 90 - 10;
+		if (fAngleDeg >= 360) fAngleDeg -= 360;
+		if (fAngleDeg < 0) fAngleDeg = 360 + fAngleDeg;
+		if (Bitmap.get(Bitmap.HELMET) != null) {
+			float x = offsetX(j) - Bitmap.get(Bitmap.HELMET).getWidthDp() / 2;
+			float y = offsetY(k) - Bitmap.get(Bitmap.HELMET).getHeightDp() / 2;
+			canvas.save();
+			canvas.rotate(fAngleDeg, x + Bitmap.get(Bitmap.HELMET).getWidthDp() / 2, y + Bitmap.get(Bitmap.HELMET).getHeightDp() / 2);
+
+			drawBitmap(Bitmap.get(Bitmap.HELMET), x, y);
+			canvas.restore();
+		}
+	}
+
+	public void _ifIIIIV(int j, int k, int l, int i1, int j1, int k1) {
+	}
+
+	public void drawTimer(long l) {
+		// logDebug("Timer: " + l);
+		String txt = String.format("%d:%02d:%02d", l / 6000, (l / 100) % 60, l % 100);
+		// logDebug("drawTimter: long = " + l + ", string = " + txt);
+		canvas.drawText(txt, 18, -infoFont.ascent() + 17, timerFont);
+	}
+
+	public synchronized void showInfoMessage(String s, int j) {
+		m_ahZ = false;
+		gc++;
+		infoMessage = s;
+		if (timer != null) {
+			timer.schedule(new SimpleMenuElement(gc), j);
+		}
+	}
+
+	public void _tryIV(int j) {
+		if (gc == j)
+			m_ahZ = true;
+	}
+
+	public void drawStartFlag(int j, int k) {
+		if (m_VI > 0x38000)
+			m_VI = 0;
+		setColor(0, 0, 0);
+		_aIIIV(j, k, j, k + 32);
+		drawBitmap(Bitmap.get(Bitmap.FLAGS, startFlagIndexes[m_VI >> 16]), offsetX(j), offsetY(k) - 32);
+	}
+
+	public void drawFinishFlag(int j, int k) {
+		if (m_VI > 0x38000)
+			m_VI = 0;
+		setColor(0, 0, 0);
+		_aIIIV(j, k, j, k + 32);
+		drawBitmap(Bitmap.get(Bitmap.FLAGS, finishFlagIndexes[m_VI >> 16]), offsetX(j), offsetY(k) - 32);
+	}
+
+	public void drawWheel(float j, float k, int l) {
+		int wheel;
+		if (l == 1)
+			wheel = 0; // small
+		else
+			wheel = 1; // big
+
+		float x = offsetX(j - Bitmap.get(Bitmap.WHEELS, wheel).getWidthDp() / 2);
+		float y = offsetY(k + Bitmap.get(Bitmap.WHEELS, wheel).getHeightDp() / 2);
+
+		drawBitmap(Bitmap.get(Bitmap.WHEELS, wheel), x, y);
+	}
+
+	int _aIIII(int j, int k, int l, int i1, boolean flag) {
+		for (j += k; j < 0; j += l) ;
+		for (; j >= l; j -= l) ;
+		if (flag)
+			j = l - j;
+		int j1;
+		if ((j1 = (int) ((long) (int) (((long) j << 32) / (long) l >> 16) * (long) (i1 << 16) >> 16)) >> 16 < i1 - 1)
+			return j1 >> 16;
+		else
+			return i1 - 1;
+	}
+
+	public void drawEngine(float j, float k, int l) {
+		float fAngleDeg = (float) (l / (float) 0xFFFF / Math.PI * 180) - 180;
+		float x = offsetX(j) - Bitmap.get(Bitmap.ENGINE).getWidthDp() / 2;
+		float y = offsetY(k) - Bitmap.get(Bitmap.ENGINE).getHeightDp() / 2;
+		if (Bitmap.get(Bitmap.ENGINE) != null) {
+			canvas.save();
+			canvas.rotate(fAngleDeg, x + Bitmap.get(Bitmap.ENGINE).getWidthDp() / 2, y + Bitmap.get(Bitmap.ENGINE).getHeightDp() / 2);
+			drawBitmap(Bitmap.get(Bitmap.ENGINE), x, y);
+			canvas.restore();
+		}
+	}
+
+	public void drawFender(float j, float k, int l) {
+		float fAngleDeg = (float) (l / (float) 0xFFFF / Math.PI * 180) - 180 + 15;
+		if (fAngleDeg >= 360) fAngleDeg -= 360;
+		if (Bitmap.get(Bitmap.FENDER) != null) {
+			float x = offsetX(j) - Bitmap.get(Bitmap.FENDER).getWidthDp() / 2;
+			float y = offsetY(k) - Bitmap.get(Bitmap.FENDER).getHeightDp() / 2;
+
+			canvas.save();
+			canvas.rotate(fAngleDeg, x + Bitmap.get(Bitmap.FENDER).getWidthDp() / 2, y + Bitmap.get(Bitmap.FENDER).getHeightDp() / 2);
+			drawBitmap(Bitmap.get(Bitmap.FENDER), x, y);
+			canvas.restore();
+		}
+	}
+
+	public void _tryvV() {
+		paint.setColor(0xFFFFFFFF);
+		canvas.drawRect(0, 0, m_abI, m_dI, paint);
+	}
+
+	public void setColor(int r, int g, int b) {
+		GDActivity _tmp = activity;
+		if (getGDActivity().isMenuShown()) {
+			r += 128;
+			g += 128;
+			b += 128;
+			if (r > 240)
+				r = 240;
+			if (g > 240)
+				g = 240;
+			if (b > 240)
+				b = 240;
+		}
+		//m_CGraphics.setColor(j, k, l);
+		paint.setColor(0xFF000000 | (r << 16) | (g << 8) | b);
+	}
+
+	// Draw boot logos and something else
+	public void drawGame(Canvas g) {
+		final GDActivity gd = getGDActivity();
+		label0:
+		{
+			int j;
+			synchronized (m_ocObject) {
+				if (gd.alive && !gd.m_caseZ)
+					break label0;
+			}
+			return;
+		}
+
+		if (m_ecZ)
+			canvas = m_dcGraphics;
+		else
+			canvas = g;
+		if (m_oI != 0) {
+			if (m_oI == 1) {
+				// Draw codebrew
+				paint.setColor(0xFFFFFFFF);
+				canvas.drawRect(0, 0, getScaledWidth(), getScaledHeight(), paint);
+				if (Bitmap.get(Bitmap.CODEBREW_LOGO) != null) {
+					drawBitmap(Bitmap.get(Bitmap.CODEBREW_LOGO),
+							getScaledWidth() / 2 - Bitmap.get(Bitmap.CODEBREW_LOGO).getWidthDp() / 2,
+							(float) (getScaledHeight() / 2 - Bitmap.get(Bitmap.CODEBREW_LOGO).getHeightDp() / 1.6));
+				}
+			} else {
+				// Draw gd
+				paint.setColor(0xFFFFFFFF);
+				canvas.drawRect(0, 0, getScaledWidth(), getScaledHeight(), paint);
+				if (Bitmap.get(Bitmap.GD_LOGO) != null) {
+					drawBitmap(Bitmap.get(Bitmap.GD_LOGO),
+							getScaledWidth() / 2 - Bitmap.get(Bitmap.GD_LOGO).getWidthDp() / 2,
+							(float) (getScaledHeight() / 2 - Bitmap.get(Bitmap.GD_LOGO).getHeightDp() / 1.6));
+				}
+			}
+			int j = (int) (((long) (gd.m_longI << 16) << 32) / 0xa0000L >> 16);
+			drawProgress(j, true);
+		} else {
+			if (m_lI != getHeight())
+				_ifvV();
+			physEngine._voidvV();
+			_doIIV(-physEngine._elsevI() + m_TI + m_abI / 2, physEngine._ifvI() + m_QI + m_dI / 2);
+			physEngine._ifiV(this);
+			if (drawTimer) {
+				long time = 0, finished;
+				if (gd.startedTime > 0) {
+					if (gd.finishedTime > 0)
+						finished = gd.finishedTime;
+					else
+						finished = System.currentTimeMillis();
+					time = (finished - gd.startedTime - gd.pausedTime) / 10;
+				}
+				drawTimer(time);
+			}
+			if (infoMessage != null) {
+				setColor(0, 0, 0);
+				infoFont.setColor(paint.getColor());
+				/*if (m_dI <= 128)
+					canvas.drawText(infoMessage, m_abI / 2 - infoFont.measureText(infoMessage) / 2, 1, infoFont);
+				else*/
+
+				canvas.drawText(infoMessage, m_abI / 2 - infoFont.measureText(infoMessage) / 2, m_dI / 5, infoFont);
+				if (m_ahZ) {
+					m_ahZ = false;
+					infoMessage = null;
+				}
+			}
+			int j = physEngine._tryvI();
+			drawProgress(j, false);
+			if (m_KZ && m_AZ)
+				_newvV();
+		}
+		canvas = null;
+		if (m_ecZ)
+			g.drawBitmap(m_MBitmap, 0, 0, null);
+	}
+
+	public void drawProgress(int j, boolean flag) {
+		double progr = j / (double) 0xFFFF;
+
+		paint.setColor(0xffc4c4c4);
+		canvas.drawRect(0, 0, getScaledWidth(), 3, paint);
+
+		paint.setColor(0xff29aa27);
+		canvas.drawRect(0, 0, Math.round(getScaledWidth() * Math.min(Math.max(progr, 0), 1)), 3, paint);
+	}
+
+	private void _ifIIV(int j, int k) {
+		if (!getGDActivity().isMenuShown()) {
+			byte byte0 = 0;
+			byte byte1 = 0;
+			m_aiI = j;
+			m_agI = k;
+			int l = j << 16;
+			int i1 = k << 16;
+			int j1 = m_abI / 2 << 16;
+			int k1 = m_dI + 40 << 16;
+			if (m_KZ && m_AZ) {
+				int l1 = FPMath._ifIII(l - j1, i1 - k1);
+				for (l1 += 25735; l1 < 0; l1 += 0x6487e) ;
+				for (; l1 > 0x6487e; l1 -= 0x6487e) ;
+				m_OI = l1;
+				int i2;
+				if ((i2 = 51471) >= l1)
+					byte0 = -1;
+				else if (l1 < (int) ((long) i2 * 0x20000L >> 16)) {
+					byte0 = -1;
+					byte1 = 1;
+				} else if (l1 < (int) ((long) i2 * 0x30000L >> 16))
+					byte1 = 1;
+				else if (l1 < (int) ((long) i2 * 0x40000L >> 16)) {
+					byte0 = 1;
+					byte1 = 1;
+				} else if (l1 < (int) ((long) i2 * 0x50000L >> 16))
+					byte0 = 1;
+				else if (l1 < (int) ((long) i2 * 0x60000L >> 16)) {
+					byte0 = 1;
+					byte1 = -1;
+				} else if (l1 < (int) ((long) i2 * 0x70000L >> 16))
+					byte1 = -1;
+				else if (l1 < (int) ((long) i2 * 0x80000L >> 16)) {
+					byte0 = -1;
+					byte1 = -1;
+				}
+				physEngine._aIIV(byte0, byte1);
+			}
+		}
+	}
+
+	public void _pointerPressedIIV(int j, int k) {
+		if (!getGDActivity().isMenuShown())
+			_ifIIV(j, k);
+	}
+
+	public void _pointerReleasedIIV(int j, int k) {
+		if (!getGDActivity().isMenuShown()) {
+			m_aiI = 0;
+			m_agI = 0;
+			physEngine._nullvV();
+		}
+	}
+
+	public void _pointerDraggedIIV(int j, int k) {
+		if (!getGDActivity().isMenuShown())
+			_ifIIV(j, k);
+	}
+
+	public void setInputOption(int option) {
+		inputOption = option;
+	}
+
+	private void _avV() {
+		for (int j = 0; j < 10; j++)
+			m_LaZ[j] = false;
+
+		for (int k = 0; k < 7; k++)
+			m_aeaZ[k] = false;
+
+	}
+
+	private void _xavV() {
+		int j = 0;
+		int k = 0;
+		int l = inputOption;
+		for (int i1 = 0; i1 < 10; i1++)
+			if (m_LaZ[i1]) {
+				j += m_maaaB[l][i1][0];
+				k += m_maaaB[l][i1][1];
+			}
+
+		for (int j1 = 0; j1 < 7; j1++)
+			if (m_aeaZ[j1]) {
+				j += m_DaaB[j1][0];
+				k += m_DaaB[j1][1];
+			}
+
+		physEngine._aIIV(j, k);
+	}
+
+	protected void processKeyPressed(int j) {
+		int k = getGameAction(j);
+		int l;
+		if ((l = j - 48) >= 0 && l < 10)
+			m_LaZ[l] = true;
+		else if (k >= 0 && k < 7)
+			m_aeaZ[k] = true;
+		_xavV();
+	}
+
+	protected void processKeyReleased(int j) {
+		int k = getGameAction(j);
+		int l;
+		if ((l = j - 48) >= 0 && l < 10)
+			m_LaZ[l] = false;
+		else if (k >= 0 && k < 7)
+			m_aeaZ[k] = false;
+		_xavV();
+	}
+
+	public void showMenu() {
+		if (menu != null) {
+			menu.m_blZ = true;
+			getGDActivity().gameToMenu();
+		}
+	}
+
+	/* protected void hideNotify() {
+		if (!getGDActivity().isMenuShown()) {
+			GDActivity.m_cZ = true;
+			activity.gameToMenu();
+		}
+	} */
+
+	/* protected void showNotify() {
+		GDActivity.m_cZ = false;
+	} */
+
+	protected void keyRepeated(int j) {
+		if (getGDActivity().isMenuShown() && menu != null)
+			menu._tryIV(j);
+	}
+
+	public synchronized void keyPressed(int j) {
+		if (getGDActivity().isMenuShown() && menu != null)
+			menu.keyPressed(j);
+		processKeyPressed(j);
+	}
+
+	public synchronized void keyReleased(int j) {
+		processKeyReleased(j);
+	}
+
+	@Override
+	public void onDraw(Canvas g) {
+		g.save();
+		if (!Global.DISABLE_SCALING)
+			g.scale(Global.density, Global.density);
+		if (getGDActivity().isMenuShown() && menu != null) {
+			menu.draw(g);
+		} else {
+			drawGame(g);
+		}
+		g.restore();
+		invalidate();
+	}
+
+	public void commandAction(Command command) {
+		if (getGDActivity().isMenuShown() && menu != null) {
+			menu.onCommand(command);
+		} else {
+			showMenu();
+		}
+	}
+
+	public void removeMenuCommand() {
+		removeCommand(menuCommand);
+	}
+
+	public void addMenuCommand() {
+		addCommand(menuCommand);
+	}
+
+	public static int getGameAction(int key) {
+		// logDebug("getGameAction: key = " + key);
+		switch (key) {
+			case 50: // 2
+				return MenuScreen.KEY_UP; // up
+			case 56: // 8
+				return MenuScreen.KEY_DOWN; // down
+			case 52: // 4
+				return MenuScreen.KEY_LEFT; // left
+			case 54: // 6
+				return MenuScreen.KEY_RIGHT; // right
+			case 53: // 5
+				return MenuScreen.KEY_FIRE; // fire
+		}
+		return 0;
+	}
+
+	public void addCommand(Command cmd) {
+		GDActivity.shared.addCommand(cmd);
+	}
+
+	public void removeCommand(Command cmd) {
+		GDActivity.shared.removeCommand(cmd);
+	}
+
+	public int getScaledWidth() {
+		float density = Global.DISABLE_SCALING ? 1 : Global.density;
+		return Math.round(getWidth() / density);
+	}
+
+	public int getScaledHeight() {
+		float density = Global.DISABLE_SCALING ? 1 : Global.density;
+		return Math.round(getHeight() / density);
+	}
+
+	@Override
+	public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+		int width = MeasureSpec.getSize(widthMeasureSpec), height = MeasureSpec.getSize(heightMeasureSpec);
+		setMeasuredDimension(width, height);
+	}
+
+	public synchronized void destroy() {
+		if (timer != null) {
+			timer.cancel();
+			timer.purge();
+			timer = null;
+		}
+	}
+
+}
diff --git a/src/org/happysanta/gd/Game/Physics.java b/src/org/happysanta/gd/Game/Physics.java
new file mode 100755
index 0000000..d6e25b3
--- /dev/null
+++ b/src/org/happysanta/gd/Game/Physics.java
@@ -0,0 +1,1336 @@
+package org.happysanta.gd.Game;
+
+// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
+// Jad home page: http://www.kpdus.com/jad.html
+// Decompiler options: packimports(3) fieldsfirst ansi 
+
+
+import org.happysanta.gd.Levels.Loader;
+import org.happysanta.gd.Menu.SimpleMenuElement;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getLevelLoader;
+
+public class Physics {
+
+	/*public static final int m_agI = 1;
+	//public static final int m_byteI;
+	public static final int m_ahI = 1;
+	public static final int m_LI = 2;
+	public static final int m_uI = 3;
+	//public static final int m_aI;
+	public static final int m_VI = 1;
+	public static final int m_BI = 2;
+	public static final int m_acI = 3;
+	public static final int m_newI = 4;
+	public static final int m_ZI = 5 */
+	public static int m_YI;
+	public static int m_voidI;
+	public static int m_gI;
+	public static int m_fI;
+	public static int m_eI;
+	public static int m_aeI;
+	public static int m_adI;
+	public static int m_yI;
+	public static int m_qI;
+	public static int m_xI;
+	public static int m_foraI[] = {
+			0x1c000, 0x10000, 32768
+	};
+	public static int m_PI;
+	public static int m_jI;
+	public static int m_QI;
+	public static int m_charI;
+	public static int m_abI;
+	public static int m_WI;
+	public static int m_AI;
+	public static int m_longI;
+	public static int m_hI = 0;
+	// private final int m_pI = 3276;
+	private final int m_KaaI[][] = {
+			{
+					0x2cccc, -52428
+			}, {
+			0x40000, 0xfffd8000
+	}, {
+			0x63333, 0xffff0000
+	}, {
+			0x6cccc, -39321
+	}, {
+			0x39999, 39321
+	}, {
+			16384, 0xfffdcccd
+	}, {
+			13107, 0xfffecccd
+	}, {
+			0x46666, 0x14000
+	}
+	};
+	private final int m_ucaaI[][] = {
+			{
+					0x2e666, 0xfffe4ccd
+			}, {
+			0x4b333, 0xfffc6667
+	}, {
+			0x51999, 0xfffe4000
+	}, {
+			0x60000, -58982
+	}, {
+			0x40000, 0x18000
+	}, {
+			0x10000, 0xfffe199a
+	}, {
+			13107, 0xfffecccd
+	}, {
+			0x46666, 0x14000
+	}
+	};
+	private final int m_SaaI[][] = {
+			{
+					0x26666, 13107
+			}, {
+			0x48000, -13107
+	}, {
+			0x59999, 0x16666
+	}, {
+			0x63333, 0x2e666
+	}, {
+			0x54ccc, 0x11999
+	}, {
+			39321, 0xfffe8000
+	}, {
+			13107, -52428
+	}, {
+			0x48000, 0x14000
+	}
+	};
+	private final int m_wcaaI[][] = {
+			{
+					0x2cccc, -39321
+			}, {
+			0x40000, 0xfffe0000
+	}, {
+			0x60000, 0xffff0000
+	}, {
+			0x70000, -39321
+	}, {
+			0x48000, 6553
+	}, {
+			16384, 0xfffdcccd
+	}, {
+			13107, 0xfffecccd
+	}, {
+			0x46666, 0x14ccc
+	}
+	};
+	private final int m_DaaI[][] = {
+			{
+					0x2e666, 0xfffe999a
+			}, {
+			0x3e666, 0xfffc6667
+	}, {
+			0x51999, 0xfffe4000
+	}, {
+			0x60000, -42598
+	}, {
+			0x49999, 6553
+	}, {
+			0x10000, 0xfffecccd
+	}, {
+			13107, 0xfffecccd
+	}, {
+			0x46666, 0x14ccc
+	}
+	};
+	private final int m_MaaI[][] = {
+			{
+					0x26666, 13107
+			}, {
+			0x48000, -13107
+	}, {
+			0x59999, 0x19999
+	}, {
+			0x63333, 0x2b333
+	}, {
+			0x54ccc, 0x11999
+	}, {
+			39321, 0xfffe8000
+	}, {
+			13107, -52428
+	}, {
+			0x46666, 0x14ccc
+	}
+	};
+	public k m_Hak[];
+	public boolean m_bZ;
+	public int m_zI;
+	public boolean m_elseZ;
+	public boolean m_UZ;
+	public boolean m_NZ;
+	SimpleMenuElement m_aaan[];
+	private int m_vaI;
+	private int m_waI;
+	private int m_xaI;
+	private SimpleMenuElement m_ian[];
+	private int m_cI;
+	private Loader m_lf;
+	private int m_EI;
+	private int m_CI;
+	private boolean m_IZ;
+	private boolean m_mZ;
+	private int m_TI;
+	private int m_kI;
+	private boolean m_vZ;
+	private boolean m_afZ;
+	private int m_tI;
+	private boolean m_dZ;
+	private boolean m_FZ;
+	private boolean m_XZ;
+	private boolean m_wZ;
+	private boolean m_ifZ;
+	private boolean m_sZ;
+	private boolean m_OZ;
+	private boolean m_rZ;
+	private boolean m_RZ;
+	private boolean m_doZ;
+	private int m_oI;
+	private int m_nI;
+	private int m_GI;
+	private int m_JaaI[][] = {
+			{
+					45875
+			}, {
+			32768
+	}, {
+			52428
+	}
+	};
+	private final int leftWheelUpdatingFrequency = 20;
+	private long leftWheelLastUpdated = 0;
+	private int leftWheelParams[][];
+
+	public Physics(Loader f1) {
+		m_vaI = 0;
+		m_waI = 1;
+		m_xaI = -1;
+		m_cI = 0;
+		m_EI = 0;
+		m_CI = 0;
+		m_IZ = false;
+		m_mZ = false;
+		m_TI = 32768;
+		m_kI = 0;
+		m_vZ = false;
+		m_bZ = false;
+		m_afZ = false;
+		m_aaan = new SimpleMenuElement[6];
+		for (int j = 0; j < 6; j++)
+			m_aaan[j] = new SimpleMenuElement();
+
+		m_tI = 0;
+		m_zI = 0;
+		m_elseZ = false;
+		m_UZ = false;
+		m_dZ = false;
+		m_FZ = false;
+		m_XZ = false;
+		m_wZ = false;
+		m_ifZ = false;
+		m_sZ = false;
+		m_OZ = false;
+		m_rZ = false;
+		m_RZ = false;
+		m_NZ = false;
+		m_doZ = true;
+		m_oI = 0;
+		m_nI = 0;
+		m_GI = 0xa0000;
+		m_lf = f1;
+		_doZV(true);
+		m_vZ = false;
+		_charvV();
+		m_IZ = false;
+
+		leftWheelParams = new int[5][4];
+	}
+
+	public static int _doIII(int j, int i1) {
+		int j1 = j >= 0 ? j : -j;
+		int k1;
+		int l1;
+		int i2;
+		if ((k1 = i1 >= 0 ? i1 : -i1) >= j1) {
+			l1 = k1;
+			i2 = j1;
+		} else {
+			l1 = j1;
+			i2 = k1;
+		}
+		return (int) (64448L * (long) l1 >> 16) + (int) (28224L * (long) i2 >> 16);
+	}
+
+	public int _bytevI() {
+		if (m_elseZ && m_UZ)
+			return 3;
+		if (m_UZ)
+			return 1;
+		return !m_elseZ ? 0 : 2;
+	}
+
+	public void _doIV(int j) {
+		m_elseZ = false;
+		m_UZ = false;
+		if ((j & 2) != 0)
+			m_elseZ = true;
+		if ((j & 1) != 0)
+			m_UZ = true;
+	}
+
+	public void _byteIV(int j) {
+		m_zI = j;
+		switch (j) {
+			case 1: // '\001'
+			default:
+				m_YI = 1310;
+				break;
+		}
+		m_voidI = 0x190000;
+		setLeague(1);
+		_doZV(true);
+	}
+
+	public void setLeague(int j) {
+		m_hI = j;
+		m_gI = 45875;
+		m_fI = 13107;
+		m_eI = 39321;
+		m_yI = 0x140000;
+		m_xI = 0x40000;
+		m_jI = 6553;
+		switch (j) {
+			case 3: // '\003'
+				m_aeI = 32768;
+				m_adI = 32768;
+				m_PI = 0x160000;
+				m_QI = 0x4b00000;
+				m_charI = 0x360000;
+				m_abI = 6553;
+				m_WI = 26214;
+				m_AI = 0x10000;
+				m_longI = 0x140000;
+				m_qI = 0x14a0000;
+				break;
+
+			case 2: // '\002'
+				m_aeI = 32768;
+				m_adI = 32768;
+				m_PI = 0x140000;
+				m_QI = 0x47e0000;
+				m_charI = 0x350000;
+				m_abI = 6553;
+				m_WI = 26214;
+				m_AI = 39321;
+				m_longI = 0x50000;
+				m_qI = 0x14a0000;
+				break;
+
+			case 1: // '\001'
+				m_aeI = 32768;
+				m_adI = 32768;
+				m_PI = 0x110000;
+				m_QI = 0x3e80000;
+				m_charI = 0x320000;
+				m_abI = 6553;
+				m_WI = 26214;
+				m_AI = 26214;
+				m_longI = 0x50000;
+				m_qI = 0x12c0000;
+				break;
+
+			case 0: // '\0'
+			default:
+				m_aeI = 19660;
+				m_adI = 19660;
+				m_PI = 0x110000;
+				m_QI = 0x3200000;
+				m_charI = 0x320000;
+				m_abI = 327;
+				m_WI = 0;
+				m_AI = 32768;
+				m_longI = 0x50000;
+				m_qI = 0x12c0000;
+				break;
+		}
+		_doZV(true);
+	}
+
+	public void _doZV(boolean flag) {
+		m_tI = 0;
+		_iIIV(m_lf._newvI(), m_lf._avI());
+		m_cI = 0;
+		m_kI = 0;
+		m_IZ = false;
+		m_mZ = false;
+		m_RZ = false;
+		m_NZ = false;
+		m_vZ = false;
+		m_bZ = false;
+		m_afZ = false;
+		m_lf.levels._aIIV((m_Hak[2].m_ifan[5].x + 0x18000) - m_foraI[0], (m_Hak[1].m_ifan[5].x - 0x18000) + m_foraI[0]);
+	}
+
+	public void _aZV(boolean flag) {
+		int j = (flag ? 0x10000 : 0xffff0000) << 1;
+		for (int i1 = 0; i1 < 6; i1++) {
+			for (int j1 = 0; j1 < 6; j1++)
+				m_Hak[i1].m_ifan[j1].y += j;
+		}
+
+	}
+
+	private void _iIIV(int j, int i1) {
+		if (m_Hak == null)
+			m_Hak = new k[6];
+		if (m_ian == null)
+			m_ian = new SimpleMenuElement[10];
+		int l1 = 0;
+		int i2 = 0;
+		int j2 = 0;
+		int k2 = 0;
+		for (int j1 = 0; j1 < 6; j1++) {
+			int l2 = 0;
+			switch (j1) {
+				case 0: // '\0'
+					i2 = 1;
+					l1 = 0x58000;
+					j2 = 0;
+					k2 = 0;
+					break;
+
+				case 4: // '\004'
+					i2 = 1;
+					l1 = 0x38000;
+					j2 = 0xfffe0000;
+					k2 = 0x30000;
+					break;
+
+				case 3: // '\003'
+					i2 = 1;
+					l1 = 0x38000;
+					j2 = 0x20000;
+					k2 = 0x30000;
+					break;
+
+				case 1: // '\001'
+					i2 = 0;
+					l1 = 0x18000;
+					j2 = 0x38000;
+					k2 = 0;
+					break;
+
+				case 2: // '\002'
+					i2 = 0;
+					l1 = 0x58000;
+					j2 = 0xfffc8000;
+					k2 = 0;
+					l2 = 21626;
+					break;
+
+				case 5: // '\005'
+					i2 = 2;
+					l1 = 0x48000;
+					j2 = 0;
+					k2 = 0x50000;
+					break;
+			}
+			if (m_Hak[j1] == null)
+				m_Hak[j1] = new k();
+			m_Hak[j1]._avV();
+			m_Hak[j1].m_aI = m_foraI[i2];
+			m_Hak[j1].m_intI = i2;
+			m_Hak[j1].m_forI = (int) ((long) (int) (0x1000000000000L / (long) l1 >> 16) * (long) m_yI >> 16);
+			m_Hak[j1].m_ifan[m_vaI].x = j + j2;
+			m_Hak[j1].m_ifan[m_vaI].y = i1 + k2;
+			m_Hak[j1].m_ifan[5].x = j + j2;
+			m_Hak[j1].m_ifan[5].y = i1 + k2;
+			m_Hak[j1].m_newI = l2;
+		}
+
+		for (int k1 = 0; k1 < 10; k1++) {
+			if (m_ian[k1] == null)
+				m_ian[k1] = new SimpleMenuElement();
+			m_ian[k1].init();
+			m_ian[k1].x = m_qI;
+			m_ian[k1].m_bI = m_xI;
+		}
+
+		m_ian[0].y = 0x38000;
+		m_ian[1].y = 0x38000;
+		m_ian[2].y = 0x39b05;
+		m_ian[3].y = 0x39b05;
+		m_ian[4].y = 0x40000;
+		m_ian[5].y = 0x35aa6;
+		m_ian[6].y = 0x35aa6;
+		m_ian[7].y = 0x2d413;
+		m_ian[8].y = 0x2d413;
+		m_ian[9].y = 0x50000;
+		m_ian[5].m_bI = (int) ((long) m_xI * 45875L >> 16);
+		m_ian[6].x = (int) (6553L * (long) m_qI >> 16);
+		m_ian[5].x = (int) (6553L * (long) m_qI >> 16);
+		m_ian[9].x = (int) (0x11999L * (long) m_qI >> 16);
+		m_ian[8].x = (int) (0x11999L * (long) m_qI >> 16);
+		m_ian[7].x = (int) (0x11999L * (long) m_qI >> 16);
+	}
+
+	public void _ifIIV(int j, int i1) {
+		m_lf._ifIIV(j, i1);
+	}
+
+	public void _nullvV() {
+		m_ifZ = m_sZ = m_rZ = m_OZ = false;
+	}
+
+	public void _aIIV(int j, int i1) {
+		if (!m_vZ) {
+			m_ifZ = m_sZ = m_rZ = m_OZ = false;
+			if (j > 0)
+				m_ifZ = true;
+			else if (j < 0)
+				m_sZ = true;
+			if (i1 > 0) {
+				m_rZ = true;
+				return;
+			}
+			if (i1 < 0)
+				m_OZ = true;
+		}
+	}
+
+	public synchronized void _casevV() {
+		_doZV(true);
+		m_vZ = true;
+	}
+
+	public synchronized void _avV() {
+		m_vZ = false;
+	}
+
+	public boolean _gotovZ() {
+		return m_vZ;
+	}
+
+	private void _pvV() {
+		int j = m_Hak[1].m_ifan[m_vaI].x - m_Hak[2].m_ifan[m_vaI].x;
+		int i1 = m_Hak[1].m_ifan[m_vaI].y - m_Hak[2].m_ifan[m_vaI].y;
+		int j1 = _doIII(j, i1);
+		int _tmp = (int) (((long) j << 32) / (long) j1 >> 16);
+		i1 = (int) (((long) i1 << 32) / (long) j1 >> 16);
+		m_FZ = false;
+		if (i1 < 0) {
+			m_XZ = true;
+			m_wZ = false;
+		} else if (i1 > 0) {
+			m_wZ = true;
+			m_XZ = false;
+		}
+		boolean flag;
+		if ((flag = (m_Hak[2].m_ifan[m_vaI].y - m_Hak[0].m_ifan[m_vaI].y <= 0 ? -1 : 1) * (m_Hak[2].m_ifan[m_vaI].m_eI - m_Hak[0].m_ifan[m_vaI].m_eI <= 0 ? -1 : 1) > 0) && m_wZ || !flag && m_XZ) {
+			m_dZ = true;
+			return;
+		} else {
+			m_dZ = false;
+			return;
+		}
+	}
+
+	private void _qvV() {
+		if (!m_IZ) {
+			int j = m_Hak[1].m_ifan[m_vaI].x - m_Hak[2].m_ifan[m_vaI].x;
+			int i1 = m_Hak[1].m_ifan[m_vaI].y - m_Hak[2].m_ifan[m_vaI].y;
+			int j1 = _doIII(j, i1);
+			j = (int) (((long) j << 32) / (long) j1 >> 16);
+			i1 = (int) (((long) i1 << 32) / (long) j1 >> 16);
+			if (m_dZ && m_cI >= -m_QI)
+				m_cI -= m_charI;
+			if (m_FZ) {
+				m_cI = 0;
+				m_Hak[1].m_ifan[m_vaI].m_gotoI = (int) ((long) m_Hak[1].m_ifan[m_vaI].m_gotoI * (long) (0x10000 - m_abI) >> 16);
+				m_Hak[2].m_ifan[m_vaI].m_gotoI = (int) ((long) m_Hak[2].m_ifan[m_vaI].m_gotoI * (long) (0x10000 - m_abI) >> 16);
+				if (m_Hak[1].m_ifan[m_vaI].m_gotoI < 6553)
+					m_Hak[1].m_ifan[m_vaI].m_gotoI = 0;
+				if (m_Hak[2].m_ifan[m_vaI].m_gotoI < 6553)
+					m_Hak[2].m_ifan[m_vaI].m_gotoI = 0;
+			}
+			m_Hak[0].m_forI = (int) (11915L * (long) m_yI >> 16);
+			m_Hak[0].m_forI = (int) (11915L * (long) m_yI >> 16);
+			m_Hak[4].m_forI = (int) (18724L * (long) m_yI >> 16);
+			m_Hak[3].m_forI = (int) (18724L * (long) m_yI >> 16);
+			m_Hak[1].m_forI = (int) (43690L * (long) m_yI >> 16);
+			m_Hak[2].m_forI = (int) (11915L * (long) m_yI >> 16);
+			m_Hak[5].m_forI = (int) (14563L * (long) m_yI >> 16);
+			if (m_XZ) {
+				m_Hak[0].m_forI = (int) (18724L * (long) m_yI >> 16);
+				m_Hak[4].m_forI = (int) (14563L * (long) m_yI >> 16);
+				m_Hak[3].m_forI = (int) (18724L * (long) m_yI >> 16);
+				m_Hak[1].m_forI = (int) (43690L * (long) m_yI >> 16);
+				m_Hak[2].m_forI = (int) (10082L * (long) m_yI >> 16);
+			} else if (m_wZ) {
+				m_Hak[0].m_forI = (int) (18724L * (long) m_yI >> 16);
+				m_Hak[4].m_forI = (int) (18724L * (long) m_yI >> 16);
+				m_Hak[3].m_forI = (int) (14563L * (long) m_yI >> 16);
+				m_Hak[1].m_forI = (int) (26214L * (long) m_yI >> 16);
+				m_Hak[2].m_forI = (int) (11915L * (long) m_yI >> 16);
+			}
+			if (m_XZ || m_wZ) {
+				int k1 = -i1;
+				int l1 = j;
+				if (m_XZ && m_kI > -m_longI) {
+					int i2 = 0x10000;
+					if (m_kI < 0)
+						i2 = (int) (((long) (m_longI - (m_kI >= 0 ? m_kI : -m_kI)) << 32) / (long) m_longI >> 16);
+					int k2 = (int) ((long) m_AI * (long) i2 >> 16);
+					int i3 = (int) ((long) k1 * (long) k2 >> 16);
+					int k3 = (int) ((long) l1 * (long) k2 >> 16);
+					int i4 = (int) ((long) j * (long) k2 >> 16);
+					int k4 = (int) ((long) i1 * (long) k2 >> 16);
+					if (m_TI > 32768)
+						m_TI = m_TI - 1638 >= 0 ? m_TI - 1638 : 0;
+					else
+						m_TI = m_TI - 3276 >= 0 ? m_TI - 3276 : 0;
+					m_Hak[4].m_ifan[m_vaI].m_eI -= i3;
+					m_Hak[4].m_ifan[m_vaI].m_dI -= k3;
+					m_Hak[3].m_ifan[m_vaI].m_eI += i3;
+					m_Hak[3].m_ifan[m_vaI].m_dI += k3;
+					m_Hak[5].m_ifan[m_vaI].m_eI -= i4;
+					m_Hak[5].m_ifan[m_vaI].m_dI -= k4;
+				}
+				if (m_wZ && m_kI < m_longI) {
+					int j2 = 0x10000;
+					if (m_kI > 0)
+						j2 = (int) (((long) (m_longI - m_kI) << 32) / (long) m_longI >> 16);
+					int l2 = (int) ((long) m_AI * (long) j2 >> 16);
+					int j3 = (int) ((long) k1 * (long) l2 >> 16);
+					int l3 = (int) ((long) l1 * (long) l2 >> 16);
+					int j4 = (int) ((long) j * (long) l2 >> 16);
+					int l4 = (int) ((long) i1 * (long) l2 >> 16);
+					if (m_TI > 32768)
+						m_TI = m_TI + 1638 >= 0x10000 ? 0x10000 : m_TI + 1638;
+					else
+						m_TI = m_TI + 3276 >= 0x10000 ? 0x10000 : m_TI + 3276;
+					m_Hak[4].m_ifan[m_vaI].m_eI += j3;
+					m_Hak[4].m_ifan[m_vaI].m_dI += l3;
+					m_Hak[3].m_ifan[m_vaI].m_eI -= j3;
+					m_Hak[3].m_ifan[m_vaI].m_dI -= l3;
+					m_Hak[5].m_ifan[m_vaI].m_eI += j4;
+					m_Hak[5].m_ifan[m_vaI].m_dI += l4;
+				}
+				return;
+			}
+			if (m_TI < 26214) {
+				m_TI += 3276;
+				return;
+			}
+			if (m_TI > 39321) {
+				m_TI -= 3276;
+				return;
+			}
+			m_TI = 32768;
+		}
+	}
+
+	public synchronized int _dovI() {
+		m_dZ = m_ifZ;
+		m_FZ = m_sZ;
+		m_XZ = m_OZ;
+		m_wZ = m_rZ;
+		if (m_vZ)
+			_pvV();
+		GameView._dovV();
+		_qvV();
+		int j;
+		if ((j = _uII(m_YI)) == 5 || m_mZ)
+			return 5;
+		if (m_IZ)
+			return 3;
+		if (_newvZ()) {
+			m_NZ = false;
+			return 4;
+		} else {
+			return j;
+		}
+	}
+
+	public boolean _newvZ() {
+		return m_Hak[1].m_ifan[m_vaI].x < m_lf._intvI();
+	}
+
+	public boolean _longvZ() {
+		return m_Hak[1].m_ifan[m_waI].x > m_lf._dovI() || m_Hak[2].m_ifan[m_waI].x > m_lf._dovI();
+	}
+
+	private int _uII(int j) {
+		boolean flag = m_RZ;
+		int i1 = 0;
+		int j1 = j;
+		int j2;
+		do {
+			if (i1 >= j)
+				break;
+			_aaIV(j1 - i1);
+			int k1;
+			if (!flag && _longvZ())
+				k1 = 3;
+			else
+				k1 = _baII(m_waI);
+			if (!flag && m_RZ)
+				return k1 == 3 ? 1 : 2;
+			if (k1 == 0) {
+				if (((j1 = i1 + j1 >> 1) - i1 >= 0 ? j1 - i1 : -(j1 - i1)) < 65)
+					return 5;
+			} else if (k1 == 3) {
+				m_RZ = true;
+				j1 = i1 + j1 >> 1;
+			} else {
+				int i2;
+				if (k1 == 1)
+					do {
+						_caIV(m_waI);
+						j2 = _baII(m_waI);
+						i2 = j2;
+						if (j2 == 0)
+							return 5;
+					} while (i2 != 2);
+				i1 = j1;
+				j1 = j;
+				m_vaI = m_vaI != 1 ? 1 : 0;
+				m_waI = m_waI != 1 ? 1 : 0;
+			}
+		} while (true);
+		int l1;
+		if ((l1 = (int) ((long) (m_Hak[1].m_ifan[m_vaI].x - m_Hak[2].m_ifan[m_vaI].x) * (long) (m_Hak[1].m_ifan[m_vaI].x - m_Hak[2].m_ifan[m_vaI].x) >> 16) + (int) ((long) (m_Hak[1].m_ifan[m_vaI].y - m_Hak[2].m_ifan[m_vaI].y) * (long) (m_Hak[1].m_ifan[m_vaI].y - m_Hak[2].m_ifan[m_vaI].y) >> 16)) < 0xf0000)
+			m_IZ = true;
+		if (l1 > 0x460000)
+			m_IZ = true;
+		return 0;
+	}
+
+	private void _aIV(int j) {
+		for (int i1 = 0; i1 < 6; i1++) {
+			k k1;
+			SimpleMenuElement n1;
+			(n1 = (k1 = m_Hak[i1]).m_ifan[j]).m_nullI = 0;
+			n1.m_longI = 0;
+			n1.m_fI = 0;
+			n1.m_longI -= (int) (((long) m_voidI << 32) / (long) k1.m_forI >> 16);
+		}
+
+		if (!m_IZ) {
+			_akkV(m_Hak[0], m_ian[1], m_Hak[2], j, 0x10000);
+			_akkV(m_Hak[0], m_ian[0], m_Hak[1], j, 0x10000);
+			_akkV(m_Hak[2], m_ian[6], m_Hak[4], j, 0x20000);
+			_akkV(m_Hak[1], m_ian[5], m_Hak[3], j, 0x20000);
+		}
+		_akkV(m_Hak[0], m_ian[2], m_Hak[3], j, 0x10000);
+		_akkV(m_Hak[0], m_ian[3], m_Hak[4], j, 0x10000);
+		_akkV(m_Hak[3], m_ian[4], m_Hak[4], j, 0x10000);
+		_akkV(m_Hak[5], m_ian[8], m_Hak[3], j, 0x10000);
+		_akkV(m_Hak[5], m_ian[7], m_Hak[4], j, 0x10000);
+		_akkV(m_Hak[5], m_ian[9], m_Hak[0], j, 0x10000);
+		SimpleMenuElement n2 = m_Hak[2].m_ifan[j];
+		m_cI = (int) ((long) m_cI * (long) (0x10000 - m_jI) >> 16);
+		n2.m_fI = m_cI;
+		if (n2.m_gotoI > m_PI)
+			n2.m_gotoI = m_PI;
+		if (n2.m_gotoI < -m_PI)
+			n2.m_gotoI = -m_PI;
+		int j1 = 0;
+		int l1 = 0;
+		for (int i2 = 0; i2 < 6; i2++) {
+			j1 += m_Hak[i2].m_ifan[j].m_eI;
+			l1 += m_Hak[i2].m_ifan[j].m_dI;
+		}
+
+		j1 = (int) (((long) j1 << 32) / 0x60000L >> 16);
+		l1 = (int) (((long) l1 << 32) / 0x60000L >> 16);
+		int j3 = 0;
+		for (int k3 = 0; k3 < 6; k3++) {
+			int j2 = m_Hak[k3].m_ifan[j].m_eI - j1;
+			int k2 = m_Hak[k3].m_ifan[j].m_dI - l1;
+			if ((j3 = _doIII(j2, k2)) > 0x1e0000) {
+				int l2 = (int) (((long) j2 << 32) / (long) j3 >> 16);
+				int i3 = (int) (((long) k2 << 32) / (long) j3 >> 16);
+				m_Hak[k3].m_ifan[j].m_eI -= l2;
+				m_Hak[k3].m_ifan[j].m_dI -= i3;
+			}
+		}
+
+		byte byte0 = ((byte) (m_Hak[2].m_ifan[j].y - m_Hak[0].m_ifan[j].y < 0 ? -1 : 1));
+		byte byte1 = ((byte) (m_Hak[2].m_ifan[j].m_eI - m_Hak[0].m_ifan[j].m_eI < 0 ? -1 : 1));
+		if (byte0 * byte1 > 0) {
+			m_kI = j3;
+			return;
+		} else {
+			m_kI = -j3;
+			return;
+		}
+	}
+
+	private void _akkV(k k1, SimpleMenuElement n1, k k2, int j, int i1) {
+		SimpleMenuElement n2 = k1.m_ifan[j];
+		SimpleMenuElement n3 = k2.m_ifan[j];
+		int j1 = n2.x - n3.x;
+		int l1 = n2.y - n3.y;
+		int i2;
+		if (((i2 = _doIII(j1, l1)) >= 0 ? i2 : -i2) >= 3) {
+			j1 = (int) (((long) j1 << 32) / (long) i2 >> 16);
+			l1 = (int) (((long) l1 << 32) / (long) i2 >> 16);
+			int j2 = i2 - n1.y;
+			int l2 = (int) ((long) j1 * (long) (int) ((long) j2 * (long) n1.x >> 16) >> 16);
+			int i3 = (int) ((long) l1 * (long) (int) ((long) j2 * (long) n1.x >> 16) >> 16);
+			int j3 = n2.m_eI - n3.m_eI;
+			int k3 = n2.m_dI - n3.m_dI;
+			int l3 = (int) ((long) ((int) ((long) j1 * (long) j3 >> 16) + (int) ((long) l1 * (long) k3 >> 16)) * (long) n1.m_bI >> 16);
+			l2 += (int) ((long) j1 * (long) l3 >> 16);
+			i3 += (int) ((long) l1 * (long) l3 >> 16);
+			l2 = (int) ((long) l2 * (long) i1 >> 16);
+			i3 = (int) ((long) i3 * (long) i1 >> 16);
+			n2.m_nullI -= l2;
+			n2.m_longI -= i3;
+			n3.m_nullI += l2;
+			n3.m_longI += i3;
+		}
+	}
+
+	private void _aIIV(int j, int i1, int j1) {
+		for (int l1 = 0; l1 < 6; l1++) {
+			SimpleMenuElement n1 = m_Hak[l1].m_ifan[j];
+			SimpleMenuElement n2;
+			(n2 = m_Hak[l1].m_ifan[i1]).x = (int) ((long) n1.m_eI * (long) j1 >> 16);
+			n2.y = (int) ((long) n1.m_dI * (long) j1 >> 16);
+			int k1 = (int) ((long) j1 * (long) m_Hak[l1].m_forI >> 16);
+			n2.m_eI = (int) ((long) n1.m_nullI * (long) k1 >> 16);
+			n2.m_dI = (int) ((long) n1.m_longI * (long) k1 >> 16);
+		}
+
+	}
+
+	private void _zIIV(int j, int i1, int j1) {
+		for (int k1 = 0; k1 < 6; k1++) {
+			SimpleMenuElement n1 = m_Hak[k1].m_ifan[j];
+			SimpleMenuElement n2 = m_Hak[k1].m_ifan[i1];
+			SimpleMenuElement n3 = m_Hak[k1].m_ifan[j1];
+			n1.x = n2.x + (n3.x >> 1);
+			n1.y = n2.y + (n3.y >> 1);
+			n1.m_eI = n2.m_eI + (n3.m_eI >> 1);
+			n1.m_dI = n2.m_dI + (n3.m_dI >> 1);
+		}
+
+	}
+
+	private void _aaIV(int j) {
+		_aIV(m_vaI);
+		_aIIV(m_vaI, 2, j);
+		_zIIV(4, m_vaI, 2);
+		_aIV(4);
+		_aIIV(4, 3, j >> 1);
+		_zIIV(4, m_vaI, 3);
+		_zIIV(m_waI, m_vaI, 2);
+		_zIIV(m_waI, m_waI, 3);
+
+		// wheels?!?!?!?! oh my god i found it!!!!!
+		for (int i1 = 1; i1 <= 2; i1++) {
+			SimpleMenuElement n1 = m_Hak[i1].m_ifan[m_vaI];
+			SimpleMenuElement n2;
+			(n2 = m_Hak[i1].m_ifan[m_waI]).m_bI = n1.m_bI + (int) ((long) j * (long) n1.m_gotoI >> 16);
+			n2.m_gotoI = n1.m_gotoI + (int) ((long) j * (long) (int) ((long) m_Hak[i1].m_newI * (long) n1.m_fI >> 16) >> 16);
+		}
+
+	}
+
+	private int _baII(int j) {
+		byte byte0 = 2;
+		int i1;
+		i1 = (i1 = m_Hak[1].m_ifan[j].x >= m_Hak[2].m_ifan[j].x ? m_Hak[1].m_ifan[j].x : m_Hak[2].m_ifan[j].x) >= m_Hak[5].m_ifan[j].x ? i1 : m_Hak[5].m_ifan[j].x;
+		int j1;
+		j1 = (j1 = m_Hak[1].m_ifan[j].x >= m_Hak[2].m_ifan[j].x ? m_Hak[2].m_ifan[j].x : m_Hak[1].m_ifan[j].x) >= m_Hak[5].m_ifan[j].x ? m_Hak[5].m_ifan[j].x : j1;
+		m_lf._aIIV(j1 - m_foraI[0], i1 + m_foraI[0], m_Hak[5].m_ifan[j].y);
+		int k1 = m_Hak[1].m_ifan[j].x - m_Hak[2].m_ifan[j].x;
+		int l1 = m_Hak[1].m_ifan[j].y - m_Hak[2].m_ifan[j].y;
+		int i2 = _doIII(k1, l1);
+		k1 = (int) (((long) k1 << 32) / (long) i2 >> 16);
+		int j2 = -(int) (((long) l1 << 32) / (long) i2 >> 16);
+		int k2 = k1;
+		for (int l2 = 0; l2 < 6; l2++) {
+			if (l2 == 4 || l2 == 3)
+				continue;
+			SimpleMenuElement n1 = m_Hak[l2].m_ifan[j];
+			if (l2 == 0) {
+				n1.x += (int) ((long) j2 * 0x10000L >> 16);
+				n1.y += (int) ((long) k2 * 0x10000L >> 16);
+			}
+			int i3 = m_lf._anvI(n1, m_Hak[l2].m_intI);
+			if (l2 == 0) {
+				n1.x -= (int) ((long) j2 * 0x10000L >> 16);
+				n1.y -= (int) ((long) k2 * 0x10000L >> 16);
+			}
+			m_EI = m_lf.m_eI;
+			m_CI = m_lf.m_dI;
+			if (l2 == 5 && i3 != 2)
+				m_mZ = true;
+			if (l2 == 1 && i3 != 2)
+				m_NZ = true;
+			if (i3 == 1) {
+				m_xaI = l2;
+				byte0 = 1;
+				continue;
+			}
+			if (i3 != 0)
+				continue;
+			m_xaI = l2;
+			byte0 = 0;
+			break;
+		}
+
+		return byte0;
+	}
+
+	private void _caIV(int j) {
+		k k1;
+		SimpleMenuElement n1;
+		(n1 = (k1 = m_Hak[m_xaI]).m_ifan[j]).x += (int) ((long) m_EI * 3276L >> 16);
+		n1.y += (int) ((long) m_CI * 3276L >> 16);
+		int i1;
+		int j1;
+		int l1;
+		int i2;
+		int j2;
+		if (m_FZ && (m_xaI == 2 || m_xaI == 1) && n1.m_gotoI < 6553) {
+			i1 = m_gI - m_WI;
+			j1 = 13107;
+			l1 = 39321;
+			i2 = 26214 - m_WI;
+			j2 = 26214 - m_WI;
+		} else {
+			i1 = m_gI;
+			j1 = m_fI;
+			l1 = m_eI;
+			i2 = m_aeI;
+			j2 = m_adI;
+		}
+		int k2 = _doIII(m_EI, m_CI);
+		m_EI = (int) (((long) m_EI << 32) / (long) k2 >> 16);
+		m_CI = (int) (((long) m_CI << 32) / (long) k2 >> 16);
+		int l2 = n1.m_eI;
+		int i3 = n1.m_dI;
+		int j3 = -((int) ((long) l2 * (long) m_EI >> 16) + (int) ((long) i3 * (long) m_CI >> 16));
+		int k3 = -((int) ((long) l2 * (long) (-m_CI) >> 16) + (int) ((long) i3 * (long) m_EI >> 16));
+		int l3 = (int) ((long) i1 * (long) n1.m_gotoI >> 16) - (int) ((long) j1 * (long) (int) (((long) k3 << 32) / (long) k1.m_aI >> 16) >> 16);
+		int i4 = (int) ((long) i2 * (long) k3 >> 16) - (int) ((long) l1 * (long) (int) ((long) n1.m_gotoI * (long) k1.m_aI >> 16) >> 16);
+		int j4 = -(int) ((long) j2 * (long) j3 >> 16);
+		int k4 = (int) ((long) (-i4) * (long) (-m_CI) >> 16);
+		int l4 = (int) ((long) (-i4) * (long) m_EI >> 16);
+		int i5 = (int) ((long) (-j4) * (long) m_EI >> 16);
+		int j5 = (int) ((long) (-j4) * (long) m_CI >> 16);
+		n1.m_gotoI = l3;
+		n1.m_eI = k4 + i5;
+		n1.m_dI = l4 + j5;
+	}
+
+	public void _ifZV(boolean flag) {
+		m_doZ = flag;
+	}
+
+	public void _caseIV(int j) {
+		m_GI = (int) (((long) (int) (0xa0000L * (long) (j << 16) >> 16) << 32) / 0x800000L >> 16);
+	}
+
+	public int _elsevI() {
+		if (m_doZ)
+			m_oI = (int) (((long) m_aaan[0].m_eI << 32) / 0x180000L >> 16) + (int) ((long) m_oI * 57344L >> 16);
+		else
+			m_oI = 0;
+		m_oI = m_oI >= m_GI ? m_GI : m_oI;
+		m_oI = m_oI >= -m_GI ? m_oI : -m_GI;
+		return (m_aaan[0].x + m_oI << 2) >> 16;
+	}
+
+	public int _ifvI() {
+		if (m_doZ)
+			m_nI = (int) (((long) m_aaan[0].m_dI << 32) / 0x180000L >> 16) + (int) ((long) m_nI * 57344L >> 16);
+		else
+			m_nI = 0;
+		m_nI = m_nI >= m_GI ? m_GI : m_nI;
+		m_nI = m_nI >= -m_GI ? m_nI : -m_GI;
+		return (m_aaan[0].y + m_nI << 2) >> 16;
+	}
+
+	public int _tryvI() {
+		int j = m_aaan[1].x >= m_aaan[2].x ? m_aaan[1].x : m_aaan[2].x;
+		if (m_IZ)
+			return m_lf._aII(m_aaan[0].x);
+		else
+			return m_lf._aII(j);
+	}
+
+	public void _charvV() {
+		synchronized (m_Hak) {
+			for (int j = 0; j < 6; j++) {
+				m_Hak[j].m_ifan[5].x = m_Hak[j].m_ifan[m_vaI].x;
+				m_Hak[j].m_ifan[5].y = m_Hak[j].m_ifan[m_vaI].y;
+				m_Hak[j].m_ifan[5].m_bI = m_Hak[j].m_ifan[m_vaI].m_bI;
+			}
+
+			m_Hak[0].m_ifan[5].m_eI = m_Hak[0].m_ifan[m_vaI].m_eI;
+			m_Hak[0].m_ifan[5].m_dI = m_Hak[0].m_ifan[m_vaI].m_dI;
+			m_Hak[2].m_ifan[5].m_gotoI = m_Hak[2].m_ifan[m_vaI].m_gotoI;
+		}
+	}
+
+	public void _voidvV() {
+		synchronized (m_Hak) {
+			for (int j = 0; j < 6; j++) {
+				m_aaan[j].x = m_Hak[j].m_ifan[5].x;
+				m_aaan[j].y = m_Hak[j].m_ifan[5].y;
+				m_aaan[j].m_bI = m_Hak[j].m_ifan[5].m_bI;
+			}
+
+			m_aaan[0].m_eI = m_Hak[0].m_ifan[5].m_eI;
+			m_aaan[0].m_dI = m_Hak[0].m_ifan[5].m_dI;
+			m_aaan[2].m_gotoI = m_Hak[2].m_ifan[5].m_gotoI;
+		}
+	}
+
+	private void _aiIV(GameView view, int i1, int j1) {
+		int k1 = FPMath._ifIII(m_aaan[0].x - m_aaan[3].x, m_aaan[0].y - m_aaan[3].y);
+		int l1 = FPMath._ifIII(m_aaan[0].x - m_aaan[4].x, m_aaan[0].y - m_aaan[4].y);
+		int engineX = (m_aaan[0].x >> 1) + (m_aaan[3].x >> 1);
+		int engineY = (m_aaan[0].y >> 1) + (m_aaan[3].y >> 1);
+		int fenderX = (m_aaan[0].x >> 1) + (m_aaan[4].x >> 1);
+		int fenderY = (m_aaan[0].y >> 1) + (m_aaan[4].y >> 1);
+		int i3 = -j1;
+		int j3 = i1;
+		engineX += (int) ((long) i3 * 0x10000L >> 16) - (int) ((long) i1 * 32768L >> 16);
+		engineY += (int) ((long) j3 * 0x10000L >> 16) - (int) ((long) j1 * 32768L >> 16);
+		fenderX += (int) ((long) i3 * 0x10000L >> 16) - (int) ((long) i1 * 0x1ccccL >> 16);
+		fenderY += (int) ((long) j3 * 0x10000L >> 16) - (int) ((long) j1 * 0x20000L >> 16);
+		view.drawFender((fenderX << 2) / (float) 0xFFFF /*>> 16*/, (fenderY << 2) / (float) 0xFFFF /*>> 16*/, l1);
+		view.drawEngine((engineX << 2) / (float) 0xFFFF /*>> 16*/, (engineY << 2) / (float) 0xFFFF /*>> 16*/, k1);
+	}
+
+	private void _laiV(GameView view) {
+		view.setColor(128, 128, 128);
+		view.drawLine(m_aaan[3].x, m_aaan[3].y, m_aaan[1].x, m_aaan[1].y);
+	}
+
+	private void _aiV(GameView gameView) {
+		int i1 = 1;
+		int j1 = 1;
+		switch (m_hI) {
+			case 2: // '\002'
+			case 3: // '\003'
+				i1 = j1 = 0;
+				break;
+
+			case 1: // '\001'
+				i1 = 0;
+				break;
+		}
+		gameView.drawWheel((m_aaan[2].x << 2) / (float) 0xFFFF /*>> 16*/, (m_aaan[2].y << 2) / (float) 0xFFFF /*>> 16*/, i1);
+		gameView.drawWheel((m_aaan[1].x << 2) / (float) 0xFFFF /*>> 16*/, (m_aaan[1].y << 2) / (float) 0xFFFF /*>> 16*/, j1);
+	}
+
+	private void _doiV(GameView gameView) {
+		int i1;
+		int j1 = (int) ((long) (i1 = m_Hak[1].m_aI) * 58982L >> 16);
+		int k1 = (int) ((long) i1 * 45875L >> 16);
+		gameView.setColor(0, 0, 0);
+		if (getGDActivity().isMenuShown()) {
+			gameView.drawLineWheel((m_aaan[1].x << 2) >> 16, (m_aaan[1].y << 2) >> 16, (i1 + i1 << 2) >> 16);
+			gameView.drawLineWheel((m_aaan[1].x << 2) >> 16, (m_aaan[1].y << 2) >> 16, (j1 + j1 << 2) >> 16);
+			gameView.drawLineWheel((m_aaan[2].x << 2) >> 16, (m_aaan[2].y << 2) >> 16, (i1 + i1 << 2) >> 16);
+			gameView.drawLineWheel((m_aaan[2].x << 2) >> 16, (m_aaan[2].y << 2) >> 16, (k1 + k1 << 2) >> 16);
+		}
+
+		// right wheel
+		int l1 = j1;
+		int i2 = 0;
+		int j2;
+		int k2 = FPMath._doII(j2 = m_aaan[1].m_bI);
+		int l2 = FPMath.sin(j2);
+		int i3 = l1;
+		l1 = (int) ((long) k2 * (long) l1 >> 16) + (int) ((long) (-l2) * (long) i2 >> 16);
+		i2 = (int) ((long) l2 * (long) i3 >> 16) + (int) ((long) k2 * (long) i2 >> 16);
+		k2 = FPMath._doII(j2 = 0x141b2);
+		l2 = FPMath.sin(j2);
+		for (int k3 = 0; k3 < 5; k3++) {
+			gameView.drawLine(m_aaan[1].x, m_aaan[1].y, m_aaan[1].x + l1, m_aaan[1].y + i2);
+			i3 = l1;
+			l1 = (int) ((long) k2 * (long) l1 >> 16) + (int) ((long) (-l2) * (long) i2 >> 16);
+			i2 = (int) ((long) l2 * (long) i3 >> 16) + (int) ((long) k2 * (long) i2 >> 16);
+		}
+
+		// left wheel
+		l1 = j1;
+		i2 = 0;
+		// k2 = FPMath._doII(j2 = m_aaan[2].m_bI);
+		k2 = FPMath._doII(j2 = Math.round(m_aaan[2].m_bI / 1.75f));
+		l2 = FPMath.sin(j2);
+		i3 = l1;
+		l1 = (int) ((long) k2 * (long) l1 >> 16) + (int) ((long) (-l2) * (long) i2 >> 16);
+		i2 = (int) ((long) l2 * (long) i3 >> 16) + (int) ((long) k2 * (long) i2 >> 16);
+		k2 = FPMath._doII(j2 = 0x141b2);
+		l2 = FPMath.sin(j2);
+
+		boolean toUpdate = true;
+		for (int l3 = 0; l3 < 5; l3++) {
+			if (toUpdate) {
+				// Log.d("AGDTR", "toUpdate is true");
+				leftWheelParams[l3][0] = m_aaan[2].x;
+				leftWheelParams[l3][1] = m_aaan[2].y;
+				leftWheelParams[l3][2] = m_aaan[2].x + l1;
+				leftWheelParams[l3][3] = m_aaan[2].y + i2;
+			}
+			// gameView.drawLine(m_aaan[2].x, m_aaan[2].y, m_aaan[2].x + l1, m_aaan[2].y + i2);
+			gameView.drawLine(leftWheelParams[l3][0], leftWheelParams[l3][1], leftWheelParams[l3][2], leftWheelParams[l3][3]);
+			int j3 = l1;
+			l1 = (int) ((long) k2 * (long) l1 >> 16) + (int) ((long) (-l2) * (long) i2 >> 16);
+			i2 = (int) ((long) l2 * (long) j3 >> 16) + (int) ((long) k2 * (long) i2 >> 16);
+		}
+		// if (toUpdate) leftWheelLastUpdated = System.currentTimeMillis();
+		// Log.d("AGDTR", "diff: " + (System.currentTimeMillis() - leftWheelLastUpdated));
+
+		if (m_hI > 0) {
+			gameView.setColor(255, 0, 0);
+			if (m_hI > 2)
+				gameView.setColor(100, 100, 255);
+			gameView.drawLineWheel((m_aaan[2].x << 2) / (float) 0xFFFF /*>> 16*/, (m_aaan[2].y << 2) / (float) 0xFFFF /*>> 16*/, 4);
+			gameView.drawLineWheel((m_aaan[1].x << 2) / (float) 0xFFFF /*>> 16*/, (m_aaan[1].y << 2) / (float) 0xFFFF /*>> 16*/, 4);
+		}
+	}
+
+	private void _ifiIIV(GameView j, int i1, int j1, int k1, int l1) {
+		int i2 = 0;
+		int j2 = 0x10000;
+		int k2 = m_aaan[0].x;
+		int l2 = m_aaan[0].y;
+		int i3 = 0;
+		int j3 = 0;
+		int k3 = 0;
+		int l3 = 0;
+		int i4 = 0;
+		int j4 = 0;
+		int k4 = 0;
+		int l4 = 0;
+		int i5 = 0;
+		int j5 = 0;
+		int k5 = 0;
+		int l5 = 0;
+		int i6 = 0;
+		int j6 = 0;
+		int k6 = 0;
+		int l6 = 0;
+		int ai[][] = (int[][]) null;
+		int ai1[][] = (int[][]) null;
+		int ai2[][] = (int[][]) null;
+		if (m_elseZ) {
+			if (m_TI < 32768) {
+				ai1 = m_ucaaI;
+				ai2 = m_KaaI;
+				j2 = (int) ((long) m_TI * 0x20000L >> 16);
+			} else if (m_TI > 32768) {
+				i2 = 1;
+				ai1 = m_KaaI;
+				ai2 = m_SaaI;
+				j2 = (int) ((long) (m_TI - 32768) * 0x20000L >> 16);
+			} else {
+				ai = m_KaaI;
+			}
+		} else if (m_TI < 32768) {
+			ai1 = m_DaaI;
+			ai2 = m_wcaaI;
+			j2 = (int) ((long) m_TI * 0x20000L >> 16);
+		} else if (m_TI > 32768) {
+			i2 = 1;
+			ai1 = m_wcaaI;
+			ai2 = m_MaaI;
+			j2 = (int) ((long) (m_TI - 32768) * 0x20000L >> 16);
+		} else {
+			ai = m_wcaaI;
+		}
+		for (int j7 = 0; j7 < m_KaaI.length; j7++) {
+			int i8;
+			int j8;
+			if (ai1 != null) {
+				j8 = (int) ((long) ai1[j7][0] * (long) (0x10000 - j2) >> 16) + (int) ((long) ai2[j7][0] * (long) j2 >> 16);
+				i8 = (int) ((long) ai1[j7][1] * (long) (0x10000 - j2) >> 16) + (int) ((long) ai2[j7][1] * (long) j2 >> 16);
+			} else {
+				j8 = ai[j7][0];
+				i8 = ai[j7][1];
+			}
+			int k8 = k2 + (int) ((long) k1 * (long) j8 >> 16) + (int) ((long) i1 * (long) i8 >> 16);
+			int l8 = l2 + (int) ((long) l1 * (long) j8 >> 16) + (int) ((long) j1 * (long) i8 >> 16);
+			switch (j7) {
+				case 0: // '\0'
+					k4 = k8;
+					l4 = l8;
+					break;
+
+				case 1: // '\001'
+					i5 = k8;
+					j5 = l8;
+					break;
+
+				case 2: // '\002'
+					k5 = k8;
+					l5 = l8;
+					break;
+
+				case 3: // '\003'
+					i6 = k8;
+					j6 = l8;
+					break;
+
+				case 4: // '\004'
+					k6 = k8;
+					l6 = l8;
+					break;
+
+				case 5: // '\005'
+					k3 = k8;
+					l3 = l8;
+					break;
+
+				case 6: // '\006'
+					i4 = k8;
+					j4 = l8;
+					break;
+
+				case 7: // '\007'
+					i3 = k8;
+					j3 = l8;
+					break;
+			}
+		}
+
+		int i7 = (int) ((long) m_JaaI[i2][0] * (long) (0x10000 - j2) >> 16) + (int) ((long) m_JaaI[i2 + 1][0] * (long) j2 >> 16);
+		if (m_elseZ) {
+			j._aIIIV(k3 << 2, l3 << 2, k4 << 2, l4 << 2, 1);
+			j._aIIIV(k4 << 2, l4 << 2, i5 << 2, j5 << 2, 1);
+			j.drawBikerPart(i5 << 2, j5 << 2, k5 << 2, l5 << 2, 2, i7);
+			j._aIIIV(k5 << 2, l5 << 2, k6 << 2, l6 << 2, 0);
+			int k7 = FPMath._ifIII(i1, j1);
+			if (m_TI > 32768)
+				k7 += 20588;
+			j.drawHelmet((i6 << 2) / (float) 0xFFFF /*>> 16*/, (j6 << 2) / (float) 0xFFFF /*>> 16*/, k7);
+		} else {
+			j.setColor(0, 0, 0);
+			j.drawLine(k3, l3, k4, l4);
+			j.drawLine(k4, l4, i5, j5);
+			j.setColor(0, 0, 128);
+			j.drawLine(i5, j5, k5, l5);
+			j.drawLine(k5, l5, k6, l6);
+			j.drawLine(k6, l6, i3, j3);
+			int l7 = 0x10000;
+			j.setColor(156, 0, 0);
+			j.drawLineWheel((i6 << 2) >> 16, (j6 << 2) >> 16, (l7 + l7 << 2) >> 16);
+		}
+		j.setColor(0, 0, 0);
+		j.drawSteering((i3 << 2) >> 16, (j3 << 2) >> 16);
+		j.drawSteering((i4 << 2) >> 16, (j4 << 2) >> 16);
+	}
+
+	private void _aiIIV(GameView j, int i1, int j1, int k1, int l1) {
+		int i2 = m_aaan[2].x;
+		int j2 = m_aaan[2].y;
+		int k2 = i2 + (int) ((long) k1 * (long) 32768 >> 16);
+		int l2 = j2 + (int) ((long) l1 * (long) 32768 >> 16);
+		int i3 = i2 - (int) ((long) k1 * (long) 32768 >> 16);
+		int j3 = j2 - (int) ((long) l1 * (long) 32768 >> 16);
+		int k3 = m_aaan[0].x + (int) ((long) i1 * 32768L >> 16);
+		int l3 = m_aaan[0].y + (int) ((long) j1 * 32768L >> 16);
+		int i4 = k3 - (int) ((long) i1 * 0x20000L >> 16);
+		int j4 = l3 - (int) ((long) j1 * 0x20000L >> 16);
+		int k4 = i4 + (int) ((long) k1 * 0x10000L >> 16);
+		int l4 = j4 + (int) ((long) l1 * 0x10000L >> 16);
+		int i5 = i4 + (int) ((long) i1 * 49152L >> 16) + (int) ((long) k1 * 49152L >> 16);
+		int j5 = j4 + (int) ((long) j1 * 49152L >> 16) + (int) ((long) l1 * 49152L >> 16);
+		int k5 = i4 + (int) ((long) k1 * 32768L >> 16);
+		int l5 = j4 + (int) ((long) l1 * 32768L >> 16);
+		int i6 = m_aaan[1].x;
+		int j6 = m_aaan[1].y;
+		int k6 = m_aaan[4].x - (int) ((long) i1 * 49152L >> 16);
+		int l6 = m_aaan[4].y - (int) ((long) j1 * 49152L >> 16);
+		int i7 = k6 - (int) ((long) k1 * 32768L >> 16);
+		int j7 = l6 - (int) ((long) l1 * 32768L >> 16);
+		int k7 = (k6 - (int) ((long) i1 * 0x20000L >> 16)) + (int) ((long) k1 * 16384L >> 16);
+		int l7 = (l6 - (int) ((long) j1 * 0x20000L >> 16)) + (int) ((long) l1 * 16384L >> 16);
+		int i8 = m_aaan[3].x;
+		int j8 = m_aaan[3].y;
+		int k8 = i8 + (int) ((long) k1 * 32768L >> 16);
+		int l8 = j8 + (int) ((long) l1 * 32768L >> 16);
+		int i9 = (i8 + (int) ((long) k1 * 0x1c000L >> 16)) - (int) ((long) i1 * 32768L >> 16);
+		int j9 = (j8 + (int) ((long) l1 * 0x1c000L >> 16)) - (int) ((long) j1 * 32768L >> 16);
+		j.setColor(50, 50, 50);
+		j.drawLineWheel((k5 << 2) >> 16, (l5 << 2) >> 16, (32768 + 32768 << 2) >> 16);
+		if (!m_IZ) {
+			j.drawLine(k2, l2, k4, l4);
+			j.drawLine(i3, j3, i4, j4);
+		}
+		j.drawLine(k3, l3, i4, j4);
+		j.drawLine(k3, l3, i8, j8);
+		j.drawLine(i5, j5, k8, l8);
+		j.drawLine(k8, l8, i9, j9);
+		if (!m_IZ) {
+			j.drawLine(i8, j8, i6, j6);
+			j.drawLine(i9, j9, i6, j6);
+		}
+		j.drawLine(k4, l4, i7, j7);
+		j.drawLine(i5, j5, k6, l6);
+		j.drawLine(k6, l6, k7, l7);
+		j.drawLine(i7, j7, k7, l7);
+	}
+
+	public void _ifiV(GameView j) {
+		j._tryvV();
+		int i1 = m_aaan[3].x - m_aaan[4].x;
+		int j1 = m_aaan[3].y - m_aaan[4].y;
+		int k1;
+		if ((k1 = _doIII(i1, j1)) != 0) {
+			i1 = (int) (((long) i1 << 32) / (long) k1 >> 16);
+			j1 = (int) (((long) j1 << 32) / (long) k1 >> 16);
+		}
+		int l1 = -j1;
+		int i2 = i1;
+		if (m_IZ) {
+			int k2 = m_aaan[4].x;
+			int j2;
+			if ((j2 = m_aaan[3].x) >= k2) {
+				int l2 = j2;
+				j2 = k2;
+				k2 = l2;
+			}
+			m_lf.levels._aIIV(j2, k2);
+		}
+
+		Loader loader = getLevelLoader();
+		if (loader != null && loader.isPerspectiveEnabled())
+			m_lf._aiIV(j, m_aaan[0].x, m_aaan[0].y);
+		if (m_UZ)
+			_aiIV(j, i1, j1);
+		if (!getGDActivity().isMenuShown())
+			_aiV(j);
+		_doiV(j);
+		if (m_UZ)
+			j.setColor(170, 0, 0);
+		else
+			j.setColor(50, 50, 50);
+		j._ifIIIV((m_aaan[1].x << 2) >> 16, (m_aaan[1].y << 2) >> 16, (m_foraI[0] << 2) >> 16, FPMath._ifIII(i1, j1));
+		if (!m_IZ)
+			_laiV(j);
+		_ifiIIV(j, i1, j1, l1, i2);
+		if (!m_UZ)
+			_aiIIV(j, i1, j1, l1, i2);
+		m_lf._aiV(j);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Game/k.java b/src/org/happysanta/gd/Game/k.java
new file mode 100755
index 0000000..7a45482
--- /dev/null
+++ b/src/org/happysanta/gd/Game/k.java
@@ -0,0 +1,34 @@
+package org.happysanta.gd.Game;
+
+// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
+// Jad home page: http://www.kpdus.com/jad.html
+// Decompiler options: packimports(3) fieldsfirst ansi 
+
+
+import org.happysanta.gd.Menu.SimpleMenuElement;
+
+public class k {
+
+	public boolean m_doZ;
+	public int m_aI;
+	public int m_intI;
+	public int m_forI;
+	public int m_newI;
+	public SimpleMenuElement m_ifan[];
+
+	public k() {
+		m_ifan = new SimpleMenuElement[6];
+		for (int i = 0; i < 6; i++)
+			m_ifan[i] = new SimpleMenuElement();
+
+		_avV();
+	}
+
+	public void _avV() {
+		m_aI = m_forI = m_newI = 0;
+		m_doZ = true;
+		for (int i = 0; i < 6; i++)
+			m_ifan[i].init();
+
+	}
+}
diff --git a/src/org/happysanta/gd/Global.java b/src/org/happysanta/gd/Global.java
new file mode 100755
index 0000000..3fb600b
--- /dev/null
+++ b/src/org/happysanta/gd/Global.java
@@ -0,0 +1,21 @@
+package org.happysanta.gd;
+
+import android.graphics.Typeface;
+
+public class Global {
+
+	public static final boolean DEBUG = false;
+	public static final boolean DISABLE_SCALING = false;
+	public static final boolean INSTALLED_FROM_APK = true;
+	public static final boolean ACRA_ENABLED = true;
+	// public static final boolean ENABLE_TOUCH_HACK_FOR_ALL = false;
+
+	public static float density = 0;
+	public static Typeface robotoCondensedTypeface;
+
+	static {
+		density = Helpers.getGDActivity().getResources().getDisplayMetrics().density;
+		robotoCondensedTypeface = Typeface.createFromAsset(Helpers.getGDActivity().getAssets(), "RobotoCondensed-Regular.ttf");
+	}
+
+}
diff --git a/src/org/happysanta/gd/Helpers.java b/src/org/happysanta/gd/Helpers.java
new file mode 100755
index 0000000..667a880
--- /dev/null
+++ b/src/org/happysanta/gd/Helpers.java
@@ -0,0 +1,309 @@
+package org.happysanta.gd;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.Build;
+import android.util.Log;
+import org.happysanta.gd.Game.GameView;
+import org.happysanta.gd.Levels.Loader;
+import org.happysanta.gd.Menu.Menu;
+import org.happysanta.gd.Storage.LevelsManager;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class Helpers {
+
+	private static char[] cp1251Map = new char[]{
+			'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', '\u0007',
+			'\u0008', '\u0009', '\n', '\u000B', '\u000C', '\r', '\u000E', '\u000F',
+			'\u0010', '\u0011', '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
+			'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D', '\u001E', '\u001F',
+			'\u0020', '\u0021', '\u0022', '\u0023', '\u0024', '\u0025', '\u0026', '\'',
+			'\u0028', '\u0029', '\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
+			'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035', '\u0036', '\u0037',
+			'\u0038', '\u0039', '\u003A', '\u003B', '\u003C', '\u003D', '\u003E', '\u003F',
+			'\u0040', '\u0041', '\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
+			'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D', '\u004E', '\u004F',
+			'\u0050', '\u0051', '\u0052', '\u0053', '\u0054', '\u0055', '\u0056', '\u0057',
+			'\u0058', '\u0059', '\u005A', '\u005B', '\\', '\u005D', '\u005E', '\u005F',
+			'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065', '\u0066', '\u0067',
+			'\u0068', '\u0069', '\u006A', '\u006B', '\u006C', '\u006D', '\u006E', '\u006F',
+			'\u0070', '\u0071', '\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
+			'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D', '\u007E', '\u007F',
+			'\u0402', '\u0403', '\u201A', '\u0453', '\u201E', '\u2026', '\u2020', '\u2021',
+			'\u20AC', '\u2030', '\u0409', '\u2039', '\u040A', '\u040C', '\u040B', '\u040F',
+			'\u0452', '\u2018', '\u2019', '\u201C', '\u201D', '\u2022', '\u2013', '\u2014',
+			'\uFFFD', '\u2122', '\u0459', '\u203A', '\u045A', '\u045C', '\u045B', '\u045F',
+			'\u00A0', '\u040E', '\u045E', '\u0408', '\u00A4', '\u0490', '\u00A6', '\u00A7',
+			'\u0401', '\u00A9', '\u0404', '\u00AB', '\u00AC', '\u00AD', '\u00AE', '\u0407',
+			'\u00B0', '\u00B1', '\u0406', '\u0456', '\u0491', '\u00B5', '\u00B6', '\u00B7',
+			'\u0451', '\u2116', '\u0454', '\u00BB', '\u0458', '\u0405', '\u0455', '\u0457',
+			'\u0410', '\u0411', '\u0412', '\u0413', '\u0414', '\u0415', '\u0416', '\u0417',
+			'\u0418', '\u0419', '\u041A', '\u041B', '\u041C', '\u041D', '\u041E', '\u041F',
+			'\u0420', '\u0421', '\u0422', '\u0423', '\u0424', '\u0425', '\u0426', '\u0427',
+			'\u0428', '\u0429', '\u042A', '\u042B', '\u042C', '\u042D', '\u042E', '\u042F',
+			'\u0430', '\u0431', '\u0432', '\u0433', '\u0434', '\u0435', '\u0436', '\u0437',
+			'\u0438', '\u0439', '\u043A', '\u043B', '\u043C', '\u043D', '\u043E', '\u043F',
+			'\u0440', '\u0441', '\u0442', '\u0443', '\u0444', '\u0445', '\u0446', '\u0447',
+			'\u0448', '\u0449', '\u044A', '\u044B', '\u044C', '\u044D', '\u044E', '\u044F'
+	};
+
+	public static GDActivity getGDActivity() {
+		return GDActivity.shared;
+	}
+
+	public static GameView getGDView() {
+		return GDActivity.shared.gameView;
+	}
+
+	public static Menu getGameMenu() {
+		return GDActivity.shared.menu;
+	}
+
+	public static Loader getLevelLoader() {
+		return GDActivity.shared.levelLoader;
+	}
+
+	public static LevelsManager getLevelsManager() {
+		return GDActivity.shared.levelsManager;
+	}
+
+	public static int getDp(int px) {
+		return Math.round(px * Global.density);
+	}
+
+	public static int getDp(float px) {
+		return Math.round(px * Global.density);
+	}
+
+	public static String getCurrentStackTrace() {
+		String del = "\n";
+		StringBuilder sb = new StringBuilder();
+		StackTraceElement[] list = Thread.currentThread().getStackTrace();
+		// for (StackTraceElement e: list) {
+		for (int i = 0; i < list.length; i++) {
+			sb.append(list[i].toString() + (i < list.length - 1 ? del : ""));
+		}
+		return sb.toString();
+	}
+
+	public static Bitmap loadBitmapFromDrawable(int id) {
+		BitmapFactory.Options options = null;
+		if (!isSDK11OrHigher()) {
+			options = new BitmapFactory.Options();
+			options.inPreferredConfig = Bitmap.Config.ARGB_8888;
+		}
+		return BitmapFactory.decodeResource(getGDActivity().getResources(), id);
+	}
+
+	public static Bitmap loadBitmapFromAsset(String name) throws IOException {
+		if (name.startsWith("/")) name = name.substring(1);
+		Bitmap bmp = null;
+		InputStream s = getGDActivity().getAssets().open(name);
+		bmp = BitmapFactory.decodeStream(s);
+		s.close();
+		return bmp;
+	}
+
+	public static void logDebug(String s) {
+		Log.d("AGDTR<" + Thread.currentThread().getName() + ">", s);
+	}
+
+	public static void logDebug(Object s) {
+		Log.d("AGDTR<" + Thread.currentThread().getName() + ">", s.toString());
+	}
+
+	public static boolean isOnline() {
+		ConnectivityManager cm = (ConnectivityManager) getGDActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
+		NetworkInfo netInfo = cm.getActiveNetworkInfo();
+		return netInfo != null && netInfo.isConnectedOrConnecting();
+	}
+
+	/*public static String trimLine(String s, Paint f, int w) {
+		// logDebug("trimLine; s = " + s + ", w = " + w + "; measure = " + f.measureText(s));
+		String points = "...", result = s;
+		float avgWidth = f.measureText("o"), pointsWidth = f.measureText(points);
+		float diff;
+		int i = 0,
+			len = s.length(),
+			half = 0,
+			c = 0,
+			st1 = 0,
+			st2 = len - 1;
+
+		if (s.equals("") || f.measureText(s) <= w) return s;
+
+		w -= pointsWidth;
+
+		int tmpMax = (int)Math.round(Math.floor(w / Math.round(avgWidth / 1.5)) * 2);
+		if (len > tmpMax) {
+			s = s.substring(0, tmpMax);
+			len = s.length();
+		}
+
+		while (true) {
+			i++;
+			// if (i >= 100) return s;
+			if (half == 0) {
+				c = Math.round(len / 2);
+			} else {
+				switch (half) {
+					case 1:
+						st2 = c;
+						c -= (st2 - st1) / 2;
+						break;
+
+					case 2:
+						st1 = c;
+						c += (st2 - st1) / 2;
+						break;
+				}
+			}
+
+			String sub = s.substring(0, c > len - 1 ? len - 1 : c);
+			float subWidth = f.measureText(sub);
+
+			if (subWidth > w + avgWidth) half = 1;
+			else if (subWidth < w - avgWidth) half = 2;
+			else {
+				diff = subWidth - w;
+
+				if (diff > 0) {
+					result = s.substring(0, c - 1);
+					if (!result.equals(s)) result += points;
+				} else  {
+					result = s.substring(0, c + 1);
+					if (!result.equals(s)) result += points;
+				}
+
+				return result;
+			}
+		}
+
+		// return s;
+	}*/
+
+	public static String getString(int r) {
+		return GDActivity.shared.getString(r);
+	}
+
+	public static String[] getStringArray(int r) {
+		return GDActivity.shared.getResources().getStringArray(r);
+	}
+
+	public static void runOnUiThread(Runnable runnable) {
+		GDActivity.shared.runOnUiThread(runnable);
+	}
+
+	public static long getTimestamp() {
+		return System.currentTimeMillis() / 1000L;
+	}
+
+	public static void showAlert(String title, String message, final Runnable listener) {
+		Context context = getGDActivity();
+		AlertDialog alertDialog = new AlertDialog.Builder(context)
+				.setTitle(title)
+				.setMessage(message)
+				.setPositiveButton(getString(R.string.ok), new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						if (listener != null) listener.run();
+					}
+				})
+				.setOnCancelListener(new DialogInterface.OnCancelListener() {
+					@Override
+					public void onCancel(DialogInterface dialog) {
+						if (listener != null) listener.run();
+					}
+				})
+				.create();
+		alertDialog.show();
+	}
+
+	public static void showConfirm(String title, String message, final Runnable onOk, final Runnable onCancel) {
+		Context context = getGDActivity();
+		AlertDialog.Builder alert = new AlertDialog.Builder(context)
+				.setTitle(title)
+				.setMessage(message)
+				.setPositiveButton(getString(R.string.ok), new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						if (onOk != null) onOk.run();
+					}
+				})
+				.setNegativeButton(getString(R.string.cancel), new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						if (onCancel != null) onCancel.run();
+					}
+				})
+				.setOnCancelListener(new DialogInterface.OnCancelListener() {
+					@Override
+					public void onCancel(DialogInterface dialog) {
+						if (onCancel != null) onCancel.run();
+					}
+				});
+		alert.show();
+	}
+
+	public static boolean isSDK11OrHigher() {
+		return Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH;
+	}
+
+	public static boolean isSDK10OrLower() {
+		return Build.VERSION.SDK_INT <= 10;
+	}
+
+	public static String getAppVersion() {
+		String v = "0.0";
+		try {
+			PackageInfo pInfo = GDActivity.shared.getPackageManager().getPackageInfo(GDActivity.shared.getPackageName(), 0);
+			v = pInfo.versionName;
+		} catch (PackageManager.NameNotFoundException e) {
+		}
+		return v;
+	}
+
+	public static String decodeCp1251(byte[] data) {
+		if (data == null) {
+			return "";
+		}
+		StringBuffer sb = new StringBuffer(data.length);
+		for (int i = 0; i < data.length; i++) {
+			if (data[i] == 0) break;
+			sb.append(cp1251Map[data[i] & 0xFF]);
+		}
+		return sb.toString();
+	}
+
+	public static String getDeviceName() {
+		String manufacturer = Build.MANUFACTURER;
+		String model = Build.MODEL;
+		if (model.startsWith(manufacturer)) {
+			return capitalize(model);
+		} else {
+			return capitalize(manufacturer) + " " + model;
+		}
+	}
+
+	private static String capitalize(String s) {
+		if (s == null || s.length() == 0) {
+			return "";
+		}
+		char first = s.charAt(0);
+		if (Character.isUpperCase(first)) {
+			return s;
+		} else {
+			return Character.toUpperCase(first) + s.substring(1);
+		}
+	}
+
+}
diff --git a/src/org/happysanta/gd/KeyboardController.java b/src/org/happysanta/gd/KeyboardController.java
new file mode 100644
index 0000000..4438677
--- /dev/null
+++ b/src/org/happysanta/gd/KeyboardController.java
@@ -0,0 +1,303 @@
+package org.happysanta.gd;
+
+import android.graphics.Rect;
+import android.util.Log;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.LinearLayout;
+import org.happysanta.gd.Game.GameView;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+
+import static org.happysanta.gd.Helpers.getDp;
+
+public class KeyboardController implements View.OnTouchListener {
+
+	private static final int MAX_POINTERS = 10;
+	public static final int PADDING = 15;
+	private static final boolean DISABLE_MOVE = false;
+
+	private static int PADDING_DP = 0;
+
+	private GDActivity gd;
+	private int[] buf;
+	private LinearLayout[] btns;
+	private PointerInfo[] pointers;
+	private StringBuffer logBuffer;
+
+	static {
+		PADDING_DP = getDp(PADDING);
+	}
+
+	KeyboardController(GDActivity gd) {
+		this.gd = gd;
+		buf = new int[2];
+		btns = new LinearLayout[9];
+		pointers = new PointerInfo[MAX_POINTERS];
+		for (int i = 0; i < MAX_POINTERS; i++) {
+			pointers[i] = new PointerInfo(i);
+		}
+
+		logBuffer = new StringBuffer();
+	}
+
+	@Override
+	public boolean onTouch(View v, MotionEvent event) {
+		GameView gameView = gd.gameView;
+
+		v.getLocationOnScreen(buf);
+		Rect rect = new Rect(buf[0], buf[1], buf[0] + v.getWidth(), buf[1] + v.getHeight());
+
+		rect.left += PADDING_DP;
+		rect.right -= PADDING_DP;
+		rect.top += PADDING_DP;
+		rect.bottom -= PADDING_DP;
+
+		/*int actionRaw = MotionEventCompat.getAction/event.getAction();
+		if (actionRaw != MotionEvent.ACTION_MOVE) {
+			log("EVT_RAW " + actionRaw + " " + actionToString(actionRaw));
+		}*/
+
+		// int action = actionRaw & MotionEvent.ACTION_MASK;
+		int action = event.getActionMasked();
+		if (action == MotionEvent.ACTION_DOWN
+				|| action == MotionEvent.ACTION_POINTER_DOWN
+				|| action == MotionEvent.ACTION_UP
+				|| action == MotionEvent.ACTION_POINTER_UP
+//				|| action == MotionEvent.ACTION_CANCEL
+				/*|| action == MotionEvent.ACTION_POINTER_2_DOWN
+				|| action == MotionEvent.ACTION_POINTER_3_DOWN
+				|| action == MotionEvent.ACTION_POINTER_2_UP
+				|| action == MotionEvent.ACTION_POINTER_3_UP*/) {
+			/*int index = event.getActionIndex();
+			int pointerId = event.getPointerId(index);*/
+
+			int index = event.getActionIndex();
+			int pointerId = event.getPointerId(index);
+//			int pointerId = event.getPointerId(index);
+
+			if (pointerId >= MAX_POINTERS) {
+				return true;
+			}
+
+			int x = Math.round(event.getX(index));
+			int y = Math.round(event.getY(index));
+
+			//if (Global.DEBUG || true) {
+//				log("EVT [ind=" + index + ", pntId=" + pointerId + "] " + actionToString(action) + " "
+//						+ "(x=" + x + ", y=" + y + "), "
+//						+ "(rx=" + event.getRawX() + ", ry=" + event.getRawY() + ")"
+//				);
+//				log("EVT DUMP " + event.toString());
+//				log("RECT l="+rect.left+", r="+rect.right+", t="+rect.top+", b="+rect.bottom);
+			// }
+
+			LinearLayout btn;
+			PointerInfo pointer = pointers[pointerId];
+
+			int btnIndex = whichButton(rect, x, y);
+
+//			log("BTN index="+btnIndex, true);
+
+			// logBuffer("x="+x+", y="+y+", btn="+btnIndex);
+
+			switch (action) {
+				case MotionEvent.ACTION_DOWN:
+				case MotionEvent.ACTION_POINTER_DOWN:
+					press(v);
+
+					pointer.setButtonIndex(btnIndex);
+					btn = pointer.getButton();
+
+					btn.setPressed(true);
+					gameView.keyPressed(gameKeyCode(btnIndex));
+					break;
+
+				case MotionEvent.ACTION_UP:
+				case MotionEvent.ACTION_POINTER_UP:
+					// case MotionEvent.ACTION_CANCEL:
+					btn = pointer.getButton();
+					if (btn != null) {
+						btn.setPressed(false);
+						if (DISABLE_MOVE) {
+							btnIndex = pointer.btnIndex;
+						}
+						gameView.keyReleased(gameKeyCode(btnIndex));
+						pointer.finish();
+					}
+					break;
+			}
+		} else if (action == MotionEvent.ACTION_MOVE && !gd.isMenuShown() && !DISABLE_MOVE) {
+			int pointerCount = event.getPointerCount();
+//			int pointerCount = event.getPointerCount();
+			LinearLayout btn, oldBtn;
+			PointerInfo pointer;
+
+			for (int pointerIndex = 0; pointerIndex < pointerCount; pointerIndex++) {
+				int pointerId = event.getPointerId(pointerIndex);
+				if (pointerId >= MAX_POINTERS) continue;
+
+				int x = Math.round(event.getX(pointerIndex));
+				int y = Math.round(event.getY(pointerIndex));
+
+//				int x = Math.round(event.getX(pointerIndex));
+//				int y = Math.round(event.getY(pointerIndex));
+				int btnIndex = whichButton(rect, x, y);
+
+				pointer = pointers[pointerId];
+				if (btnIndex != pointer.btnIndex) {
+					oldBtn = btns[pointer.btnIndex];
+					oldBtn.setPressed(false);
+					gameView.keyReleased(gameKeyCode(pointer.btnIndex));
+
+					press(v);
+
+					pointer.setButtonIndex(btnIndex);
+					btn = pointer.getButton();
+					btn.setPressed(true);
+					gameView.keyPressed(gameKeyCode(pointer.btnIndex));
+				}
+			}
+		}
+
+		return true;
+	}
+
+	private synchronized void log(Object o, boolean last) {
+		String logStr = o.toString();
+		Log.d("GD Keyboard", o.toString());
+
+		if (last)
+			Log.d("", "");
+
+		/*if (!gd.isMenuShown()) {
+			logBuffer.append("<");
+			logBuffer.append(getCurrentTime());
+			logBuffer.append("> ");
+
+			logBuffer.append(logStr);
+			logBuffer.append("\n");
+
+			if (last)
+				logBuffer.append("\n");
+		}*/
+	}
+
+	private void log(Object o) {
+		log(o, false);
+	}
+
+	public synchronized void clearLogBuffer() {
+		logBuffer = null;
+		logBuffer = new StringBuffer();
+	}
+
+	public String getLog() {
+		return logBuffer.toString();
+	}
+
+	private static String getCurrentTime() {
+		Calendar cal = Calendar.getInstance();
+		cal.getTime();
+		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
+		return sdf.format(cal.getTime());
+	}
+
+	private static String actionToString(int action) {
+		switch (action) {
+			case MotionEvent.ACTION_DOWN:
+				return "ACTION_DOWN";
+			case MotionEvent.ACTION_POINTER_DOWN:
+				return "ACTION_POINTER_DOWN";
+			case MotionEvent.ACTION_POINTER_2_DOWN:
+				return "ACTION_POINTER_2_DOWN";
+			case MotionEvent.ACTION_POINTER_2_UP:
+				return "ACTION_POINTER_2_UP";
+			case MotionEvent.ACTION_POINTER_3_DOWN:
+				return "ACTION_POINTER_3_DOWN";
+			case MotionEvent.ACTION_POINTER_3_UP:
+				return "ACTION_POINTER_3_UP";
+			case MotionEvent.ACTION_UP:
+				return "ACTION_UP";
+			case MotionEvent.ACTION_POINTER_UP:
+				return "ACTION_POINTER_UP";
+			case MotionEvent.ACTION_MOVE:
+				return "ACTION_MOVE";
+		}
+		return "?";
+	}
+
+	private static int whichButton(Rect rect, int x, int y) {
+		int cellW = rect.width() / 3,
+				cellH = rect.height() / 3;
+
+		// logBuffer("cellW="+cellW+", cellH="+cellH);
+
+		int posX = 0, posY = 0;
+
+		if (x < PADDING_DP + cellW)
+			posX = 0;
+		else if (x < PADDING_DP + cellW * 2)
+			posX = 1;
+		else
+			posX = 2;
+
+		if (y < PADDING_DP + cellH)
+			posY = 0;
+		else if (y < PADDING_DP + cellH * 2)
+			posY = 1;
+		else
+			posY = 2;
+
+		return posY * 3 + posX;
+	}
+
+	private static int gameKeyCode(int btnIndex) {
+		return btnIndex + 49;
+	}
+
+	private static void press(View v) {
+		if (Settings.isVibrateOnTouchEnabled()) {
+			v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
+		}
+	}
+
+	public void addButton(LinearLayout btn, int x, int y) {
+		btns[y * 3 + x] = btn;
+	}
+
+	private class PointerInfo {
+
+		private int id;
+		private int btnIndex = -1;
+		private boolean active = false;
+
+		PointerInfo(int id) {
+			this.id = id;
+		}
+
+		void finish() {
+			active = false;
+			btnIndex = -1;
+		}
+
+		/*void setActive() {
+			active = true;
+		}*/
+
+		void setButtonIndex(int index) {
+			active = true;
+			btnIndex = index;
+		}
+
+		LinearLayout getButton() {
+			if (!active)
+				return null;
+			return btns[btnIndex];
+		}
+
+	}
+
+}
diff --git a/src/org/happysanta/gd/Levels/InvalidTrackException.java b/src/org/happysanta/gd/Levels/InvalidTrackException.java
new file mode 100644
index 0000000..9b2b827
--- /dev/null
+++ b/src/org/happysanta/gd/Levels/InvalidTrackException.java
@@ -0,0 +1,12 @@
+package org.happysanta.gd.Levels;
+
+/**
+ * Created by evgeny on 6/15/14.
+ */
+public class InvalidTrackException extends Exception {
+
+	public InvalidTrackException(Exception e) {
+		super(e);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Levels/Level.java b/src/org/happysanta/gd/Levels/Level.java
new file mode 100755
index 0000000..78f89ac
--- /dev/null
+++ b/src/org/happysanta/gd/Levels/Level.java
@@ -0,0 +1,245 @@
+package org.happysanta.gd.Levels;
+
+import org.happysanta.gd.Game.GameView;
+import org.happysanta.gd.Game.Physics;
+
+import java.io.DataInputStream;
+
+import static org.happysanta.gd.Helpers.getLevelLoader;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class Level {
+
+	public int startX;
+	public int startY;
+	public int finishX;
+	public int m_gotoI;
+	public int m_forI;
+	public int finishY;
+	public int pointsCount;
+	public int m_intI;
+	public int points[][];
+	public String levelName;
+	private int m_aI;
+	private int m_dI;
+	private int m_eI;
+	private int m_bI;
+	private int m_gI;
+	private int m_rI;
+
+	public Level() {
+		m_aI = 0;
+		m_dI = 0;
+		m_eI = 0;
+		m_bI = 0;
+		m_gI = 0;
+		m_gotoI = 0;
+		m_forI = 0;
+		points = (int[][]) null;
+		levelName = "levelname";
+		m_rI = 0;
+		clear();
+	}
+
+	public void clear() {
+		startX = 0;
+		startY = 0;
+		finishX = 0xc80000;
+		pointsCount = 0;
+		m_intI = 0;
+	}
+
+	public int _doII(int j) {
+		int k = j - points[m_gotoI][0];
+		int i1;
+		if (((i1 = points[m_forI][0] - points[m_gotoI][0]) >= 0 ? i1 : -i1) < 3 || k > i1)
+			return 0x10000;
+		else
+			return (int) (((long) k << 32) / (long) i1 >> 16);
+	}
+
+	public void _ifIIV(int j, int k) {
+		m_aI = (j << 16) >> 3;
+		m_dI = (k << 16) >> 3;
+	}
+
+	public void _aIIV(int j, int k) {
+		m_eI = j >> 1;
+		m_bI = k >> 1;
+	}
+
+	public void _aIIV(int j, int k, int i1) {
+		m_eI = j;
+		m_bI = k;
+		m_gI = i1;
+	}
+
+	public void _ifiIV(GameView view, int k, int i1) {
+		if (i1 <= pointsCount - 1) {
+			int j1 = m_gI - (points[k][1] + points[i1 + 1][1] >> 1) >= 0 ? m_gI - (points[k][1] + points[i1 + 1][1] >> 1) : 0;
+			if (m_gI <= points[k][1] || m_gI <= points[i1 + 1][1])
+				j1 = j1 >= 0x50000 ? 0x50000 : j1;
+			m_rI = (int) ((long) m_rI * 49152L >> 16) + (int) ((long) j1 * 16384L >> 16);
+			if (m_rI <= 0x88000) {
+				int k1 = (int) (0x190000L * (long) m_rI >> 16) >> 16;
+				view.setColor(k1, k1, k1);
+				int l1 = points[k][0] - points[k + 1][0];
+				int i2 = (int) (((long) (points[k][1] - points[k + 1][1]) << 32) / (long) l1 >> 16);
+				int j2 = points[k][1] - (int) ((long) points[k][0] * (long) i2 >> 16);
+				int k2 = (int) ((long) m_eI * (long) i2 >> 16) + j2;
+				l1 = points[i1][0] - points[i1 + 1][0];
+				i2 = (int) (((long) (points[i1][1] - points[i1 + 1][1]) << 32) / (long) l1 >> 16);
+				j2 = points[i1][1] - (int) ((long) points[i1][0] * (long) i2 >> 16);
+				int l2 = (int) ((long) m_bI * (long) i2 >> 16) + j2;
+				if (k == i1) {
+					view._aIIIV((m_eI << 3) >> 16, (k2 + 0x10000 << 3) >> 16, (m_bI << 3) >> 16, (l2 + 0x10000 << 3) >> 16);
+					return;
+				}
+				view._aIIIV((m_eI << 3) >> 16, (k2 + 0x10000 << 3) >> 16, (points[k + 1][0] << 3) >> 16, (points[k + 1][1] + 0x10000 << 3) >> 16);
+				for (int i3 = k + 1; i3 < i1; i3++)
+					view._aIIIV((points[i3][0] << 3) >> 16, (points[i3][1] + 0x10000 << 3) >> 16, (points[i3 + 1][0] << 3) >> 16, (points[i3 + 1][1] + 0x10000 << 3) >> 16);
+
+				view._aIIIV((points[i1][0] << 3) >> 16, (points[i1][1] + 0x10000 << 3) >> 16, (m_bI << 3) >> 16, (l2 + 0x10000 << 3) >> 16);
+			}
+		}
+	}
+
+	public synchronized void _aiIV(GameView view, int k, int i1) {
+		int k2 = 0;
+		int l2 = 0;
+		int j2;
+		for (j2 = 0; j2 < pointsCount - 1 && points[j2][0] <= m_aI; j2++) ;
+		if (j2 > 0)
+			j2--;
+		int i3 = k - points[j2][0];
+		int j3 = (i1 + 0x320000) - points[j2][1];
+		int k3 = Physics._doIII(i3, j3);
+		i3 = (int) (((long) i3 << 32) / (long) (k3 >> 1 >> 1) >> 16);
+		j3 = (int) (((long) j3 << 32) / (long) (k3 >> 1 >> 1) >> 16);
+		view.setColor(0, 170, 0);
+		do {
+			if (j2 >= pointsCount - 1)
+				break;
+			int j1 = i3;
+			int l1 = j3;
+			i3 = k - points[j2 + 1][0];
+			j3 = (i1 + 0x320000) - points[j2 + 1][1];
+			int l3 = Physics._doIII(i3, j3);
+			i3 = (int) (((long) i3 << 32) / (long) (l3 >> 1 >> 1) >> 16);
+			j3 = (int) (((long) j3 << 32) / (long) (l3 >> 1 >> 1) >> 16);
+			view._aIIIV((points[j2][0] + j1 << 3) >> 16, (points[j2][1] + l1 << 3) >> 16, (points[j2 + 1][0] + i3 << 3) >> 16, (points[j2 + 1][1] + j3 << 3) >> 16);
+			view._aIIIV((points[j2][0] << 3) >> 16, (points[j2][1] << 3) >> 16, (points[j2][0] + j1 << 3) >> 16, (points[j2][1] + l1 << 3) >> 16);
+			if (j2 > 1) {
+				if (points[j2][0] > m_eI && k2 == 0)
+					k2 = j2 - 1;
+				if (points[j2][0] > m_bI && l2 == 0)
+					l2 = j2 - 1;
+			}
+			if (m_gotoI == j2) {
+				view.drawStartFlag((points[m_gotoI][0] + j1 << 3) >> 16, (points[m_gotoI][1] + l1 << 3) >> 16);
+				view.setColor(0, 170, 0);
+			}
+			if (m_forI == j2) {
+				view.drawFinishFlag((points[m_forI][0] + j1 << 3) >> 16, (points[m_forI][1] + l1 << 3) >> 16);
+				view.setColor(0, 170, 0);
+			}
+			if (points[j2][0] > m_dI)
+				break;
+			j2++;
+		} while (true);
+		int k1 = i3;
+		int i2 = j3;
+		view._aIIIV((points[pointsCount - 1][0] << 3) >> 16, (points[pointsCount - 1][1] << 3) >> 16, (points[pointsCount - 1][0] + k1 << 3) >> 16, (points[pointsCount - 1][1] + i2 << 3) >> 16);
+		if (getLevelLoader().isShadowsEnabled())
+			_ifiIV(view, k2, l2);
+	}
+
+	public synchronized void _aiV(GameView view) {
+		int k;
+		for (k = 0; k < pointsCount - 1 && points[k][0] <= m_aI; k++) ;
+		if (k > 0)
+			k--;
+		do {
+			if (k >= pointsCount - 1)
+				break;
+			view._aIIIV((points[k][0] << 3) >> 16, (points[k][1] << 3) >> 16, (points[k + 1][0] << 3) >> 16, (points[k + 1][1] << 3) >> 16);
+			if (m_gotoI == k) {
+				view.drawStartFlag((points[m_gotoI][0] << 3) >> 16, (points[m_gotoI][1] << 3) >> 16);
+				view.setColor(0, 255, 0);
+			}
+			if (m_forI == k) {
+				view.drawFinishFlag((points[m_forI][0] << 3) >> 16, (points[m_forI][1] << 3) >> 16);
+				view.setColor(0, 255, 0);
+			}
+			if (points[k][0] > m_dI)
+				break;
+			k++;
+		} while (true);
+	}
+
+	public void unpackInt(int x, int y) {
+		addPoint((x << 16) >> 3, (y << 16) >> 3);
+	}
+
+	public void addPoint(int x, int y) {
+		if (points == null || points.length <= pointsCount) {
+			int i1 = 100;
+			if (points != null)
+				i1 = i1 >= points.length + 30 ? i1 : points.length + 30;
+			int ai[][] = new int[i1][2];
+			if (points != null)
+				System.arraycopy(points, 0, ai, 0, points.length);
+			points = ai;
+		}
+		if (pointsCount == 0 || points[pointsCount - 1][0] < x) {
+			points[pointsCount][0] = x;
+			points[pointsCount][1] = y;
+			pointsCount++;
+		}
+	}
+
+	public synchronized void readTrackData(DataInputStream in) {
+		try {
+			clear();
+			if (in.readByte() == 50) {
+				byte bytes[] = new byte[20];
+				in.readFully(bytes);
+			}
+			m_forI = 0;
+			m_gotoI = 0;
+			startX = in.readInt();
+			startY = in.readInt();
+			finishX = in.readInt();
+			finishY = in.readInt();
+			short pointsCount = in.readShort();
+			int firstPointX = in.readInt();
+			int firstPointY = in.readInt();
+			int k1 = firstPointX;
+			int l1 = firstPointY;
+			unpackInt(k1, l1);
+			for (int i = 1; i < pointsCount; i++) {
+				int x;
+				int y;
+				byte byte0;
+				if ((byte0 = in.readByte()) == -1) {
+					k1 = l1 = 0;
+					x = in.readInt();
+					y = in.readInt();
+				} else {
+					x = byte0;
+					y = in.readByte();
+				}
+				k1 += x;
+				l1 += y;
+				unpackInt(k1, l1);
+			}
+
+			/*logDebug("Points: ");
+			for (int[] point: points) {
+				logDebug("(" + ((point[0] >> 16) << 3) + ", " + ((point[1] >> 16) << 3) + ")");
+			}*/
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+	}
+}
diff --git a/src/org/happysanta/gd/Levels/LevelHeader.java b/src/org/happysanta/gd/Levels/LevelHeader.java
new file mode 100644
index 0000000..68aa112
--- /dev/null
+++ b/src/org/happysanta/gd/Levels/LevelHeader.java
@@ -0,0 +1,53 @@
+package org.happysanta.gd.Levels;
+
+public class LevelHeader {
+
+	private int pointers[][] = new int[3][];
+	private String names[][] = new String[3][];
+	private int counts[] = new int[3];
+
+	public LevelHeader() {
+	}
+
+	public void setCount(int level, int count) {
+		if (level >= counts.length)
+			return;
+
+		pointers[level] = new int[count];
+		names[level] = new String[count];
+		counts[level] = count;
+	}
+
+	public int getCount(int level) {
+		if (level < counts.length)
+			return counts[level];
+		else
+			return 0;
+	}
+
+	public void setPointer(int level, int index, int value) {
+		pointers[level][index] = value;
+	}
+
+	public void setName(int level, int index, String value) {
+		names[level][index] = value;
+	}
+
+	public int[][] getPointers() {
+		return pointers;
+	}
+
+	public String[][] getNames() {
+		return names;
+	}
+
+	public boolean isCountsOk() {
+		for (int i = 0; i < counts.length; i++) {
+			if (counts[i] <= 0)
+				return false;
+		}
+
+		return true;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Levels/Loader.java b/src/org/happysanta/gd/Levels/Loader.java
new file mode 100755
index 0000000..48ef645
--- /dev/null
+++ b/src/org/happysanta/gd/Levels/Loader.java
@@ -0,0 +1,335 @@
+package org.happysanta.gd.Levels;
+
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Game.GameView;
+import org.happysanta.gd.Menu.SimpleMenuElement;
+import org.happysanta.gd.Game.Physics;
+
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class Loader {
+
+	//public static final int m_bI;
+	// public static final int m_forI = 1;
+	// public static final int m_intI = 2;
+	//public static final int m_doI;
+	// public static final int m_ifI = 1;
+
+	public File levelsFile;
+	public Level levels;
+	public int m_nullI;
+	public int m_fI;
+	public String names[][];
+	public int m_jI;
+	public int m_iI;
+	public int m_longI;
+	public int m_eI;
+	public int m_dI;
+
+	private boolean perspectiveEnabled = true;
+	private boolean shadowsEnabled = true;
+	private int pointers[][] = new int[3][];
+	private int m_eaI = 0;
+	private int m_faI = 0;
+	private int m_aI = 0;
+	private int m_kI = 0;
+	private int m_saaI[][];
+	private int m_haI[];
+	private int m_vaI[];
+	private int m_daI;
+
+	public Loader() throws IOException {
+		reset();
+	}
+
+	public Loader(File levelsFile) throws IOException {
+		if (levelsFile != null)
+			this.levelsFile = levelsFile;
+		reset();
+	}
+
+	private void reset() throws IOException {
+		m_saaI = null;
+		levels = null;
+		m_haI = new int[3];
+		m_vaI = new int[3];
+		m_nullI = 0;
+		m_fI = -1;
+		names = new String[3][];
+		m_daI = 0;
+		for (int j = 0; j < 3; j++) {
+			m_haI[j] = (int) ((long) (Physics.m_foraI[j] + 19660 >> 1) * (long) (Physics.m_foraI[j] + 19660 >> 1) >> 16);
+			m_vaI[j] = (int) ((long) (Physics.m_foraI[j] - 19660 >> 1) * (long) (Physics.m_foraI[j] - 19660 >> 1) >> 16);
+		}
+
+		// try {
+		readLevels();
+		// } catch ( _ex) {
+		//	_ex.printStackTrace();
+		//}
+		_ifvV();
+	}
+
+
+	public void setLevelsFile(File file) throws IOException {
+		levelsFile = file;
+		reset();
+	}
+
+	public InputStream getLevelsInputStream(String s) throws IOException {
+		if (levelsFile == null)
+			return GDActivity.shared.getAssets().open(s);
+		else
+			return new FileInputStream(levelsFile);
+	}
+
+	private void readLevels() throws IOException {
+		//try {
+		InputStream in = getLevelsInputStream("levels.mrg");
+		LevelHeader header = Reader.readHeader(in);
+
+		pointers = header.getPointers();
+		names = header.getNames();
+		//} catch (Exception ex) {
+		//	logDebug("Levels.Loader: error while reading mrg file");
+		//	ex.printStackTrace();
+		//}
+	}
+
+	public String getLevelName(int j, int k) {
+		if (j < names.length && k < names[j].length)
+			return names[j][k];
+		else
+			return "---";
+	}
+
+	public void _ifvV() {
+		try {
+			_doIII(m_nullI, m_fI + 1);
+		} catch (InvalidTrackException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public int _doIII(int j, int k) throws InvalidTrackException {
+		m_nullI = j;
+		m_fI = k;
+		if (m_fI >= names[m_nullI].length)
+			m_fI = 0;
+		_hIIV(m_nullI + 1, m_fI + 1);
+		return m_fI;
+	}
+
+	private void _hIIV(int j, int k) throws InvalidTrackException {
+		try {
+			InputStream is = getLevelsInputStream("levels.mrg");
+			DataInputStream dis = new DataInputStream(is);
+			for (int i1 = pointers[j - 1][k - 1]; i1 > 0; i1 -= dis.skipBytes(i1)) ;
+			if (levels == null)
+				levels = new Level();
+			levels.readTrackData(dis);
+			dis.close();
+			load(levels);
+		} catch (IOException _ex) {
+			_ex.printStackTrace();
+		}
+	}
+
+	public void _ifIV(int j) {
+		m_jI = levels.startX << 1;
+		m_iI = levels.startY << 1;
+	}
+
+	public int _dovI() {
+		return levels.points[levels.m_forI][0] << 1;
+	}
+
+	public int _intvI() {
+		return levels.points[levels.m_gotoI][0] << 1;
+	}
+
+	public int _newvI() {
+		return levels.startX << 1;
+	}
+
+	public int _avI() {
+		return levels.startY << 1;
+	}
+
+	public int _aII(int j) {
+		return levels._doII(j >> 1);
+	}
+
+	public void load(Level l1) throws InvalidTrackException {
+		try {
+			m_longI = 0x80000000;
+			levels = l1;
+			int j = levels.pointsCount;
+			if (m_saaI == null || m_daI < j) {
+				m_saaI = (int[][]) null;
+				// System.gc();
+				m_daI = j >= 100 ? j : 100;
+				m_saaI = new int[m_daI][2];
+			}
+			m_eaI = 0;
+			m_faI = 0;
+			m_aI = l1.points[m_eaI][0];
+			m_kI = l1.points[m_faI][0];
+			for (int k = 0; k < j; k++) {
+				int i1 = l1.points[(k + 1) % j][0] - l1.points[k][0];
+				int j1 = l1.points[(k + 1) % j][1] - l1.points[k][1];
+				if (k != 0 && k != j - 1)
+					m_longI = m_longI >= l1.points[k][0] ? m_longI : l1.points[k][0];
+				int k1 = -j1;
+				int i2 = i1;
+				int j2 = Physics._doIII(k1, i2);
+				m_saaI[k][0] = (int) (((long) k1 << 32) / (long) j2 >> 16);
+				m_saaI[k][1] = (int) (((long) i2 << 32) / (long) j2 >> 16);
+				if (levels.m_gotoI == 0 && l1.points[k][0] > levels.startX)
+					levels.m_gotoI = k + 1;
+				if (levels.m_forI == 0 && l1.points[k][0] > levels.finishX)
+					levels.m_forI = k;
+			}
+
+			m_eaI = 0;
+			m_faI = 0;
+			m_aI = 0;
+			m_kI = 0;
+		} catch (ArithmeticException e) {
+			throw new InvalidTrackException(e);
+		}
+	}
+
+	public void _ifIIV(int j, int k) {
+		levels._ifIIV(j, k);
+	}
+
+	public void _aiIV(GameView j, int k, int i1) {
+		if (j != null) {
+			j.setColor(0, 170, 0);
+			k >>= 1;
+			i1 >>= 1;
+			levels._aiIV(j, k, i1);
+		}
+	}
+
+	public void _aiV(GameView j) {
+		j.setColor(0, 255, 0);
+		levels._aiV(j);
+	}
+
+	public void _aIIV(int j, int k, int i1) {
+		levels._aIIV(j + 0x18000 >> 1, k - 0x18000 >> 1, i1 >> 1);
+		k >>= 1;
+		j >>= 1;
+		m_faI = m_faI >= levels.pointsCount - 1 ? levels.pointsCount - 1 : m_faI;
+		m_eaI = m_eaI >= 0 ? m_eaI : 0;
+		if (k > m_kI)
+			while (m_faI < levels.pointsCount - 1 && k > levels.points[++m_faI][0]) ;
+		else if (j < m_aI) {
+			while (m_eaI > 0 && j < levels.points[--m_eaI][0]) ;
+		} else {
+			while (m_eaI < levels.pointsCount && j > levels.points[++m_eaI][0]) ;
+			if (m_eaI > 0)
+				m_eaI--;
+			while (m_faI > 0 && k < levels.points[--m_faI][0]) ;
+			m_faI = m_faI + 1 >= levels.pointsCount - 1 ? levels.pointsCount - 1 : m_faI + 1;
+		}
+		m_aI = levels.points[m_eaI][0];
+		m_kI = levels.points[m_faI][0];
+	}
+
+	public int _anvI(SimpleMenuElement n1, int j) {
+		int k3 = 0;
+		byte byte1 = 2;
+		int l3 = n1.x >> 1;
+		int i4 = n1.y >> 1;
+		if (perspectiveEnabled)
+			i4 -= 0x10000;
+		int j4 = 0;
+		int k4 = 0;
+		for (int l4 = m_eaI; l4 < m_faI; l4++) {
+			int k = levels.points[l4][0];
+			int i1 = levels.points[l4][1];
+			int j1 = levels.points[l4 + 1][0];
+			int k1;
+			int _tmp = (k1 = levels.points[l4 + 1][1]) < i1 ? i1 : k1;
+			if (l3 - m_haI[j] > j1 || l3 + m_haI[j] < k)
+				continue;
+			int l1 = k - j1;
+			int i2 = i1 - k1;
+			int j2 = (int) ((long) l1 * (long) l1 >> 16) + (int) ((long) i2 * (long) i2 >> 16);
+			int k2 = (int) ((long) (l3 - k) * (long) (-l1) >> 16) + (int) ((long) (i4 - i1) * (long) (-i2) >> 16);
+			int l2;
+			if ((j2 >= 0 ? j2 : -j2) >= 3)
+				l2 = (int) (((long) k2 << 32) / (long) j2 >> 16);
+			else
+				l2 = (k2 <= 0 ? -1 : 1) * (j2 <= 0 ? -1 : 1) * 0x7fffffff;
+			if (l2 < 0)
+				l2 = 0;
+			if (l2 > 0x10000)
+				l2 = 0x10000;
+			int i3 = k + (int) ((long) l2 * (long) (-l1) >> 16);
+			int j3 = i1 + (int) ((long) l2 * (long) (-i2) >> 16);
+			l1 = l3 - i3;
+			i2 = i4 - j3;
+			byte byte0;
+			long l5;
+			if ((l5 = ((long) l1 * (long) l1 >> 16) + ((long) i2 * (long) i2 >> 16)) < (long) m_haI[j]) {
+				if (l5 >= (long) m_vaI[j])
+					byte0 = 1;
+				else
+					byte0 = 0;
+			} else {
+				byte0 = 2;
+			}
+			if (byte0 == 0 && (int) ((long) m_saaI[l4][0] * (long) n1.m_eI >> 16) + (int) ((long) m_saaI[l4][1] * (long) n1.m_dI >> 16) < 0) {
+				m_eI = m_saaI[l4][0];
+				m_dI = m_saaI[l4][1];
+				return 0;
+			}
+			if (byte0 != 1 || (int) ((long) m_saaI[l4][0] * (long) n1.m_eI >> 16) + (int) ((long) m_saaI[l4][1] * (long) n1.m_dI >> 16) >= 0)
+				continue;
+			k3++;
+			byte1 = 1;
+			if (k3 == 1) {
+				j4 = m_saaI[l4][0];
+				k4 = m_saaI[l4][1];
+			} else {
+				j4 += m_saaI[l4][0];
+				k4 += m_saaI[l4][1];
+			}
+		}
+
+		if (byte1 == 1) {
+			if ((int) ((long) j4 * (long) n1.m_eI >> 16) + (int) ((long) k4 * (long) n1.m_dI >> 16) >= 0)
+				return 2;
+			m_eI = j4;
+			m_dI = k4;
+		}
+		return byte1;
+	}
+
+	public boolean isShadowsEnabled() {
+		return shadowsEnabled;
+	}
+
+	public boolean isPerspectiveEnabled() {
+		return perspectiveEnabled;
+	}
+
+	public void setPerspectiveEnabled(boolean enabled) {
+		perspectiveEnabled = enabled;
+	}
+
+	public void setShadowsEnabled(boolean enabled) {
+		shadowsEnabled = enabled;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Levels/Reader.java b/src/org/happysanta/gd/Levels/Reader.java
new file mode 100644
index 0000000..f0ce9a6
--- /dev/null
+++ b/src/org/happysanta/gd/Levels/Reader.java
@@ -0,0 +1,52 @@
+package org.happysanta.gd.Levels;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.happysanta.gd.Helpers.decodeCp1251;
+
+public class Reader {
+
+	private static final int MAX_VALID_TRACKS = 16384;
+
+	public static LevelHeader readHeader(InputStream in) throws IOException {
+		LevelHeader header = new LevelHeader();
+		DataInputStream din = new DataInputStream(in);
+		byte buf[] = new byte[40];
+		String tmp;
+		for (int i = 0; i < 3; i++) {
+			int tCount = din.readInt();
+			if (tCount > MAX_VALID_TRACKS) {
+				din.close();
+				throw new IOException("Level file is not valid");
+			}
+			header.setCount(i, tCount);
+
+			label0:
+			for (int j = 0; j < header.getCount(i); j++) {
+				int trackPointer = din.readInt();
+				header.setPointer(i, j, trackPointer);
+				int nameLen = 0;
+				do {
+					if (nameLen >= 40)
+						continue label0;
+
+					buf[nameLen] = din.readByte();
+					if (buf[nameLen] == 0) {
+						// tmp = (new String(buf, 0, nameLen, "CP-1251"));
+						tmp = decodeCp1251(buf);
+						header.setName(i, j, tmp.replace('_', ' '));
+						continue label0;
+					}
+					nameLen++;
+				} while (true);
+			}
+
+		}
+		din.close();
+
+		return header;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/ActionMenuElement.java b/src/org/happysanta/gd/Menu/ActionMenuElement.java
new file mode 100755
index 0000000..fb0b706
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/ActionMenuElement.java
@@ -0,0 +1,141 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+import org.happysanta.gd.R;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class ActionMenuElement
+		extends ClickableMenuElement
+		implements MenuHandler, MenuElement {
+
+	protected static final int DISABLED_COLOR = 0xff999999;
+	public static final int LOCK_IMAGE_MARGIN_RIGHT = 5;
+	public static final int locks[] = new int[]{
+			R.drawable.s_lock0,
+			R.drawable.s_lock1,
+			R.drawable.s_lock2
+	};
+
+	public static final int LINE_SPACING = 15;
+	public static final int X_OFFSET = 48;
+
+	public static final int OK = 0;
+	public static final int BACK = 1;
+	public static final int EXIT = 2;
+	public static final int YES = 3;
+	public static final int NO = 4;
+	public static final int PLAY_MENU = 5;
+	public static final int GO_TO_MAIN = 6;
+	public static final int RESTART = 7;
+	public static final int NEXT = 8;
+	public static final int CONTINUE = 9;
+	public static final int INSTALL = 10;
+	public static final int LOAD = 11;
+	public static final int SELECT_FILE = 12;
+	public static final int DELETE = 13;
+	public static final int RESTART_WITH_NEW_LEVEL = 14;
+	public static final int SEND_LOGS = 15;
+
+	protected MenuHandler handler;
+	protected boolean isLocked = false;
+	protected boolean isBlackLock = true;
+	protected MenuImageView lockImage = null;
+
+	protected int actionValue = -1;
+
+	public ActionMenuElement(String s, int value, MenuHandler handler) {
+		actionValue = value;
+		this.handler = handler;
+
+		text = s;
+
+		createAllViews();
+	}
+
+	@Override
+	protected void createAllViews() {
+		super.createAllViews();
+
+		Context context = getGDActivity();
+		lockImage = new MenuImageView(context);
+		lockImage.setScaleType(ImageView.ScaleType.CENTER);
+		lockImage.setVisibility(View.GONE);
+
+		LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.MATCH_PARENT);
+		lp.setMargins(0, 0, getDp(ActionMenuElement.LOCK_IMAGE_MARGIN_RIGHT), 0);
+		lockImage.setLayoutParams(lp);
+
+		layout.addView(lockImage, 1);
+	}
+
+	public ActionMenuElement(String s, MenuHandler handler/*, MenuScreen screen*/) {
+		this(s, -1, handler);
+	}
+
+	public int getActionValue() {
+		return actionValue;
+	}
+
+	public void setHandler(MenuHandler hander) {
+		this.handler = hander;
+	}
+
+	public void setLock(boolean flag, boolean flag1) {
+		isLocked = flag;
+		isBlackLock = flag1;
+
+		lockImage.setVisibility(isLocked ? View.VISIBLE : View.GONE);
+		lockImage.setImageResource(locks[isBlackLock ? 0 : 1]);
+	}
+
+	@Override
+	public void setText(String s) {
+		text = s;
+		updateViewText();
+	}
+
+	@Override
+	public void performAction(int k) {
+		if (disabled || handler == null) return;
+
+		if (k == MenuScreen.KEY_FIRE) {
+			handler.handleAction(this);
+		}
+	}
+
+	@Override
+	protected void onHighlightChanged() {
+		lockImage.setImageResource(locks[isHighlighted ? 2 : (isBlackLock ? 0 : 1)]);
+	}
+
+	@Override
+	public MenuScreen getCurrentMenu() {
+		return null;
+	}
+
+	@Override
+	public void setCurrentMenu(MenuScreen e1, boolean flag) {
+	}
+
+	@Override
+	public void handleAction(MenuElement item) {
+	}
+
+	public void setDisabled(boolean disabled) {
+		this.disabled = disabled;
+
+		if (disabled) {
+			((MenuTextView) textView).setTextColor(DISABLED_COLOR);
+		} else {
+			((MenuTextView) textView).setTextColor(defaultColorStateList());
+		}
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/BigTextMenuElement.java b/src/org/happysanta/gd/Menu/BigTextMenuElement.java
new file mode 100644
index 0000000..8b30e64
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/BigTextMenuElement.java
@@ -0,0 +1,30 @@
+package org.happysanta.gd.Menu;
+
+import android.text.Spanned;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+
+public class BigTextMenuElement
+		extends TextMenuElement {
+
+	public static final int TEXT_SIZE = 19;
+
+	public BigTextMenuElement(String s) {
+		super(s);
+		createTextView();
+		setTextParams(textView);
+	}
+
+	public BigTextMenuElement(Spanned s) {
+		super(s);
+		createTextView();
+		setTextParams(textView);
+	}
+
+	protected static void setTextParams(MenuTextView textView) {
+		textView.setTextSize(TEXT_SIZE);
+		textView.setTypeface(Global.robotoCondensedTypeface);
+		textView.setLineSpacing(0f, 1.2f);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/ClickableMenuElement.java b/src/org/happysanta/gd/Menu/ClickableMenuElement.java
new file mode 100644
index 0000000..f33db34
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/ClickableMenuElement.java
@@ -0,0 +1,196 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.Rect;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.MenuHelmetView;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+import org.happysanta.gd.R;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class ClickableMenuElement
+		implements MenuElement {
+
+	public static final int TEXT_SIZE = 20;
+	public static final int PADDING_TOP = 5;
+	protected View textView;
+	protected String text;
+	protected View.OnTouchListener onTouchListener;
+	protected LinearLayout layout;
+	protected MenuHelmetView helmet;
+	protected OnMenuElementHighlightListener onMenuElementHighlightListener = null;
+	protected boolean isHighlighted = false;
+	protected Thread originalThread = null;
+	protected boolean disabled = false;
+
+	public ClickableMenuElement() {
+	}
+
+	public ClickableMenuElement(String text) {
+		this.text = text;
+		originalThread = Thread.currentThread();
+
+		createAllViews();
+	}
+
+	protected boolean inViewBounds(View view, int x, int y) {
+		Rect rect = new Rect();
+		int location[] = new int[2];
+
+		view.getDrawingRect(rect);
+		view.getLocationOnScreen(location);
+		rect.offset(location[0], location[1]);
+
+		return rect.contains(x, y);
+	}
+
+	protected void createAllViews() {
+		final ClickableMenuElement self = this;
+		Context context = getGDActivity();
+
+		layout = new LinearLayout(context);
+		layout.setOrientation(LinearLayout.HORIZONTAL);
+		layout.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+
+		helmet = new MenuHelmetView(context);
+		helmet.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.MATCH_PARENT));
+
+		/*if (!isSDK11OrHigher()) {
+			helmet.setMeasuredHeight(true);
+		}*/
+
+		onTouchListener = new View.OnTouchListener() {
+			@Override
+			public boolean onTouch(View view, MotionEvent motionEvent) {
+				if (disabled) return false;
+
+				switch (motionEvent.getAction()) {
+					case MotionEvent.ACTION_DOWN:
+						view.setSelected(true);
+						helmet.setShow(true);
+
+						if (onMenuElementHighlightListener != null)
+							onMenuElementHighlightListener.onElementHighlight(self);
+
+						setHighlighted(true);
+						break;
+
+					case MotionEvent.ACTION_CANCEL:
+					case MotionEvent.ACTION_UP:
+						view.setSelected(false);
+
+						if (motionEvent.getAction() == MotionEvent.ACTION_UP && inViewBounds(view, (int) motionEvent.getRawX(), (int) motionEvent.getRawY())) {
+							performAction(MenuScreen.KEY_FIRE);
+						}
+
+						setHighlighted(false);
+						break;
+
+					case MotionEvent.ACTION_MOVE:
+						if (!inViewBounds(view, (int) motionEvent.getRawX(), (int) motionEvent.getRawY())) {
+							view.setSelected(false);
+							setHighlighted(false);
+						} else {
+							view.setSelected(true);
+							setHighlighted(true);
+						}
+						break;
+				}
+				return true;
+			}
+		};
+
+		textView = createMainView();
+
+		layout.addView(helmet);
+		layout.addView(textView);
+		layout.setOnTouchListener(onTouchListener);
+	}
+
+	protected View createMainView() {
+		Context context = getGDActivity();
+		MenuTextView mtv = new MenuTextView(context);
+		mtv.setText(getTextForView());
+		mtv.setTextColor(defaultColorStateList());
+		mtv.setTypeface(Global.robotoCondensedTypeface);
+		mtv.setTextSize(TEXT_SIZE);
+		mtv.setLayoutParams(new ViewGroup.LayoutParams(
+				ViewGroup.LayoutParams.MATCH_PARENT,
+				ViewGroup.LayoutParams.WRAP_CONTENT
+		));
+		mtv.setPadding(0, getDp(PADDING_TOP), 0, getDp(PADDING_TOP));
+
+		return mtv;
+	}
+
+	protected ColorStateList defaultColorStateList() {
+		return getGDActivity().getResources().getColorStateList(R.drawable.menu_item_color);
+	}
+
+	@Override
+	public boolean isSelectable() {
+		return true;
+	}
+
+	@Override
+	public View getView() {
+		return layout;
+	}
+
+	protected MenuTextView getMenuTextView() {
+		return (MenuTextView) textView;
+	}
+
+	@Override
+	public void setText(String text) {
+		this.text = text;
+		updateViewText();
+	}
+
+	public String getText() {
+		return text;
+	}
+
+	protected void updateViewText() {
+		if (textView != null && textView instanceof MenuTextView)
+			((MenuTextView) textView).setTextOnUiThread(getTextForView());
+	}
+
+	protected String getTextForView() {
+		return text;
+	}
+
+	@Override
+	public void performAction(int k) {
+
+	}
+
+	public void setOnHighlightListener(OnMenuElementHighlightListener listener) {
+		onMenuElementHighlightListener = listener;
+	}
+
+	public void showHelmet() {
+		helmet.setShow(true);
+	}
+
+	private void setHighlighted(boolean highlighted) {
+		isHighlighted = highlighted;
+		onHighlightChanged();
+	}
+
+	protected void onHighlightChanged() {
+	}
+
+	public boolean isDisabled() {
+		return disabled;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/DownloadLevelsMenuScreen.java b/src/org/happysanta/gd/Menu/DownloadLevelsMenuScreen.java
new file mode 100755
index 0000000..fe072ce
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/DownloadLevelsMenuScreen.java
@@ -0,0 +1,222 @@
+package org.happysanta.gd.Menu;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.view.View;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+import org.happysanta.gd.API.*;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.R;
+import org.happysanta.gd.API.Response;
+import org.happysanta.gd.Settings;
+import org.happysanta.gd.WaitForNetworkConnection;
+
+import static org.happysanta.gd.Helpers.*;
+import static org.happysanta.gd.Helpers.getDp;
+
+public class DownloadLevelsMenuScreen extends LevelsMenuScreen {
+
+	protected final static int API_LIMIT = 100;
+	public static API.LevelsSortType sort;
+
+	protected MenuImageView sortImage;
+	// protected API api;
+	protected Request request;
+	protected int offset = 0;
+	protected boolean isLoading = false;
+	protected boolean fullLoaded = false;
+	protected WaitForNetworkConnection waitForNetworkConnection = null;
+	protected Toast toast;
+
+	public DownloadLevelsMenuScreen(String title, MenuScreen navTarget) {
+		super(title, navTarget);
+
+		// api = new API();
+		// api.setSort(sort);
+
+		Context context = getGDActivity();
+
+		// Sort icon
+		sortImage = new MenuImageView(context);
+		sortImage.setImageResource(R.drawable.ic_sort);
+		sortImage.setAdjustViewBounds(true);
+		sortImage.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				showSortDialog();
+			}
+		});
+		sortImage.setVisibility(View.GONE);
+		sortImage.setPadding(getDp(10), 0, 0, 0);
+
+		RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
+				RelativeLayout.LayoutParams.WRAP_CONTENT,
+				getDp(40)
+		);
+		params.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
+
+		sortImage.setLayoutParams(params);
+	}
+
+	@Override
+	protected void loadLevels() {
+		try {
+			if (!checkNetwork())
+				return;
+
+			showLoading();
+			isLoading = true;
+			request = API.getLevels(offset, API_LIMIT, sort, new ResponseHandler() {
+				@Override
+				public void onResponse(final Response response) {
+					final LevelsResponse levelsResponse = new LevelsResponse(response);
+					if (status != Statuses.NORMAL) {
+						clearList();
+						setStatus(Statuses.NORMAL);
+					}
+
+					hideLoading();
+
+					addElements = new AsyncAddElements() {
+						@Override
+						protected void onPostExecute(Void v) {
+							logDebug("offset = " + offset + ", totalCount = " + levelsResponse.getTotalCount());
+							fullLoaded = offset >= levelsResponse.getTotalCount();
+							if (!fullLoaded)
+								showLoading();
+
+							isLoading = false;
+						}
+					};
+					addElements.execute(levelsResponse.getLevels());
+				}
+
+				@Override
+				public void onError(APIException error) {
+					showError(error.getMessage());
+					isLoading = false;
+				}
+			});
+
+			offset += API_LIMIT;
+		} catch (Exception e) {
+			e.printStackTrace();
+			showError(getString(R.string.download_error));
+
+			isLoading = false;
+		}
+	}
+
+	@Override
+	public void reloadLevels() {
+		if (request != null) request.cancel();
+		offset = 0;
+		isLoading = false;
+		fullLoaded = false;
+
+		super.reloadLevels();
+	}
+
+	protected void showSortDialog() {
+		final CharSequence[] items = getStringArray(R.array.sort_variants);
+
+		AlertDialog dialog = new AlertDialog.Builder(getGDActivity())
+				.setTitle(getString(R.string.sort_by))
+				.setSingleChoiceItems(items, API.getIdBySortType(sort), new DialogInterface.OnClickListener() {
+					public void onClick(DialogInterface dialog, int item) {
+						API.LevelsSortType newSort = API.getSortTypeById(item);
+
+						if (newSort != sort) {
+							sort = newSort;
+							// api.setSort(newSort);
+							Settings.setLevelsSort(sort);
+							reloadLevels();
+						}
+
+						dialog.dismiss();
+					}
+				})
+				.create();
+
+		dialog.show();
+	}
+
+	protected boolean checkNetwork() {
+		if (!isOnline()) {
+			if (elements.isEmpty()) {
+				showError(getString(R.string.waiting_for_network));
+
+				if (waitForNetworkConnection != null)
+					waitForNetworkConnection.cancel(true);
+
+				waitForNetworkConnection = new WaitForNetworkConnection();
+				waitForNetworkConnection.execute(null, new Runnable() {
+					@Override
+					public void run() {
+						reloadLevels();
+					}
+				});
+			} else {
+				if (toast != null) {
+					toast.cancel();
+				}
+
+				toast = Toast.makeText(getGDActivity().getApplicationContext(), getString(R.string.no_internet_connection), Toast.LENGTH_SHORT);
+				toast.show();
+			}
+
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void onHide(MenuScreen newMenu) {
+		logDebug("onHide");
+		super.onHide(newMenu);
+
+		GDActivity activity = getGDActivity();
+
+		if (newMenu != getGameMenu().levelScreen) {
+			offset = 0;
+			isLoading = false;
+			fullLoaded = false;
+
+			if (request != null) request.cancel();
+			// api.cancelRequest();
+			if (waitForNetworkConnection != null)
+				waitForNetworkConnection.cancel(true);
+		}
+
+		activity.titleLayout.removeView(sortImage);
+		sortImage.setVisibility(View.GONE);
+	}
+
+	@Override
+	public void onShow() {
+		super.onShow();
+
+		GDActivity activity = getGDActivity();
+
+		activity.titleLayout.addView(sortImage);
+		sortImage.setVisibility(View.VISIBLE);
+	}
+
+	@Override
+	public void onScroll(double percent) {
+		if (percent >= 97 && !isLoading && !fullLoaded) {
+			loadLevels();
+		}
+	}
+
+	@Override
+	public void deleteElement(LevelMenuElement el) {
+		super.deleteElement(el);
+		offset--;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/EmptyLineMenuElement.java b/src/org/happysanta/gd/Menu/EmptyLineMenuElement.java
new file mode 100755
index 0000000..e0901f9
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/EmptyLineMenuElement.java
@@ -0,0 +1,42 @@
+package org.happysanta.gd.Menu;
+
+import android.view.View;
+import android.view.ViewGroup;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class EmptyLineMenuElement implements MenuElement {
+
+	protected String text;
+	protected int offset;
+	protected MenuTextView view;
+
+	EmptyLineMenuElement(int offset) {
+		this.offset = offset;
+
+		view = new MenuTextView(getGDActivity());
+		view.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, getDp(offset)));
+	}
+
+	@Override
+	public View getView() {
+		return view;
+	}
+
+	@Override
+	public boolean isSelectable() {
+		return false;
+	}
+
+	@Override
+	public void setText(String s) {
+		text = s;
+	}
+
+	@Override
+	public void performAction(int k) {
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/HighScoreTextMenuElement.java b/src/org/happysanta/gd/Menu/HighScoreTextMenuElement.java
new file mode 100755
index 0000000..fc392df
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/HighScoreTextMenuElement.java
@@ -0,0 +1,100 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.graphics.Typeface;
+import android.text.Spanned;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+import org.happysanta.gd.R;
+
+import static org.happysanta.gd.Helpers.*;
+
+public class HighScoreTextMenuElement
+		extends TextMenuElement
+		implements MenuElement {
+
+	protected static final int TEXT_LEFT_MARGIN = 5;
+	protected static final int SUBTITLE_MARGIN_BOTTOM = 8;
+	protected static final int SUBTITLE_TEXT_SIZE = 20;
+	protected static final int LAYOUT_PADDING = 3;
+	protected static int medals[] = new int[]{
+			R.drawable.s_medal_gold,
+			R.drawable.s_medal_silver,
+			R.drawable.s_medal_bronze
+	};
+	protected static Typeface defaultTypeface = null;
+
+	protected boolean showMedal = false;
+	protected MenuLinearLayout layout;
+	protected MenuImageView image;
+
+	public HighScoreTextMenuElement(String s) {
+		super(s);
+		createAllViews();
+	}
+
+	public HighScoreTextMenuElement(Spanned text) {
+		super(text);
+		createAllViews();
+	}
+
+	protected void createAllViews() {
+		Context context = getGDActivity();
+
+		layout = new MenuLinearLayout(context);
+		layout.setOrientation(LinearLayout.HORIZONTAL);
+		layout.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+
+		image = new MenuImageView(context);
+		image.setScaleType(ImageView.ScaleType.CENTER);
+		image.setVisibility(View.GONE);
+
+		// textView was already created in super constructor
+		textView.setLineSpacing(0, 1);
+
+		if (defaultTypeface == null) {
+			defaultTypeface = textView.getTypeface();
+		}
+
+		LinearLayout.LayoutParams textViewLayoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+		// textViewLayoutParams.setMargins(getDp(TEXT_LEFT_MARGIN), 0, 0, 0);
+		textView.setLayoutParams(textViewLayoutParams);
+
+		layout.addView(image, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.MATCH_PARENT));
+		layout.addView(textView);
+	}
+
+	@Override
+	public View getView() {
+		return layout;
+	}
+
+	public void setMedal(boolean showMedal, int medalIndex) {
+		image.setVisibility(showMedal ? View.VISIBLE : View.GONE);
+		image.setImageResource(medals[medalIndex]);
+
+		LinearLayout.LayoutParams textViewLayoutParams = (LinearLayout.LayoutParams) textView.getLayoutParams();
+		textViewLayoutParams.setMargins(showMedal ? getDp(TEXT_LEFT_MARGIN) : 0, 0, 0, 0);
+		textView.setLayoutParams(textViewLayoutParams);
+
+		this.showMedal = showMedal;
+	}
+
+	public void setIsSubtitle(boolean is) {
+		textView.setTextSize(is ? SUBTITLE_TEXT_SIZE : TEXT_SIZE);
+		textView.setTypeface(is ? Global.robotoCondensedTypeface : defaultTypeface);
+
+		LinearLayout.LayoutParams textViewLayoutParams = (LinearLayout.LayoutParams) textView.getLayoutParams();
+		textViewLayoutParams.setMargins(!is && showMedal ? getDp(TEXT_LEFT_MARGIN) : 0, 0, 0, is ? getDp(SUBTITLE_MARGIN_BOTTOM) : 0);
+		textView.setLayoutParams(textViewLayoutParams);
+	}
+
+	public void setLayoutPadding(boolean use) {
+		layout.setPadding(0, use ? getDp(LAYOUT_PADDING) : 0, 0, use ? getDp(LAYOUT_PADDING) : 0);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/InstalledLevelsMenuScreen.java b/src/org/happysanta/gd/Menu/InstalledLevelsMenuScreen.java
new file mode 100644
index 0000000..b3adbab
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/InstalledLevelsMenuScreen.java
@@ -0,0 +1,103 @@
+package org.happysanta.gd.Menu;
+
+import android.os.AsyncTask;
+import android.view.ViewTreeObserver;
+import org.happysanta.gd.Storage.Level;
+import org.happysanta.gd.Storage.LevelsManager;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class InstalledLevelsMenuScreen extends LevelsMenuScreen {
+
+	LevelsManager levelsManager;
+	protected boolean isLoading = false;
+	AsyncLoadLevels asyncLoadLevels = null;
+
+	public InstalledLevelsMenuScreen(String title, MenuScreen navTarget) {
+		super(title, navTarget);
+		levelsManager = getGDActivity().levelsManager;
+	}
+
+	@Override
+	public void loadLevels() {
+		showLoading();
+		isLoading = true;
+
+		asyncLoadLevels = new AsyncLoadLevels() {
+			@Override
+			public void onPostExecute(Level[] levels) {
+				if (status != Statuses.NORMAL) {
+					clearList();
+					setStatus(Statuses.NORMAL);
+				}
+				hideLoading();
+
+				addElements = new AsyncAddElements() {
+					@Override
+					protected void onPostExecute(Void v) {
+						isLoading = false;
+						if (selectedIndex != -1) {
+							// listLayout.requestLayout();
+							// listLayout.invalidate();
+
+							// View someView = findViewById(R.id.someView);
+							final ViewTreeObserver obs = listLayout.getViewTreeObserver();
+							obs.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+
+								public boolean onPreDraw() {
+									scrollToItem(selectedIndex);
+									try {
+										obs.removeOnPreDrawListener(this);
+									} catch (IllegalStateException e) {
+									}
+
+									return true;
+								}
+							});
+
+							// scrollToItem(selectedIndex);
+						}
+					}
+				};
+				addElements.execute(levels);
+			}
+		};
+		asyncLoadLevels.execute();
+	}
+
+	@Override
+	public void onShow() {
+		super.onShow();
+	}
+
+	@Override
+	public void onHide(MenuScreen newMenu) {
+		super.onHide(newMenu);
+	}
+
+	@Override
+	protected boolean hideDate() {
+		return true;
+	}
+
+	@Override
+	public void reloadLevels() {
+		if (asyncLoadLevels != null) {
+			asyncLoadLevels.cancel(true);
+			asyncLoadLevels = null;
+		}
+
+		isLoading = false;
+		super.reloadLevels();
+	}
+
+	private class AsyncLoadLevels extends AsyncTask<Void, Void, Level[]> {
+
+		@Override
+		protected Level[] doInBackground(Void... params) {
+			return levelsManager.getAllInstalledLevels();
+		}
+
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/LevelMenuElement.java b/src/org/happysanta/gd/Menu/LevelMenuElement.java
new file mode 100755
index 0000000..e577e94
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/LevelMenuElement.java
@@ -0,0 +1,370 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.text.Html;
+import android.text.SpannableString;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import org.happysanta.gd.Callback;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.LevelNameLeadingMarginSpan2;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+import org.happysanta.gd.Menu.Views.MenuRelativeLayout;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+import org.happysanta.gd.R;
+import org.happysanta.gd.Storage.Level;
+import org.happysanta.gd.Storage.LevelsManager;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getGameMenu;
+import static org.happysanta.gd.Helpers.getLevelsManager;
+import static org.happysanta.gd.Helpers.getString;
+import static org.happysanta.gd.Helpers.logDebug;
+import static org.happysanta.gd.Helpers.showConfirm;
+
+public class LevelMenuElement
+		extends ClickableMenuElement
+		implements MenuHandler {
+
+	protected static final int PADDING_TOP = 7;
+	protected static final int PADDING_BOTTOM = 7;
+	protected static final int LEVEL_TEXT_SIZE = 16;
+	protected static final int NAME_SIZE = 20;
+
+	protected static final int INSTALLED_MARGIN = 15;
+	protected static final int ACTIVE_MARGIN = 21;
+
+	protected Level level;
+
+	protected MenuTextView textView;
+	protected MenuLinearLayout mainLayout;
+	protected MenuRelativeLayout nameLayout;
+	protected MenuTextView tracksCountTextView;
+	protected MenuScreen screen;
+	protected MenuImageView installedIcon = null;
+	protected MenuImageView activeIcon = null;
+	protected boolean installed = false;
+	protected boolean active = false;
+	protected boolean showDate = true;
+
+	public LevelMenuElement() {
+	}
+
+	public LevelMenuElement(Level level, MenuScreen screen) {
+		this.level = level;
+		this.screen = screen;
+
+		createAllViews();
+	}
+
+	@Override
+	protected View createMainView() {
+		Context context = getGDActivity();
+
+		mainLayout = new MenuLinearLayout(context);
+		mainLayout.setOrientation(LinearLayout.VERTICAL);
+		mainLayout.setPadding(0, getDp(PADDING_TOP), 0, getDp(PADDING_BOTTOM));
+
+		nameLayout = new MenuRelativeLayout(context);
+		// nameLayout.setOrientation(LinearLayout.HORIZONTAL);
+
+		// Text
+		textView = new MenuTextView(context);
+		// textView.setText(level.getName());
+		updateNameLine();
+		textView.setTextColor(context.getResources().getColorStateList(R.drawable.menu_item_color));
+		textView.setTypeface(Global.robotoCondensedTypeface);
+		textView.setTextSize(NAME_SIZE);
+		textView.setLineSpacing(0f, 1.1f);
+		textView.setLayoutParams(new ViewGroup.LayoutParams(
+				ViewGroup.LayoutParams.MATCH_PARENT,
+				ViewGroup.LayoutParams.WRAP_CONTENT
+		));
+		textView.setPadding(0, getDp(PADDING_TOP), 0, 0);
+
+		tracksCountTextView = new MenuTextView(context);
+		tracksCountTextView.setTextSize(LEVEL_TEXT_SIZE);
+		tracksCountTextView.setTypeface(Global.robotoCondensedTypeface);
+		updateLevelsLine();
+
+		nameLayout.addView(textView);
+		mainLayout.addView(nameLayout);
+		mainLayout.addView(tracksCountTextView);
+
+		return mainLayout;
+	}
+
+	public void updateNameLine() {
+		String name = level.getName() + (Global.DEBUG ? " (id" + level.getAnyId() + ")" : "");
+		// if (!active) {
+		int margin = 0;
+		if (installed)
+			margin = INSTALLED_MARGIN;
+		else if (active)
+			margin = ACTIVE_MARGIN;
+
+		SpannableString ss = new SpannableString(name);
+		ss.setSpan(new LevelNameLeadingMarginSpan2(1, installed || active ? getDp(margin) : 0), 0, ss.length(), 0);
+		textView.setTextOnUiThread(ss);
+		/*} else {
+			textView.setTextOnUiThread(Html.fromHtml(String.format(getString(R.string.active_name_tpl), name)));
+		}*/
+	}
+
+	public void updateLevelsLine() {
+		if (showDate) {
+			tracksCountTextView.setText(Html.fromHtml(String.format(getString(R.string.levels_count_tpl),
+					level.getCountEasy() + " - " + level.getCountMedium() + " - " + level.getCountHard(), level.getShortAddedDate())));
+		} else {
+			tracksCountTextView.setText(level.getCountEasy() + " - " + level.getCountMedium() + " - " + level.getCountHard());
+		}
+	}
+
+	@Override
+	protected void onHighlightChanged() {
+		if (installed && installedIcon != null) {
+			installedIcon.setImageResource(isHighlighted ? R.drawable.ic_downloaded_selected : R.drawable.ic_downloaded);
+		}
+		if (active && activeIcon != null) {
+			activeIcon.setImageResource(isHighlighted ? R.drawable.ic_installed_selected : R.drawable.ic_installed);
+		}
+	}
+
+	@Override
+	protected void createAllViews() {
+		super.createAllViews();
+
+		helmet.setMeasuredHeight(true);
+
+		LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.WRAP_CONTENT,
+				LinearLayout.LayoutParams.WRAP_CONTENT
+		);
+		lp.setMargins(0, getDp(PADDING_TOP * 2 + 5), 0, 0);
+
+		helmet.setLayoutParams(lp);
+	}
+
+	public void setInstalled(boolean installed) {
+		this.installed = installed;
+		if (installed) {
+			if (installedIcon == null) {
+				RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
+						RelativeLayout.LayoutParams.WRAP_CONTENT,
+						RelativeLayout.LayoutParams.WRAP_CONTENT
+				);
+				// params.setMargins(0, getDp(PADDING_TOP * 2 + 2), getDp(7), 0);
+				params.setMargins(0, getDp(PADDING_TOP * 2 + 2), 0, 0);
+
+				installedIcon = new MenuImageView(getGDActivity());
+				installedIcon.setLayoutParams(params);
+				installedIcon.setImageResource(R.drawable.ic_downloaded);
+			}
+
+			if (installedIcon.getParent() != nameLayout) {
+				nameLayout.addView(installedIcon);
+			}
+		} else if (!installed && installedIcon != null && installedIcon.getParent() == nameLayout) {
+			nameLayout.removeView(installedIcon);
+		}
+
+		updateNameLine();
+	}
+
+	public void setActive(boolean active) {
+		this.active = active;
+		if (active) {
+			if (activeIcon == null) {
+				RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
+						RelativeLayout.LayoutParams.WRAP_CONTENT,
+						RelativeLayout.LayoutParams.WRAP_CONTENT
+				);
+				// params.setMargins(0, getDp(PADDING_TOP * 2 + 2), getDp(7), 0);
+				params.setMargins(0, getDp(PADDING_TOP * 2 + 2), 0, 0);
+
+				activeIcon = new MenuImageView(getGDActivity());
+				activeIcon.setLayoutParams(params);
+				activeIcon.setImageResource(R.drawable.ic_installed);
+			}
+
+			if (activeIcon.getParent() != nameLayout) {
+				nameLayout.addView(activeIcon);
+			}
+		} else if (!active && activeIcon != null && activeIcon.getParent() == nameLayout) {
+			nameLayout.removeView(activeIcon);
+		}
+
+		updateNameLine();
+	}
+
+	public void setShowDate(boolean showDate) {
+		this.showDate = showDate;
+		updateLevelsLine();
+	}
+
+	@Override
+	public void performAction(int k) {
+		if (k == MenuScreen.KEY_FIRE) {
+			buildScreen();
+		}
+	}
+
+	protected void buildScreen() {
+		Menu menu = getGameMenu();
+		MenuScreen screen = menu.levelScreen;
+		LevelsManager levelsManager = getLevelsManager();
+
+		screen.clear();
+		// System.gc();
+
+		logDebug(level);
+
+		screen.setNavTarget(this.screen);
+		screen.setTitle(level.getName());
+
+		if (!level.getAuthor().equals(""))
+			screen.addItem(new BigTextMenuElement(Html.fromHtml(String.format(getString(R.string.author_tpl), level.getAuthor()))));
+		if (level.getInstalledTs() > 0)
+			screen.addItem(new BigTextMenuElement(Html.fromHtml(String.format(getString(R.string.installed_tpl), level.getFullInstalledDate()))));
+		else if (level.getAddedTs() > 0)
+			screen.addItem(new BigTextMenuElement(Html.fromHtml(String.format(getString(R.string.added_tpl), level.getFullAddedDate()))));
+		screen.addItem(new BigTextMenuElement(Html.fromHtml(String.format(getString(R.string.tracks_tpl), level.getCountEasy() + " / " + level.getCountMedium() + " / " + level.getCountHard()))));
+		screen.addItem(menu.createEmptyLine(true));
+
+		if (!level.isInstalled()) {
+			ActionMenuElement installAction = menu.createAction(ActionMenuElement.INSTALL);
+			installAction.setText(String.format(
+					getString(R.string.install_kb), level.getSizeKb()
+			));
+			installAction.setHandler(this);
+
+			screen.addItem(installAction);
+		} else {
+			if (!level.isDefault()) {
+				ActionMenuElement installed = new ActionMenuElement(getString(R.string.installed), null);
+				installed.setDisabled(true);
+				screen.addItem(installed);
+			}
+
+			if (level.getId() == levelsManager.getCurrentId()) {
+				ActionMenuElement active = new ActionMenuElement(getString(R.string.active), null);
+				active.setDisabled(true);
+				screen.addItem(active);
+			} else {
+				ActionMenuElement loadAction = menu.createAction(ActionMenuElement.LOAD);
+				loadAction.setHandler(this);
+				screen.addItem(loadAction);
+			}
+
+			if (!level.isDefault() && levelsManager.getCurrentId() != level.getId()) {
+				ActionMenuElement deleteAction = menu.createAction(ActionMenuElement.DELETE);
+				deleteAction.setHandler(this);
+
+				screen.addItem(deleteAction);
+			}
+		}
+
+		screen.addItem(menu.createAction(ActionMenuElement.BACK));
+
+		if (menu.getCurrentMenu() != screen) {
+			menu.setCurrentMenu(screen, false);
+		} else {
+			screen.highlightElement();
+		}
+	}
+
+	@Override
+	public MenuScreen getCurrentMenu() {
+		return null;
+	}
+
+	@Override
+	public void setCurrentMenu(MenuScreen e1, boolean flag) {
+	}
+
+	@Override
+	public void handleAction(MenuElement item) {
+		if (item instanceof ActionMenuElement) {
+			final GDActivity gd = getGDActivity();
+			final Menu menu = getGameMenu();
+
+			switch (((ActionMenuElement) item).getActionValue()) {
+				case ActionMenuElement.DELETE:
+					if (!level.isInstalled())
+						break;
+
+					showConfirm(
+							getString(R.string.delete_levels),
+							getString(R.string.delete_levels_confirmation),
+							new Runnable() {
+								@Override
+								public void run() {
+									gd.levelsManager.deleteAsync(level, new Runnable() {
+										@Override
+										public void run() {
+											long id = level.getId();
+
+											MenuScreen target = menu.getCurrentMenu().getNavTarget();
+											if (target instanceof InstalledLevelsMenuScreen) {
+												InstalledLevelsMenuScreen installedScreen = (InstalledLevelsMenuScreen) target;
+												LevelMenuElement el = installedScreen.getElementByLevelId(id, 0);
+												if (el != null)
+													installedScreen.deleteElement(el);
+												level.setId(0);
+												menu.back();
+											} else if (target instanceof DownloadLevelsMenuScreen) {
+												DownloadLevelsMenuScreen downloadScreen = (DownloadLevelsMenuScreen) target;
+												LevelMenuElement el = downloadScreen.getElementByLevelId(id, 0);
+												if (el != null)
+													el.setInstalled(false);
+
+												level.setId(0);
+												buildScreen();
+											}
+										}
+									});
+								}
+							},
+							null
+					);
+					break;
+
+				case ActionMenuElement.INSTALL:
+					gd.levelsManager.downloadLevel(level, new Callback() {
+						@Override
+						public void onDone(Object... objects) {
+							long id = (long) objects[0];
+							level.setId(id);
+
+							MenuScreen target = menu.getCurrentMenu().getNavTarget();
+							if (target instanceof DownloadLevelsMenuScreen) {
+								DownloadLevelsMenuScreen downloadScreen = (DownloadLevelsMenuScreen) target;
+								LevelMenuElement el = downloadScreen.getElementByLevelId(id, 0);
+								if (el != null)
+									el.setInstalled(true);
+							}
+
+							buildScreen();
+						}
+					});
+					break;
+
+				case ActionMenuElement.LOAD:
+					gd.levelsManager.load(level);
+					// buildScreen();
+					break;
+			}
+		}
+	}
+
+	@Override
+	public String toString() {
+		return level.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/src/org/happysanta/gd/Menu/LevelsAdapter.java b/src/org/happysanta/gd/Menu/LevelsAdapter.java
new file mode 100644
index 0000000..9f7ddc9
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/LevelsAdapter.java
@@ -0,0 +1,53 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.text.Html;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.TextView;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.R;
+import org.happysanta.gd.Storage.Level;
+
+import java.util.ArrayList;
+
+import static org.happysanta.gd.Helpers.getString;
+
+public class LevelsAdapter extends ArrayAdapter<Level> {
+
+	private ArrayList<Level> levels;
+
+	public LevelsAdapter(Context context, ArrayList<Level> levels) {
+		super(context, R.layout.levels_list_item, levels);
+		this.levels = levels;
+	}
+
+	@Override
+	public View getView(int position, View convertView, ViewGroup parent) {
+		View v = convertView;
+		if (v == null) {
+			LayoutInflater inflater = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+			v = inflater.inflate(R.layout.levels_list_item, null);
+		}
+
+		Level level = levels.get(position);
+		if (level != null) {
+			TextView name = (TextView) v.findViewById(R.id.level_name);
+			TextView count = (TextView) v.findViewById(R.id.level_count);
+
+			name.setTypeface(Global.robotoCondensedTypeface);
+			count.setTypeface(Global.robotoCondensedTypeface);
+
+			name.setText(level.getName());
+			count.setText(Html.fromHtml(String.format(getString(R.string.levels_count_tpl),
+					level.getCountEasy() + " - " + level.getCountMedium() + " - " + level.getCountHard(), level.getShortAddedDate())));
+		}
+
+		return v;
+	}
+
+}
+
+
diff --git a/src/org/happysanta/gd/Menu/LevelsCountTextMenuElement.java b/src/org/happysanta/gd/Menu/LevelsCountTextMenuElement.java
new file mode 100644
index 0000000..7ead337
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/LevelsCountTextMenuElement.java
@@ -0,0 +1,86 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.LinearLayout;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+import org.happysanta.gd.R;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class LevelsCountTextMenuElement
+		extends BigTextMenuElement {
+
+	protected static final int PADDING_LEFT = 4;
+	protected static final int PADDING_RIGHT = 8;
+	protected static final int MARGIN_RIGHT = 3;
+
+	protected int tracks[];
+
+	protected MenuLinearLayout layout;
+	protected MenuImageView tracksImages[];
+	protected MenuTextView tracksTexts[];
+
+	public LevelsCountTextMenuElement(String s, int easy, int medium, int hard) {
+		super(s);
+
+		tracks = new int[3];
+		tracks[0] = easy;
+		tracks[1] = medium;
+		tracks[2] = hard;
+
+		createViews();
+	}
+
+	protected void createViews() {
+		Context context = getGDActivity();
+
+		layout = new MenuLinearLayout(context);
+		layout.setOrientation(LinearLayout.HORIZONTAL);
+		layout.setLayoutParams(new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.MATCH_PARENT,
+				LinearLayout.LayoutParams.WRAP_CONTENT
+		));
+
+		tracksImages = new MenuImageView[3];
+		for (int i = 0; i < 3; i++) {
+			tracksImages[i] = new MenuImageView(context);
+			tracksImages[i].setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.MATCH_PARENT));
+		}
+
+		tracksImages[0].setImageResource(R.drawable.levels_wheel0);
+		tracksImages[1].setImageResource(R.drawable.levels_wheel1);
+		tracksImages[2].setImageResource(R.drawable.levels_wheel2);
+
+		// Tracks texts
+		tracksTexts = new MenuTextView[3];
+		for (int i = 0; i < 3; i++) {
+			tracksTexts[i] = new MenuTextView(context);
+			setTextParams(tracksTexts[i]);
+
+			tracksTexts[i].setText(String.valueOf(tracks[i]));
+			tracksTexts[i].setPadding(getDp(PADDING_LEFT), 0, getDp(PADDING_RIGHT), 0);
+		}
+
+		LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+		params.setMargins(0, 0, getDp(MARGIN_RIGHT), 0);
+
+		textView.setLayoutParams(params);
+
+		layout.addView(textView);
+
+		// Add tracks to layout
+		for (int i = 0; i < 3; i++) {
+			layout.addView(tracksImages[i]);
+			layout.addView(tracksTexts[i]);
+		}
+	}
+
+	@Override
+	public View getView() {
+		return layout;
+	}
+}
diff --git a/src/org/happysanta/gd/Menu/LevelsMenuScreen.java b/src/org/happysanta/gd/Menu/LevelsMenuScreen.java
new file mode 100644
index 0000000..22b7539
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/LevelsMenuScreen.java
@@ -0,0 +1,429 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.os.AsyncTask;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+import org.happysanta.gd.R;
+import org.happysanta.gd.Storage.Level;
+import org.happysanta.gd.Storage.LevelsManager;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Vector;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getGDView;
+import static org.happysanta.gd.Helpers.getGameMenu;
+import static org.happysanta.gd.Helpers.getLevelsManager;
+import static org.happysanta.gd.Helpers.getString;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class LevelsMenuScreen extends MenuScreen {
+
+	enum Statuses {NORMAL, DOWNLOADING, ERROR}
+
+	protected final static int ERROR_COLOR = 0xff777777;
+
+	protected Statuses status = Statuses.NORMAL;
+	protected int savedScrollY = 0;
+
+	protected Vector elements;
+	protected ArrayList<Level> levels;
+
+	protected FrameLayout progressWrap;
+	protected ProgressBar progressBar;
+
+	protected MenuLinearLayout listLayout;
+	protected TextMenuElement errorText;
+	protected AsyncAddElements addElements = null;
+	protected boolean leftFromScreen = false;
+
+	public LevelsMenuScreen(String title, MenuScreen navTarget) {
+		super(title, navTarget);
+
+		elements = new Vector();
+		levels = new ArrayList<>();
+
+		Context context = getGDActivity();
+
+		// Create progress
+		progressWrap = new FrameLayout(context);
+		progressWrap.setLayoutParams(new LinearLayout.LayoutParams(
+				FrameLayout.LayoutParams.MATCH_PARENT,
+				FrameLayout.LayoutParams.MATCH_PARENT
+		));
+
+		progressBar = new ProgressBar(context);
+		progressBar.setIndeterminate(true);
+
+		// Create error
+		errorText = new TextMenuElement(getString(R.string.download_error));
+		TextView errorTextView = (TextView) errorText.getView();
+
+		errorTextView.setTextColor(ERROR_COLOR);
+		errorTextView.setLayoutParams(new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.MATCH_PARENT,
+				LinearLayout.LayoutParams.MATCH_PARENT
+		));
+		errorTextView.setGravity(Gravity.CENTER);
+
+		listLayout = new MenuLinearLayout(context);
+		listLayout.setOrientation(LinearLayout.VERTICAL);
+		listLayout.setLayoutParams(new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.MATCH_PARENT,
+				LinearLayout.LayoutParams.MATCH_PARENT
+		));
+
+		layout.addView(listLayout);
+
+		// List view
+		// listView = new ListView(context);
+		/*listView.setLayoutParams(new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.WRAP_CONTENT,
+				LinearLayout.LayoutParams.WRAP_CONTENT
+		));*/
+
+		// adapter = new LevelsAdapter(context, levels);
+		// listView.setAdapter(adapter);
+
+		// layout.addView(listView);
+	}
+
+	public int addListItem(MenuElement item) {
+		elements.addElement(item);
+		listLayout.addView(item.getView());
+
+		if (item instanceof ClickableMenuElement)
+			((ClickableMenuElement) item).setOnHighlightListener(this);
+
+		return elements.size() - 1;
+	}
+
+	public void setStatus(Statuses status) {
+		this.status = status;
+
+		getGDView().invalidate();
+	}
+
+	protected void clearList() {
+		elements.removeAllElements();
+		levels.clear();
+		listLayout.removeAllViews();
+		lastHighlighted = null;
+		// System.gc();
+	}
+
+	protected void showError(String error) {
+		clearList();
+		errorText.setText(error);
+		addListItem(errorText);
+
+		setStatus(Statuses.ERROR);
+	}
+
+	protected void showLoading() {
+		// clearList();
+
+		if (elements.isEmpty()) {
+			if (progressBar.getParent() == listLayout) {
+				listLayout.removeView(progressBar);
+			} else if (progressBar.getParent() != progressWrap) {
+				progressWrap.addView(progressBar, new FrameLayout.LayoutParams(
+						FrameLayout.LayoutParams.WRAP_CONTENT,
+						FrameLayout.LayoutParams.WRAP_CONTENT,
+						Gravity.CENTER_HORIZONTAL | Gravity.CENTER_VERTICAL
+				));
+			}
+
+			listLayout.addView(progressWrap);
+		} else {
+			if (progressBar.getParent() == progressWrap) {
+				progressWrap.removeView(progressBar);
+			} else if (progressBar.getParent() != listLayout) {
+				listLayout.addView(progressBar, new LinearLayout.LayoutParams(
+						LinearLayout.LayoutParams.MATCH_PARENT,
+						LinearLayout.LayoutParams.WRAP_CONTENT,
+						Gravity.CENTER_HORIZONTAL
+				));
+			}
+		}
+
+		// setStatus(Statuses.DOWNLOADING);
+	}
+
+	protected void hideLoading() {
+		if (progressBar.getParent() == listLayout) {
+			listLayout.removeView(progressBar);
+		} else if (progressBar.getParent() == progressWrap) {
+			// progressWrap.setVisibility(GameView.GONE);
+			listLayout.removeView(progressWrap);
+		}
+	}
+
+	public void highlightFirstElement() {
+		for (int i = 0; i < elements.size(); i++) {
+			if (elements.elementAt(i) instanceof LevelMenuElement) {
+				highlightElementAt(i);
+				break;
+			}
+		}
+	}
+
+	public void highlightElementAt(int index) {
+		LevelMenuElement item = null;
+		try {
+			item = (LevelMenuElement) elements.elementAt(index);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return;
+		}
+
+		item.showHelmet();
+		lastHighlighted = item;
+		selectedIndex = index;
+	}
+
+	protected void load() {
+		clearList();
+		loadLevels();
+	}
+
+	protected void loadLevels() {
+
+	}
+
+	@Override
+	public void onShow() {
+		super.onShow();
+		GDActivity activity = getGDActivity();
+
+		if (leftFromScreen) {
+			clearList();
+			leftFromScreen = false;
+		}
+
+		switch (status) {
+			case DOWNLOADING:
+				break;
+
+			case NORMAL:
+				if (elements.isEmpty()) {
+					load();
+				}
+				break;
+		}
+
+		if (lastHighlighted != null) {
+			lastHighlighted.showHelmet();
+		}
+
+		if (savedScrollY != 0) {
+			activity.scrollView.scrollTo(0, savedScrollY);
+		}
+	}
+
+	@Override
+	public void onHide(MenuScreen newMenu) {
+		GDActivity activity = getGDActivity();
+
+		if (newMenu != getGameMenu().levelScreen) {
+			if (addElements != null) {
+				addElements.cancel(true);
+				addElements = null;
+			}
+
+			savedScrollY = 0;
+			status = Statuses.NORMAL;
+
+			hideLoading();
+			clearList();
+
+			leftFromScreen = true;
+		} else {
+			savedScrollY = activity.scrollView.getScrollY();
+		}
+	}
+
+	protected boolean hideDate() {
+		return false;
+	}
+
+	protected LevelsMenuScreen getThis() {
+		return this;
+	}
+
+	public void reloadLevels() {
+		if (addElements != null) {
+			addElements.cancel(true);
+			addElements = null;
+		}
+
+		clearList();
+		loadLevels();
+	}
+
+	public LevelMenuElement getElementByLevelId(long id, long apiId) {
+		for (Object _el : elements) {
+			LevelMenuElement el = (LevelMenuElement) _el;
+
+			if ((id > 0 && el.level.getId() == id) || apiId > 0 && el.level.getApiId() == apiId)
+				return el;
+		}
+
+		return null;
+	}
+
+	public void deleteElement(LevelMenuElement el) {
+		View view = el.getView();
+		listLayout.removeView(view);
+
+		int index = elements.indexOf(el);
+
+		elements.remove(el);
+		levels.remove(el.level);
+
+		if (el == lastHighlighted) {
+			index--;
+			if (index < 0)
+				index = 0;
+
+			highlightElementAt(index);
+		}
+	}
+
+	@Override
+	public void performAction(int k) {
+		logDebug("LevelsMenuScreen.performAction: k = " + k);
+		int from = 0;
+		switch (k) {
+			default:
+				if (selectedIndex != -1) {
+					for (int i = selectedIndex; i < elements.size(); i++) {
+						MenuElement item;
+						if ((item = (MenuElement) elements.elementAt(i)) != null && item.isSelectable()) {
+							item.performAction(k);
+							return;
+						}
+					}
+				}
+				break;
+
+			case KEY_UP:
+				if (selectedIndex > 0) {
+					from = selectedIndex - 1;
+				} else {
+					from = elements.size() - 1;
+				}
+
+				for (int i = from; i >= 0; i--) {
+					MenuElement el = (MenuElement) elements.elementAt(i);
+					if (!(el instanceof LevelMenuElement)) {
+						continue;
+					}
+
+					highlightElementAt(i);
+					scrollToItem(el);
+					break;
+				}
+				break;
+
+			case KEY_DOWN:
+				if (selectedIndex < elements.size() - 1) {
+					from = selectedIndex + 1;
+				} else {
+					from = 0;
+				}
+
+				for (int i = from; i < elements.size(); i++) {
+					MenuElement el = (MenuElement) elements.elementAt(i);
+					if (!(el instanceof LevelMenuElement)) {
+						continue;
+					}
+
+					highlightElementAt(i);
+					scrollToItem(el);
+					break;
+				}
+				break;
+		}
+	}
+
+	protected void scrollToItem(int index) {
+		LevelMenuElement el = (LevelMenuElement) elements.elementAt(index);
+		// logDebug(el);
+		scrollToItem(el);
+	}
+
+	protected class AsyncAddElements extends AsyncTask<Level[], Void, Void> {
+
+		@Override
+		protected Void doInBackground(Level[]... params) {
+			Level[] _levels = params[0];
+			boolean checkInstalled = getThis() instanceof DownloadLevelsMenuScreen;
+			boolean checkActive = getThis() instanceof InstalledLevelsMenuScreen;
+
+			ArrayList<Long> ids;
+			HashMap<Long, Long> installed = null;
+			LevelsManager levelsManager = getLevelsManager();
+
+			if (checkInstalled) {
+				ids = new ArrayList<>();
+
+				for (Level level : _levels) {
+					ids.add(level.getApiId());
+				}
+
+				installed = getGDActivity().levelsManager.findInstalledLevels(ids);
+			}
+
+			boolean alreadyHl = false;
+
+			for (Level level : _levels) {
+				if (isCancelled()) {
+					clearList();
+					return null;
+				}
+
+				LevelMenuElement el = new LevelMenuElement(level, getThis());
+				boolean toHl = false;
+
+				if (hideDate())
+					el.setShowDate(false);
+
+				if (checkInstalled && installed.containsKey(level.getApiId())) {
+					level.setId(installed.get(level.getApiId()));
+					el.setInstalled(true);
+				}
+				if (checkActive && level.getId() == levelsManager.getCurrentId()) {
+					el.setActive(true);
+					toHl = true;
+				}
+
+				if (!isCancelled()) {
+					int index = addListItem(el);
+					if (toHl && !alreadyHl) {
+						highlightElementAt(index);
+						// scrollToItem(index);
+						alreadyHl = true;
+					}
+
+					if (lastHighlighted == null)
+						highlightFirstElement();
+				}
+			}
+
+			levels.addAll(Arrays.asList(_levels));
+			return null;
+		}
+
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Menu.java b/src/org/happysanta/gd/Menu/Menu.java
new file mode 100755
index 0000000..7485176
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Menu.java
@@ -0,0 +1,1554 @@
+package org.happysanta.gd.Menu;
+
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.os.Environment;
+import android.text.Html;
+import android.text.InputType;
+import android.widget.EditText;
+import org.happysanta.gd.Command;
+import org.happysanta.gd.FileDialog;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Game.GameView;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Levels.InvalidTrackException;
+import org.happysanta.gd.Levels.Loader;
+import org.happysanta.gd.R;
+import org.happysanta.gd.Settings;
+import org.happysanta.gd.Storage.HighScores;
+import org.happysanta.gd.Storage.Level;
+import org.happysanta.gd.Storage.LevelsManager;
+import org.acra.ACRA;
+
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+
+import static org.happysanta.gd.Helpers.*;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class Menu
+		implements MenuHandler {
+
+	// private final static int SETTINGS_LENGTH = 21;
+	// private final static boolean ENABLE_MANAGER = true;
+
+	public MenuScreen currentMenu;
+	public Level level;
+	private HighScores currentScores;
+	public int selectedLeague = 0;
+	public boolean m_blZ = false;
+	public boolean menuDisabled = false;
+	// byte[] unlockedTracks = new byte[3];
+	// byte leaguesUnlockedCount = 0;
+	// byte levelsUnlockedCount = 0;
+	int[] selectedTrack = {
+			0, 0, 0
+	};
+	String[][] trackNames;
+	String[] leagues = new String[3];
+	String[] fullLeaguesList = new String[4];
+	// private byte[] settings;
+	// private SaveManager saveManager;
+	private Command okCommand;
+	private Command backCommand;
+	private MenuScreen mainMenu;
+	private MenuScreen playMenu;
+	private MenuScreen optionsMenu;
+	private MenuScreen aboutScreen;
+	private MenuScreen helpMenu;
+	private MenuScreen eraseScreen;
+	private MenuScreen resetScreen;
+	private MenuScreen finishedMenu;
+	private MenuScreen ingameScreen;
+	private SimpleMenuElementNew gameMenuItem;
+	// private SimpleMenuElementNew optionsMenuItem;
+	// private SimpleMenuElementNew helpMenuItem;
+	private OptionsMenuElement levelSelector;
+	private MenuScreen levelSelectorCurrentMenu;
+	private OptionsMenuElement trackSelector;
+	private MenuScreen trackSelectorCurrentMenu;
+	private OptionsMenuElement leagueSelector;
+	private MenuScreen leagueSelectorCurrentMenu;
+	private MenuScreen highScoreMenu;
+	private SimpleMenuElementNew highscoreItem;
+	private ActionMenuElement startItem;
+	private OptionsMenuElement perspectiveOptionItem;
+	private OptionsMenuElement shadowsOptionItem;
+	private OptionsMenuElement driverSpriteOptionItem;
+	private OptionsMenuElement bikeSpriteOptionItem;
+	private OptionsMenuElement inputOptionItem;
+	private OptionsMenuElement lookAheadOptionItem;
+	private OptionsMenuElement keyboardInMenuOptionItem;
+	private OptionsMenuElement vibrateOnTouchOptionItem;
+	private SimpleMenuElementNew clearHighscoreOptionItem;
+	private SimpleMenuElementNew fullResetItem;
+	// private ActionMenuElement yesAction;
+	// private ActionMenuElement noAction;
+	private SimpleMenuElementNew aboutMenuItem;
+	private MenuScreen objectiveHelpScreen;
+	private SimpleMenuElementNew objectiveHelpItem;
+	private MenuScreen keysHelpScreen;
+	private SimpleMenuElementNew keysHelpItem;
+	private MenuScreen unlockingHelpScreen;
+	private SimpleMenuElementNew unlockingHelpItem;
+	private MenuScreen highscoreHelpScreen;
+	private SimpleMenuElementNew highscoreHelpItem;
+	private MenuScreen optionsHelpScreen;
+	private SimpleMenuElementNew optionsHelpItem;
+	private NameInputMenuScreen nameScreen;
+	private ActionMenuElement continueAction;
+	// private ActionMenuElement goToMainAction;
+	// private ActionMenuElement exitMenuItem;
+	private ActionMenuElement ingameRestartAction;
+	private ActionMenuElement finishedRestartAction;
+	private ActionMenuElement nextAction;
+	// private ActionMenuElement okAction;
+	private ActionMenuElement nameAction;
+	private long lastTrackTime;
+	private int m_ajI;
+	private int m_atI;
+	private String finishedTime;
+	private byte[] nameChars;
+	// private RecordStore recordStore;
+	// private int m_afI = -1;
+	private boolean settingsLoadedOK;
+	private int levelIndex = 0;
+	private int track = 0;
+	private boolean leagueCompleted = false;
+	private boolean m_SZ = false;
+	private Object m_BObject;
+	private String[] difficultyLevels = null; /* {
+			"Easy", "Medium", "Hard"
+	}; */
+	// private long finishTime = 0L;
+	/*private byte perspectiveOptionEnabled = 0;
+	private byte shadowsOptionEnabled = 0;
+	private byte driverSpriteOptionEnabled = 0;
+	private byte bikerSpriteOptionEnabled = 0;
+	private byte inputOptionValue = 0;
+	private byte lookAheadOptionEnabled = 0;
+	private byte keyboardInMenuEnabled = 1;
+	private byte vibrateOnTouchEnabled = 1;*/
+	// private byte selectedTrackIndex = 0;
+	// private byte selectedLevel = 0;
+	// private byte selectedLeague = 0;
+	// private byte m_aTB = 0;
+	// private byte m_arB = 0;
+	private String[] onOffStrings = null;
+	private String[] keysetStrings = null;
+	// private EmptyLineMenuElement emptyLine;
+	// private EmptyLineMenuElement emptyLineBeforeAction;
+	// private AlertDialog alertDialog = null;
+	private Paint bgPaint;
+	public MenuScreen managerScreen;
+	public InstalledLevelsMenuScreen managerInstalledScreen;
+	public DownloadLevelsMenuScreen managerDownloadScreen;
+	// private MenuScreen managerDownloadOptionsScreen;
+	private SimpleMenuElementNew managerMenuItem;
+	public MenuScreen levelScreen;
+	// private SimpleMenuElement managerInstalledItem;
+	// private SimpleMenuElement managerDownloadItem;
+	// private HelmetRotationTask helmetRotationTask;
+	// private Timer helmetRotationTimer;
+	// public int helmetAngle;
+
+	public Menu() {
+		// Background color (instead of raster.png)
+		bgPaint = new Paint();
+		bgPaint.setColor(0x80FFFFFF);
+	}
+
+	public void load(int step) {
+		GDActivity activity = getGDActivity();
+		Loader loader = getLevelLoader();
+		LevelsManager levelsManager = getLevelsManager();
+
+		level = levelsManager.getCurrentLevel();
+
+		switch (step) {
+			case 1:
+				m_BObject = new Object();
+				nameChars = new byte[]{
+						65, 65, 65 // A A A
+				};
+				onOffStrings = getStringArray(R.array.on_off);
+				keysetStrings = getStringArray(R.array.keyset);
+				difficultyLevels = getStringArray(R.array.difficulty);
+
+				// saveManager = new SaveManager();
+				lastTrackTime = -1L;
+				m_ajI = -1;
+				m_atI = -1;
+				finishedTime = null;
+				// settingsLoadedOK = false;
+				/*settings = new byte[SETTINGS_LENGTH];
+				for (int l = 0; l < SETTINGS_LENGTH; l++)
+					settings[l] = -127;*/
+
+				settingsLoadedOK = true;
+				/*try {
+					recordStore = RecordStore.openRecordStore(*//*(Loader.levelsFile != null ? Loader.levelsFile.getName().hashCode() : "") + *//*
+							getLevelsManager().getCurrentId() + "_" + "GDTRStates", true);
+					settingsLoadedOK = true;
+					return;
+				} catch (Exception _ex) {
+					settingsLoadedOK = false;
+				}*/
+
+				break;
+
+			case 2:
+				// m_afI = -1;
+				/*RecordEnumeration enumeration;
+				try {
+					enumeration = recordStore.enumerateRecords(null, null, false);
+				} catch (*//*RecordStoreNotOpen*//*Exception _ex) {
+					return;
+				}
+				if (enumeration.numRecords() > 0) {
+					byte[] abyte0;
+					try {
+						abyte0 = enumeration.nextRecord();
+						enumeration.reset();
+						m_afI = enumeration.nextRecordId();
+					} catch (Exception _ex) {
+						return;
+					}
+					if (abyte0.length <= SETTINGS_LENGTH)
+						System.arraycopy(abyte0, 0, settings, 0, abyte0.length);
+					enumeration.destroy();
+				}*/
+
+				/*byte[] chars;
+				if ((chars = readNameChars(16, (byte) -1)) != null && chars[0] != -1) {
+					for (int i = 0; i < 3; i++)
+						nameChars[i] = chars[i];
+
+				}*/
+
+				nameChars = Settings.getName();
+				// if (nameChars[0] == 82 && nameChars[1] == 75 && nameChars[2] == 69) {
+				if (isNameCheat(nameChars)) {
+					// Unlock everything for cheat
+					level.setUnlockedLeagues(3);
+					level.setUnlockedLevels(2);
+					level.setUnlocked(
+							loader.names[0].length - 1,
+							loader.names[1].length - 1,
+							loader.names[2].length - 1
+					);
+					// logDebug(level);
+					// leaguesUnlockedCount = 3;
+					// levelsUnlockedCount = 2;
+					/*unlockedTracks[0] = (byte) (loader.names[0].length - 1);
+					unlockedTracks[1] = (byte) (loader.names[1].length - 1);
+					unlockedTracks[2] = (byte) (loader.names[2].length - 1);*/
+				} else if (level.isSettingsClear()) {
+					level.setUnlockedLeagues(0);
+					level.setUnlockedLevels(1);
+					level.setUnlocked(0, 0, -1);
+					// leaguesUnlockedCount = 0;
+					// levelsUnlockedCount = 1;
+					/*unlockedTracks[0] = 0;
+					unlockedTracks[1] = 0;
+					unlockedTracks[2] = -1;*/
+				}
+				break;
+
+			case 3:
+				// Load settings
+				/*perspectiveOptionEnabled = readSetting(0, perspectiveOptionEnabled);
+				shadowsOptionEnabled = readSetting(1, shadowsOptionEnabled);
+				driverSpriteOptionEnabled = readSetting(2, driverSpriteOptionEnabled);
+				bikerSpriteOptionEnabled = readSetting(3, bikerSpriteOptionEnabled);
+				lookAheadOptionEnabled = readSetting(4, lookAheadOptionEnabled);
+
+				keyboardInMenuEnabled = readSetting(13, keyboardInMenuEnabled);
+				inputOptionValue = readSetting(14, inputOptionValue);*/
+				// m_arB = readSetting(15, m_arB); // nonsense
+
+				/*vibrateOnTouchEnabled = readSetting(19, keyboardInMenuEnabled);
+
+				selectedLevel = readSetting(10, selectedLevel);
+				selectedTrackIndex = readSetting(11, selectedTrackIndex);
+				selectedLeague = readSetting(12, selectedLeague);*/
+
+				// byte levelsSort = readSetting(20, (byte)0);
+
+				DownloadLevelsMenuScreen.sort = Settings.getLevelsSort();
+
+
+				levelIndex = level.getSelectedLevel();
+				track = level.getSelectedTrack();
+
+				if (nameChars[0] != 82 || nameChars[1] != 75 || nameChars[2] != 69) {
+					//level.setUnlockedLeagues();
+					/*leaguesUnlockedCount = readSetting(5, leaguesUnlockedCount);
+					levelsUnlockedCount = readSetting(6, levelsUnlockedCount);
+					for (int i = 0; i < 3; i++)
+						unlockedTracks[i] = readSetting(7 + i, unlockedTracks[i]);*/
+				}
+
+				try {
+					selectedTrack[level.getSelectedLevel()] = level.getSelectedTrack();
+				} catch (ArrayIndexOutOfBoundsException _ex) {
+					level.setSelectedLevel(0);
+					level.setSelectedTrack(0);
+					selectedTrack[level.getSelectedLevel()] = level.getSelectedTrack();
+				}
+				getLevelLoader().setPerspectiveEnabled(Settings.isPerspectiveEnabled());
+				getLevelLoader().setShadowsEnabled(Settings.isShadowsEnabled());
+				activity.physEngine._ifZV(Settings.isLookAheadEnabled());
+				getGDView().setInputOption(Settings.getInputOption());
+				// getGDView()._aZV(m_aTB == 0);
+				getGDView()._aZV(true);
+				String[] leaguesList = getStringArray(R.array.leagues);
+				fullLeaguesList = getStringArray(R.array.leagues_full);
+				trackNames = getLevelLoader().names;
+
+				if (level.getUnlockedLeagues() < 3) {
+					leagues = leaguesList;
+				} else {
+					leagues = fullLeaguesList;
+				}
+
+				selectedLeague = level.getSelectedLeague();
+
+				break;
+
+			case 4:
+				mainMenu = new MenuScreen(getString(R.string.main), null);
+				playMenu = new MenuScreen(getString(R.string.play), mainMenu);
+				managerScreen = new MenuScreen(getString(R.string.mods), mainMenu);
+				optionsMenu = new MenuScreen(getString(R.string.options), mainMenu);
+				aboutScreen = new MenuScreen(getString(R.string.about) + " v" + getAppVersion(), mainMenu);
+				helpMenu = new MenuScreen(getString(R.string.help), mainMenu);
+
+				continueAction = new ActionMenuElement(getString(R.string._continue), ActionMenuElement.CONTINUE, this);
+				nextAction = new ActionMenuElement(getString(R.string.track) + ": " + getLevelLoader().getLevelName(0, 1), ActionMenuElement.NEXT, this);
+				ingameRestartAction = new ActionMenuElement(getString(R.string.restart) + ": " + getLevelLoader().getLevelName(0, 0), ActionMenuElement.RESTART, this);
+				finishedRestartAction = new ActionMenuElement(getString(R.string.restart) + ": " + getLevelLoader().getLevelName(0, 0), ActionMenuElement.RESTART, this);
+
+				/*nextAction = new ActionMenuElement(getString(R.string.track) + ": DEFAULT", ActionMenuElement.NEXT, this);
+				ingameRestartAction = new ActionMenuElement(getString(R.string.restart) + ": DEFAULT", ActionMenuElement.RESTART, this);
+				finishedRestartAction = new ActionMenuElement(getString(R.string.restart) + ": DEFAULT", ActionMenuElement.RESTART, this);*/
+
+				highScoreMenu = new MenuScreen(getString(R.string.highscores), playMenu);
+				finishedMenu = new MenuScreen(getString(R.string.finished), playMenu);
+				ingameScreen = new MenuScreen(getString(R.string.ingame), playMenu);
+				nameScreen = new NameInputMenuScreen(getString(R.string.enter_name), finishedMenu, nameChars);
+				eraseScreen = new MenuScreen(getString(R.string.confirm_clear), optionsMenu);
+				resetScreen = new MenuScreen(getString(R.string.confirm_reset), eraseScreen);
+
+				gameMenuItem = new SimpleMenuElementNew(getString(R.string.play_menu), playMenu, this);
+				managerMenuItem = new SimpleMenuElementNew(getString(R.string.mods), managerScreen, this);
+				aboutMenuItem = new SimpleMenuElementNew(getString(R.string.about), aboutScreen, this);
+
+				mainMenu.addItem(gameMenuItem);
+				//if (ENABLE_MANAGER)
+				mainMenu.addItem(new SimpleMenuElementNew(getString(R.string.mods), managerScreen, this));
+				mainMenu.addItem(new SimpleMenuElementNew(getString(R.string.options), optionsMenu, this));
+				mainMenu.addItem(new SimpleMenuElementNew(getString(R.string.help), helpMenu, this));
+				mainMenu.addItem(aboutMenuItem);
+				if (Global.DEBUG) {
+					// mainMenu.addItem(createAction(ActionMenuElement.RESTART_WITH_NEW_LEVEL));
+					mainMenu.addItem(createAction(ActionMenuElement.SEND_LOGS));
+				}
+				mainMenu.addItem(createAction(ActionMenuElement.EXIT));
+
+				levelSelector = new OptionsMenuElement(getString(R.string.level), level.getSelectedLevel(), this, difficultyLevels, false, playMenu);
+				trackSelector = new OptionsMenuElement(getString(R.string.track), selectedTrack[level.getSelectedLevel()], this, trackNames[level.getSelectedLevel()], false, playMenu);
+				leagueSelector = new OptionsMenuElement(getString(R.string.league), selectedLeague, this, leagues, false, playMenu);
+				try {
+					trackSelector.setUnlockedCount(level.getUnlocked(level.getSelectedLevel()));
+				} catch (ArrayIndexOutOfBoundsException _ex) {
+					trackSelector.setUnlockedCount(0);
+				}
+				levelSelector.setUnlockedCount(level.getUnlockedLevels());
+				leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+				highscoreItem = new SimpleMenuElementNew(getString(R.string.highscores), highScoreMenu, this);
+				highScoreMenu.addItem(createAction(ActionMenuElement.BACK));
+				startItem = new ActionMenuElement(getString(R.string.start) + ">", this);
+				playMenu.addItem(startItem);
+				playMenu.addItem(levelSelector);
+				playMenu.addItem(trackSelector);
+				playMenu.addItem(leagueSelector);
+				playMenu.addItem(highscoreItem);
+				playMenu.addItem(createAction(ActionMenuElement.GO_TO_MAIN));
+				// if (hasPointer)
+				// 	softwareJoystickOptionItem = new ActionMenuElement("Software Joystick", m_aTB, this, onOffStrings, true, activity, optionsMenu, false);
+				perspectiveOptionItem = new OptionsMenuElement(getString(R.string.perspective), Settings.isPerspectiveEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				shadowsOptionItem = new OptionsMenuElement(getString(R.string.shadows), Settings.isShadowsEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				driverSpriteOptionItem = new OptionsMenuElement(getString(R.string.driver_sprite), Settings.isDriverSpriteEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				bikeSpriteOptionItem = new OptionsMenuElement(getString(R.string.bike_sprite), Settings.isBikeSpriteEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				inputOptionItem = new OptionsMenuElement(getString(R.string.input), Settings.getInputOption(), this, keysetStrings, false, optionsMenu);
+				lookAheadOptionItem = new OptionsMenuElement(getString(R.string.look_ahead), Settings.isLookAheadEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				vibrateOnTouchOptionItem = new OptionsMenuElement(getString(R.string.vibrate_on_touch), Settings.isVibrateOnTouchEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				keyboardInMenuOptionItem = new OptionsMenuElement(getString(R.string.keyboard_in_menu), Settings.isKeyboardInMenuEnabled() ? 0 : 1, this, onOffStrings, true, optionsMenu);
+				clearHighscoreOptionItem = new SimpleMenuElementNew(getString(R.string.clear_highscore), eraseScreen, this);
+
+				// if (hasPointer)
+				//	optionsMenu.addItem(softwareJoystickOptionItem);
+				optionsMenu.addItem(perspectiveOptionItem);
+				optionsMenu.addItem(shadowsOptionItem);
+				optionsMenu.addItem(driverSpriteOptionItem);
+				optionsMenu.addItem(bikeSpriteOptionItem);
+				optionsMenu.addItem(inputOptionItem);
+				optionsMenu.addItem(lookAheadOptionItem);
+				optionsMenu.addItem(vibrateOnTouchOptionItem);
+				optionsMenu.addItem(keyboardInMenuOptionItem);
+				optionsMenu.addItem(clearHighscoreOptionItem);
+				optionsMenu.addItem(createAction(ActionMenuElement.BACK));
+
+				// noAction = new ActionMenuElement(getString(R.string.no), 0, this, null, false, mainMenu, true);
+				// yesAction = new ActionMenuElement(getString(R.string.yes), 0, this, null, false, mainMenu, true);
+				fullResetItem = new SimpleMenuElementNew(getString(R.string.full_reset), resetScreen, this);
+				eraseScreen.addItem(new TextMenuElement(getString(R.string.erase_text1)));
+				eraseScreen.addItem(new TextMenuElement(getString(R.string.erase_text2)));
+				eraseScreen.addItem(createEmptyLine(true));
+				eraseScreen.addItem(createAction(ActionMenuElement.NO));
+				eraseScreen.addItem(createAction(ActionMenuElement.YES));
+				eraseScreen.addItem(fullResetItem);
+				resetScreen.addItem(new TextMenuElement(getString(R.string.reset_text1)));
+				resetScreen.addItem(new TextMenuElement(getString(R.string.reset_text2)));
+				resetScreen.addItem(createEmptyLine(true));
+				resetScreen.addItem(createAction(ActionMenuElement.NO));
+				resetScreen.addItem(createAction(ActionMenuElement.YES));
+
+				objectiveHelpScreen = new MenuScreen(getString(R.string.objective), helpMenu);
+				objectiveHelpScreen.setIsTextScreen(true);
+				objectiveHelpItem = new SimpleMenuElementNew(getString(R.string.objective), objectiveHelpScreen, this);
+				objectiveHelpScreen.addItem(new TextMenuElement(Html.fromHtml(getString(R.string.objective_text))));
+				objectiveHelpScreen.addItem(createAction(ActionMenuElement.BACK));
+
+				keysHelpScreen = new MenuScreen(getString(R.string.keys), helpMenu);
+				keysHelpScreen.setIsTextScreen(true);
+				keysHelpItem = new SimpleMenuElementNew(getString(R.string.keys), keysHelpScreen, this);
+				keysHelpScreen.addItem(new TextMenuElement(Html.fromHtml(getString(R.string.keyset_text))));
+				keysHelpScreen.addItem(new ActionMenuElement(getString(R.string.back), ActionMenuElement.BACK, this));
+
+				unlockingHelpScreen = new MenuScreen(getString(R.string.unlocking), helpMenu);
+				unlockingHelpScreen.setIsTextScreen(true);
+				unlockingHelpItem = new SimpleMenuElementNew(getString(R.string.unlocking), unlockingHelpScreen, this);
+				unlockingHelpScreen.addItem(new TextMenuElement(Html.fromHtml(getString(R.string.unlocking_text))));
+				unlockingHelpScreen.addItem(createAction(ActionMenuElement.BACK));
+
+				highscoreHelpScreen = new MenuScreen(getString(R.string.highscores), helpMenu);
+				highscoreHelpScreen.setIsTextScreen(true);
+				highscoreHelpItem = new SimpleMenuElementNew(getString(R.string.highscores), highscoreHelpScreen, this);
+				highscoreHelpScreen.addItem(new TextMenuElement(Html.fromHtml(getString(R.string.highscore_text))));
+				highscoreHelpScreen.addItem(createAction(ActionMenuElement.BACK));
+
+				optionsHelpScreen = new MenuScreen(getString(R.string.options), helpMenu);
+				optionsHelpScreen.setIsTextScreen(true);
+				optionsHelpItem = new SimpleMenuElementNew(getString(R.string.options), optionsHelpScreen, this);
+				optionsHelpScreen.addItem(new TextMenuElement(Html.fromHtml(getString(R.string.options_text))));
+				optionsHelpScreen.addItem(createAction(ActionMenuElement.BACK));
+
+				helpMenu.addItem(objectiveHelpItem);
+				helpMenu.addItem(keysHelpItem);
+				helpMenu.addItem(unlockingHelpItem);
+				helpMenu.addItem(highscoreHelpItem);
+				helpMenu.addItem(optionsHelpItem);
+				helpMenu.addItem(createAction(ActionMenuElement.BACK));
+
+				aboutScreen.setIsTextScreen(true);
+				aboutScreen.addItem(new TextMenuElement(Html.fromHtml(getString(R.string.about_text))));
+				aboutScreen.addItem(createAction(ActionMenuElement.BACK));
+
+				ingameScreen.addItem(continueAction);
+				ingameScreen.addItem(ingameRestartAction);
+				ingameScreen.addItem(new SimpleMenuElementNew(getString(R.string.options), optionsMenu, this));
+				ingameScreen.addItem(new SimpleMenuElementNew(getString(R.string.help), helpMenu, this));
+				ingameScreen.addItem(createAction(ActionMenuElement.PLAY_MENU));
+				nameAction = new ActionMenuElement(getString(R.string.name) + " - " + new String(nameChars), 0, this);
+				okCommand = new Command(getString(R.string.ok), 4, 1);
+				backCommand = new Command(getString(R.string.back), 2, 1);
+				setCurrentMenu(mainMenu, false);
+
+				// LevelsManager
+				managerInstalledScreen = new InstalledLevelsMenuScreen(getString(R.string.installed_mods), managerScreen);
+				managerDownloadScreen = new DownloadLevelsMenuScreen(getString(R.string.download_mods), managerScreen);
+				// managerDownloadOptionsScreen = new MenuScreen(getString(R.string.download_options), managerDownloadScreen);
+
+				/*managerInstalledScreen.setIsLevelsList(true);
+				managerDownloadScreen.setIsLevelsList(true);*/
+
+				// LevelsManager
+				managerScreen.addItem(new SimpleMenuElementNew(getString(R.string.download_mods), managerDownloadScreen, this));
+				managerScreen.addItem(new SimpleMenuElementNew(getString(R.string.installed_mods), managerInstalledScreen, this));
+				managerScreen.addItem(createEmptyLine(true));
+				// managerScreen.addItem(new ActionMenuElement(getString(R.string.install_mrg), this));
+				managerScreen.addItem(new ActionMenuElement(getString(R.string.install_mrg), ActionMenuElement.SELECT_FILE, this));
+
+				// LevelsManager installed
+				// managerInstalledScreen.addItem(new TextMenuElement(getString(R.string.installed_levels_text)));
+
+				// Level screen
+				levelScreen = new MenuScreen("", null);
+				break;
+		}
+	}
+
+	/*public void reloadLevels() {
+		Loader loader = getLevelLoader();
+		trackNames = loader.names;
+		setUnlockedLevels();
+	}*/
+
+	protected ActionMenuElement createAction(int action) {
+		int r;
+		switch (action) {
+			case ActionMenuElement.BACK:
+				r = R.string.back;
+				break;
+
+			case ActionMenuElement.NO:
+				r = R.string.no;
+				break;
+
+			case ActionMenuElement.YES:
+				r = R.string.yes;
+				break;
+
+			case ActionMenuElement.EXIT:
+				r = R.string.exit;
+				break;
+
+			case ActionMenuElement.OK:
+				r = R.string.ok;
+				break;
+
+			case ActionMenuElement.PLAY_MENU:
+				r = R.string.play_menu;
+				break;
+
+			case ActionMenuElement.GO_TO_MAIN:
+				r = R.string.go_to_main;
+				break;
+
+			case ActionMenuElement.RESTART:
+				r = R.string.restart;
+				break;
+
+			case ActionMenuElement.NEXT:
+				r = R.string.next;
+				break;
+
+			case ActionMenuElement.CONTINUE:
+				r = R.string._continue;
+				break;
+
+			case ActionMenuElement.LOAD:
+				r = R.string.load_this_game;
+				break;
+
+			case ActionMenuElement.INSTALL:
+				r = R.string.install_kb;
+				break;
+
+			case ActionMenuElement.DELETE:
+				r = R.string.delete;
+				break;
+
+			case ActionMenuElement.RESTART_WITH_NEW_LEVEL:
+				r = R.string.restart_with_new_level;
+				break;
+
+			case ActionMenuElement.SEND_LOGS:
+				r = R.string.send_logs;
+				break;
+
+			default:
+				return null;
+		}
+
+		return new ActionMenuElement(getString(r), action, this);
+	}
+
+	public EmptyLineMenuElement createEmptyLine(boolean beforeAction) {
+		return new EmptyLineMenuElement(beforeAction ? 10 : 20);
+	}
+
+	public int getSelectedLevel() {
+		return levelSelector.getSelectedOption();
+	}
+
+	public int getSelectedTrack() {
+		return trackSelector.getSelectedOption();
+	}
+
+	// not sure about this name
+	public boolean canStartTrack() {
+		if (m_SZ) {
+			m_SZ = false;
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	private void saveCompletedTrack() {
+		// ATTENTION!!!
+		// WHEN CHANGING THIS CODE, COPY-PASTE TO startTrack() !!!
+
+		LevelsManager levelsManager = getLevelsManager();
+
+		try {
+			currentScores.saveHighScore(leagueSelector.getSelectedOption(), new String(nameChars, "UTF-8"), lastTrackTime);
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+			showAlert(getString(R.string.error), e.getMessage(), null);
+		}
+		// saveManager.write();
+		levelsManager.saveHighScores(currentScores);
+
+		leagueCompleted = false;
+
+		finishedMenu.clear();
+		finishedMenu.addItem(new TextMenuElement(Html.fromHtml("<b>" + getString(R.string.time) + "</b>: " + finishedTime)));
+
+		System.gc();
+		String[] as = currentScores.getScores(leagueSelector.getSelectedOption());
+		for (int k = 0; k < as.length; k++)
+			if (as[k] != null)
+				finishedMenu.addItem(new TextMenuElement("" + (k + 1) + ". " + as[k]));
+
+		byte byte0 = -1;
+		// logDebug("trackSelector.getUnlockedCount() = " + trackSelector.getUnlockedCount());
+		// logDebug("trackSelector.getSelectedOption() = " + trackSelector.getSelectedOption());
+
+		// {
+		// int unlockedTracks = trackSelector.getUnlockedCount();
+		// int selectedTrack = trackSelector.getSelectedOption();
+		// int selectedLevel = levelSelector.getSelectedOption();
+		// int unlockedInLevel = level.getUnlocked(selectedLevel);
+
+		// logDebug("unlockedTracks (trackSelector) = " + trackSelector.getUnlockedCount());
+		// logDebug("selectedTrack (trackSelector) = " + selectedTrack);
+		// logDebug("selectedLevel (levelSelector) = " + levelSelector.getSelectedOption());
+		// logDebug("unlockedInLevel (level.getUnlocked()) = " + level.getUnlocked(levelSelector.getSelectedOption()));
+
+		if (trackSelector.getUnlockedCount() >= trackSelector.getSelectedOption()) {
+			trackSelector.setUnlockedCount(
+					trackSelector.getSelectedOption() + 1 >= level.getUnlocked(levelSelector.getSelectedOption())
+							? trackSelector.getSelectedOption() + 1
+							: level.getUnlocked(levelSelector.getSelectedOption())
+			);
+			level.setUnlocked(levelSelector.getSelectedOption(),
+					trackSelector.getUnlockedCount() >= level.getUnlocked(levelSelector.getSelectedOption())
+							? trackSelector.getUnlockedCount()
+							: level.getUnlocked(levelSelector.getSelectedOption())
+			);
+		}
+		// }
+
+		// Completed league
+		if (trackSelector.getSelectedOption() == trackSelector.getOptionCount()) {
+			leagueCompleted = true;
+			switch (levelSelector.getSelectedOption()) {
+				default:
+					break;
+
+				case 0:
+					if (level.getUnlockedLeagues() < 1) {
+						byte0 = 1;
+						level.setUnlockedLeagues(1);
+						// leaguesUnlockedCount = 1;
+						leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+					}
+					break;
+
+				case 1:
+					if (level.getUnlockedLeagues() < 2) {
+						byte0 = 2;
+						level.setUnlockedLeagues(2);
+						// leaguesUnlockedCount = 2;
+						leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+					}
+					break;
+
+				case 2:
+					if (level.getUnlockedLeagues() < 3) {
+						byte0 = 3;
+						level.setUnlockedLeagues(3);
+						leagueSelector.setOptions(fullLeaguesList);
+						leagues = fullLeaguesList;
+						leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+					}
+					break;
+			}
+
+			levelSelector.setUnlockedCount(levelSelector.getUnlockedCount() + 1);
+
+			int newUnlocked = level.getUnlocked(levelSelector.getSelectedOption()) + 1,
+					tracksCount = level.getCount(levelSelector.getSelectedOption());
+
+			if (newUnlocked > tracksCount)
+				newUnlocked = tracksCount;
+
+			level.setUnlocked(levelSelector.getSelectedOption(), newUnlocked);
+			if (level.getUnlocked(levelSelector.getUnlockedCount()) == -1) {
+				level.setUnlocked(levelSelector.getUnlockedCount(), 0);
+			}
+			// if (unlockedTracks[levelSelector.getUnlockedCount()] == -1)
+			//	unlockedTracks[levelSelector.getUnlockedCount()] = 0;
+		} else {
+			trackSelector.performAction(MenuScreen.KEY_RIGHT);
+		}
+
+		// int completedCount = _bbII(levelSelector.getSelectedOption());
+		int completedCount = level.getUnlocked(levelSelector.getSelectedOption()); // TODO test
+		finishedMenu.addItem(new TextMenuElement(Html.fromHtml(String.format(getString(R.string.tracks_completed_tpl),
+				completedCount, trackNames[levelSelector.getSelectedOption()].length, difficultyLevels[levelSelector.getSelectedOption()]))));
+		System.gc();
+
+		if (!leagueCompleted) {
+			ingameRestartAction.setText(getString(R.string.restart) + ": " + getLevelLoader().getLevelName(levelSelector.getSelectedOption(), trackSelector.getSelectedOption()));
+			nextAction.setText(getString(R.string.next) + ": " + getLevelLoader().getLevelName(levelIndex, track + 1));
+
+			// getLevelsManager().updateLevelSettings();
+			saveAll();
+		} else {
+			// League completed
+			if (levelSelector.getSelectedOption() < levelSelector.getOptionCount()) {
+				levelSelector.setSelectedOption(levelSelector.getSelectedOption() + 1);
+				trackSelector.setSelectedOption(0);
+				trackSelector.setUnlockedCount(level.getUnlocked(levelSelector.getSelectedOption()));
+			}
+
+			if (byte0 != -1) {
+				finishedMenu.addItem(new TextMenuElement(getString(R.string.congratulations) + leagues[byte0]));
+				if (byte0 == 3)
+					finishedMenu.addItem(new TextMenuElement(getString(R.string.enjoy)));
+				showAlert(getString(R.string.league_unlocked), getString(R.string.league_unlocked_text) + leagues[byte0], null);
+
+				// getLevelsManager().updateLevelSettings();
+				saveAll();
+			} else {
+				boolean flag = true;
+				for (int i1 = 0; i1 < 3; i1++)
+					if (level.getUnlocked(i1) != getLevelLoader().names[i1].length - 1)
+						flag = false;
+
+				if (!flag)
+					finishedMenu.addItem(new TextMenuElement(getString(R.string.level_completed_text)));
+			}
+		}
+
+		if (!leagueCompleted)
+			finishedMenu.addItem(nextAction);
+
+		finishedRestartAction.setText(getString(R.string.restart) + ": " + getLevelLoader().getLevelName(levelIndex, track));
+		finishedMenu.addItem(finishedRestartAction);
+		finishedMenu.addItem(createAction(ActionMenuElement.PLAY_MENU));
+
+		setCurrentMenu(finishedMenu, false);
+	}
+
+	//public void _hvV() {
+	//	getGDActivity().m_di.postInvalidate();
+	//}
+
+	/* public int getGameViewScaledHeight() {
+		return getGDView().getScaledHeight();
+	}
+
+	public int getGameViewScaledWidth() {
+		return getGDView().getScaledWidth();
+	} */
+
+	public void showMenu(int k) {
+		logDebug("[Menu] showMenu()");
+		// k = 2;
+
+		GDActivity gd = getGDActivity();
+		GameView view = getGDView();
+		Loader loader = getLevelLoader();
+
+		m_blZ = false;
+		menuDisabled = false;
+		switch (k) {
+			case 0: // Just started
+				setCurrentMenu(mainMenu, false);
+				gd.physEngine._casevV();
+				m_SZ = true;
+				break;
+
+			case 1: // Ingame
+				levelIndex = levelSelector.getSelectedOption();
+				track = trackSelector.getSelectedOption();
+				ingameRestartAction.setText(getString(R.string.restart) + ": " + loader.getLevelName(levelIndex, track));
+				m_SZ = false;
+				ingameScreen.resetHighlighted();
+				setCurrentMenu(ingameScreen, false);
+				break;
+
+			case 2: // Finished
+				// finishTime = System.currentTimeMillis();
+				finishedMenu.clear();
+
+				levelIndex = levelSelector.getSelectedOption();
+				track = trackSelector.getSelectedOption();
+				HighScores scores = getLevelsManager().getHighScores(levelSelector.getSelectedOption(), trackSelector.getSelectedOption());
+				currentScores = scores;
+
+				// saveManager.setTrack(levelSelector.getSelectedOption(), trackSelector.getSelectedOption());
+				int place = scores.getPlace(leagueSelector.getSelectedOption(), lastTrackTime);
+				finishedTime = getDurationString(lastTrackTime);
+
+				if (place >= 0 && place <= 2) {
+					HighScoreTextMenuElement placeText = new HighScoreTextMenuElement("");
+					placeText.setText(getStringArray(R.array.finished_places)[place]);
+					placeText.setMedal(true, place);
+
+					finishedMenu.addItem(placeText);
+
+					TextMenuElement h2 = new TextMenuElement(finishedTime);
+					finishedMenu.addItem(h2);
+
+					// finishedMenu.addItem(createEmptyLine(true));
+					finishedMenu.addItem(createAction(ActionMenuElement.OK));
+					finishedMenu.addItem(nameAction);
+
+					setCurrentMenu(finishedMenu, false);
+					m_blZ = false;
+				} else {
+					saveCompletedTrack();
+				}
+				break;
+
+			default:
+				setCurrentMenu(mainMenu, false);
+				break;
+		}
+
+		long l1 = System.currentTimeMillis();
+		view.drawTimer = false;
+		long l4 = 0L;
+		int i1 = 50;
+		gd.physEngine._charvV();
+		gd.gameToMenu();
+
+		do {
+			if (!gd.isMenuShown() || !gd.alive || currentMenu == null)
+				break;
+
+			if (gd.m_cZ) {
+				while (gd.m_cZ) {
+					// logDebug("[Menu] showMenu() waiting loop");
+					if (!gd.alive || currentMenu == null) {
+						break;
+					}
+
+					try {
+						Thread.sleep(100L);
+					} catch (InterruptedException e) {
+					}
+				}
+			}
+			if (gd.physEngine != null && gd.physEngine._gotovZ()) {
+				int j1;
+				if ((j1 = gd.physEngine._dovI()) != 0 && j1 != 4)
+					try {
+						gd.physEngine._doZV(true);
+					} catch (NullPointerException e) {
+					}
+				gd.physEngine._charvV();
+				// _hvV();
+				long l2;
+				if ((l2 = System.currentTimeMillis()) - l4 < (long) i1) {
+					try {
+						synchronized (m_BObject) {
+							m_BObject.wait((long) i1 - (l2 - l4) >= 1L ? (long) i1 - (l2 - l4) : 1L);
+						}
+					} catch (InterruptedException e) {
+					}
+					l4 = System.currentTimeMillis();
+				} else {
+					l4 = l2;
+				}
+			} else {
+				i1 = 50;
+				long l3;
+				if ((l3 = System.currentTimeMillis()) - l4 < (long) i1) {
+					Object obj;
+					try {
+						synchronized (obj = new Object()) {
+							obj.wait((long) i1 - (l3 - l4) >= 1L ? (long) i1 - (l3 - l4) : 1L);
+						}
+					} catch (InterruptedException e) {
+					}
+					l4 = System.currentTimeMillis();
+				} else {
+					l4 = l3;
+				}
+			}
+		} while (true);
+
+		logDebug("[Menu.showMenu] out loop");
+
+		gd.m_forJ += System.currentTimeMillis() - l1;
+		if (view != null)
+			view.drawTimer = true;
+
+		if (currentMenu == null && gd != null) {
+			logDebug("[Menu.showMenu] currentMenu == null, set alive = false");
+			gd.exiting = true;
+			gd.alive = false;
+		}
+	}
+
+	public synchronized void draw(Canvas g1) {
+		if (currentMenu != null && !m_blZ) {
+			getGDView().drawGame(g1);
+			drawBackgroundColor(g1);
+			// currentMenu.draw(g1);
+		}
+	}
+
+	private void drawBackgroundColor(Canvas g1) {
+		g1.drawRect(0, 0, getGDView().getScaledWidth(), getGDView().getScaledHeight(), bgPaint);
+	}
+
+	public void _tryIV(int k) {
+		// logDebug("_tryIV k = " + k);
+		if (getGDView().getGameAction(k) != 8)
+			keyPressed(k);
+	}
+
+	public void keyPressed(int k) {
+		if (currentMenu != null && !menuDisabled)
+			switch (getGDView().getGameAction(k)) {
+				case MenuScreen.KEY_UP: // up
+					currentMenu.performAction(MenuScreen.KEY_UP);
+					return;
+
+				case MenuScreen.KEY_DOWN: // down
+					currentMenu.performAction(MenuScreen.KEY_DOWN);
+					return;
+
+				case MenuScreen.KEY_FIRE: // fire
+					currentMenu.performAction(MenuScreen.KEY_FIRE);
+					return;
+
+				case MenuScreen.KEY_RIGHT: // right
+					currentMenu.performAction(MenuScreen.KEY_RIGHT);
+					if (currentMenu == highScoreMenu) {
+						selectedLeague++;
+						if (selectedLeague > leagueSelector.getUnlockedCount())
+							selectedLeague = leagueSelector.getUnlockedCount();
+						showHighScoreMenu(selectedLeague);
+						return;
+					}
+					break;
+
+				case MenuScreen.KEY_LEFT: // left
+					currentMenu.performAction(MenuScreen.KEY_LEFT);
+					if (currentMenu != highScoreMenu)
+						break;
+					selectedLeague--;
+					if (selectedLeague < 0)
+						selectedLeague = 0;
+					showHighScoreMenu(selectedLeague);
+					break;
+			}
+	}
+
+	public void onCommand(Command command) {
+		if (command == okCommand) {
+			ok();
+		} else if (command == backCommand && currentMenu != null) {
+			back();
+		}
+	}
+
+	public void back() {
+		if (currentMenu == ingameScreen) {
+			getGDActivity().menuToGame();
+			return;
+		}
+		if (currentMenu != null)
+			setCurrentMenu(currentMenu.getNavTarget(), true);
+	}
+
+	public void ok() {
+		if (currentMenu != null) {
+			currentMenu.performAction(1);
+			return;
+		}
+	}
+
+	public MenuScreen getCurrentMenu() {
+		return currentMenu;
+	}
+
+	public void setCurrentMenu(MenuScreen newMenu, boolean flag) {
+		menuDisabled = false;
+		GDActivity gd = getGDActivity();
+		GameView view = getGDView();
+
+		if (!Settings.isKeyboardInMenuEnabled()) {
+			if (newMenu == nameScreen) {
+				gd.showKeyboardLayout();
+			} else {
+				gd.hideKeyboardLayout();
+			}
+		}
+
+		view.removeCommand(backCommand);
+		if (newMenu != mainMenu && newMenu != finishedMenu && newMenu != null)
+			view.addCommand(backCommand);
+
+		if (newMenu == highScoreMenu) {
+			selectedLeague = leagueSelector.getSelectedOption();
+			showHighScoreMenu(selectedLeague);
+		} else if (newMenu == finishedMenu) {
+			// logDebug("it's finished!!!");
+			nameChars = nameScreen.getChars();
+			nameAction.setText(getString(R.string.name) + " - " + new String(nameChars));
+		} else if (newMenu == playMenu) {
+			trackSelector.setOptions(getLevelLoader().names[levelSelector.getSelectedOption()], false);
+			if (currentMenu == trackSelectorCurrentMenu) {
+				selectedTrack[levelSelector.getSelectedOption()] = trackSelector.getSelectedOption();
+			}
+			trackSelector.setUnlockedCount(level.getUnlocked(levelSelector.getSelectedOption()));
+			trackSelector.setSelectedOption(selectedTrack[levelSelector.getSelectedOption()]);
+		}
+		if (newMenu == mainMenu || newMenu == playMenu && gd.physEngine != null)
+			gd.physEngine._casevV();
+
+		if (currentMenu != null)
+			currentMenu.onHide(newMenu);
+
+		currentMenu = newMenu;
+		if (currentMenu != null) {
+			gd.setMenu(currentMenu.getLayout());
+			currentMenu.onShow();
+
+			// getGDActivity().setMenu(currentMenu.getTable());
+			// if (!isOnOffToggle) currentMenu.scrollUp();
+		}
+
+		// getGDActivity().physEngine._casevV();
+		m_blZ = false;
+
+		// */
+	}
+
+	public void showHighScoreMenu(int league) {
+		HighScores highScores = getLevelsManager().getHighScores(levelSelector.getSelectedOption(), trackSelector.getSelectedOption());
+
+		highScoreMenu.clear();
+		highScoreMenu.setTitle(getString(R.string.highscores) + ": " + getLevelLoader().getLevelName(levelSelector.getSelectedOption(), trackSelector.getSelectedOption()));
+
+		HighScoreTextMenuElement subtitle = new HighScoreTextMenuElement(Html.fromHtml(getString(R.string.league) + ": " + leagueSelector.getOptions()[league]));
+		subtitle.setIsSubtitle(true);
+
+		highScoreMenu.addItem(subtitle);
+
+		String[] scores = highScores.getScores(league);
+
+		for (int place = 0; place < scores.length; place++) {
+			if (scores[place] == null)
+				continue;
+
+			HighScoreTextMenuElement h1 = new HighScoreTextMenuElement("" + (place + 1) + ". " + scores[place]);
+			if (place == 0)
+				h1.setMedal(true, 0);
+			else if (place == 1)
+				h1.setMedal(true, 1);
+			else if (place == 2)
+				h1.setMedal(true, 2);
+
+			h1.setLayoutPadding(true);
+			highScoreMenu.addItem(h1);
+		}
+
+		// saveManager.closeRecordStore();
+		if (scores[0] == null)
+			highScoreMenu.addItem(new TextMenuElement(getString(R.string.no_highscores)));
+
+		highScoreMenu.addItem(createAction(ActionMenuElement.BACK));
+		highScoreMenu.highlightElement();
+
+		// System.gc();
+	}
+
+	public synchronized void destroy() {
+		currentMenu = null;
+	}
+
+	public synchronized void saveAll() {
+		logDebug("saveAll()");
+
+		try {
+			if (level != null) {
+				Settings.setName(nameChars);
+
+				level.setUnlockedLeagues(leagueSelector.getUnlockedCount());
+				level.setUnlockedLevels(levelSelector.getUnlockedCount());
+
+				level.setSelectedLevel(levelSelector.getSelectedOption());
+				level.setSelectedTrack(trackSelector.getSelectedOption());
+				level.setSelectedLeague(leagueSelector.getSelectedOption());
+
+				getLevelsManager().updateLevelSettings();
+			} else {
+				logDebug("saveAll(): level == null");
+			}
+		} catch (Exception e) {
+			logDebug("saveAll exception: " + e);
+		}
+	}
+
+	public void handleAction(MenuElement item) {
+		final GDActivity gd = getGDActivity();
+
+		if (currentMenu == null) {
+			return;
+		}
+
+		if (item == startItem)
+			if (levelSelector.getSelectedOption() > levelSelector.getUnlockedCount() || trackSelector.getSelectedOption() > trackSelector.getUnlockedCount() || leagueSelector.getSelectedOption() > leagueSelector.getUnlockedCount()) {
+				showAlert("GD Classic", getString(R.string.complete_to_unlock), null);
+				return;
+			} else {
+				gd.physEngine._avV();
+				startTrack(levelSelector.getSelectedOption(), trackSelector.getSelectedOption());
+				gd.physEngine.setLeague(leagueSelector.getSelectedOption());
+				m_SZ = true;
+				gd.menuToGame();
+				return;
+			}
+
+		if (item == vibrateOnTouchOptionItem) {
+			Settings.setVibrateOnTouchEnabled(((OptionsMenuElement) item).getSelectedOption() == 0);
+		}
+		if (item == keyboardInMenuOptionItem) {
+			boolean enabled = ((OptionsMenuElement) item).getSelectedOption() == 0;
+			Settings.setKeyboardInMenuEnabled(enabled);
+			if (enabled) gd.showKeyboardLayout();
+			else gd.hideKeyboardLayout();
+		}
+		if (item == perspectiveOptionItem) {
+			gd.physEngine._aZV(perspectiveOptionItem.getSelectedOption() == 0);
+			getLevelLoader().setPerspectiveEnabled(perspectiveOptionItem.getSelectedOption() == 0);
+			Settings.setPerspectiveEnabled(perspectiveOptionItem.getSelectedOption() == 0);
+			return;
+		}
+		if (item == shadowsOptionItem) {
+			getLevelLoader().setShadowsEnabled(shadowsOptionItem.getSelectedOption() == 0);
+			Settings.setShadowsEnabled(shadowsOptionItem.getSelectedOption() == 0);
+			return;
+		}
+		if (item == driverSpriteOptionItem) {
+			if (driverSpriteOptionItem._charvZ()) {
+				driverSpriteOptionItem.setSelectedOption(driverSpriteOptionItem.getSelectedOption() + 1);
+			}
+			Settings.setDriverSpriteEnabled(driverSpriteOptionItem.getSelectedOption() == 0);
+		} else if (item == bikeSpriteOptionItem) {
+			if (bikeSpriteOptionItem._charvZ()) {
+				bikeSpriteOptionItem.setSelectedOption(bikeSpriteOptionItem.getSelectedOption() + 1);
+			}
+			Settings.setBikeSpriteEnabled(bikeSpriteOptionItem.getSelectedOption() == 0);
+		} else {
+			if (item == inputOptionItem) {
+				if (inputOptionItem._charvZ())
+					inputOptionItem.setSelectedOption(inputOptionItem.getSelectedOption() + 1);
+				getGDView().setInputOption(inputOptionItem.getSelectedOption());
+				Settings.setInputOption(inputOptionItem.getSelectedOption());
+				return;
+			}
+			if (item == lookAheadOptionItem) {
+				gd.physEngine._ifZV(lookAheadOptionItem.getSelectedOption() == 0);
+				Settings.setLookAheadEnabled(lookAheadOptionItem.getSelectedOption() == 0);
+				return;
+			}
+			if (item instanceof ActionMenuElement) {
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.RESTART_WITH_NEW_LEVEL) {
+					LevelsManager manager = gd.levelsManager;
+					long nextId = manager.getCurrentId() == 1 ? 2 : 1;
+					gd.levelsManager.load(manager.getLeveL(nextId));
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.SEND_LOGS) {
+					gd.sendKeyboardLogs();
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.SELECT_FILE) {
+					installFromFileBrowse();
+					return;
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.YES) {
+					if (currentMenu == eraseScreen) {
+						getLevelsManager().clearHighScores();
+						showAlert(getString(R.string.cleared), getString(R.string.cleared_text), null);
+					} else if (currentMenu == resetScreen) {
+						showAlert(getString(R.string.reset), getString(R.string.reset_text), new Runnable() {
+							@Override
+							public void run() {
+								resetAll();
+							}
+						});
+					}
+					setCurrentMenu(currentMenu.getNavTarget(), false);
+					return;
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.NO) {
+					setCurrentMenu(currentMenu.getNavTarget(), false);
+					return;
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.BACK) {
+					setCurrentMenu(currentMenu.getNavTarget(), true);
+					return;
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.PLAY_MENU) {
+					levelSelector.setSelectedOption(levelIndex);
+					trackSelector.setUnlockedCount(level.getUnlocked(levelIndex));
+					trackSelector.setSelectedOption(track);
+					setCurrentMenu(currentMenu.getNavTarget(), false);
+					return;
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.GO_TO_MAIN) {
+					setCurrentMenu(mainMenu, false);
+					return;
+				}
+				if (((ActionMenuElement) item).getActionValue() == ActionMenuElement.EXIT) {
+					getGDActivity().exiting = true;
+					if (currentMenu != null) {
+						setCurrentMenu(currentMenu.getNavTarget(), false);
+					} else {
+						setCurrentMenu(null, false);
+					}
+					return;
+				}
+			}
+
+			if (item == ingameRestartAction || item == finishedRestartAction) {
+				if (leagueSelector.getSelectedOption() <= leagueSelector.getUnlockedCount()) {
+					levelSelector.setSelectedOption(levelIndex);
+					trackSelector.setUnlockedCount(level.getUnlocked(levelIndex));
+					trackSelector.setSelectedOption(track);
+					gd.physEngine.setLeague(leagueSelector.getSelectedOption());
+					m_SZ = true;
+					gd.menuToGame();
+					return;
+				}
+			} else {
+				if (item == nextAction) {
+					// if (!leagueCompleted)
+					//	trackSelector.performAction(MenuScreen.KEY_RIGHT);
+					startTrack(levelSelector.getSelectedOption(), trackSelector.getSelectedOption());
+					gd.physEngine.setLeague(leagueSelector.getSelectedOption());
+					// saveAll();
+					// getLevelsManager().updateLevelSettings();
+					m_SZ = true;
+					gd.menuToGame();
+					return;
+				}
+				if (item == continueAction) {
+					// _hvV();
+					gd.menuToGame();
+					return;
+				}
+				if (item == nameAction) {
+					nameScreen.resetCursorPosition();
+					setCurrentMenu(nameScreen, false);
+					return;
+				}
+				if (item instanceof ActionMenuElement && ((ActionMenuElement) item).getActionValue() == ActionMenuElement.OK) {
+					saveCompletedTrack();
+					return;
+				}
+				if (item == trackSelector) {
+					if (trackSelector._charvZ()) {
+						trackSelector.setUnlockedCount(level.getUnlocked(levelSelector.getSelectedOption()));
+						trackSelector.update();
+						trackSelectorCurrentMenu = trackSelector.getCurrentMenu();
+						setCurrentMenu(trackSelectorCurrentMenu, false);
+						// trackSelectorCurrentMenu._doIV(trackSelector.getSelectedOption());
+					}
+					selectedTrack[levelSelector.getSelectedOption()] = trackSelector.getSelectedOption();
+					return;
+				}
+				if (item == levelSelector) {
+					if (levelSelector._charvZ()) {
+						levelSelectorCurrentMenu = levelSelector.getCurrentMenu();
+						setCurrentMenu(levelSelectorCurrentMenu, false);
+					}
+					trackSelector.setOptions(getLevelLoader().names[levelSelector.getSelectedOption()], false);
+					trackSelector.setUnlockedCount(level.getUnlocked(levelSelector.getSelectedOption()));
+					trackSelector.setSelectedOption(selectedTrack[levelSelector.getSelectedOption()]);
+					// trackSelector.update();
+					// logDebug("update tracks ");
+					return;
+				}
+				if (item == leagueSelector && leagueSelector._charvZ()) {
+					leagueSelectorCurrentMenu = leagueSelector.getCurrentMenu();
+					// leagueSelector.update();
+					leagueSelector.setScreen(currentMenu);
+					setCurrentMenu(leagueSelectorCurrentMenu, false);
+					// leagueSelectorCurrentMenu._doIV(leagueSelector.getSelectedOption());
+				}
+			}
+		}
+	}
+
+	protected void startTrack(int levelIndex, int trackIndex) {
+		// ATTENTION!!!
+		// WHEN CHANGING THIS CODE, COPY-PASTE TO saveCompletedTrack() !!!
+
+		if (Global.ACRA_ENABLED) {
+			ACRA.getErrorReporter().putCustomData("level_index:", String.valueOf(levelIndex));
+			ACRA.getErrorReporter().putCustomData("track_index:", String.valueOf(trackIndex));
+		}
+
+		/*Menu _menu = null;
+		_menu.back();*/
+
+		try {
+			getLevelLoader()._doIII(levelIndex, trackIndex);
+		} catch (InvalidTrackException e) {
+			showConfirm(getString(R.string.oops), getString(R.string.e_level_damaged), new Runnable() {
+				@Override
+				public void run() {
+					if (trackSelector.getSelectedOption() + 1 < level.getCount(levelSelector.getSelectedOption())) {
+						trackSelector.setUnlockedCount(trackSelector.getSelectedOption() + 1);
+						level.setUnlocked(levelSelector.getSelectedOption(), trackSelector.getUnlockedCount());
+					} else {
+						switch (levelSelector.getSelectedOption()) {
+							case 0:
+								if (level.getUnlockedLeagues() < 1) {
+									level.setUnlockedLeagues(1);
+									leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+								}
+								break;
+
+							case 1:
+								if (level.getUnlockedLeagues() < 2) {
+									level.setUnlockedLeagues(2);
+									leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+								}
+								break;
+
+							case 2:
+								if (level.getUnlockedLeagues() < 3) {
+									level.setUnlockedLeagues(3);
+									leagueSelector.setOptions(fullLeaguesList);
+									leagues = fullLeaguesList;
+									leagueSelector.setUnlockedCount(level.getUnlockedLeagues());
+								}
+								break;
+						}
+
+						int newUnlocked = level.getUnlocked(levelSelector.getSelectedOption()) + 1,
+								tracksCount = level.getCount(levelSelector.getSelectedOption());
+
+						if (newUnlocked > tracksCount)
+							newUnlocked = tracksCount;
+
+						levelSelector.setUnlockedCount(levelSelector.getUnlockedCount() + 1);
+						level.setUnlocked(levelSelector.getSelectedOption(), newUnlocked);
+					}
+				}
+			}, null);
+		}
+	}
+
+	public int _jvI() {
+		int k = 0;
+		if (driverSpriteOptionItem.getSelectedOption() == 0)
+			k |= 2;
+		if (bikeSpriteOptionItem.getSelectedOption() == 0)
+			k |= 1;
+		return k;
+	}
+
+	public void _intIV(int k) {
+		bikeSpriteOptionItem.setSelectedOption(1);
+		driverSpriteOptionItem.setSelectedOption(1);
+		if ((k & 1) > 0)
+			bikeSpriteOptionItem.setSelectedOption(0);
+		if ((k & 2) > 0)
+			driverSpriteOptionItem.setSelectedOption(0);
+	}
+
+	/*public int _ovI() {
+		return levelSelector.getSelectedOption();
+	}
+
+	public int _nvI() {
+		return trackSelector.getSelectedOption();
+	}
+
+	public int _lvI() {
+		return leagueSelector.getSelectedOption();
+	}*/
+
+	public void setLastTrackTime(long l) {
+		lastTrackTime = l;
+	}
+
+	/*private byte[] readNameChars(int pos, byte defaultValue) {
+		switch (pos) {
+			case 16: // '\020'
+				byte[] abyte0 = new byte[3];
+				for (int l = 0; l < 3; l++)
+					abyte0[l] = settings[16 + l];
+
+				if (abyte0[0] == -127)
+					abyte0[0] = defaultValue;
+				return abyte0;
+		}
+		return null;
+	}
+
+	private byte readSetting(int index, byte defaultValue) {
+		if (settings[index] == -127)
+			return defaultValue;
+		else
+			return settings[index];
+	}
+
+	private void saveNameChars(int pos, byte[] chars) {
+		if (settingsLoadedOK && pos == 16) {
+			for (int l = 0; l < 3; l++)
+				settings[16 + l] = chars[l];
+
+		}
+	}*/
+
+	private String getDurationString(long l) {
+		m_ajI = (int) (l / 100L);
+		m_atI = (int) (l % 100L);
+		String s;
+		if (m_ajI / 60 < 10)
+			s = " 0" + m_ajI / 60;
+		else
+			s = " " + m_ajI / 60;
+		if (m_ajI % 60 < 10)
+			s = s + ":0" + m_ajI % 60;
+		else
+			s = s + ":" + m_ajI % 60;
+		if (m_atI < 10)
+			s = s + ".0" + m_atI;
+		else
+			s = s + "." + m_atI;
+		return s;
+	}
+
+	/*private void setSetting(int k, byte byte0) {
+		if (settingsLoadedOK)
+			settings[k] = byte0;
+	}*/
+
+	private void resetAll() {
+		Settings.resetAll();
+		getLevelsManager().resetAllLevelsSettings();
+		getLevelsManager().clearAllHighScores();
+
+		getGDActivity().fullResetting = true;
+		getGDActivity().destroyApp(true);
+	}
+
+	public void removeCommands() {
+		getGDView().removeCommand(okCommand);
+		getGDView().removeCommand(backCommand);
+	}
+
+	public void addCommands() {
+		if (currentMenu != mainMenu && currentMenu != finishedMenu && currentMenu != null)
+			getGDView().addCommand(backCommand);
+		getGDView().addCommand(okCommand);
+	}
+
+	/*private int _bbII(int k) {
+		String[] as = RecordStore.listRecordStores();
+		if (saveManager == null || as == null)
+			return 0;
+		int l = 0;
+		for (int i1 = 0; i1 < as.length; i1++)
+			if (as[i1].startsWith("" + k))
+				l++;
+
+		return l;
+	}*/
+
+	/*public boolean isKeyboardEnabled() {
+		return keyboardInMenuEnabled == 0;
+	}*/
+
+	// public boolean isVibrateOnTouchEnabled() {
+	//	return vibrateOnTouchEnabled == 0;
+	//}
+
+	/*public void hideKeyboard(boolean firstRun) {
+		if (!Settings.isKeyboardInMenuEnabled()) {
+			getGDActivity().hideKeyboardLayout();
+			// MenuScreen.setSize(getGDView().getScaledWidth(), getGDView().getScaledHeight());
+		} else if (firstRun) {
+			getGDActivity().showKeyboardLayout();
+		}*//*else {
+			// MenuScreen.setSize(getGDView().getScaledWidth(), getGDView().getScaledHeight() - getGDActivity().getButtonsLayoutHeight());
+		}*//*
+	}
+
+	public void showKeyboard() {
+		getGDActivity().showKeyboardLayout();
+		// MenuScreen.setSize(getGDView().getScaledWidth(), getGDView().getScaledHeight() - getGDActivity().getButtonsLayoutHeight());
+	}*/
+
+	public void installFromFileBrowse() {
+		if (!LevelsManager.isExternalStorageReadable()) {
+			showAlert(getString(R.string.error), getString(R.string.e_external_storage_is_not_readable), null);
+			return;
+		}
+
+		final GDActivity gd = getGDActivity();
+		FileDialog fileDialog = new FileDialog(gd, Environment.getExternalStorageDirectory(), ".mrg");
+		fileDialog.addFileListener(new FileDialog.FileSelectedListener() {
+			public void fileSelected(final File file) {
+				final EditText input = new EditText(gd);
+				input.setInputType(InputType.TYPE_CLASS_TEXT);
+
+				AlertDialog.Builder alert = new AlertDialog.Builder(gd)
+						.setTitle(getString(R.string.enter_levels_name_title))
+						.setMessage(getString(R.string.enter_levels_name))
+						.setView(input)
+						.setPositiveButton(getString(R.string.ok), new DialogInterface.OnClickListener() {
+							public void onClick(DialogInterface dialog, int whichButton) {
+								boolean ok = true;
+								String name = input.getText().toString();
+								if (name.equals("")) name = file.getName();
+
+								ProgressDialog progressDialog = ProgressDialog.show(gd, getString(R.string.install), getString(R.string.installing), true);
+
+								try {
+									gd.levelsManager.install(file, name, "", 0);
+								} catch (Exception e) {
+									ok = false;
+									e.printStackTrace();
+									showAlert(getString(R.string.error), e.getMessage(), null);
+								} finally {
+									progressDialog.dismiss();
+								}
+
+								if (ok) {
+									gd.levelsManager.showSuccessfullyInstalledDialog();
+								}
+							}
+						})
+						.setNegativeButton(getString(R.string.cancel), null);
+				alert.show();
+			}
+		});
+		fileDialog.showDialog();
+	}
+
+	public static boolean isNameCheat(byte[] chars) {
+		return chars[0] == 82 && chars[1] == 75 && chars[2] == 69;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/MenuElement.java b/src/org/happysanta/gd/Menu/MenuElement.java
new file mode 100644
index 0000000..82fe490
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/MenuElement.java
@@ -0,0 +1,20 @@
+package org.happysanta.gd.Menu;
+
+import android.view.View;
+
+/**
+ * Author: ch1p
+ */
+public interface MenuElement {
+
+	// public abstract void setText(String s);
+
+	public abstract boolean isSelectable();
+
+	public abstract View getView();
+
+	public abstract void setText(String text);
+
+	public void performAction(int k);
+
+}
diff --git a/src/org/happysanta/gd/Menu/MenuElementOld.java b/src/org/happysanta/gd/Menu/MenuElementOld.java
new file mode 100755
index 0000000..6a4400f
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/MenuElementOld.java
@@ -0,0 +1,32 @@
+package org.happysanta.gd.Menu;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.view.View;
+
+public interface MenuElementOld {
+
+	public abstract void setText(String s);
+
+	// Why y before x?!
+	public abstract void draw(Canvas g, int y, int x);
+
+	public abstract boolean isSelectable();
+
+	public abstract int getLineSpacing();
+
+	public abstract void performAction(int i);
+
+	public abstract void setFont(Paint font);
+
+	public abstract int getHeight();
+
+	public abstract int getFirstLineHeight();
+
+	public abstract int getXOffset();
+
+	public abstract void setPressed(boolean flag);
+
+	public abstract View getView();
+
+}
diff --git a/src/org/happysanta/gd/Menu/MenuHandler.java b/src/org/happysanta/gd/Menu/MenuHandler.java
new file mode 100755
index 0000000..208e579
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/MenuHandler.java
@@ -0,0 +1,12 @@
+package org.happysanta.gd.Menu;
+
+public interface MenuHandler {
+
+	public abstract MenuScreen getCurrentMenu();
+
+	public abstract void setCurrentMenu(MenuScreen e, boolean flag);
+
+	// public abstract void destroy();
+
+	public abstract void handleAction(MenuElement item);
+}
diff --git a/src/org/happysanta/gd/Menu/MenuScreen.java b/src/org/happysanta/gd/Menu/MenuScreen.java
new file mode 100755
index 0000000..c49c085
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/MenuScreen.java
@@ -0,0 +1,277 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.view.ViewTreeObserver;
+import android.widget.LinearLayout;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+
+import java.util.Vector;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.isSDK11OrHigher;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class MenuScreen
+		implements OnMenuElementHighlightListener {
+
+	public static final int KEY_FIRE = 5;
+	public static final int KEY_UP = 2;
+	public static final int KEY_DOWN = 8;
+	public static final int KEY_LEFT = 4;
+	public static final int KEY_RIGHT = 6;
+
+	protected static final int LAYOUT_LEFT_PADDING = 30;
+	protected static final int LAYOUT_TOP_PADDING = 0;
+	protected static final int LAYOUT_BOTTOM_PADDING = 15;
+
+	protected MenuScreen navTarget;
+	protected String title;
+	protected int selectedIndex;
+	protected Vector menuItems;
+	protected MenuLinearLayout layout;
+	protected ClickableMenuElement lastHighlighted;
+	protected boolean isTextScreen = false;
+
+	public MenuScreen(String title, MenuScreen navTarget) {
+		this.title = title;
+		selectedIndex = -1;
+		menuItems = new Vector();
+		this.navTarget = navTarget;
+
+		Context context = getGDActivity();
+
+		layout = new MenuLinearLayout(context);
+		layout.setOrientation(LinearLayout.VERTICAL);
+		layout.setPadding(getDp(LAYOUT_LEFT_PADDING), getDp(LAYOUT_TOP_PADDING), getDp(LAYOUT_LEFT_PADDING), getDp(LAYOUT_BOTTOM_PADDING));
+
+		// Disable multi-touch in menu
+		if (isSDK11OrHigher())
+			layout.setMotionEventSplittingEnabled(false);
+	}
+
+	public void addItem(MenuElement item) {
+		layout.addView(item.getView());
+		menuItems.add(item);
+
+		if (item instanceof ClickableMenuElement)
+			((ClickableMenuElement) item).setOnHighlightListener(this);
+	}
+
+	protected void scrollToItem(MenuElement item) {
+		// int y = item.getView().getTop();
+		// logDebug("scrollTo: y = " + y);
+
+		// getGameMenu().scrollTo(y);
+		getGDActivity().scrollToView(item.getView());
+	}
+
+	public void performAction(int k) {
+		// logDebug("MenuScreen.performAction: k = " + k);
+		int from = 0;
+		switch (k) {
+			default:
+				// logDebug("selectedIndex = " + selectedIndex);
+				if (selectedIndex != -1) {
+					for (int i = selectedIndex; i < menuItems.size(); i++) {
+						MenuElement item;
+						if ((item = (MenuElement) menuItems.elementAt(i)) != null && item.isSelectable()) {
+							item.performAction(k);
+							return;
+						}
+					}
+				}
+				break;
+
+			case KEY_UP:
+				if (isTextScreen) {
+					getGDActivity().scrollTextMenuUp();
+					return;
+				}
+
+				if (selectedIndex > 0 && !elementIsFirstClickable(selectedIndex)) {
+					from = selectedIndex - 1;
+				} else {
+					from = menuItems.size() - 1;
+				}
+
+				for (int i = from; i >= 0; i--) {
+					MenuElement el = (MenuElement) menuItems.elementAt(i);
+					if (!(el instanceof ClickableMenuElement) || ((ClickableMenuElement) el).isDisabled()) {
+						continue;
+					}
+
+					highlightElement((ClickableMenuElement) el);
+					selectedIndex = i;
+					scrollToItem(el);
+					break;
+				}
+				break;
+
+			case KEY_DOWN:
+				if (isTextScreen) {
+					getGDActivity().scrollTextMenuDown();
+					return;
+				}
+
+				if (selectedIndex < menuItems.size() - 1) {
+					from = selectedIndex + 1;
+				} else {
+					from = 0;
+				}
+				for (int i = from; i < menuItems.size(); i++) {
+					MenuElement el = (MenuElement) menuItems.elementAt(i);
+					if (!(el instanceof ClickableMenuElement) || ((ClickableMenuElement) el).isDisabled()) {
+						continue;
+					}
+
+					highlightElement((ClickableMenuElement) el);
+					selectedIndex = i;
+					scrollToItem(el);
+					break;
+				}
+				break;
+		}
+	}
+
+	protected boolean elementIsFirstClickable(int index) {
+		for (int i = 0; i < menuItems.size(); i++) {
+			MenuElement el = (MenuElement) menuItems.elementAt(i);
+			if (!(el instanceof ClickableMenuElement) || ((ClickableMenuElement) el).isDisabled()) {
+				if (i == index) {
+					return false;
+				}
+			} else {
+				if (i < index) return false;
+				if (i == index) return true;
+			}
+		}
+
+		return false;
+	}
+
+	public MenuScreen getNavTarget() {
+		return navTarget;
+	}
+
+	public void setNavTarget(MenuScreen target) {
+		navTarget = target;
+	}
+
+	/*public void setIsLevelsList(boolean is) {
+		isLevelsList = is;
+	}*/
+
+	public void clear() {
+		menuItems.removeAllElements();
+		layout.removeAllViews();
+
+		selectedIndex = -1;
+		lastHighlighted = null;
+	}
+
+	public LinearLayout getLayout() {
+		return layout;
+	}
+
+	protected void setTitle(String s) {
+		title = s;
+	}
+
+	protected void updateTitle() {
+		final GDActivity gd = getGDActivity();
+		gd.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				gd.menuTitleTextView.setText(title);
+				// activity.menuTitleTextView.invalidate();
+				gd.titleLayout.invalidate();
+			}
+		});
+	}
+
+	public void onHide(MenuScreen newMenu) {
+	}
+
+	public void onShow() {
+		updateTitle();
+		highlightElement();
+	}
+
+	public void resetHighlighted() {
+		lastHighlighted = null;
+	}
+
+	public void highlightElement() {
+		if (lastHighlighted != null) {
+			lastHighlighted.showHelmet();
+			final ViewTreeObserver obs = layout.getViewTreeObserver();
+			obs.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+				@Override
+				public boolean onPreDraw() {
+					try {
+						obs.removeOnPreDrawListener(this);
+						scrollToItem(lastHighlighted);
+					} catch (Exception e) {
+					}
+
+					return true;
+				}
+			});
+		} else {
+			for (int i = 0; i < menuItems.size(); i++) {
+				if (menuItems.elementAt(i) instanceof ClickableMenuElement) {
+					ClickableMenuElement item = (ClickableMenuElement) menuItems.elementAt(i);
+					if (item.isDisabled()) continue;
+
+					highlightElement(item);
+					scrollToItem(lastHighlighted);
+					selectedIndex = i;
+
+					break;
+				}
+			}
+		}
+	}
+
+	public void setSelected(int index) {
+		try {
+			if (menuItems.elementAt(index) instanceof ClickableMenuElement) {
+				ClickableMenuElement item = (ClickableMenuElement) menuItems.elementAt(index);
+				if (item.isDisabled()) return;
+
+				highlightElement(item);
+				selectedIndex = index;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	protected void highlightElement(ClickableMenuElement el) {
+		el.showHelmet();
+		lastHighlighted = el;
+	}
+
+	public void onScroll(double percent) {
+	}
+
+	@Override
+	public void onElementHighlight(ClickableMenuElement el) {
+		lastHighlighted = el;
+
+		int index = menuItems.indexOf(el);
+		if (index != -1)
+			selectedIndex = index;
+	}
+
+	public void setIsTextScreen(boolean isTextScreen) {
+		this.isTextScreen = isTextScreen;
+	}
+
+	/*public boolean isTextScreen() {
+		return isTextScreen;
+	}*/
+
+}
diff --git a/src/org/happysanta/gd/Menu/NameInputMenuScreen.java b/src/org/happysanta/gd/Menu/NameInputMenuScreen.java
new file mode 100644
index 0000000..e742c7c
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/NameInputMenuScreen.java
@@ -0,0 +1,175 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.MenuLinearLayout;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getGameMenu;
+
+public class NameInputMenuScreen extends MenuScreen {
+
+	protected static final String CURSOR = "^";
+	protected static final int WORD_SPACE = 3;
+
+	protected static int wordWidth = 0;
+
+	protected int cursorPosition = 0;
+	protected byte chars[];
+
+	protected MenuTextView nameTextViews[];
+	protected MenuTextView cursorTextViews[];
+	protected MenuLinearLayout nameLayout;
+	protected MenuLinearLayout cursorLayout;
+
+	static {
+		wordWidth = getWordWidth();
+	}
+
+	public NameInputMenuScreen(String title, MenuScreen navTarget, byte nameChars[]) {
+		super(title, navTarget);
+
+		chars = nameChars;
+
+		Context context = getGDActivity();
+
+		nameTextViews = new MenuTextView[3];
+		cursorTextViews = new MenuTextView[3];
+
+		nameLayout = new MenuLinearLayout(context);
+		nameLayout.setOrientation(LinearLayout.HORIZONTAL);
+
+		cursorLayout = new MenuLinearLayout(context);
+		cursorLayout.setOrientation(LinearLayout.HORIZONTAL);
+
+		for (int i = 0; i < 3; i++) {
+			nameTextViews[i] = createTextView();
+			nameLayout.addView(nameTextViews[i]);
+
+			cursorTextViews[i] = createTextView();
+			cursorLayout.addView(cursorTextViews[i]);
+		}
+
+		layout.addView(nameLayout, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+		layout.addView(cursorLayout, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+
+		updateText();
+		updateCursorPosition();
+	}
+
+	protected MenuTextView createTextView() {
+		Context context = getGDActivity();
+		MenuTextView textView = new MenuTextView(context);
+		textView.setTextColor(0xff000000);
+		textView.setTypeface(Global.robotoCondensedTypeface);
+		textView.setTextSize(ClickableMenuElement.TEXT_SIZE);
+		textView.setLayoutParams(new LinearLayout.LayoutParams(
+				wordWidth,
+				ViewGroup.LayoutParams.WRAP_CONTENT
+		));
+		return textView;
+	}
+
+	protected static int getWordWidth() {
+		Context context = getGDActivity();
+
+		String text = "W";
+		TextView textView = new TextView(context);
+		textView.setTextSize(ClickableMenuElement.TEXT_SIZE);
+		textView.setTypeface(Global.robotoCondensedTypeface);
+
+		Rect bounds = new Rect();
+
+		Paint textPaint = textView.getPaint();
+		textPaint.getTextBounds(text, 0, text.length(), bounds);
+
+		return bounds.width() + getDp(WORD_SPACE);
+	}
+
+	@Override
+	public void performAction(int k) {
+		switch (k) {
+			default:
+				break;
+
+			case MenuScreen.KEY_FIRE: // select
+				if (cursorPosition == 2) {
+					getGameMenu().setCurrentMenu(navTarget, false);
+				} else {
+					cursorPosition++;
+					updateCursorPosition();
+				}
+				break;
+
+			case MenuScreen.KEY_RIGHT: // right
+				cursorPosition++;
+				if (cursorPosition > 2) {
+					cursorPosition = 2;
+				}
+				updateCursorPosition();
+				break;
+
+			case MenuScreen.KEY_LEFT: // left
+				cursorPosition--;
+				if (cursorPosition < 0)
+					cursorPosition = 0;
+				updateCursorPosition();
+				break;
+
+			case MenuScreen.KEY_UP: // up
+				if (chars[cursorPosition] == 32) {
+					chars[cursorPosition] = 65;
+					updateText();
+					break;
+				}
+				chars[cursorPosition]++;
+				if (chars[cursorPosition] > 90) {
+					chars[cursorPosition] = 32;
+				}
+				updateText();
+				break;
+
+			case MenuScreen.KEY_DOWN: // down
+				if (chars[cursorPosition] == 32) {
+					chars[cursorPosition] = 90;
+					updateText();
+					break;
+				}
+				chars[cursorPosition]--;
+				if (chars[cursorPosition] < 65) {
+					chars[cursorPosition] = 32;
+				}
+				updateText();
+				break;
+		}
+	}
+
+	protected void updateText() {
+		for (int i = 0; i < nameTextViews.length; i++) {
+			nameTextViews[i].setTextOnUiThread(String.valueOf((char) chars[i]));
+		}
+	}
+
+	protected void updateCursorPosition() {
+		for (int i = 0; i < cursorTextViews.length; i++) {
+			cursorTextViews[i].setTextOnUiThread(i == cursorPosition ? CURSOR : "");
+		}
+	}
+
+	public byte[] getChars() {
+		return chars;
+	}
+
+	public void resetCursorPosition() {
+		cursorPosition = 0;
+		updateCursorPosition();
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/OnMenuElementHighlightListener.java b/src/org/happysanta/gd/Menu/OnMenuElementHighlightListener.java
new file mode 100644
index 0000000..f065bf1
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/OnMenuElementHighlightListener.java
@@ -0,0 +1,10 @@
+package org.happysanta.gd.Menu;
+
+/**
+ * Author: ch1p
+ */
+public interface OnMenuElementHighlightListener {
+
+	public abstract void onElementHighlight(ClickableMenuElement el);
+
+}
diff --git a/src/org/happysanta/gd/Menu/OptionsMenuElement.java b/src/org/happysanta/gd/Menu/OptionsMenuElement.java
new file mode 100644
index 0000000..2119b32
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/OptionsMenuElement.java
@@ -0,0 +1,301 @@
+package org.happysanta.gd.Menu;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.MenuImageView;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+import org.happysanta.gd.R;
+// import com.grishka.agdtr.R;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getString;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class OptionsMenuElement
+		extends ClickableMenuElement
+		implements MenuElement, MenuHandler {
+
+	protected int selectedIndex;
+	protected String options[];
+	protected int unlockedCount;
+	protected MenuHandler handler;
+	protected MenuScreen optionsScreen = null;
+	protected MenuScreen screen = null;
+	protected boolean isOnOffToggle;
+	protected boolean m_oZ = false;
+	protected String selectedOption;
+	protected ActionMenuElement optionsScreenItems[] = null;
+	protected MenuImageView lockImage = null;
+	protected MenuTextView optionTextView = null;
+
+	public OptionsMenuElement(String text, int selectedIndex, MenuHandler handler, String options[], boolean isOnOffToggle, MenuScreen screen) {
+		this.text = text;
+		this.selectedIndex = selectedIndex;
+		this.handler = handler;
+		this.options = options;
+		if (this.options == null) this.options = new String[]{""};
+		unlockedCount = this.options.length - 1;
+		this.isOnOffToggle = isOnOffToggle;
+
+		createAllViews();
+		setSelectedOption(selectedIndex);
+
+		if (isOnOffToggle) {
+			if (selectedIndex == 1) {
+				selectedOption = getString(R.string.off);
+			} else {
+				selectedOption = getString(R.string.on);
+			}
+		} else {
+			this.screen = screen;
+			updateSelectedOption();
+			update();
+		}
+	}
+
+	@Override
+	protected void createAllViews() {
+		Context context = getGDActivity();
+
+		super.createAllViews();
+
+		textView.setLayoutParams(new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.WRAP_CONTENT,
+				LinearLayout.LayoutParams.WRAP_CONTENT
+		));
+
+		optionTextView = new MenuTextView(context);
+		optionTextView.setText(selectedOption);
+		optionTextView.setTextColor(getMenuTextView().getTextColors());
+		optionTextView.setTextSize(TEXT_SIZE);
+		optionTextView.setTypeface(Global.robotoCondensedTypeface);
+		optionTextView.setLayoutParams(new LinearLayout.LayoutParams(
+				LinearLayout.LayoutParams.WRAP_CONTENT,
+				LinearLayout.LayoutParams.WRAP_CONTENT
+		));
+		optionTextView.setPadding(
+				textView.getPaddingLeft(),
+				textView.getPaddingTop(),
+				textView.getPaddingRight(),
+				textView.getPaddingBottom()
+		);
+
+		lockImage = new MenuImageView(context);
+		lockImage.setImageResource(ActionMenuElement.locks[0]);
+		lockImage.setScaleType(ImageView.ScaleType.CENTER);
+		lockImage.setVisibility(View.GONE);
+
+		LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.MATCH_PARENT);
+		lp.setMargins(0, 0, getDp(ActionMenuElement.LOCK_IMAGE_MARGIN_RIGHT), 0);
+		lockImage.setLayoutParams(lp);
+		lockImage.setVisibility(View.GONE);
+
+		layout.addView(lockImage);
+		layout.addView(optionTextView);
+	}
+
+	private void updateSelectedOption() {
+		selectedOption = options[selectedIndex];
+		updateViewText();
+
+		if (selectedIndex > unlockedCount && !isOnOffToggle) {
+			lockImage.setVisibility(View.VISIBLE);
+		} else {
+			lockImage.setVisibility(View.GONE);
+		}
+	}
+
+	public int getUnlockedCount() {
+		return unlockedCount;
+	}
+
+	public void setUnlockedCount(int k) {
+		unlockedCount = k;
+		if (unlockedCount > options.length - 1)
+			unlockedCount = options.length - 1;
+		if (optionsScreen != null) {
+			for (int l = 0; l < optionsScreenItems.length; l++)
+				if (l > k)
+					optionsScreenItems[l].setLock(true, true);
+				else
+					optionsScreenItems[l].setLock(false, false);
+		}
+		updateSelectedOption();
+	}
+
+	public int getOptionCount() {
+		return options.length - 1;
+	}
+
+	public String[] getOptions() {
+		return options;
+	}
+
+	public void setOptions(String as[]) {
+		setOptions(as, true);
+	}
+
+	public void setOptions(String as[], boolean update) {
+		options = as;
+		if (selectedIndex > options.length - 1)
+			selectedIndex = options.length - 1;
+		if (unlockedCount > options.length - 1)
+			unlockedCount = options.length - 1;
+		updateSelectedOption();
+		if (update) update();
+	}
+
+	public int getSelectedOption() {
+		return selectedIndex;
+	}
+
+	public void setSelectedOption(int k) {
+		selectedIndex = k;
+		if (selectedIndex > options.length - 1)
+			selectedIndex = 0;
+		if (selectedIndex < 0)
+			selectedIndex = options.length - 1;
+		updateSelectedOption();
+	}
+
+	public void update() {
+		optionsScreen = new MenuScreen(text, screen);
+		optionsScreenItems = new ActionMenuElement[options.length];
+		for (int k = 0; k < optionsScreenItems.length; k++) {
+			if (k > unlockedCount) {
+				optionsScreenItems[k] = new ActionMenuElement(options[k], this);
+				optionsScreenItems[k].setLock(true, true);
+			} else {
+				optionsScreenItems[k] = new ActionMenuElement(options[k], this);
+			}
+			optionsScreen.addItem(optionsScreenItems[k]);
+		}
+		optionsScreen.setSelected(selectedIndex);
+
+		// System.gc();
+	}
+
+	public boolean _charvZ() {
+		if (m_oZ) {
+			m_oZ = false;
+			return true;
+		} else {
+			return m_oZ;
+		}
+	}
+
+	@Override
+	public void handleAction(MenuElement item) {
+		int k = 0;
+		do {
+			if (k >= optionsScreenItems.length)
+				break;
+			if (item == optionsScreenItems[k]) {
+				selectedIndex = k;
+				updateSelectedOption();
+				break;
+			}
+			k++;
+		} while (true);
+
+		handler.setCurrentMenu(screen, true);
+		handler.handleAction(this);
+	}
+
+	@Override
+	public MenuScreen getCurrentMenu() {
+		return optionsScreen;
+	}
+
+	@Override
+	public void setCurrentMenu(MenuScreen e1, boolean flag) {
+	}
+
+	@Override
+	protected void updateViewText() {
+		if (textView != null && textView instanceof MenuTextView)
+			((MenuTextView) textView).setTextOnUiThread(getTextForView());
+		if (optionTextView != null) optionTextView.setTextOnUiThread(selectedOption);
+	}
+
+	@Override
+	public void performAction(int k) {
+		// logDebug("OptionMenuElement performAction: k = " + k);
+		switch (k) {
+			case MenuScreen.KEY_FIRE:
+				if (isOnOffToggle) {
+					selectedIndex++;
+					if (selectedIndex > 1)
+						selectedIndex = 0;
+					if (selectedIndex == 1)
+						selectedOption = getString(R.string.off);
+					else
+						selectedOption = getString(R.string.on);
+					updateViewText();
+					handler.handleAction(this);
+					return;
+				} else {
+					m_oZ = true;
+					handler.handleAction(this);
+					return;
+				}
+
+			case MenuScreen.KEY_RIGHT:
+				if (isOnOffToggle) {
+					if (selectedIndex == 1) {
+						selectedIndex = 0;
+						selectedOption = getString(R.string.on);
+						handler.handleAction(this);
+						updateViewText();
+					}
+					return;
+				}
+				selectedIndex++;
+				if (selectedIndex > options.length - 1)
+					selectedIndex = options.length - 1;
+				else
+					handler.handleAction(this);
+				updateSelectedOption();
+				return;
+
+			case MenuScreen.KEY_LEFT: // '\003'
+				if (isOnOffToggle) {
+					if (selectedIndex == 0) {
+						selectedIndex = 1;
+						selectedOption = getString(R.string.off);
+						handler.handleAction(this);
+						updateViewText();
+					}
+					return;
+				}
+				selectedIndex--;
+				if (selectedIndex < 0) {
+					selectedIndex = 0;
+				} else {
+					updateSelectedOption();
+					handler.handleAction(this);
+				}
+				updateSelectedOption();
+				break;
+		}
+	}
+
+	public void setScreen(MenuScreen screen) {
+		this.screen = screen;
+	}
+
+	@Override
+	protected String getTextForView() {
+		return text + ": ";
+	}
+
+	@Override
+	protected void onHighlightChanged() {
+		lockImage.setImageResource(ActionMenuElement.locks[isHighlighted ? 2 : 0]);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/SimpleMenuElement.java b/src/org/happysanta/gd/Menu/SimpleMenuElement.java
new file mode 100755
index 0000000..57842f5
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/SimpleMenuElement.java
@@ -0,0 +1,176 @@
+package org.happysanta.gd.Menu;
+
+// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
+// Jad home page: http://www.kpdus.com/jad.html
+// Decompiler options: packimports(3) fieldsfirst ansi 
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.view.View;
+import android.view.ViewGroup;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+
+import java.util.TimerTask;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getGDView;
+
+public class SimpleMenuElement extends TimerTask
+		implements MenuElementOld {
+
+	// public static final int LINE_SPACING = 15;
+	protected static Paint gFont;
+
+	public int x;
+	public int y;
+	public int m_bI;
+	public int m_eI;
+	public int m_dI;
+	public int m_gotoI;
+	public int m_nullI;
+	public int m_longI;
+	public int m_fI;
+	int m_cI;
+	// GDActivity activity;
+	protected String text;
+	protected MenuScreen m_we;
+	protected MenuHandler m_hc;
+	protected Paint font;
+	protected boolean isPressed = false;
+	protected MenuTextView textView;
+
+	/*static {
+		gFont = ActionMenuElement.getGFont();
+	}*/
+
+	public SimpleMenuElement() {
+		init();
+	}
+
+	public SimpleMenuElement(int k) {
+		m_cI = k;
+		font = gFont;
+	}
+
+	public SimpleMenuElement(String s, MenuScreen e1, MenuHandler c1) {
+		text = s + ">";
+		m_we = e1;
+		m_hc = c1;
+		font = gFont;
+
+		textView = new MenuTextView(getGDActivity());
+		textView.setText(text);
+		textView.setTextColor(0xff000000);
+		// textView.setTextColor(R.drawable.menu_item_color);
+		textView.setTypeface(Global.robotoCondensedTypeface);
+		textView.setTextSize(20);
+		textView.setLayoutParams(new ViewGroup.LayoutParams(
+				ViewGroup.LayoutParams.MATCH_PARENT,
+				ViewGroup.LayoutParams.WRAP_CONTENT
+		));
+	}
+
+	public void init() {
+		x = y = m_bI = 0;
+		m_eI = m_dI = m_gotoI = 0;
+		m_nullI = m_longI = m_fI = 0;
+	}
+
+	@Override
+	public View getView() {
+		return textView;
+	}
+
+	@Override
+	public void run() {
+		getGDView()._tryIV(m_cI);
+	}
+
+	@Override
+	public void setText(String s) {
+		text = s + ">";
+	}
+
+	public String getText() {
+		return text;
+	}
+
+	@Override
+	public boolean isSelectable() {
+		return true;
+	}
+
+	@Override
+	public void performAction(int k) {
+		/*switch (k) {
+			case MenuScreen.KEY_FIRE:
+			case MenuScreen.KEY_RIGHT:
+				m_hc.handleAction(this);
+				m_we.setNavTarget(m_hc.getCurrentMenu());
+				m_hc.setCurrentMenu(m_we, false);
+				// fall through
+
+			case 3: // '\003'
+			default:
+				return;
+		}*/
+	}
+
+	/* public void _aeV(MenuScreen e1) {
+		screen = e1;
+	} */
+
+	@Override
+	public void draw(Canvas g, int y, int x) {
+		// if (isPressed)
+		// setPressedColor();
+		g.drawText(text, x, y - font.ascent(), font);
+		// if (isPressed)
+		// setNormalColor();
+	}
+
+	@Override
+	public int getLineSpacing() {
+		return ActionMenuElement.LINE_SPACING;
+	}
+
+	@Override
+	public void setFont(Paint font) {
+		this.font = font;
+	}
+
+	@Override
+	public int getHeight() {
+		return Math.round(font.descent() - font.ascent());
+	}
+
+	@Override
+	public int getFirstLineHeight() {
+		return getHeight();
+	}
+
+	/* @Override
+	public int getHeight() {
+		return getHeight() + getLineSpacing();
+	} */
+
+	@Override
+	public int getXOffset() {
+		return ActionMenuElement.X_OFFSET;
+	}
+
+	@Override
+	public void setPressed(boolean flag) {
+		isPressed = flag;
+	}
+
+	/*protected void setPressedColor() {
+		font.setColor(ActionMenuElement.PRESSED_COLOR);
+	}
+
+	protected void setNormalColor() {
+		font.setColor(ActionMenuElement.NORMAL_COLOR);
+	}*/
+
+}
diff --git a/src/org/happysanta/gd/Menu/SimpleMenuElementNew.java b/src/org/happysanta/gd/Menu/SimpleMenuElementNew.java
new file mode 100644
index 0000000..474a6ad
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/SimpleMenuElementNew.java
@@ -0,0 +1,77 @@
+package org.happysanta.gd.Menu;
+
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class SimpleMenuElementNew extends ClickableMenuElement
+		implements MenuElement {
+
+	// protected static Paint gFont;
+
+	public int x;
+	public int y;
+	/* public int m_bI;
+	public int m_eI;
+	public int m_dI;
+	public int m_gotoI;
+	public int m_nullI;
+	public int m_longI;
+	public int m_fI;
+	int m_cI; */
+	protected MenuScreen screen;
+	protected MenuHandler handler;
+	// protected Paint font;
+	// protected boolean isPressed = false;
+
+	/* static {
+		gFont = ActionMenuElement.getGFont();
+	} */
+
+	/* public SimpleMenuElementNew() {
+		init();
+	}
+
+	public SimpleMenuElementNew(int k) {
+		m_cI = k;
+		// font = gFont;
+	} */
+
+	public SimpleMenuElementNew(String text, MenuScreen screen, MenuHandler handler) {
+		this.text = text + ">";
+		this.screen = screen;
+		this.handler = handler;
+
+		createAllViews();
+
+		// textView = createAllViews();
+	}
+
+	/* public void init() {
+		x = y = m_bI = 0;
+		m_eI = m_dI = m_gotoI = 0;
+		m_nullI = m_longI = m_fI = 0;
+	} */
+
+	@Override
+	public void setText(String s) {
+		super.setText(s + ">");
+	}
+
+	// @Override
+	public void performAction(int k) {
+		logDebug("SimpleMenuElementNew performAction k = " + k);
+
+		switch (k) {
+			case MenuScreen.KEY_FIRE:
+			case MenuScreen.KEY_RIGHT:
+				handler.handleAction(this);
+				screen.setNavTarget(handler.getCurrentMenu());
+				handler.setCurrentMenu(screen, false);
+				break;
+		}
+	}
+
+	/* public void _aeV(MenuScreen e1) {
+		screen = e1;
+	} */
+
+}
diff --git a/src/org/happysanta/gd/Menu/TextMenuElement.java b/src/org/happysanta/gd/Menu/TextMenuElement.java
new file mode 100755
index 0000000..7485389
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/TextMenuElement.java
@@ -0,0 +1,80 @@
+package org.happysanta.gd.Menu;
+
+// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
+// Jad home page: http://www.kpdus.com/jad.html
+// Decompiler options: packimports(3) fieldsfirst ansi 
+
+import android.content.Context;
+import android.text.Html;
+import android.text.Spanned;
+import android.text.SpannedString;
+import android.text.util.Linkify;
+import android.view.View;
+import android.view.ViewGroup;
+import org.happysanta.gd.Menu.Views.MenuTextView;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class TextMenuElement
+		implements MenuElement {
+
+	protected static final int TEXT_SIZE = 15;
+	protected static final int TEXT_COLOR = 0xff000000;
+
+	protected Spanned spanned;
+	protected MenuTextView textView;
+
+	public TextMenuElement(String text) {
+		this.spanned = SpannedString.valueOf(text);
+		textView = createTextView();
+	}
+
+	public TextMenuElement(Spanned text) {
+		this.spanned = text;
+		textView = createTextView();
+	}
+
+	protected MenuTextView createTextView() {
+		Context activity = getGDActivity();
+
+		MenuTextView textView = new MenuTextView(activity);
+		textView.setText(spanned);
+		textView.setTextColor(TEXT_COLOR);
+		textView.setTextSize(TEXT_SIZE);
+		textView.setLineSpacing(0f, 1.5f);
+		textView.setLayoutParams(new ViewGroup.LayoutParams(
+				ViewGroup.LayoutParams.MATCH_PARENT,
+				ViewGroup.LayoutParams.WRAP_CONTENT
+		));
+
+		Linkify.addLinks(textView, Linkify.WEB_URLS);
+		textView.setLinksClickable(true);
+
+		return textView;
+	}
+
+	@Override
+	public View getView() {
+		return textView;
+	}
+
+	public String getText() {
+		return spanned.toString();
+	}
+
+	@Override
+	public void setText(String text) {
+		this.spanned = Html.fromHtml(text);
+		textView.setTextOnUiThread(spanned);
+	}
+
+	@Override
+	public boolean isSelectable() {
+		return false;
+	}
+
+	@Override
+	public void performAction(int k) {
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/LevelNameLeadingMarginSpan2.java b/src/org/happysanta/gd/Menu/Views/LevelNameLeadingMarginSpan2.java
new file mode 100644
index 0000000..09c744d
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/LevelNameLeadingMarginSpan2.java
@@ -0,0 +1,38 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.text.Layout;
+import android.text.style.LeadingMarginSpan;
+
+public class LevelNameLeadingMarginSpan2 implements LeadingMarginSpan.LeadingMarginSpan2 {
+
+	private int margin;
+	private int lines;
+
+	public LevelNameLeadingMarginSpan2(int lines, int margin) {
+		this.margin = margin;
+		this.lines = lines;
+	}
+
+	@Override
+	public int getLeadingMargin(boolean first) {
+		if (first) {
+			return margin;
+		} else {
+			return 0;
+		}
+	}
+
+	@Override
+	public void drawLeadingMargin(Canvas c, Paint p, int x, int dir,
+								  int top, int baseline, int bottom, CharSequence text,
+								  int start, int end, boolean first, Layout layout) {
+	}
+
+	@Override
+	public int getLeadingMarginLineCount() {
+		return lines;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuHelmetView.java b/src/org/happysanta/gd/Menu/Views/MenuHelmetView.java
new file mode 100644
index 0000000..bb2a37a
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuHelmetView.java
@@ -0,0 +1,111 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.view.View;
+import org.happysanta.gd.Game.Bitmap;
+import org.happysanta.gd.Global;
+
+import static org.happysanta.gd.Helpers.getDp;
+import static org.happysanta.gd.Helpers.isSDK11OrHigher;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class MenuHelmetView extends View {
+
+	protected static final int WIDTH = 8;
+	protected static final int HEIGHT = 8;
+	/*protected static final int PADDING_LEFT = 0;
+	protected static final int PADDING_TOP = 5;
+	protected static final int PADDING_RIGHT = 5;
+	protected static final int PADDING_BOTTOM = 0;*/
+
+	protected static int angle = 0;
+	protected static long angleLastMs = 0;
+	protected static final int angleInterval = 50;
+	protected static final int angleDelta = 10;
+
+	protected boolean show = false;
+	protected boolean _setMeasuredHeight = false;
+	protected Bitmap helmet = Bitmap.get(Bitmap.HELMET);
+	protected static MenuHelmetView lastActive = null;
+
+	public static void clearStaticFields() {
+		lastActive = null;
+		angle = 0;
+		angleLastMs = 0;
+	}
+
+	public MenuHelmetView(Context context) {
+		super(context);
+	}
+
+	public MenuHelmetView(Context context, AttributeSet attributeSet) {
+		super(context, attributeSet);
+	}
+
+	@Override
+	public void onDraw(Canvas canvas) {
+		canvas.save();
+		canvas.scale(Global.density, Global.density);
+
+		drawHelmet(canvas);
+
+		canvas.restore();
+		invalidate();
+	}
+
+	protected void drawHelmet(Canvas canvas) {
+		if (show) {
+			long ms = System.currentTimeMillis();
+			if (angleLastMs == 0 || ms - angleLastMs >= angleInterval) {
+				angle += angleDelta;
+				if (angle >= 360) angle -= 360;
+				angleLastMs = ms;
+			}
+
+			int y = getScaledHeight() / 2 - helmet.getHeightDp() / 2;
+
+			canvas.save();
+			canvas.rotate(angle, helmet.getWidthDp() / 2, y + helmet.getHeightDp() / 2);
+			canvas.drawBitmap(helmet.bitmap, new Rect(0, 0, helmet.getWidth(), helmet.getHeight()), new RectF(0, y, helmet.getWidthDp(), y + helmet.getHeightDp()), null);
+			canvas.restore();
+		}
+	}
+
+	@Override
+	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+		int width = MeasureSpec.getSize(getDp(WIDTH * 2.2f));
+		int height = heightMeasureSpec;
+		if (_setMeasuredHeight)
+			height = MeasureSpec.getSize(getDp(HEIGHT * 2.2f));
+		else if (!isSDK11OrHigher()) {
+			height = MeasureSpec.getSize(getDp(HEIGHT * 4.5f));
+		}
+		setMeasuredDimension(width, height);
+	}
+
+	public void setShow(boolean show) {
+		setShow(show, true);
+	}
+
+	public void setShow(boolean show, boolean checkLast) {
+		if (checkLast && lastActive != null) {
+			lastActive.setShow(false, false);
+		}
+		this.show = show;
+		lastActive = this;
+	}
+
+	protected int getScaledHeight() {
+		return Math.round(getHeight() / Global.density);
+	}
+
+	public void setMeasuredHeight(boolean setMeasuredHeight) {
+		this._setMeasuredHeight = setMeasuredHeight;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuImageView.java b/src/org/happysanta/gd/Menu/Views/MenuImageView.java
new file mode 100644
index 0000000..1ef3f70
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuImageView.java
@@ -0,0 +1,34 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.content.Context;
+import android.widget.ImageView;
+
+import static org.happysanta.gd.Helpers.runOnUiThread;
+
+public class MenuImageView extends ImageView {
+
+	public MenuImageView(Context context) {
+		super(context);
+	}
+
+	@Override
+	public void setImageResource(final int resid) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuImageView.super.setImageResource(resid);
+			}
+		});
+	}
+
+	@Override
+	public void setVisibility(final int visibility) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuImageView.super.setVisibility(visibility);
+			}
+		});
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuLinearLayout.java b/src/org/happysanta/gd/Menu/Views/MenuLinearLayout.java
new file mode 100644
index 0000000..98f665e
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuLinearLayout.java
@@ -0,0 +1,68 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.content.Context;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.LinearLayout;
+
+import static org.happysanta.gd.Helpers.runOnUiThread;
+
+public class MenuLinearLayout extends LinearLayout {
+
+	boolean interceptTouchEvents = false;
+
+	public MenuLinearLayout(Context context) {
+		super(context);
+	}
+
+	public MenuLinearLayout(Context context, boolean interceptTouchEvents) {
+		super(context);
+		this.interceptTouchEvents = interceptTouchEvents;
+	}
+
+	@Override
+	public void removeAllViews() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuLinearLayout.super.removeAllViews();
+			}
+		});
+	}
+
+	@Override
+	public void setVisibility(final int visibility) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuLinearLayout.super.setVisibility(visibility);
+			}
+		});
+	}
+
+	@Override
+	public void addView(final View view) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuLinearLayout.super.addView(view);
+			}
+		});
+	}
+
+	@Override
+	public void setPadding(final int left, final int top, final int right, final int bottom) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuLinearLayout.super.setPadding(left, top, right, bottom);
+			}
+		});
+	}
+
+	@Override
+	public boolean onInterceptTouchEvent(MotionEvent evt) {
+		return interceptTouchEvents;
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuRelativeLayout.java b/src/org/happysanta/gd/Menu/Views/MenuRelativeLayout.java
new file mode 100644
index 0000000..3e5e0d2
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuRelativeLayout.java
@@ -0,0 +1,55 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.RelativeLayout;
+
+import static org.happysanta.gd.Helpers.runOnUiThread;
+
+public class MenuRelativeLayout extends RelativeLayout {
+
+	public MenuRelativeLayout(Context context) {
+		super(context);
+	}
+
+	@Override
+	public void removeAllViews() {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuRelativeLayout.super.removeAllViews();
+			}
+		});
+	}
+
+	@Override
+	public void setVisibility(final int visibility) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuRelativeLayout.super.setVisibility(visibility);
+			}
+		});
+	}
+
+	@Override
+	public void addView(final View view) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuRelativeLayout.super.addView(view);
+			}
+		});
+	}
+
+	@Override
+	public void setPadding(final int left, final int top, final int right, final int bottom) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuRelativeLayout.super.setPadding(left, top, right, bottom);
+			}
+		});
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuTextView.java b/src/org/happysanta/gd/Menu/Views/MenuTextView.java
new file mode 100644
index 0000000..4b48f5f
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuTextView.java
@@ -0,0 +1,73 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.content.Context;
+import android.graphics.Typeface;
+import android.widget.TextView;
+
+import static org.happysanta.gd.Helpers.runOnUiThread;
+
+public class MenuTextView extends TextView {
+
+	protected boolean isAttached = false;
+
+	public MenuTextView(Context context) {
+		super(context);
+	}
+
+	@Override
+	protected void onAttachedToWindow() {
+		super.onAttachedToWindow();
+		isAttached = true;
+	}
+
+	@Override
+	protected void onDetachedFromWindow() {
+		super.onDetachedFromWindow();
+		isAttached = false;
+	}
+
+	@Override
+	public boolean isAttachedToWindow() {
+		return isAttached;
+	}
+
+	public void setTextOnUiThread(final CharSequence sequence) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuTextView.super.setText(sequence);
+			}
+		});
+	}
+
+	@Override
+	public void setTextSize(final float size) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuTextView.super.setTextSize(size);
+			}
+		});
+	}
+
+	@Override
+	public void setTypeface(final Typeface typeface) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuTextView.super.setTypeface(typeface);
+			}
+		});
+	}
+
+	@Override
+	public void setVisibility(final int visibility) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				MenuTextView.super.setVisibility(visibility);
+			}
+		});
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuTitleLinearLayout.java b/src/org/happysanta/gd/Menu/Views/MenuTitleLinearLayout.java
new file mode 100644
index 0000000..5c3f790
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuTitleLinearLayout.java
@@ -0,0 +1,39 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.app.Activity;
+import android.widget.RelativeLayout;
+
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class MenuTitleLinearLayout extends RelativeLayout {
+
+	private Callback onSizeChangedCallback = null;
+
+	public MenuTitleLinearLayout(Activity activity) {
+		super(activity);
+	}
+
+	@Override
+	public void onSizeChanged(final int w, final int h, final int oldw, final int oldh) {
+		super.onSizeChanged(w, h, oldw, oldh);
+
+		if (onSizeChangedCallback != null) {
+			onSizeChangedCallback.run(w, h, oldw, oldh);
+		}
+	}
+
+	/*public void forceInvokeOnSizeChangedCallback() {
+		if (onSizeChangedCallback != null) {
+			onSizeChangedCallback.run(getWidth(), getHeight(), 0, 0);
+		}
+	}*/
+
+	public void setOnSizeChangedCallback(Callback callback) {
+		onSizeChangedCallback = callback;
+	}
+
+	public interface Callback {
+		public abstract void run(int w, int h, int oldw, int oldh);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/MenuView.java b/src/org/happysanta/gd/Menu/Views/MenuView.java
new file mode 100644
index 0000000..ba47071
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/MenuView.java
@@ -0,0 +1,12 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.view.View;
+import org.happysanta.gd.GDActivity;
+
+public class MenuView extends View {
+
+	public MenuView(GDActivity activity) {
+		super(activity);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Menu/Views/ObservableScrollView.java b/src/org/happysanta/gd/Menu/Views/ObservableScrollView.java
new file mode 100644
index 0000000..5801928
--- /dev/null
+++ b/src/org/happysanta/gd/Menu/Views/ObservableScrollView.java
@@ -0,0 +1,31 @@
+package org.happysanta.gd.Menu.Views;
+
+import android.content.Context;
+import android.widget.ScrollView;
+
+public class ObservableScrollView
+		extends ScrollView {
+
+	private OnScrollListener scrollListener = null;
+
+	public ObservableScrollView(Context context) {
+		super(context);
+	}
+
+	public void setOnScrollListener(OnScrollListener scrollListener) {
+		this.scrollListener = scrollListener;
+	}
+
+	@Override
+	protected void onScrollChanged(int x, int y, int oldx, int oldy) {
+		super.onScrollChanged(x, y, oldx, oldy);
+		if (scrollListener != null) {
+			scrollListener.onScroll(this, x, y, oldx, oldy);
+		}
+	}
+
+	public interface OnScrollListener {
+		public abstract void onScroll(ObservableScrollView scrollView, int x, int y, int oldx, int oldy);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Settings.java b/src/org/happysanta/gd/Settings.java
new file mode 100644
index 0000000..93857ca
--- /dev/null
+++ b/src/org/happysanta/gd/Settings.java
@@ -0,0 +1,215 @@
+package org.happysanta.gd;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Build;
+import org.happysanta.gd.API.API;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class Settings {
+
+	private static final String LEVEL_ID = "level_id";
+	private static final int LEVEL_ID_DEFAULT = 0;
+
+	private static final String PERSPECTIVE_ENABLED = "perspective_enabled";
+	private static final boolean PERSPECTIVE_ENABLED_DEFAULT = true;
+
+	private static final String SHADOWS_ENABLED = "shadows_enabled";
+	private static final boolean SHADOWS_ENABLED_DEFAULT = true;
+
+	private static final String DRIVER_SPRITE_ENABLED = "driver_sprite_enabled";
+	private static final boolean DRIVER_SPRITE_ENABLED_DEFAULT = true;
+
+	private static final String BIKE_SPRITE_ENABLED = "bike_sprite_enabled";
+	private static final boolean BIKE_SPRITE_ENABLED_DEFAULT = true;
+
+	private static final String INPUT_OPTION = "input_option";
+	private static final int INPUT_OPTION_DEFAULT = 0;
+
+	private static final String LOOK_AHEAD_ENABLED = "look_ahead_enabled";
+	private static final boolean LOOK_AHEAD_ENABLED_DEFAULT = true;
+
+	private static final String VIBRATE_ENABLED = "vibrate_enabled";
+	private static final boolean VIBRATE_ENABLED_DEFAULT = true;
+
+	private static final String KEYBOARD_IN_MENU_ENABLED = "keyboard_enabled";
+	private static final boolean KEYBOARD_IN_MENU_ENABLED_DEFAULT = true;
+
+	private static final String LAST_SEND_STATS = "last_send_stats";
+	private static final long LAST_SEND_STATS_DEFAULT = 0;
+
+	private static final String NAME = "name";
+	public static final String NAME_DEFAULT = "AAA";
+	public static final byte[] NAME_CHARS_DEFALUT = new byte[]{65, 65, 65};
+
+	private static final String LEVELS_SORT = "level_sort"; // in download list
+	private static final int LEVELS_SORT_DEFAULT = 0;
+
+	private static SharedPreferences preferences;
+
+	static {
+		preferences = getGDActivity().getSharedPreferences("GDSettings", Context.MODE_PRIVATE);
+	}
+
+	public static void resetAll() {
+		setPerspectiveEnabled(PERSPECTIVE_ENABLED_DEFAULT);
+		setShadowsEnabled(SHADOWS_ENABLED_DEFAULT);
+		setDriverSpriteEnabled(DRIVER_SPRITE_ENABLED_DEFAULT);
+		setBikeSpriteEnabled(BIKE_SPRITE_ENABLED_DEFAULT);
+		setLookAheadEnabled(LOOK_AHEAD_ENABLED_DEFAULT);
+		setVibrateOnTouchEnabled(VIBRATE_ENABLED_DEFAULT);
+		setKeyboardInMenuEnabled(KEYBOARD_IN_MENU_ENABLED_DEFAULT);
+		setInputOption(INPUT_OPTION_DEFAULT);
+		setLevelsSort(LEVELS_SORT_DEFAULT);
+		setName(NAME_CHARS_DEFALUT);
+	}
+
+	public static long getLevelId() {
+		return preferences.getLong(LEVEL_ID, LEVEL_ID_DEFAULT);
+	}
+
+	public static void setLevelId(long levelId) {
+		setLong(LEVEL_ID, levelId);
+	}
+
+	public static boolean isPerspectiveEnabled() {
+		return preferences.getBoolean(PERSPECTIVE_ENABLED, PERSPECTIVE_ENABLED_DEFAULT);
+	}
+
+	public static void setPerspectiveEnabled(boolean enabled) {
+		setBoolean(PERSPECTIVE_ENABLED, enabled);
+	}
+
+	public static boolean isShadowsEnabled() {
+		return preferences.getBoolean(SHADOWS_ENABLED, SHADOWS_ENABLED_DEFAULT);
+	}
+
+	public static void setShadowsEnabled(boolean enabled) {
+		setBoolean(SHADOWS_ENABLED, enabled);
+	}
+
+	public static boolean isDriverSpriteEnabled() {
+		return preferences.getBoolean(DRIVER_SPRITE_ENABLED, DRIVER_SPRITE_ENABLED_DEFAULT);
+	}
+
+	public static void setDriverSpriteEnabled(boolean enabled) {
+		setBoolean(DRIVER_SPRITE_ENABLED, enabled);
+	}
+
+	public static boolean isBikeSpriteEnabled() {
+		return preferences.getBoolean(BIKE_SPRITE_ENABLED, BIKE_SPRITE_ENABLED_DEFAULT);
+	}
+
+	public static void setBikeSpriteEnabled(boolean enabled) {
+		setBoolean(BIKE_SPRITE_ENABLED, enabled);
+	}
+
+	public static boolean isLookAheadEnabled() {
+		return preferences.getBoolean(LOOK_AHEAD_ENABLED, LOOK_AHEAD_ENABLED_DEFAULT);
+	}
+
+	public static void setLookAheadEnabled(boolean enabled) {
+		setBoolean(LOOK_AHEAD_ENABLED, enabled);
+	}
+
+	public static boolean isKeyboardInMenuEnabled() {
+		return preferences.getBoolean(KEYBOARD_IN_MENU_ENABLED, KEYBOARD_IN_MENU_ENABLED_DEFAULT);
+	}
+
+	public static void setKeyboardInMenuEnabled(boolean enabled) {
+		setBoolean(KEYBOARD_IN_MENU_ENABLED, enabled);
+	}
+
+	public static boolean isVibrateOnTouchEnabled() {
+		return preferences.getBoolean(VIBRATE_ENABLED, VIBRATE_ENABLED_DEFAULT);
+	}
+
+	public static void setVibrateOnTouchEnabled(boolean enabled) {
+		setBoolean(VIBRATE_ENABLED, enabled);
+	}
+
+	public static int getInputOption() {
+		return preferences.getInt(INPUT_OPTION, INPUT_OPTION_DEFAULT);
+	}
+
+	public static void setInputOption(int value) {
+		setInt(INPUT_OPTION, value);
+	}
+
+	public static long getLastSendStats() {
+		return preferences.getLong(LAST_SEND_STATS, LAST_SEND_STATS_DEFAULT);
+	}
+
+	public static void setLastSendStats(long value) {
+		setLong(LAST_SEND_STATS, value);
+	}
+
+	public static API.LevelsSortType getLevelsSort() {
+		return API.getSortTypeById(preferences.getInt(LEVELS_SORT, LEVELS_SORT_DEFAULT));
+	}
+
+	public static void setLevelsSort(API.LevelsSortType type) {
+		setInt(LEVELS_SORT, API.getIdBySortType(type));
+	}
+
+	public static void setLevelsSort(int type) {
+		setInt(LEVELS_SORT, type);
+	}
+
+	public static byte[] getName() {
+		String name = preferences.getString(NAME, NAME_DEFAULT);
+		if (name.length() < 3) {
+			name = NAME_DEFAULT;
+		}
+		return new byte[]{
+				(byte) name.charAt(0),
+				(byte) name.charAt(1),
+				(byte) name.charAt(2)
+		};
+	}
+
+	public static void setName(byte[] chars) {
+		if (chars.length < 3) {
+			setString(NAME, NAME_DEFAULT);
+		} else {
+			String name = "";
+			for (int i = 0; i < 3; i++) {
+				name += String.valueOf((char) chars[i]);
+			}
+			setString(NAME, name);
+		}
+	}
+
+	private static void setLong(String key, long value) {
+		SharedPreferences.Editor editor = preferences.edit();
+		editor.putLong(key, value);
+		editorApply(editor);
+	}
+
+	private static void setInt(String key, int value) {
+		SharedPreferences.Editor editor = preferences.edit();
+		editor.putInt(key, value);
+		editorApply(editor);
+	}
+
+	private static void setBoolean(String key, boolean value) {
+		SharedPreferences.Editor editor = preferences.edit();
+		editor.putBoolean(key, value);
+		editorApply(editor);
+	}
+
+	private static void setString(String key, String value) {
+		SharedPreferences.Editor editor = preferences.edit();
+		editor.putString(key, value);
+		editorApply(editor);
+	}
+
+	private static void editorApply(SharedPreferences.Editor editor) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD)
+			editor.apply();
+		else
+			editor.commit();
+	}
+
+}
diff --git a/src/org/happysanta/gd/Storage/HighScores.java b/src/org/happysanta/gd/Storage/HighScores.java
new file mode 100644
index 0000000..e3678c9
--- /dev/null
+++ b/src/org/happysanta/gd/Storage/HighScores.java
@@ -0,0 +1,152 @@
+package org.happysanta.gd.Storage;
+
+import org.happysanta.gd.Settings;
+
+public class HighScores {
+
+	private static final long MAX_TIME = 0xffff28L;
+
+	private long id;
+	private long levelId = 0;
+	private int level = 0;
+	private int track = 0;
+	private long[][] times = new long[4][3];
+	private String[][] names = new String[4][3];
+
+	public HighScores() {
+	}
+
+	public long getId() {
+		return id;
+	}
+
+	public void setId(long id) {
+		this.id = id;
+	}
+
+	public long getLevelId() {
+		return levelId;
+	}
+
+	public void setLevelId(long levelId) {
+		this.levelId = levelId;
+	}
+
+	public int getLevel() {
+		return level;
+	}
+
+	public void setLevel(int level) {
+		this.level = level;
+	}
+
+	public long getTrack() {
+		return track;
+	}
+
+	public void setTrack(int track) {
+		this.track = track;
+	}
+
+	public long getTime(int league, int place) {
+		return times[league][place];
+	}
+
+	public void setTime(int league, int place, long value) {
+		times[league][place] = value;
+	}
+
+	public String getName(int league, int place) {
+		return names[league][place];
+	}
+
+	public void setName(int league, int place, String value) {
+		names[league][place] = value;
+	}
+
+	public String[] getScores(int league) {
+		String[] scores = new String[3];
+		for (int places = 0; places < 3; places++) {
+			if (times[league][places] != 0L) {
+				int k = (int) times[league][places] / 100;
+				int l = (int) times[league][places] % 100;
+				scores[places] = names[league][places] + " ";
+				if (k / 60 < 10)
+					scores[places] += " 0" + k / 60;
+				else
+					scores[places] += " " + k / 60;
+				if (k % 60 < 10)
+					scores[places] += ":0" + k % 60;
+				else
+					scores[places] += ":" + k % 60;
+				if (l < 10)
+					scores[places] += ".0" + l;
+				else
+					scores[places] += "." + l;
+			} else {
+				scores[places] = null;
+			}
+		}
+
+		return scores;
+	}
+
+	public int getPlace(int league, long time) {
+		for (int place = 0; place < 3; place++)
+			if (times[league][place] > time || times[league][place] == 0L)
+				return place;
+
+		return 3;
+	}
+
+	private void clearTimes() {
+		for (int leagues = 0; leagues < 4; leagues++) {
+			for (int places = 0; places < 3; places++)
+				times[leagues][places] = 0L;
+		}
+	}
+
+	public void saveHighScore(int league, String name, long time) {
+		name = trimName(name);
+		int place;
+		if ((place = getPlace(league, time)) != 3) {
+			if (time > MAX_TIME)
+				time = MAX_TIME;
+			moveScoreEntries(league, place);
+
+			times[league][place] = time;
+			names[league][place] = name;
+		}
+	}
+
+	private void moveScoreEntries(int league, int i) {
+		for (int place = 2; place > i; place--) {
+			times[league][place] = times[league][place - 1];
+			names[league][place] = names[league][place - 1];
+		}
+	}
+
+	private static String trimName(String name) {
+		if (name.length() > 3)
+			name = name.substring(0, 3);
+		else if (name.length() < 3)
+			name = Settings.NAME_DEFAULT;
+
+		return name.toUpperCase();
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder s = new StringBuilder();
+		s.append("Storage.HighScores {");
+
+		s.append("id: " + id + ", ");
+		s.append("level_id: " + levelId + ", ");
+		s.append("level: " + level + ", ");
+		s.append("track: " + track);
+
+		s.append("}");
+		return s.toString();
+	}
+
+}
diff --git a/src/org/happysanta/gd/Storage/Level.java b/src/org/happysanta/gd/Storage/Level.java
new file mode 100644
index 0000000..3030b7b
--- /dev/null
+++ b/src/org/happysanta/gd/Storage/Level.java
@@ -0,0 +1,300 @@
+package org.happysanta.gd.Storage;
+
+import android.text.format.DateUtils;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+
+public class Level {
+
+	private long id = 0;
+	private String name;
+	private String author;
+	private int[] count;
+	private int size = 0;
+	private long addedTs = 0;
+	private long installedTs = 0;
+	private boolean _isDefault = false;
+	private long apiId = 0;
+	private int[] unlocked;
+	private int selectedTrack = 0;
+	private int selectedLevel = 0;
+	private int selectedLeague = 0;
+	private int unlockedLevels = 0;
+	private int unlockedLeagues = 0;
+
+	public Level() {
+		count = new int[3];
+		unlocked = new int[3];
+	}
+
+	public Level(long id, String name, String author, int countEasy, int countMedium, int countHard, int addedTs, int size, long apiId) {
+		this(id, name, author, countEasy, countMedium, countHard, addedTs, size, apiId, 0, 0, 0);
+	}
+
+	public Level(long id, String name, String author, int countEasy, int countMedium, int countHard, int addedTs, int size, long apiId, int unlockedEasy, int unlockedMedium, int unlockedHard) {
+		this.id = id;
+		this.name = name;
+		this.author = author;
+		this.count = new int[]{
+				countEasy, countMedium, countHard
+		};
+		this.addedTs = addedTs;
+		this.size = size;
+		this.apiId = apiId;
+		this.unlocked = new int[]{
+				unlockedEasy, unlockedMedium, unlockedHard
+		};
+	}
+
+	public long getId() {
+		return id;
+	}
+
+	public long getAnyId() {
+		return id > 0 ? id : apiId;
+	}
+
+	public void setId(long id) {
+		this.id = id;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getAuthor() {
+		return author;
+	}
+
+	public void setAuthor(String author) {
+		this.author = author;
+	}
+
+	public int getCountEasy() {
+		return this.count[0];
+	}
+
+	public int getCountMedium() {
+		return this.count[1];
+	}
+
+	public int getCountHard() {
+		return this.count[2];
+	}
+
+	public int getCount(int level) {
+		return this.count[level];
+	}
+
+	public void setCountEasy(int count) {
+		this.count[0] = count;
+	}
+
+	public void setCountMedium(int count) {
+		this.count[1] = count;
+	}
+
+	public void setCountHard(int count) {
+		this.count[2] = count;
+	}
+
+	public void setCount(int easy, int medium, int hard) {
+		setCountEasy(easy);
+		setCountMedium(medium);
+		setCountHard(hard);
+	}
+
+	public long getAddedTs() {
+		return addedTs;
+	}
+
+	public void setAddedTs(long ts) {
+		addedTs = ts;
+	}
+
+	public long getInstalledTs() {
+		return installedTs;
+	}
+
+	public void setInstalledTs(long ts) {
+		installedTs = ts;
+	}
+
+	public void setIsDefault(boolean isDefault) {
+		this._isDefault = isDefault;
+	}
+
+	public boolean isDefault() {
+		return _isDefault;
+	}
+
+	public long getApiId() {
+		return apiId;
+	}
+
+	public void setApiId(long apiId) {
+		this.apiId = apiId;
+	}
+
+	public int getSize() {
+		return size;
+	}
+
+	public void setSize(int size) {
+		this.size = size;
+	}
+
+	public boolean isInstalled() {
+		return id > 0;
+	}
+
+	public String getSizeKb() {
+		return String.valueOf(Math.round((size / 1024f) * 100f) / 100f);
+	}
+
+	public String getShortAddedDate() {
+		return getShortDate(addedTs);
+	}
+
+	public String getFullAddedDate() {
+		return getFullDate(addedTs);
+	}
+
+	public String getShortInstalledDate() {
+		return getShortDate(installedTs);
+	}
+
+	public String getFullInstalledDate() {
+		return getFullDate(installedTs);
+	}
+
+	public int getUnlockedEasy() {
+		return this.unlocked[0];
+	}
+
+	public int getUnlockedMedium() {
+		return this.unlocked[1];
+	}
+
+	public int getUnlockedHard() {
+		return this.unlocked[2];
+	}
+
+	public int getUnlocked(int level) {
+		//if (level < 3)
+		return unlocked[level];
+
+		//logDebug("Level.getUnlocked: level = " + level + ", out of bounds");
+		//return 0;
+	}
+
+	public int[] getUnlockedAll() {
+		return unlocked;
+	}
+
+	public void setUnlockedEasy(int unlocked) {
+		this.unlocked[0] = unlocked;
+	}
+
+	public void setUnlockedMedium(int unlocked) {
+		this.unlocked[1] = unlocked;
+	}
+
+	public void setUnlockedHard(int unlocked) {
+		this.unlocked[2] = unlocked;
+	}
+
+	public void setUnlocked(int easy, int medium, int hard) {
+		setUnlockedEasy(easy);
+		setUnlockedMedium(medium);
+		setUnlockedHard(hard);
+	}
+
+	public void setUnlocked(int level, int value) {
+		unlocked[level] = value;
+	}
+
+	public int getSelectedTrack() {
+		return selectedTrack;
+	}
+
+	public int getSelectedLevel() {
+		return selectedLevel;
+	}
+
+	public int getSelectedLeague() {
+		return selectedLeague;
+	}
+
+	public void setSelectedTrack(int selectedTrack) {
+		this.selectedTrack = selectedTrack;
+	}
+
+	public void setSelectedLevel(int selectedLevel) {
+		this.selectedLevel = selectedLevel;
+	}
+
+	public void setSelectedLeague(int selectedLeague) {
+		this.selectedLeague = selectedLeague;
+	}
+
+	public int getUnlockedLevels() {
+		return unlockedLevels;
+	}
+
+	public int getUnlockedLeagues() {
+		return unlockedLeagues;
+	}
+
+	public void setUnlockedLevels(int unlockedLevels) {
+		this.unlockedLevels = unlockedLevels;
+	}
+
+	public void setUnlockedLeagues(int unlockedLeagues) {
+		this.unlockedLeagues = unlockedLeagues;
+	}
+
+	public boolean isSettingsClear() {
+		return unlockedLevels == 0
+				&& unlocked[0] == 0
+				&& unlocked[1] == 0
+				&& unlocked[2] == 0;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder s = new StringBuilder();
+		s.append("Storage.Level {");
+
+		s.append("id: " + id + ", ");
+		s.append("name: \"" + name + "\", ");
+		s.append("author: \"" + author + "\", ");
+		s.append("count: " + count[0] + "/" + count[1] + "/" + count[2] + ", ");
+		s.append("added_ts: " + addedTs + ", ");
+		s.append("installed_ts: " + installedTs + ", ");
+		s.append("default: " + (_isDefault ? 1 : 0) + ", ");
+		s.append("api_id: " + apiId + ", ");
+		s.append("unlocked: " + unlocked[0] + "/" + unlocked[1] + "/" + unlocked[2] + ", ");
+		s.append("selected_track: " + selectedTrack + ", ");
+		s.append("selected_level: " + selectedLevel + ", ");
+		s.append("selected_league: " + selectedLeague + ", ");
+		s.append("unlocked_levels: " + unlockedLevels + ", ");
+		s.append("unlocked_leagues: " + unlockedLeagues);
+
+		s.append("}");
+		return s.toString();
+	}
+
+	private static String getShortDate(long date) {
+		return DateUtils.formatDateTime(getGDActivity(), date * 1000L, DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_ABBREV_MONTH);
+	}
+
+	private static String getFullDate(long date) {
+		return DateUtils.formatDateTime(getGDActivity(), date * 1000L, DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR);
+	}
+
+}
diff --git a/src/org/happysanta/gd/Storage/LevelsDataSource.java b/src/org/happysanta/gd/Storage/LevelsDataSource.java
new file mode 100644
index 0000000..40e7f14
--- /dev/null
+++ b/src/org/happysanta/gd/Storage/LevelsDataSource.java
@@ -0,0 +1,293 @@
+package org.happysanta.gd.Storage;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class LevelsDataSource {
+
+	private SQLiteDatabase db;
+	private LevelsSQLiteOpenHelper dbHelper;
+
+	public LevelsDataSource(Context context) {
+		dbHelper = new LevelsSQLiteOpenHelper(context);
+	}
+
+	public synchronized void open() throws SQLException {
+		db = dbHelper.getWritableDatabase();
+	}
+
+	public synchronized void close() {
+		dbHelper.close();
+	}
+
+	public synchronized Level createLevel(String name, String author, int countEasy, int countMedium, int countHard, long addedTs, long installedTs, boolean isDefault, long apiId) {
+		ContentValues values = new ContentValues();
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_NAME, name);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_AUTHOR, author);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_EASY, countEasy);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_MEDIUM, countMedium);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_HARD, countHard);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_ADDED, addedTs);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_INSTALLED, installedTs);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_IS_DEFAULT, isDefault ? 1 : 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID, apiId);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES, 0);
+
+		long insertId = db.insert(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, values);
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null,
+				LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + insertId,
+				null, null, null, null);
+
+		cursor.moveToFirst();
+
+		Level level = cursorToLevel(cursor);
+		cursor.close();
+		return level;
+	}
+
+	public synchronized void deleteLevel(Level level) {
+		long id = level.getId();
+		db.delete(LevelsSQLiteOpenHelper.TABLE_LEVELS, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + id, null);
+		db.delete(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID + " = " + id, null);
+	}
+
+	// This will also reset auto increment counter
+	public synchronized void deleteAllLevels() {
+		db.delete(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, null);
+		db.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" + LevelsSQLiteOpenHelper.TABLE_LEVELS + "'");
+	}
+
+	public synchronized void resetAllLevelsSettings() {
+		ContentValues values = new ContentValues();
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES, 0);
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS, 0);
+
+		int result = db.update(LevelsSQLiteOpenHelper.TABLE_LEVELS, values, null, null);
+		logDebug("LevelsDataSource.resetAllLevelsSettings: result = " + result);
+	}
+
+	public synchronized void updateLevel(Level level) {
+		ContentValues values = new ContentValues();
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY, level.getUnlockedEasy());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM, level.getUnlockedMedium());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD, level.getUnlockedHard());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE, level.getSelectedLeague());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL, level.getSelectedLevel());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK, level.getSelectedTrack());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES, level.getUnlockedLeagues());
+		values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS, level.getUnlockedLevels());
+
+		// logDebug("LevelsDataSource.updateLevel selectedLeague: " + level.getSelectedLeague());
+
+		db.update(LevelsSQLiteOpenHelper.TABLE_LEVELS, values, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + level.getId(), null);
+	}
+
+	public synchronized HashMap<Long, Long> findInstalledLevels(ArrayList<Long> apiIds) {
+		HashMap<Long, Long> installed = new HashMap<>();
+
+		String[] apiIdsArray = new String[apiIds.size()];
+		for (int i = 0; i < apiIdsArray.length; i++) {
+			apiIdsArray[i] = apiIds.get(i).toString();
+		}
+
+		Cursor cursor = db.rawQuery("SELECT " + LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID + ", " + LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " FROM " + LevelsSQLiteOpenHelper.TABLE_LEVELS + " WHERE " + LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID + " IN (" + makePlaceholders(apiIdsArray.length) + ")", apiIdsArray);
+		cursor.moveToFirst();
+
+		while (!cursor.isAfterLast()) {
+			long apiId = cursor.getLong(0),
+					id = cursor.getLong(1);
+			installed.put(apiId, id);
+			cursor.moveToNext();
+		}
+		cursor.close();
+
+		return installed;
+	}
+
+	public synchronized List<Level> getAllLevels() {
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, null, null, null, null, null);
+
+		List<Level> levels = levelsFromCursor(cursor);
+		cursor.close();
+
+		return levels;
+	}
+
+	public synchronized List<Level> getLevels(int offset, int count) {
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, null, null, null, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " ASC", offset + ", " + count);
+
+		List<Level> levels = levelsFromCursor(cursor);
+		cursor.close();
+
+		return levels;
+	}
+
+	public synchronized Level getLevel(long id) {
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + id, null, null, null, null);
+		cursor.moveToFirst();
+
+		Level level = null;
+		if (cursor.getCount() > 0) {
+			level = cursorToLevel(cursor);
+		}
+
+		cursor.close();
+		return level;
+	}
+
+	public List<Level> levelsFromCursor(Cursor cursor) {
+		cursor.moveToFirst();
+		List<Level> levels = new ArrayList<>();
+		while (!cursor.isAfterLast()) {
+			Level level = cursorToLevel(cursor);
+			levels.add(level);
+			cursor.moveToNext();
+		}
+		return levels;
+	}
+
+	public synchronized boolean isDefaultLevelCreated() {
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, new String[]{LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID}, LevelsSQLiteOpenHelper.LEVELS_COLUMN_IS_DEFAULT + " = 1", null, null, null, null);
+		boolean created = cursor.getCount() > 0;
+		cursor.close();
+		return created;
+	}
+
+	public synchronized boolean isApiIdInstalled(long apiId) {
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, new String[]{LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID}, LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID + " = " + apiId, null, null, null, null);
+		boolean installed = cursor.getCount() > 0;
+		cursor.close();
+		return installed;
+	}
+
+	public synchronized HighScores getHighScores(long levelId, int level, int track) {
+		Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, null,
+				LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID + " = " + levelId + " AND " + LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL + " = " + level + " AND " + LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_TRACK + " = " + track,
+				null, null, null, null);
+		cursor.moveToFirst();
+
+		HighScores highScores = new HighScores();
+		highScores.setLevelId(levelId);
+		highScores.setLevel(level);
+		highScores.setTrack(track);
+		if (cursor.getCount() > 0)
+			fillHighScoresFromCursor(cursor, highScores);
+		else {
+			long id = createEmptyHighScore(levelId, level, track);
+			highScores.setId(id);
+		}
+
+		cursor.close();
+		return highScores;
+	}
+
+	private synchronized long createEmptyHighScore(long levelId, int level, int track) {
+		ContentValues values = new ContentValues();
+		values.put(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID, levelId);
+		values.put(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL, level);
+		values.put(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_TRACK, track);
+		for (int league = 0; league < 4; league++) {
+			for (int place = 0; place < 3; place++) {
+				values.put(LevelsSQLiteOpenHelper.getHighscoresTimeColumn(league, place), 0);
+				values.put(LevelsSQLiteOpenHelper.getHighscoresNameColumn(league, place), 0);
+			}
+		}
+
+		long insertId = db.insert(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, null, values);
+		return insertId;
+	}
+
+	public synchronized void updateHighScores(HighScores scores) {
+		ContentValues values = new ContentValues();
+		for (int league = 0; league < 4; league++) {
+			for (int place = 0; place < 3; place++) {
+				values.put(LevelsSQLiteOpenHelper.getHighscoresTimeColumn(league, place), scores.getTime(league, place));
+				values.put(LevelsSQLiteOpenHelper.getHighscoresNameColumn(league, place), scores.getName(league, place));
+			}
+		}
+
+		db.update(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, values, LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_ID + " = " + scores.getId(), null);
+	}
+
+	public synchronized void clearHighScores(long levelId) {
+		db.delete(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES,
+				levelId > 0 ? LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID + " = " + levelId : null,
+				null);
+		if (levelId == 0) {
+			db.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" + LevelsSQLiteOpenHelper.TABLE_HIGHSCORES + "'");
+		}
+	}
+
+	private Level cursorToLevel(Cursor cursor) {
+		Level level = new Level();
+		level.setId(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID)));
+		level.setName(cursor.getString(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_NAME)));
+		level.setAuthor(cursor.getString(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_AUTHOR)));
+		level.setCount(
+				cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_EASY)),
+				cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_MEDIUM)),
+				cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_HARD)));
+		level.setAddedTs(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_ADDED)));
+		level.setInstalledTs(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_INSTALLED)));
+		level.setIsDefault(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_IS_DEFAULT)) == 1);
+		level.setApiId(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID)));
+		level.setUnlocked(
+				cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY)),
+				cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM)),
+				cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD)));
+		level.setSelectedLevel(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL)));
+		level.setSelectedTrack(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK)));
+		level.setSelectedLeague(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE)));
+		level.setUnlockedLevels(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS)));
+		level.setUnlockedLeagues(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES)));
+
+		return level;
+	}
+
+	private void fillHighScoresFromCursor(Cursor cursor, HighScores highScores) {
+		highScores.setId(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_ID)));
+
+		for (int league = 0; league < 4; league++) {
+			for (int place = 0; place < 3; place++) {
+				highScores.setTime(league, place, cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.getHighscoresTimeColumn(league, place))));
+				highScores.setName(league, place, cursor.getString(cursor.getColumnIndex(LevelsSQLiteOpenHelper.getHighscoresNameColumn(league, place))));
+			}
+		}
+	}
+
+	private String makePlaceholders(int len) {
+		if (len < 1) {
+			throw new RuntimeException("No placeholders");
+		} else {
+			StringBuilder sb = new StringBuilder(len * 2 - 1);
+			sb.append("?");
+			for (int i = 1; i < len; i++) {
+				sb.append(",?");
+			}
+			return sb.toString();
+		}
+	}
+
+}
diff --git a/src/org/happysanta/gd/Storage/LevelsManager.java b/src/org/happysanta/gd/Storage/LevelsManager.java
new file mode 100644
index 0000000..697c9ff
--- /dev/null
+++ b/src/org/happysanta/gd/Storage/LevelsManager.java
@@ -0,0 +1,503 @@
+package org.happysanta.gd.Storage;
+
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.os.AsyncTask;
+import android.os.Environment;
+import android.os.StatFs;
+import org.happysanta.gd.API.API;
+import org.happysanta.gd.API.DownloadFile;
+import org.happysanta.gd.API.DownloadHandler;
+import org.happysanta.gd.Callback;
+import org.happysanta.gd.DoubleCallback;
+import org.happysanta.gd.GDActivity;
+import org.happysanta.gd.Global;
+import org.happysanta.gd.Levels.LevelHeader;
+import org.happysanta.gd.Levels.Reader;
+import org.happysanta.gd.Menu.Menu;
+import org.happysanta.gd.Menu.MenuScreen;
+import org.happysanta.gd.R;
+import org.happysanta.gd.Settings;
+import org.acra.ACRA;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import static org.happysanta.gd.Helpers.getGDActivity;
+import static org.happysanta.gd.Helpers.getGameMenu;
+import static org.happysanta.gd.Helpers.getString;
+import static org.happysanta.gd.Helpers.getTimestamp;
+import static org.happysanta.gd.Helpers.isOnline;
+import static org.happysanta.gd.Helpers.logDebug;
+import static org.happysanta.gd.Helpers.showAlert;
+
+public class LevelsManager {
+
+	private LevelsDataSource dataSource;
+	private boolean dbOK = false;
+	private Level currentLevel;
+
+	public LevelsManager() {
+		GDActivity gd = getGDActivity();
+		dataSource = new LevelsDataSource(gd);
+
+		try {
+			dataSource.open();
+
+			if (!dataSource.isDefaultLevelCreated()) {
+				Level level = dataSource.createLevel("GDTR original", "Codebrew Software", 10, 10, 10, 0, 0, true, 1);
+				logDebug("LevelsManager: Default level created!");
+				logDebug(level);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+			logDebug("LevelsManager: db feels bad :(");
+			// return;
+		}
+
+		logDebug("LevelsManager: db feels OK :)");
+
+		// Shared prefs
+		// SharedPreferences settings = getSharedPreferences();
+		// long levelId = settings.getLong(PREFS_LEVEL_ID, 0);
+		long levelId = Settings.getLevelId();
+		if (levelId < 1 || !mrgIsAvailable(levelId)) {
+			logDebug("LevelsManager: levelId = " + levelId + ", < 1 or mrg is not available; now: reset id");
+			/*SharedPreferences.Editor editor = settings.edit();
+			editor.putLong(PREFS_LEVEL_ID, 1);
+			editor.commit();*/
+			resetId();
+		}
+
+		reload();
+		dbOK = true;
+	}
+
+	public void resetId() {
+		Settings.setLevelId(1);
+	}
+
+	public void reload() {
+		long id = Settings.getLevelId();
+		currentLevel = dataSource.getLevel(id);
+
+		if (currentLevel == null) {
+			logDebug("LevelsManager: failed to load currentLevel; currentId = " + id);
+		} else {
+			logDebug("LevelsManager: level = " + currentLevel);
+		}
+
+		if (Global.ACRA_ENABLED) {
+			ACRA.getErrorReporter().putCustomData("level_api_id:", String.valueOf(currentLevel.getApiId()));
+		}
+	}
+
+	public void closeDataSource() {
+		dataSource.close();
+	}
+
+	public long getCurrentId() {
+		return currentLevel.getId();
+	}
+
+	public void setCurrentId(long id) {
+		// currentId = id;
+		Settings.setLevelId(id);
+		/*SharedPreferences settings = getSharedPreferences();
+		SharedPreferences.Editor edit = settings.edit();
+		edit.putLong(PREFS_LEVEL_ID, id);
+		edit.commit();*/
+	}
+
+	public Level getCurrentLevel() {
+		return currentLevel;
+	}
+
+	public File getCurrentLevelsFile() {
+		if (currentLevel.getId() > 1)
+			return getMrgFileById(currentLevel.getId());
+
+		return null;
+	}
+
+	private boolean mrgIsAvailable(long id) {
+		if (id == 1) // This is default built-in levels.mrg
+			return true;
+
+		File file = getMrgFileById(id);
+		return isExternalStorageReadable() && file.exists();
+	}
+
+	public boolean isDbOK() {
+		return dbOK;
+	}
+
+	public long install(File file, String name, String author, long apiId) throws Exception {
+		if (!isSpaceAvailable(file.length())) {
+			throw new Exception(getString(R.string.e_no_space_left));
+		}
+
+		InputStream inputStream = new FileInputStream(file);
+		LevelHeader header = Reader.readHeader(inputStream);
+		try {
+			inputStream.close();
+		} catch (IOException e) {
+		}
+
+		if (!header.isCountsOk()) {
+			throw new IOException(file.getName() + " is not valid");
+		}
+
+		Level level = dataSource.createLevel(name, author, header.getCount(0), header.getCount(1), header.getCount(2), 0, getTimestamp(), false, apiId);
+		long id = level.getId();
+		if (id < 1) {
+			throw new Exception(getString(R.string.e_cannot_save_level));
+		}
+
+		File newFile = getMrgFileById(id);
+		copy(file, newFile);
+
+		return id;
+	}
+
+	public void installAsync(File file, String name, String author, long apiId, final DoubleCallback callback) {
+		GDActivity gd = getGDActivity();
+		final ProgressDialog progressDialog = ProgressDialog.show(gd, getString(R.string.install), getString(R.string.installing), true);
+
+		new AsyncInstallLevel() {
+			@Override
+			protected void onPostExecute(Object result) {
+				progressDialog.dismiss();
+
+				if (result instanceof Throwable) {
+					Throwable throwable = (Throwable) result;
+					throwable.printStackTrace();
+					showAlert(getString(R.string.error), throwable.getMessage(), null);
+					if (callback != null)
+						callback.onFail();
+					return;
+				}
+
+				if (callback != null)
+					callback.onDone((long) result);
+			}
+		}.execute(file, name, author, apiId);
+	}
+
+	public void load(Level level) throws RuntimeException {
+		/*File file = getMrgFileById(level.getId());
+		if (!mrgIsAvailable(level.getId())) {
+			throw new RuntimeException("Unable to load levels \"" +level.getName() + "\"");
+		}*/
+
+		// Loader loader = getLevelLoader();
+		// Menu menu = getGameMenu();
+
+		// loader.setLevelsFile(file);
+		// menu.reloadLevels();
+
+		setCurrentId(level.getId());
+		getGDActivity().restartApp();
+	}
+
+	public boolean isApiIdInstalled(long apiId) {
+		return dataSource.isApiIdInstalled(apiId);
+	}
+
+	public Level[] getInstalledLevels(int offset, int count) {
+		return dataSource.getLevels(offset, count).toArray(new Level[0]);
+	}
+
+	public Level getLeveL(long id) {
+		return dataSource.getLevel(id);
+	}
+
+	public Level[] getAllInstalledLevels() {
+		return dataSource.getAllLevels().toArray(new Level[0]);
+	}
+
+	public synchronized HashMap<String, Double> getLevelsStat() {
+		Level[] levels = getAllInstalledLevels();
+		HashMap<String, Double> stat = new HashMap<>();
+		if (levels.length > 0) {
+			for (Level level : levels) {
+				int[] completed = level.getUnlockedAll();
+				int completedCount = 0;
+				for (int i = 0; i < completed.length; i++) {
+					if (completed[i] < 0) completed[i] = 0;
+					completedCount += completed[i];
+				}
+
+				double totalCount = level.getCountEasy() + level.getCountMedium() + level.getCountHard();
+				double per = completedCount / totalCount * 100;
+
+				stat.put(String.valueOf(level.getApiId()), per);
+			}
+		}
+		return stat;
+	}
+
+	public void delete(Level level) {
+		dataSource.deleteLevel(level);
+		File file = getMrgFileById(level.getId());
+		try {
+			if (file.exists()) {
+				file.delete();
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void deleteAsync(Level level, final Runnable callback) {
+		GDActivity gd = getGDActivity();
+		final ProgressDialog progressDialog = ProgressDialog.show(gd, getString(R.string.delete), getString(R.string.deleting), true);
+
+		new AsyncDeleteLevel() {
+			@Override
+			protected void onPostExecute(Void v) {
+				progressDialog.dismiss();
+				if (callback != null)
+					callback.run();
+			}
+		}.execute(level);
+	}
+
+	public void updateLevelSettings() {
+		dataSource.updateLevel(currentLevel);
+	}
+
+	public void downloadLevel(final Level level, final Callback successCallback) {
+		final GDActivity gd = getGDActivity();
+		File outputDir = gd.getCacheDir();
+
+		try {
+			boolean readable = isExternalStorageReadable();
+			if (!readable) {
+				throw new Exception(getString(R.string.e_external_storage_is_not_readable));
+			}
+
+			if (!isOnline()) {
+				throw new Exception(getString(R.string.e_no_network_connection));
+			}
+
+			if (!isSpaceAvailable(level.getSize())) {
+				throw new Exception(getString(R.string.e_no_space_left));
+			}
+
+			final File outputFile = File.createTempFile("levels" + level.getApiId(), "mrg", outputDir);
+			FileOutputStream out = new FileOutputStream(outputFile);
+
+			// logDebug("downloadLevel: 4");
+			// final API api = new API();
+			final ProgressDialog progress;
+			final DownloadFile downloadFile = new DownloadFile(API.getMrgURL(level.getApiId()), out);
+
+			progress = new ProgressDialog(gd);
+			progress.setMessage(getString(R.string.downloading));
+			progress.setIndeterminate(true);
+			progress.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
+			progress.setCancelable(true);
+
+			final DownloadHandler handler = new DownloadHandler() {
+				@Override
+				public void onFinish(Throwable error) {
+					progress.dismiss();
+
+					if (error != null) {
+						// error.printStackTrace();
+						error.printStackTrace();
+						showAlert(getString(R.string.error), error.getMessage(), null);
+
+						outputFile.delete();
+						return;
+					}
+
+					// Install
+					installAsync(outputFile, level.getName(), level.getAuthor(), level.getApiId(), new DoubleCallback() {
+						@Override
+						public void onDone(Object... objects) {
+							long id = (long) objects[0];
+							outputFile.delete();
+
+							if (successCallback != null)
+								successCallback.onDone(id);
+						}
+
+						@Override
+						public void onFail() {
+							outputFile.delete();
+						}
+					});
+				}
+
+				@Override
+				public void onStart() {
+					progress.show();
+				}
+
+				@Override
+				public void onProgress(int pr) {
+					progress.setIndeterminate(false);
+					progress.setMax(100);
+					progress.setProgress(pr);
+				}
+			};
+			progress.setOnCancelListener(new DialogInterface.OnCancelListener() {
+				@Override
+				public void onCancel(DialogInterface dialog) {
+					downloadFile.cancel();
+					handler.onFinish(new InterruptedException(getString(R.string.e_downloading_was_interrupted)));
+				}
+			});
+
+			downloadFile.setDownloadHandler(handler);
+			downloadFile.start();
+		} catch (Exception e) {
+			showAlert(getString(R.string.error), e.getMessage(), null);
+		}
+	}
+
+	public void showSuccessfullyInstalledDialog() {
+		GDActivity gd = getGDActivity();
+		AlertDialog success = new AlertDialog.Builder(gd)
+				.setTitle(getString(R.string.installed))
+				.setMessage(getString(R.string.successfully_installed))
+				.setPositiveButton(getString(R.string.ok), null)
+				.setNegativeButton(getString(R.string.open_installed), new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						Menu menu = getGameMenu();
+						MenuScreen currentMenu = getGameMenu().getCurrentMenu(),
+								newMenu = menu.managerInstalledScreen;
+
+						if (currentMenu == menu.managerDownloadScreen || currentMenu.getNavTarget() == menu.managerDownloadScreen) {
+							menu.managerDownloadScreen.onHide(menu.managerScreen);
+						}
+
+						menu.setCurrentMenu(newMenu, false);
+					}
+				})
+				.create();
+		success.show();
+	}
+
+	public HashMap<Long, Long> findInstalledLevels(ArrayList<Long> apiIds) {
+		return dataSource.findInstalledLevels(apiIds);
+	}
+
+	public HighScores getHighScores(int level, int track) {
+		HighScores scores = dataSource.getHighScores(currentLevel.getId(), level, track);
+		// logDebug("LevelsManager.getHighScores: " + scores);
+		return scores;
+	}
+
+	public void saveHighScores(HighScores scores) {
+		dataSource.updateHighScores(scores);
+	}
+
+	public void clearHighScores() {
+		dataSource.clearHighScores(currentLevel.getId());
+	}
+
+	public void clearAllHighScores() {
+		dataSource.clearHighScores(0);
+	}
+
+	public void resetAllLevelsSettings() {
+		dataSource.resetAllLevelsSettings();
+
+		logDebug("All levels now: " + dataSource.getAllLevels());
+		logDebug("Level#1: " + dataSource.getLevel(1));
+	}
+
+	public static boolean isExternalStorageWritable() {
+		String state = Environment.getExternalStorageState();
+		if (Environment.MEDIA_MOUNTED.equals(state)) {
+			return true;
+		}
+		return false;
+	}
+
+	public static boolean isExternalStorageReadable() {
+		String state = Environment.getExternalStorageState();
+		if (Environment.MEDIA_MOUNTED.equals(state) ||
+				Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
+			return true;
+		}
+		return false;
+	}
+
+	public static File getLevelsDirectory() {
+		File file = new File(Environment.getExternalStorageDirectory(), "GDLevels");
+		if (!file.mkdirs()) {
+			logDebug("LevelsManager.getLevelsDirectory: directory not created");
+		}
+		return file;
+	}
+
+	public static String getMrgFileNameById(long id) {
+		return getLevelsDirectory().getAbsolutePath() + "/" + id + ".mrg";
+	}
+
+	public static File getMrgFileById(long id) {
+		if (id == 1) return null;
+		return new File(getMrgFileNameById(id));
+	}
+
+	public static void copy(File src, File dst) throws IOException {
+		InputStream in = new FileInputStream(src);
+		OutputStream out = new FileOutputStream(dst);
+
+		byte[] buf = new byte[1024];
+		int len;
+		while ((len = in.read(buf)) > 0) {
+			out.write(buf, 0, len);
+		}
+
+		in.close();
+		out.close();
+	}
+
+	public static boolean isSpaceAvailable(long bytes) {
+		StatFs stat = new StatFs(getLevelsDirectory().getPath());
+		long bytesAvailable = (long) stat.getBlockSize() * (long) stat.getAvailableBlocks();
+		return bytesAvailable >= bytes;
+	}
+
+	private class AsyncDeleteLevel extends AsyncTask<Level, Void, Void> {
+		@Override
+		protected Void doInBackground(Level... levels) {
+			delete(levels[0]);
+			return null;
+		}
+	}
+
+	private class AsyncInstallLevel extends AsyncTask<Object, Void, Object> {
+		@Override
+		protected Object doInBackground(Object... objects) {
+			File file = (File) objects[0];
+			String name = (String) objects[1];
+			String author = (String) objects[2];
+			long apiId = (long) objects[3];
+
+			long id = 0;
+			try {
+				id = install(file, name, author, apiId);
+			} catch (Throwable e) {
+				return e;
+			}
+
+			return id;
+		}
+	}
+
+}
diff --git a/src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java b/src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java
new file mode 100644
index 0000000..024a17f
--- /dev/null
+++ b/src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java
@@ -0,0 +1,141 @@
+package org.happysanta.gd.Storage;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+
+public class LevelsSQLiteOpenHelper extends SQLiteOpenHelper {
+
+	private static final int DATABASE_VERSION = 1;
+	private static final String DATABASE_NAME = "levels.db";
+
+	public static final String TABLE_LEVELS = "levels";
+	public static final String TABLE_HIGHSCORES = "highscores";
+
+	public static final String LEVELS_COLUMN_ID = "_id";
+	public static final String LEVELS_COLUMN_NAME = "name";
+	public static final String LEVELS_COLUMN_AUTHOR = "author";
+	public static final String LEVELS_COLUMN_COUNT_EASY = "count_easy";
+	public static final String LEVELS_COLUMN_COUNT_MEDIUM = "count_medium";
+	public static final String LEVELS_COLUMN_COUNT_HARD = "count_hard";
+	public static final String LEVELS_COLUMN_ADDED = "added_ts";
+	public static final String LEVELS_COLUMN_INSTALLED = "installed_ts";
+	public static final String LEVELS_COLUMN_IS_DEFAULT = "is_default";
+	public static final String LEVELS_COLUMN_API_ID = "api_id";
+	public static final String LEVELS_COLUMN_UNLOCKED_EASY = "unlocked_easy";
+	public static final String LEVELS_COLUMN_UNLOCKED_MEDIUM = "unlocked_medium";
+	public static final String LEVELS_COLUMN_UNLOCKED_HARD = "unlocked_hard";
+	public static final String LEVELS_COLUMN_SELECTED_LEVEL = "selected_level";
+	public static final String LEVELS_COLUMN_SELECTED_TRACK = "selected_track";
+	public static final String LEVELS_COLUMN_SELECTED_LEAGUE = "selected_league";
+	public static final String LEVELS_COLUMN_UNLOCKED_LEVELS = "unlocked_levels";
+	public static final String LEVELS_COLUMN_UNLOCKED_LEAGUES = "unlocked_leagues";
+
+	public static final String HIGHSCORES_COLUMN_ID = "_id";
+	public static final String HIGHSCORES_COLUMN_LEVEL_ID = "level_id";
+	public static final String HIGHSCORES_COLUMN_LEVEL = "level";
+	public static final String HIGHSCORES_COLUMN_TRACK = "track";
+
+	private static final String TABLE_LEVELS_CREATE = "CREATE TABLE "
+			+ TABLE_LEVELS + "("
+			+ LEVELS_COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "
+			+ LEVELS_COLUMN_NAME + " TEXT NOT NULL, "
+			+ LEVELS_COLUMN_AUTHOR + " TEXT NOT NULL, "
+			+ LEVELS_COLUMN_COUNT_EASY + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_COUNT_MEDIUM + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_COUNT_HARD + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_ADDED + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_INSTALLED + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_IS_DEFAULT + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_API_ID + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_UNLOCKED_EASY + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_UNLOCKED_MEDIUM + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_UNLOCKED_HARD + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_SELECTED_LEVEL + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_SELECTED_TRACK + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_SELECTED_LEAGUE + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_UNLOCKED_LEVELS + " INTEGER NOT NULL, "
+			+ LEVELS_COLUMN_UNLOCKED_LEAGUES + " INTEGER NOT NULL"
+			+ ");";
+
+	private static final String TABLE_HIGHSCORES_CREATE = " CREATE TABLE "
+			+ TABLE_HIGHSCORES + "("
+			+ HIGHSCORES_COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "
+			+ HIGHSCORES_COLUMN_LEVEL_ID + " INTEGER NOT NULL, "
+			+ HIGHSCORES_COLUMN_LEVEL + " INTEGER NOT NULL, "
+			+ HIGHSCORES_COLUMN_TRACK + " INTEGER NOT NULL, "
+
+			// 100cc
+			+ getHighscoresTimeColumn(0, 0) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(0, 0) + " TEXT, "
+			+ getHighscoresTimeColumn(0, 1) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(0, 1) + " TEXT, "
+			+ getHighscoresTimeColumn(0, 2) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(0, 2) + " TEXT, "
+
+			// 175cc
+			+ getHighscoresTimeColumn(1, 0) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(1, 0) + " TEXT, "
+			+ getHighscoresTimeColumn(1, 1) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(1, 1) + " TEXT, "
+			+ getHighscoresTimeColumn(1, 2) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(1, 2) + " TEXT, "
+
+			// 220cc
+			+ getHighscoresTimeColumn(2, 0) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(2, 0) + " TEXT, "
+			+ getHighscoresTimeColumn(2, 1) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(2, 1) + " TEXT, "
+			+ getHighscoresTimeColumn(2, 2) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(2, 2) + " TEXT, "
+
+			// 325cc
+			+ getHighscoresTimeColumn(3, 0) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(3, 0) + " TEXT, "
+			+ getHighscoresTimeColumn(3, 1) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(3, 1) + " TEXT, "
+			+ getHighscoresTimeColumn(3, 2) + " INTEGER NOT NULL, "
+			+ getHighscoresNameColumn(3, 2) + " TEXT"
+
+			+ ")";
+
+	LevelsSQLiteOpenHelper(Context context) {
+		super(context, DATABASE_NAME, null, DATABASE_VERSION);
+	}
+
+	@Override
+	public void onCreate(SQLiteDatabase db) {
+		db.execSQL(TABLE_LEVELS_CREATE);
+		createLevelsIndexes(db);
+
+		db.execSQL(TABLE_HIGHSCORES_CREATE);
+		createHighscoresIndexes(db);
+	}
+
+	@Override
+	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+
+	}
+
+	private void createLevelsIndexes(SQLiteDatabase db) {
+		db.execSQL("CREATE INDEX " + LEVELS_COLUMN_API_ID + "_index ON " + TABLE_LEVELS + "(" + LEVELS_COLUMN_API_ID + ")");
+		db.execSQL("CREATE INDEX " + LEVELS_COLUMN_IS_DEFAULT + "_index ON " + TABLE_LEVELS + "(" + LEVELS_COLUMN_IS_DEFAULT + ")");
+	}
+
+	private void createHighscoresIndexes(SQLiteDatabase db) {
+		db.execSQL("CREATE INDEX level_id_level_track_index ON " + TABLE_HIGHSCORES + "("
+				+ HIGHSCORES_COLUMN_LEVEL_ID + ", "
+				+ HIGHSCORES_COLUMN_LEVEL + ", "
+				+ HIGHSCORES_COLUMN_TRACK
+				+ ")");
+	}
+
+	public static String getHighscoresTimeColumn(int league, int place) {
+		return "l" + league + "_p" + place + "_time";
+	}
+
+	public static String getHighscoresNameColumn(int league, int place) {
+		return "l" + league + "_p" + place + "_name";
+	}
+
+}
diff --git a/src/org/happysanta/gd/Util/HexDump.java b/src/org/happysanta/gd/Util/HexDump.java
new file mode 100755
index 0000000..443555c
--- /dev/null
+++ b/src/org/happysanta/gd/Util/HexDump.java
@@ -0,0 +1,124 @@
+package org.happysanta.gd.Util;
+
+public class HexDump {
+	private final static char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+	public static String dumpHexString(byte[] array) {
+		return dumpHexString(array, 0, array.length);
+	}
+
+	public static String dumpHexString(byte[] array, int offset, int length) {
+		StringBuilder result = new StringBuilder();
+
+		byte[] line = new byte[16];
+		int lineIndex = 0;
+
+		result.append("\n0x");
+		result.append(toHexString(offset));
+
+		for (int i = offset; i < offset + length; i++) {
+			if (lineIndex == 16) {
+				result.append(" ");
+
+				for (int j = 0; j < 16; j++) {
+					if (line[j] > ' ' && line[j] < '~') {
+						result.append(new String(line, j, 1));
+					} else {
+						result.append(".");
+					}
+				}
+
+				result.append("\n0x");
+				result.append(toHexString(i));
+				lineIndex = 0;
+			}
+
+			byte b = array[i];
+			result.append(" ");
+			result.append(HEX_DIGITS[(b >>> 4) & 0x0F]);
+			result.append(HEX_DIGITS[b & 0x0F]);
+
+			line[lineIndex++] = b;
+		}
+
+		if (lineIndex != 16) {
+			int count = (16 - lineIndex) * 3;
+			count++;
+			for (int i = 0; i < count; i++) {
+				result.append(" ");
+			}
+
+			for (int i = 0; i < lineIndex; i++) {
+				if (line[i] > ' ' && line[i] < '~') {
+					result.append(new String(line, i, 1));
+				} else {
+					result.append(".");
+				}
+			}
+		}
+
+		return result.toString();
+	}
+
+	public static String toHexString(byte b) {
+		return toHexString(toByteArray(b));
+	}
+
+	public static String toHexString(byte[] array) {
+		return toHexString(array, 0, array.length);
+	}
+
+	public static String toHexString(byte[] array, int offset, int length) {
+		char[] buf = new char[length * 2];
+
+		int bufIndex = 0;
+		for (int i = offset; i < offset + length; i++) {
+			byte b = array[i];
+			buf[bufIndex++] = HEX_DIGITS[(b >>> 4) & 0x0F];
+			buf[bufIndex++] = HEX_DIGITS[b & 0x0F];
+		}
+
+		return new String(buf);
+	}
+
+	public static String toHexString(int i) {
+		return toHexString(toByteArray(i));
+	}
+
+	public static byte[] toByteArray(byte b) {
+		byte[] array = new byte[1];
+		array[0] = b;
+		return array;
+	}
+
+	public static byte[] toByteArray(int i) {
+		byte[] array = new byte[4];
+
+		array[3] = (byte) (i & 0xFF);
+		array[2] = (byte) ((i >> 8) & 0xFF);
+		array[1] = (byte) ((i >> 16) & 0xFF);
+		array[0] = (byte) ((i >> 24) & 0xFF);
+
+		return array;
+	}
+
+	private static int toByte(char c) {
+		if (c >= '0' && c <= '9') return (c - '0');
+		if (c >= 'A' && c <= 'F') return (c - 'A' + 10);
+		if (c >= 'a' && c <= 'f') return (c - 'a' + 10);
+
+		throw new RuntimeException("Invalid hex char '" + c + "'");
+	}
+
+	public static byte[] hexStringToByteArray(String hexString) {
+		int length = hexString.length();
+		byte[] buffer = new byte[length / 2];
+
+		for (int i = 0; i < length; i += 2) {
+			buffer[i / 2] = (byte) ((toByte(hexString.charAt(i)) << 4) | toByte(hexString.charAt(i + 1)));
+		}
+
+		return buffer;
+	}
+}
+
diff --git a/src/org/happysanta/gd/WaitForNetworkConnection.java b/src/org/happysanta/gd/WaitForNetworkConnection.java
new file mode 100644
index 0000000..d711715
--- /dev/null
+++ b/src/org/happysanta/gd/WaitForNetworkConnection.java
@@ -0,0 +1,34 @@
+package org.happysanta.gd;
+
+import android.os.AsyncTask;
+
+import static org.happysanta.gd.Helpers.isOnline;
+import static org.happysanta.gd.Helpers.logDebug;
+
+public class WaitForNetworkConnection extends AsyncTask<Object, Void, Void> {
+
+	protected Runnable callback;
+
+	@Override
+	public Void doInBackground(Object... params) {
+		callback = (Runnable) params[1];
+
+		while (!isOnline()) {
+			logDebug("Waiting for network...");
+			try {
+				Thread.sleep(1000);
+			} catch (InterruptedException e) {
+				break;
+			}
+		}
+
+		return null;
+	}
+
+	@Override
+	public void onPostExecute(Void v) {
+		logDebug("Network OK, callback.run() now...");
+		callback.run();
+	}
+
+}