Changed package name from org.hedgewars.mobile to org.hedgewars.hedgeroid to upload it to the market
--- a/hedgewars/options.inc Sun Oct 09 20:41:17 2011 +0200
+++ b/hedgewars/options.inc Thu Oct 20 22:54:34 2011 +0200
@@ -33,7 +33,7 @@
{$DEFINE S3D_DISABLED}
{$DEFINE GLunit:=gles11}
{$DEFINE MOBILE}
- {$DEFINE Java_Prefix := 'Java_org_hedgewars_mobile_EngineProtocol_PascalExports_'}
+ {$DEFINE Java_Prefix := 'Java_org_hedgewars_hedgeroid_EngineProtocol_PascalExports_'}
{$ENDIF}
{$IFDEF IPHONEOS}
--- a/project_files/Android-build/SDL-android-project/AndroidManifest.xml Sun Oct 09 20:41:17 2011 +0200
+++ b/project_files/Android-build/SDL-android-project/AndroidManifest.xml Thu Oct 20 22:54:34 2011 +0200
@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="org.hedgewars.mobile"
+ package="org.hedgewars.hedgeroid"
android:versionCode="3"
android:installLocation="preferExternal" android:versionName="0.1.10">
<uses-sdk android:targetSdkVersion="8" android:minSdkVersion="7"></uses-sdk>
--- a/project_files/Android-build/SDL-android-project/jni/SDL/src/core/android/SDL_android.cpp Sun Oct 09 20:41:17 2011 +0200
+++ b/project_files/Android-build/SDL-android-project/jni/SDL/src/core/android/SDL_android.cpp Thu Oct 20 22:54:34 2011 +0200
@@ -19,6 +19,9 @@
Sam Lantinga
slouken@libsdl.org
*/
+
+#define org_hedgewars_hedgeroid org_hedgewars_hedgeroid
+
#include "SDL_config.h"
#include "SDL_stdinc.h"
@@ -100,7 +103,7 @@
}
// Resize
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_onNativeResize(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_onNativeResize(
JNIEnv* env, jclass jcls,
jint width, jint height, jint format)
{
@@ -108,21 +111,21 @@
}
// Keydown
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_onNativeKeyDown(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_onNativeKeyDown(
JNIEnv* env, jclass jcls, jint keycode)
{
Android_OnKeyDown(keycode);
}
// Keyup
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_onNativeKeyUp(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_onNativeKeyUp(
JNIEnv* env, jclass jcls, jint keycode)
{
Android_OnKeyUp(keycode);
}
// Touch
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_onNativeTouch(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_onNativeTouch(
JNIEnv* env, jclass jcls,
jint action, jint pointerId, jfloat x, jfloat y, jfloat p)
{
@@ -130,7 +133,7 @@
}
// Accelerometer
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_onNativeAccel(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_onNativeAccel(
JNIEnv* env, jclass jcls,
jfloat x, jfloat y, jfloat z)
{
@@ -140,14 +143,14 @@
}
// Quit
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_nativeQuit(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_nativeQuit(
JNIEnv* env, jclass cls)
{
// Inject a SDL_QUIT event
SDL_SendQuit();
}
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_nativeRunAudioThread(
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_nativeRunAudioThread(
JNIEnv* env, jclass cls)
{
/* This is the audio thread, with a different environment */
--- a/project_files/Android-build/SDL-android-project/jni/SDL/src/main/android/SDL_android_main.cpp Sun Oct 09 20:41:17 2011 +0200
+++ b/project_files/Android-build/SDL-android-project/jni/SDL/src/main/android/SDL_android_main.cpp Thu Oct 20 22:54:34 2011 +0200
@@ -17,7 +17,7 @@
}
// Start up the SDL app
-extern "C" void Java_org_hedgewars_mobile_SDLActivity_nativeInit(JNIEnv* env, jclass cls, jobjectArray strArray)
+extern "C" void Java_org_hedgewars_hedgeroid_SDLActivity_nativeInit(JNIEnv* env, jclass cls, jobjectArray strArray)
{
/* This interface could expand with ABI negotiation, calbacks, etc. */
SDL_Android_Init(env, cls);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/Downloader/DownloadActivity.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,180 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.Downloader;
+
+import org.hedgewars.hedgeroid.MainActivity;
+import org.hedgewars.mobile.R;
+
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.preference.PreferenceManager;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class DownloadActivity extends Activity{
+ private Messenger messageService;
+ private boolean boundToService = false;
+
+ private TextView progress_sub;
+ private ProgressBar progress;
+ private Button positive, negative;
+
+ public static final int MSG_START = 0;
+ public static final int MSG_UPDATE = 1;
+ public static final int MSG_DONE = 2;
+ public static final int MSG_FAILED = 3;
+ private Handler.Callback messageCallback = new Handler.Callback() {
+
+ public boolean handleMessage(Message msg) {
+ switch(msg.what){
+ case MSG_START:
+ progress.setMax(msg.arg1);
+ progress_sub.setText(String.format("%dkb/%dkb\n%s", 0, msg.arg1, ""));
+ positive.setText(R.string.download_background);
+ positive.setOnClickListener(backgroundClicker);
+ negative.setText(R.string.download_cancel);
+ negative.setOnClickListener(cancelClicker);
+ break;
+ case MSG_UPDATE:
+ progress_sub.setText(String.format("%d%% - %dkb/%dkb\n%s",(msg.arg1*100)/msg.arg2, msg.arg1, msg.arg2, msg.obj));
+ progress.setProgress(msg.arg1);
+ break;
+ case MSG_DONE:
+ progress.setProgress(progress.getMax());
+ progress_sub.setText(R.string.download_done);
+
+ positive.setText(R.string.download_back);
+ positive.setOnClickListener(doneClicker);
+
+ negative.setVisibility(View.INVISIBLE);
+ break;
+ case MSG_FAILED:
+ progress.setProgress(progress.getMax());
+ progress_sub.setText(R.string.download_failed);
+ positive.setText(R.string.download_back);
+ positive.setOnClickListener(doneClicker);
+
+ negative.setText(R.string.download_tryagain);
+ negative.setOnClickListener(tryAgainClicker);
+ break;
+ }
+ return false;
+ }
+ };
+ private Handler messageHandler = new Handler(messageCallback);
+ private Messenger messenger = new Messenger(messageHandler);
+
+ public void onCreate(Bundle savedInstanceState){
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.download);
+
+ progress_sub = (TextView)findViewById(R.id.progressbar_sub);
+ progress = (ProgressBar)findViewById(R.id.progressbar);
+
+ positive = (Button) findViewById(R.id.background);
+ negative = (Button) findViewById(R.id.cancelDownload);
+ positive.setOnClickListener(backgroundClicker);
+ negative.setOnClickListener(cancelClicker);
+
+ }
+
+ private OnClickListener backgroundClicker = new OnClickListener(){
+ public void onClick(View v){
+ finish();
+ }
+ };
+ private OnClickListener cancelClicker = new OnClickListener(){
+ public void onClick(View v){
+ Intent i = new Intent(getApplicationContext(), DownloadService.class);
+ i.putExtra("taskID", DownloadService.TASKID_CANCEL);
+ startService(i);
+ finish();
+ }
+ };
+ private OnClickListener doneClicker = new OnClickListener(){
+ public void onClick(View v){
+ finish();
+ startActivity(new Intent(getApplicationContext(), MainActivity.class));
+ }
+ };
+
+ private OnClickListener tryAgainClicker = new OnClickListener(){
+ public void onClick(View v){
+ bindToService(DownloadService.TASKID_RETRY);
+ }
+ };
+
+ public void onStart(){
+ super.onStart();
+ bindToService(DownloadService.TASKID_START);
+ }
+
+ public void onStop(){
+ super.onStop();
+ unBindFromService();
+ }
+
+ private ServiceConnection connection = new ServiceConnection(){
+
+ public void onServiceConnected(ComponentName name, IBinder service) {
+ messageService = new Messenger(service);
+
+ try{
+ Message msg = Message.obtain(null, DownloadService.MSG_REGISTER_CLIENT);
+ msg.replyTo = messenger;
+ messageService.send(msg);
+
+ }catch (RemoteException e){}
+ }
+
+ public void onServiceDisconnected(ComponentName name) {
+ messageService = null;
+ }
+
+ };
+
+ private void bindToService(int taskId){
+ Intent i = new Intent(getApplicationContext(), DownloadService.class);
+ i.putExtra("taskID", taskId);
+ startService(i);
+ bindService(new Intent(getApplicationContext(), DownloadService.class), connection, Context.BIND_AUTO_CREATE);
+ boundToService = true;
+ }
+
+ private void unBindFromService(){
+ if(boundToService){
+ boundToService = false;
+ unbindService(connection);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/Downloader/DownloadAsyncTask.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,212 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.Downloader;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import android.os.AsyncTask;
+import android.util.Log;
+/**
+ * This is an AsyncTask which will download a zip from an URL and unzip it to a specified path
+ *
+ * a typical call to start the task would be new DownloadAsyncTask().execute(getExternalStorage(), "www.hedgewars.org/data.zip");
+ * @author Xeli
+ *
+ */
+public class DownloadAsyncTask extends AsyncTask<String, Object, Long> {
+
+ private final static String URL_WITHOUT_SUFFIX = "http://hedgewars.googlecode.com/files/data_5631.";
+ //private final static String URL_WITHOUT_SUFFIX = "http://www.xelification.com/tmp/firebutton.";
+ private final static String URL_ZIP_SUFFIX = "zip";
+ private final static String URL_HASH_SUFFIX = "hash";
+
+ private DownloadService service;
+ private long lastUpdateMillis = 0;
+
+ public DownloadAsyncTask(DownloadService _service){
+ service = _service;
+ }
+
+ /**
+ *
+ * @param params - 2 Strings, first is the path where the unzipped files will be stored, second is the URL to download from
+ */
+ protected Long doInBackground(String... params) {
+ HttpURLConnection conn = null;
+ MessageDigest digester = null;
+ String rootZipDest = params[0];
+
+ File rootDest = new File(rootZipDest);//TODO check for nullpointer, it hints to the absence of an sdcard
+ rootDest.mkdir();
+
+ try {
+ URL url = new URL(URL_WITHOUT_SUFFIX + URL_ZIP_SUFFIX);
+ conn = (HttpURLConnection)url.openConnection();
+ } catch (IOException e) {
+ e.printStackTrace();
+ return -1l;
+ }
+
+ String contentType = conn.getContentType();
+
+ if(contentType == null || contentType.contains("zip")){ //Seeing as we provide the url if the contentType is unknown lets assume zips
+ int bytesDecompressed = 0;
+ ZipEntry entry = null;
+ ZipInputStream input = null;
+ int kbytesToProcess = conn.getContentLength()/1024;
+
+ byte[] buffer = new byte[1024];
+ service.start(kbytesToProcess);
+
+ try {
+ digester = MessageDigest.getInstance("MD5");
+
+ } catch (NoSuchAlgorithmException e1) {
+ e1.printStackTrace();
+ }
+
+ try{
+ input = new ZipInputStream(conn.getInputStream());
+ entry = input.getNextEntry();
+ }catch(IOException e){
+ e.printStackTrace();
+ if(conn != null) conn.disconnect();
+ return -1l;
+ }
+
+ while(entry != null){
+ if(isCancelled()) break;
+
+ String fileName = entry.getName();
+ File f = new File(rootZipDest + fileName);
+ bytesDecompressed += entry.getCompressedSize();
+
+ if(entry.isDirectory()){
+ f.mkdir();
+ }else{
+ if(f.exists()){
+ f.delete();
+ }
+
+ FileOutputStream output = null;
+ try {
+ f.createNewFile();
+ output = new FileOutputStream(f);
+
+ int count = 0;
+ while((count = input.read(buffer)) != -1){
+ output.write(buffer, 0, count);
+ digester.update(buffer, 0, count);
+ if(System.currentTimeMillis() - lastUpdateMillis > 1000){
+ lastUpdateMillis = System.currentTimeMillis();
+ publishProgress(bytesDecompressed, kbytesToProcess, fileName);
+ }
+ }
+ output.flush();
+ input.closeEntry();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ if(conn != null) conn.disconnect();
+ return -1l;
+ } catch (IOException e) {
+ e.printStackTrace();
+ if(conn != null) conn.disconnect();
+ return -1l;
+ }finally{
+ try {
+ if( output != null) output.close();
+ } catch (IOException e) {}
+ }
+ }
+ try{
+ entry = input.getNextEntry();
+ }catch(IOException e){
+ e.printStackTrace();
+ if(conn != null) conn.disconnect();
+ return -1l;
+ }
+ }//end while(entry != null)
+
+ try {
+ input.close();
+ } catch (IOException e) {}
+ }//end if contentType == "zip"
+
+ if(conn != null) conn.disconnect();
+
+ if(checkMD5(digester))return 0l;
+ else return -1l;
+ }
+
+ //TODO proper result handling
+ protected void onPostExecute(Long result){
+ service.done(result > -1l);
+ }
+
+ protected void onProgressUpdate(Object...objects){
+ service.update((Integer)objects[0], (Integer)objects[1], (String)objects[2]);
+ }
+
+ private boolean checkMD5(MessageDigest digester){
+ if(digester != null) {
+ byte[] messageDigest = digester.digest();
+
+ try {
+ URL url = new URL(URL_WITHOUT_SUFFIX + URL_HASH_SUFFIX);
+ HttpURLConnection conn = (HttpURLConnection)url.openConnection();
+
+ byte[] buffer = new byte[1024];//size is large enough to hold the entire hash
+ BufferedInputStream bis = new BufferedInputStream(conn.getInputStream());
+ int bytesRead = bis.read(buffer);
+ if(bytesRead > -1){
+ String hash = new String(buffer, 0, bytesRead);
+ StringBuffer sb = new StringBuffer();
+ Integer tmp = 0;
+ for(int i = 0; i < messageDigest.length; i++){
+ tmp = 0xFF & messageDigest[i];
+ if(tmp < 0xF) sb.append('0');
+ sb.append(Integer.toHexString(tmp));
+ }
+ sb.append('\n');//add newline to become identical with the hash file
+
+ return hash.equals(sb.toString());
+ }
+ return false;
+ } catch (IOException e) {
+ e.printStackTrace();
+ return false;
+ }
+ }else{
+ return false;
+ }
+
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/Downloader/DownloadService.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,199 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.Downloader;
+
+import java.util.ArrayList;
+
+import org.hedgewars.hedgeroid.MainActivity;
+import org.hedgewars.hedgeroid.Utils;
+import org.hedgewars.mobile.R;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.preference.PreferenceManager;
+import android.util.Log;
+import android.widget.RemoteViews;
+
+public class DownloadService extends Service {
+
+ public static final String PREF_DOWNLOADED = "downloaded";
+ public static final int MSG_CANCEL = 0;
+ public static final int MSG_REGISTER_CLIENT = 1;
+ public static final int MSG_UNREGISTER_CLIENT = 2;
+
+ public static final int NOTIFICATION_PROCESSING = 0;
+ public static final int NOTIFICATION_DONE = 1;
+
+ private DownloadAsyncTask downloadTask;
+ private final Messenger messenger = new Messenger(new DownloadHandler());
+ private NotificationManager nM;
+ private RemoteViews contentView;
+ private Notification notification;
+
+ private ArrayList<Messenger> clientList = new ArrayList<Messenger>();
+ private Message onRegisterMessage = null;
+
+
+ class DownloadHandler extends Handler{
+
+ public void handleMessage(Message msg){
+ switch(msg.what){
+ case MSG_CANCEL:
+ downloadTask.cancel(false);
+ break;
+ case MSG_REGISTER_CLIENT:
+ clientList.add(msg.replyTo);
+ if(onRegisterMessage != null){
+ try {
+ msg.replyTo.send(Message.obtain(onRegisterMessage));
+ } catch (RemoteException e) {
+ e.printStackTrace();
+ }
+ }
+ break;
+ case MSG_UNREGISTER_CLIENT:
+ clientList.remove(msg.replyTo);
+ break;
+ }
+ }
+ }
+
+ public final static int TASKID_START = 0;
+ public final static int TASKID_CANCEL = 1;
+ public final static int TASKID_RETRY = 2;
+
+ public int onStartCommand(Intent intent, int flags, int startId){
+ switch(intent.getIntExtra("taskID", TASKID_START)){
+ case TASKID_RETRY:
+ if(downloadTask != null){
+ downloadTask.cancel(false);
+ downloadTask = null;
+ }
+ case TASKID_START:
+ nM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+
+ notification = new Notification(R.drawable.statusbar, getString(R.string.notification_title), System.currentTimeMillis());
+ //notification.flags |= Notification.FLAG_ONGOING_EVENT;// | Notification.FLAG_NO_CLEAR | Notification.FLAG_FOREGROUND_SERVICE;
+ notification.flags |= Notification.FLAG_ONGOING_EVENT;
+
+ contentView = new RemoteViews(getPackageName(), R.layout.notification);
+ contentView.setProgressBar(R.id.notification_progress, 100, 34, false);
+ notification.contentView = contentView;
+
+ PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, DownloadActivity.class), Intent.FLAG_ACTIVITY_NEW_TASK);
+ notification.contentIntent = contentIntent;
+
+ //nM.notify(NOTIFICATION_PROCESSING, notification);
+ startForeground(NOTIFICATION_PROCESSING, notification);
+
+ if(downloadTask == null){
+ downloadTask = new DownloadAsyncTask(this);
+ downloadTask.execute(Utils.getDownloadPath(this));
+ }
+ break;
+ case TASKID_CANCEL:
+ downloadTask.cancel(false);
+ stopService();
+ break;
+ }
+ return 0;
+ }
+
+ public void onDestroy(){
+ Log.e("bla", "onDestroy");
+ downloadTask.cancel(false);
+ }
+
+ public IBinder onBind(Intent intent) {
+ return messenger.getBinder();
+ }
+
+ /*
+ * Thread safe method to let clients know the processing is starting and will process int max kbytes
+ */
+ public void start(int max){
+ onRegisterMessage = Message.obtain(null, DownloadActivity.MSG_START, max, -1);
+ sendMessageToClients(onRegisterMessage);
+ }
+
+ /*
+ * periodically gets called by the ASyncTask, we can't tell for sure when it's called
+ */
+ public void update(int progress, int max, String fileName){
+ progress = (progress/1024);
+ updateNotification(progress, max, fileName);
+
+ sendMessageToClients(Message.obtain(null, DownloadActivity.MSG_UPDATE, progress, max, fileName));
+ }
+
+ /*
+ * Call back from the ASync task when the task has either run into an error or finished otherwise
+ */
+ public void done(boolean succesful){
+ if(succesful){
+ PreferenceManager.getDefaultSharedPreferences(this).edit().putBoolean(DownloadService.PREF_DOWNLOADED, true).commit();
+ sendMessageToClients(Message.obtain(null, DownloadActivity.MSG_DONE));
+ }else sendMessageToClients(Message.obtain(null, DownloadActivity.MSG_FAILED));
+ stopService();//stopService clears all notifications and thus must be called before we show the ready notification
+ showDoneNotification();
+ }
+
+ private void stopService(){
+ nM.cancelAll();
+ stopForeground(true);
+ stopSelf();
+ }
+
+ private void updateNotification(int progress, int max, String fileName){
+
+ contentView.setProgressBar(R.id.notification_progress, max, progress, false);
+ contentView.setTextViewText(R.id.progressbar_sub, String.format("%dkb/%dkb (Compressed sizes)", progress, max));
+ nM.notify(NOTIFICATION_PROCESSING, notification);
+ }
+
+ private void showDoneNotification(){
+ nM.cancelAll();
+ stopForeground(true);
+
+ String title = getString(R.string.notification_title);
+
+ notification = new Notification(R.drawable.icon, title, System.currentTimeMillis());
+ notification.flags |= Notification.FLAG_AUTO_CANCEL;
+ PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), Intent.FLAG_ACTIVITY_NEW_TASK);
+ notification.setLatestEventInfo(this, title, getString(R.string.notification_done), contentIntent);
+ nM.notify(NOTIFICATION_DONE, notification);
+ }
+ private void sendMessageToClients(Message msg){
+ for(Messenger m : clientList){
+ try {
+ m.send(Message.obtain(msg));
+ } catch (RemoteException e) {}//TODO should we catch this properly?
+ }
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/EngineProtocolNetwork.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,159 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+public class EngineProtocolNetwork extends Thread{
+
+ public static final String GAMEMODE_LOCAL = "TL";
+ public static final String GAMEMODE_DEMO = "TD";
+ public static final String GAMEMODE_NET = "TN";
+ public static final String GAMEMODE_SAVE = "TS";
+
+ public static final int BUFFER_SIZE = 255; //From iOS code which got it from the origional frontend
+
+ public static final int MODE_GENLANDPREVIEW = 0;
+ public static final int MODE_GAME = 1;
+
+ private ServerSocket serverSocket;
+ private InputStream input;
+ private OutputStream output;
+ public int port;
+ private final GameConfig config;
+ private boolean clientQuit = false;
+
+ public EngineProtocolNetwork(GameConfig _config){
+ config = _config;
+ try {
+ serverSocket = new ServerSocket(0);
+ port = serverSocket.getLocalPort();
+ Thread ipcThread = new Thread(this, "IPC - Thread");
+ ipcThread.start();
+ } catch (UnknownHostException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void run(){
+ //if(mode == MODE_GENLANDPREVIEW) genLandPreviewIPC();
+ /*else if (mode == MODE_GAME)*/ gameIPC();
+ }
+
+ private void gameIPC(){
+ Socket sock = null;
+ try{
+ sock = serverSocket.accept();
+ input = sock.getInputStream();
+ output = sock.getOutputStream();
+
+ int msgSize = 0;
+ byte[] buffer = new byte[BUFFER_SIZE];
+
+ while(!clientQuit){
+ msgSize = 0;
+
+ input.read(buffer, 0, 1);
+ msgSize = buffer[0];
+
+ input.read(buffer, 0, msgSize);
+ System.out.println("IPC" + (char)buffer[0] + " : " + new String(buffer, 1,msgSize-1, "US_ASCII"));
+ switch(buffer[0]){
+ case 'C'://game init
+ config.sendToEngine(this);
+ break;
+ case '?'://ping - pong
+ sendToEngine("!");
+ break;
+ case 'e'://Send protocol version
+ System.out.println(new String(buffer));
+ break;
+ case 'i'://game statistics
+ switch(buffer[1]){
+ case 'r'://winning team
+ break;
+ case 'D'://best shot
+ break;
+ case 'k'://best hedgehog
+ break;
+ case 'K'://# hogs killed
+ break;
+ case 'H'://team health graph
+ break;
+ case 'T':// local team stats
+ break;
+ case 'P'://teams ranking
+ break;
+ case 's'://self damage
+ break;
+ case 'S'://friendly fire
+ break;
+ case 'B'://turn skipped
+ break;
+ default:
+ }
+ break;
+ case 'E'://error - quits game
+ System.out.println(new String(buffer));
+ return;
+ case 'q'://game ended remove save file
+
+ return;
+ case 'Q'://game ended but not finished
+
+ return;
+ }
+
+ }
+ }catch(IOException e){
+ e.printStackTrace();
+ }finally{
+ try {
+ if(sock != null) sock.close();
+ } catch (IOException e) {}
+ try{
+ if(serverSocket != null) serverSocket.close();
+ } catch (IOException e) {}
+ }
+ }
+
+ public void sendToEngine(String s){
+ int length = s.length();
+
+ try {
+ output.write(length);
+ output.write(s.getBytes(), 0, length);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void quitIPC(){
+ clientQuit = true;
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/FrontendDataUtils.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,215 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+
+import org.hedgewars.hedgeroid.Utils;
+import org.hedgewars.hedgeroid.EngineProtocol.Map.MapType;
+import org.hedgewars.mobile.R;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+
+public class FrontendDataUtils {
+
+
+ public static ArrayList<Map> getMaps(Context c){
+ File[] files = Utils.getFilesFromRelativeDir(c,"Maps");
+ ArrayList<Map> ret = new ArrayList<Map>();
+
+ for(File f : files){
+ if(Utils.hasFileWithSuffix(f, ".lua")){
+ ret.add(new Map(f,MapType.TYPE_MISSION, c));
+ }else{
+ ret.add(new Map(f, MapType.TYPE_DEFAULT,c));
+ }
+ }
+ Collections.sort(ret);
+
+ return ret;
+ }
+
+ public static String[] getGameplay(Context c){
+ String[] files = Utils.getFileNamesFromRelativeDir(c, "Scripts/Multiplayer");
+ int retCounter = 0;
+
+ for(int i = 0; i < files.length; i++){
+ if(files[i].endsWith(".lua")){
+ files[i] = files[i].replace('_', ' ').substring(0, files[i].length()-4); //replace _ by a space and removed the last four characters (.lua)
+ retCounter++;
+ }else files[i] = null;
+ }
+ String[] ret = new String[retCounter];
+ retCounter = 0;
+ for(String s : files){
+ if(s != null) ret[retCounter++] = s;
+ }
+ Arrays.sort(ret);
+
+ return ret;
+ }
+
+ public static String[] getThemes(Context c){
+ return Utils.getDirsWithFileSuffix(c, "Themes", "icon.png");
+ }
+
+ public static ArrayList<Scheme> getSchemes(Context c){
+ return Scheme.getSchemes(c);
+ }
+
+ public static ArrayList<Weapon> getWeapons(Context c){
+ return Weapon.getWeapons(c);
+ }
+
+ public static ArrayList<HashMap<String, ?>> getGraves(Context c){
+ String pathPrefix = Utils.getDownloadPath(c) + "Graphics/Graves/";
+ ArrayList<String> names = Utils.getFilesFromDirWithSuffix(c, "Graphics/Graves", ".png", true);
+ ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(names.size());
+
+ for(String s : names){
+ HashMap<String, Object> map = new HashMap<String, Object>();
+ map.put("txt", s);
+ Bitmap b = BitmapFactory.decodeFile(pathPrefix + s + ".png");//create a full path - decode to to a bitmap
+ int width = b.getWidth();
+ if(b.getHeight() > width){//some pictures contain more 'frames' underneath each other, if so we only use the first frame
+ Bitmap tmp = Bitmap.createBitmap(b, 0, 0, width, width);
+ b.recycle();
+ b = tmp;
+ }
+ map.put("img", b);
+ data.add(map);
+ }
+ return data;
+ }
+
+ public static ArrayList<HashMap<String, ?>> getFlags(Context c){
+ String pathPrefix = Utils.getDownloadPath(c) + "Graphics/Flags/";
+ ArrayList<String> names = Utils.getFilesFromDirWithSuffix(c, "Graphics/Flags", ".png", true);
+ ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(names.size());
+
+ for(String s : names){
+ HashMap<String, Object> map = new HashMap<String, Object>();
+ map.put("txt", s);
+ Bitmap b = BitmapFactory.decodeFile(pathPrefix + s + ".png");//create a full path - decode to to a bitmap
+ map.put("img", b);
+ data.add(map);
+ }
+ return data;
+ }
+
+ public static ArrayList<String> getVoices(Context c){
+ File[] files = Utils.getFilesFromRelativeDir(c, "Sounds/voices");
+ ArrayList<String> ret = new ArrayList<String>();
+
+ for(File f : files){
+ if(f.isDirectory()) ret.add(f.getName());
+ }
+ return ret;
+ }
+
+ public static ArrayList<String> getForts(Context c){
+ return Utils.getFilesFromDirWithSuffix(c, "Forts", "L.png", true);
+ }
+ public static ArrayList<HashMap<String, ?>> getTypes(Context c){
+ ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(6);
+ String[] levels = {c.getString(R.string.human), c.getString(R.string.bot5), c.getString(R.string.bot4), c.getString(R.string.bot3), c.getString(R.string.bot2), c.getString(R.string.bot1)};
+ int[] images = {R.drawable.human, R.drawable.bot5, R.drawable.bot4, R.drawable.bot3, R.drawable.bot2, R.drawable.bot1};
+
+ for(int i = 0; i < levels.length; i++){
+ HashMap<String, Object> map = new HashMap<String, Object>();
+ map.put("txt", levels[i]);
+ map.put("img", images[i]);
+ data.add(map);
+ }
+
+ return data;
+ }
+
+ public static ArrayList<HashMap<String, ?>> getHats(Context c){
+ ArrayList<String> files = Utils.getFilesFromDirWithSuffix(c, "Graphics/Hats", ".png", true);
+ String pathPrefix = Utils.getDownloadPath(c) + "Graphics/Hats/";
+ int size = files.size();
+ ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(size);
+
+ HashMap<String, Object> hashmap;
+ for(String s : files){
+ hashmap = new HashMap<String, Object>();
+ hashmap.put("txt", s);
+ Bitmap b = BitmapFactory.decodeFile(pathPrefix + s + ".png");//create a full path - decode to to a bitmap
+ b = Bitmap.createBitmap(b, 0,0,b.getWidth()/2, b.getWidth()/2);
+ hashmap.put("img", b);
+ data.add(hashmap);
+ }
+
+ return data;
+ }
+
+ public static ArrayList<HashMap<String, Object>> getTeams(Context c){
+ ArrayList<HashMap<String, Object>> ret = new ArrayList<HashMap<String, Object>>();
+
+ File teamsDir = new File(c.getFilesDir().getAbsolutePath() + '/' + Team.DIRECTORY_TEAMS);
+ File[] teamFileNames = teamsDir.listFiles();
+ if(teamFileNames != null){
+ for(File s : teamFileNames){
+ Team t = Team.getTeamFromXml(s.getAbsolutePath());
+ if(t != null){
+ ret.add(teamToHashMap(t));
+ }
+ }
+ }
+ return ret;
+ }
+
+ public static HashMap<String, Object> teamToHashMap(Team t){
+ HashMap<String, Object> hashmap = new HashMap<String, Object>();
+ hashmap.put("team", t);
+ hashmap.put("txt", t.name);
+ hashmap.put("color", t.color);
+ hashmap.put("count", t.hogCount);
+ switch(t.levels[0]){
+ case 0:
+ hashmap.put("img", R.drawable.human);
+ break;
+ case 1:
+ hashmap.put("img", R.drawable.bot5);
+ break;
+ case 2:
+ hashmap.put("img", R.drawable.bot4);
+ break;
+ case 3:
+ hashmap.put("img", R.drawable.bot3);
+ break;
+ case 4:
+ hashmap.put("img", R.drawable.bot2);
+ break;
+ default:
+ case 5:
+ hashmap.put("img", R.drawable.bot1);
+ break;
+ }
+ return hashmap;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/GameConfig.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,117 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.UUID;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+
+public class GameConfig implements Parcelable{
+
+ public GameMode mode = GameMode.MODE_LOCAL;
+ public Map map = null;
+ public String theme = null;
+ public Scheme scheme = null;
+ public Weapon weapon = null;
+
+ public String mission = null;
+ public String seed = null;
+
+ public ArrayList<Team> teams = new ArrayList<Team>();
+
+ public GameConfig(){
+
+ }
+
+ public GameConfig(Parcel in){
+ readFromParcel(in);
+ }
+
+
+
+ public void sendToEngine(EngineProtocolNetwork epn) throws IOException{
+ Log.d("HW_Frontend", "Sending Gameconfig...");
+ int teamCount = 4;
+ epn.sendToEngine("TL"); //Write game mode
+ if(mission != null) epn.sendToEngine(mission);
+
+ //seed info
+ epn.sendToEngine(String.format("eseed {%s}", UUID.randomUUID().toString()));
+
+ map.sendToEngine(epn);
+ //dimensions of the map
+ //templatefilter_command
+ //mapgen_command
+ //mazesize_command
+
+ epn.sendToEngine(String.format("etheme %s", theme));
+
+ scheme.sendToEngine(epn);
+
+ weapon.sendToEngine(epn, teamCount);
+
+ for(Team t : teams){
+ if(t != null)t.sendToEngine(epn, teamCount, 50);
+ }
+ }
+
+ public int describeContents() {
+ return 0;
+ }
+
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(mode.name());
+ dest.writeParcelable(map, flags);
+ dest.writeString(theme);
+ dest.writeParcelable(scheme, flags);
+ dest.writeParcelable(weapon, flags);
+ dest.writeString(mission);
+ dest.writeString(seed);
+ dest.writeParcelableArray((Team[])teams.toArray(new Team[1]), 0);
+ }
+
+ private void readFromParcel(Parcel src){
+ mode = GameMode.valueOf(src.readString());
+ map = src.readParcelable(Map.class.getClassLoader());
+ theme = src.readString();
+ scheme = src.readParcelable(Scheme.class.getClassLoader());
+ weapon = src.readParcelable(Weapon.class.getClassLoader());
+ mission = src.readString();
+ seed = src.readString();
+ Parcelable[] parcelables = src.readParcelableArray(Team[].class.getClassLoader());
+ for(Parcelable team : parcelables){
+ teams.add((Team)team);
+ }
+
+ }
+
+ public static final Parcelable.Creator<GameConfig> CREATOR = new Parcelable.Creator<GameConfig>() {
+ public GameConfig createFromParcel(Parcel source) {
+ return new GameConfig(source);
+ }
+ public GameConfig[] newArray(int size) {
+ return new GameConfig[size];
+ }
+ };
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/GameMode.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,24 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+public enum GameMode {
+ MODE_LOCAL, MODE_DEMO, MODE_NET, MODE_SAVE
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/Grave.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,36 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+public class Grave{
+
+ public final String name;
+ public final String path;
+
+ public Grave(String _name, String _path) {
+ name = _name;
+ path = _path;
+ }
+
+ public String toString(){
+ return name;
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/Map.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,160 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.File;
+import java.io.IOException;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class Map implements Comparable<Map>, Parcelable{
+
+ private static final String MISSION_PREFIX = "Mission: ";
+
+ private String name;
+ private String path;
+ private String previewPath;
+ private MapType type;
+
+ public Map(File mapDir, MapType _type, Context c){
+ type = _type;
+
+ name = mapDir.getName();
+ path = mapDir.getAbsolutePath();
+ previewPath = path + "/preview.png";
+
+ /*switch(type){
+ case TYPE_DEFAULT:
+
+ break;
+ case TYPE_GENERATED:
+ //TODO
+ break;
+ case TYPE_MISSION:
+ name = MISSION_PREFIX + mapDir.getName();
+ path = mapDir.getAbsolutePath();
+ break;
+ }*/
+
+
+ }
+
+ public Map(Parcel in){
+ readFromParcel(in);
+ }
+
+ public String toString(){
+ switch(type){
+ default:
+ case TYPE_DEFAULT:
+ return name;
+ case TYPE_GENERATED:
+ return "bla";
+ case TYPE_MISSION:
+ return MISSION_PREFIX + name;
+ }
+ }
+
+ public void sendToEngine(EngineProtocolNetwork epn) throws IOException{
+ epn.sendToEngine(String.format("emap %s",name));
+ }
+
+ public MapType getType(){
+ return type;
+ }
+
+ public Drawable getDrawable(){
+ switch(type){
+ case TYPE_MISSION:
+ case TYPE_DEFAULT:
+ return Drawable.createFromPath(previewPath);
+ case TYPE_GENERATED:
+
+ default:
+ return null;
+ }
+ }
+
+ public int compareTo(Map another) {
+ switch(type){
+ case TYPE_GENERATED:
+ switch(another.getType()){
+ case TYPE_GENERATED:
+ return name.compareTo(another.name);
+ case TYPE_MISSION:
+ return -1;
+ case TYPE_DEFAULT:
+ return -1;
+ }
+ case TYPE_MISSION:
+ switch(another.getType()){
+ case TYPE_GENERATED:
+ return 1;
+ case TYPE_MISSION:
+ return name.compareTo(another.name);
+ case TYPE_DEFAULT:
+ return -1;
+ }
+ case TYPE_DEFAULT:
+ switch(another.getType()){
+ case TYPE_GENERATED:
+ return 1;
+ case TYPE_MISSION:
+ return 1;
+ case TYPE_DEFAULT:
+ return name.compareTo(another.name);
+ }
+ }
+ return 0;//default case this should never happen
+ }
+
+ public enum MapType{
+ TYPE_DEFAULT, TYPE_MISSION, TYPE_GENERATED
+ }
+
+ public int describeContents() {
+ return 0;
+ }
+
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(name);
+ dest.writeString(path);
+ dest.writeString(previewPath);
+ dest.writeString(type.name());
+ }
+
+ private void readFromParcel(Parcel src){
+ name = src.readString();
+ path = src.readString();
+ previewPath = src.readString();
+ type = MapType.valueOf(src.readString());
+ }
+ public static final Parcelable.Creator<Map> CREATOR = new Parcelable.Creator<Map>() {
+ public Map createFromParcel(Parcel source) {
+ return new Map(source);
+ }
+ public Map[] newArray(int size) {
+ return new Map[size];
+ }
+
+ };
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/PascalExports.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,40 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+public class PascalExports {
+
+ static{
+ System.loadLibrary("SDL");
+ System.loadLibrary("SDL_image");
+ System.loadLibrary("mikmod");
+ System.loadLibrary("SDL_net");
+ System.loadLibrary("SDL_mixer");
+ System.loadLibrary("SDL_ttf");
+ System.loadLibrary("lua5.1");
+ System.loadLibrary("hwengine");
+ }
+
+ public static native int HWversionInfoNetProto();
+ public static native String HWversionInfoVersion();
+ public static native int HWgetNumberOfWeapons();
+ public static native int HWgetMaxNumberOfTeams();
+ public static native int HWgetMaxNumberOfHogs();
+ public static native int HWterminate(boolean b);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/Scheme.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,358 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+import android.content.Context;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class Scheme implements Parcelable{
+
+ public static final String DIRECTORY_SCHEME = "schemes";
+
+ private String name;
+ //private ArrayList<Integer> basic;
+ private Integer gamemod;
+ private ArrayList<Integer> basic;;
+ private static ArrayList<LinkedHashMap<String, ?>> basicflags = new ArrayList<LinkedHashMap<String, ?>>();
+
+ public Scheme(String _name, ArrayList<Integer> _basic, int _gamemod){
+ name = _name;
+ gamemod = _gamemod;
+ basic = _basic;
+
+ }
+
+ public Scheme(Parcel in){
+ readFromParcel(in);
+ }
+
+ public void sendToEngine(EngineProtocolNetwork epn)throws IOException{
+ epn.sendToEngine(String.format("e$gmflags %d", gamemod));
+
+ for(int pos = 0; pos < basic.size(); pos++){
+ LinkedHashMap<String, ?> basicflag = basicflags.get(pos);
+
+ String command = (String)basicflag.get("command");
+ Integer value = basic.get(pos);
+ Boolean checkOverMax = (Boolean) basicflag.get("checkOverMax");
+ Boolean times1000 = (Boolean) basicflag.get("times1000");
+ Integer max = (Integer) basicflag.get("max");
+
+ if(checkOverMax && value >= max) value = max;
+ if(times1000) value *= 1000;
+
+ epn.sendToEngine(String.format("%s %d", command, value));
+ }
+ }
+ public String toString(){
+ return name;
+ }
+
+
+ public static final int STATE_START = 0;
+ public static final int STATE_ROOT = 1;
+ public static final int STATE_NAME = 2;
+ public static final int STATE_BASICFLAGS = 3;
+ public static final int STATE_GAMEMOD = 4;
+ public static final int STATE_BASICFLAG_INTEGER = 5;
+ public static final int STATE_GAMEMOD_TRUE = 6;
+ public static final int STATE_GAMEMOD_FALSE = 7;
+
+ public static ArrayList<Scheme> getSchemes(Context c) throws IllegalArgumentException{
+ String dir = c.getFilesDir().getAbsolutePath() + '/' + DIRECTORY_SCHEME + '/';
+ String[] files = new File(dir).list(fnf);
+ if(files == null) files = new String[]{};
+ Arrays.sort(files);
+ ArrayList<Scheme> schemes = new ArrayList<Scheme>();
+
+ try {
+ XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
+ XmlPullParser xmlPuller = xmlPullFactory.newPullParser();
+
+ for(String file : files){
+ BufferedReader br = new BufferedReader(new FileReader(dir + file), 1024);
+ xmlPuller.setInput(br);
+ String name = null;
+ ArrayList<Integer> basic = new ArrayList<Integer>();
+ Integer gamemod = 0;
+ int mask = 0x000000004;
+
+ int eventType = xmlPuller.getEventType();
+ int state = STATE_START;
+ while(eventType != XmlPullParser.END_DOCUMENT){
+ switch(state){
+ case STATE_START:
+ if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().equals("scheme")) state = STATE_ROOT;
+ else if(eventType != XmlPullParser.START_DOCUMENT) throwException(file, eventType);
+ break;
+ case STATE_ROOT:
+ if(eventType == XmlPullParser.START_TAG){
+ if(xmlPuller.getName().equals("basicflags")) state = STATE_BASICFLAGS;
+ else if(xmlPuller.getName().toLowerCase().equals("gamemod")) state = STATE_GAMEMOD;
+ else if(xmlPuller.getName().toLowerCase().equals("name")) state = STATE_NAME;
+ else throwException(file, eventType);
+ }else if(eventType == XmlPullParser.END_TAG) state = STATE_START;
+ else throwException(xmlPuller.getText(), eventType);
+ break;
+ case STATE_BASICFLAGS:
+ if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().toLowerCase().equals("integer")) state = STATE_BASICFLAG_INTEGER;
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_GAMEMOD:
+ if(eventType == XmlPullParser.START_TAG){
+ if(xmlPuller.getName().toLowerCase().equals("true")) state = STATE_GAMEMOD_TRUE;
+ else if(xmlPuller.getName().toLowerCase().equals("false")) state = STATE_GAMEMOD_FALSE;
+ else throwException(file, eventType);
+ }else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_NAME:
+ if(eventType == XmlPullParser.TEXT) name = xmlPuller.getText().trim();
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_BASICFLAG_INTEGER:
+ if(eventType == XmlPullParser.TEXT) basic.add(Integer.parseInt(xmlPuller.getText().trim()));
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_BASICFLAGS;
+ else throwException(file, eventType);
+ break;
+ case STATE_GAMEMOD_FALSE:
+ if(eventType == XmlPullParser.TEXT) gamemod <<= 1;
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_GAMEMOD;
+ else throwException(file, eventType);
+ break;
+ case STATE_GAMEMOD_TRUE:
+ if(eventType == XmlPullParser.TEXT){
+ gamemod |= mask;
+ gamemod <<= 1;
+ }else if(eventType == XmlPullParser.END_TAG) state = STATE_GAMEMOD;
+ else throwException(file, eventType);
+ break;
+ }
+ eventType = getEventType(xmlPuller);
+ }//end while(eventtype != END_DOCUMENT
+ schemes.add(new Scheme(name, basic, gamemod));
+ }//end for(string file : files
+ return schemes;
+ } catch (XmlPullParserException e) {
+ e.printStackTrace();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return new ArrayList<Scheme>();//TODO handle correctly
+ }
+
+ private static FilenameFilter fnf = new FilenameFilter(){
+ public boolean accept(File dir, String filename) {
+ return filename.toLowerCase().startsWith("scheme_");
+ }
+ };
+
+ /**
+ * This method will parse the basic flags from a prespecified xml file.
+ * I use a raw xml file rather than one parsed by aatp at compile time
+ * to keep it generic with other frontends, ie in the future we could
+ * use one provided by the Data folder.
+ */
+ public static void parseBasicFlags(Context c){
+ String filename = String.format("%s/%s/basicflags", c.getFilesDir().getAbsolutePath(), DIRECTORY_SCHEME);
+
+ XmlPullParser xmlPuller = null;
+ BufferedReader br = null;
+ try {
+ XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
+ xmlPuller = xmlPullFactory.newPullParser();
+ br = new BufferedReader(new FileReader(filename), 1024);
+ xmlPuller.setInput(br);
+
+ int eventType = getEventType(xmlPuller);
+ boolean continueParsing = true;
+ do{
+ switch(eventType){
+
+ case XmlPullParser.START_TAG:
+ if(xmlPuller.getName().toLowerCase().equals("flag")){
+ basicflags.add(parseFlag(xmlPuller));
+ }else if(xmlPuller.getName().toLowerCase().equals("basicflags")){
+ eventType = getEventType(xmlPuller);
+ }else{
+ skipCurrentTag(xmlPuller);
+ eventType = getEventType(xmlPuller);
+ }
+ break;
+ case XmlPullParser.START_DOCUMENT://ignore all tags not being "flag"
+ case XmlPullParser.END_TAG:
+ case XmlPullParser.TEXT:
+ default:
+ continueParsing = true;
+ case XmlPullParser.END_DOCUMENT:
+ continueParsing = false;
+ }
+ }while(continueParsing);
+
+ }catch(IOException e){
+ e.printStackTrace();
+ }catch (XmlPullParserException e) {
+ e.printStackTrace();
+ }finally{
+ if(br != null)
+ try {
+ br.close();
+ } catch (IOException e) {}
+ }
+
+ }
+
+ /*
+ * * Parses a Tag structure from xml as example we use
+ *<flag>
+ * <checkOverMax>
+ * <boolean>false</boolean>
+ * </checkOverMax>
+ *</flag>
+ *
+ * It returns a LinkedHashMap with key/value pairs
+ */
+ private static LinkedHashMap<String, Object> parseFlag(XmlPullParser xmlPuller)throws XmlPullParserException, IOException{
+ LinkedHashMap<String, Object> hash = new LinkedHashMap<String, Object>();
+
+ int eventType = xmlPuller.getEventType();//Get the event type which triggered this method
+ if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().toLowerCase().equals("flag")){//valid start of flag tag
+ String lcKey = null;
+ String lcType = null;
+ String value = null;
+
+ eventType = getEventType(xmlPuller);//<checkOverMax>
+ while(eventType == XmlPullParser.START_TAG){
+ lcKey = xmlPuller.getName();//checkOverMax
+ if(getEventType(xmlPuller) == XmlPullParser.START_TAG){//<boolean>
+ lcType = xmlPuller.getName().toLowerCase();
+ if(getEventType(xmlPuller) == XmlPullParser.TEXT){
+ value = xmlPuller.getText();
+ if(getEventType(xmlPuller) == XmlPullParser.END_TAG && //</boolean>
+ getEventType(xmlPuller) == XmlPullParser.END_TAG){//</checkOverMax>
+ if(lcType.equals("boolean")) hash.put(lcKey, new Boolean(value));
+ else if(lcType.equals("string"))hash.put(lcKey, value);
+ else if(lcType.equals("integer")){
+ try{
+ hash.put(lcKey, new Integer(value));
+ }catch (NumberFormatException e){
+ throw new XmlPullParserException("Wrong integer value in xml file");
+ }
+ }else{
+ throwException("basicflags", eventType);
+ }
+ }//</boolean> / </checkOverMax>
+ }//if TEXT
+ }//if boolean
+ eventType = getEventType(xmlPuller);//start new loop
+ }
+ eventType = getEventType(xmlPuller);//</flag>
+ }
+
+ return hash;
+ }
+
+ private static void skipCurrentTag(XmlPullParser xmlPuller) throws XmlPullParserException, IOException{
+ int eventType = xmlPuller.getEventType();
+ if(eventType != XmlPullParser.START_TAG)return;
+ String tag = xmlPuller.getName().toLowerCase();
+
+ while(true){
+ eventType = getEventType(xmlPuller);//getNext()
+ switch(eventType){
+ case XmlPullParser.START_DOCUMENT://we're inside of a start tag so START_ or END_DOCUMENT is just wrong
+ case XmlPullParser.END_DOCUMENT:
+ throw new XmlPullParserException("invalid xml file");
+ case XmlPullParser.START_TAG://if we get a new tag recursively handle it
+ skipCurrentTag(xmlPuller);
+ break;
+ case XmlPullParser.TEXT:
+ break;
+ case XmlPullParser.END_TAG:
+ if(!xmlPuller.getName().toLowerCase().equals(tag)){//if the end tag doesn't match the start tag
+ throw new XmlPullParserException("invalid xml file");
+ }else{
+ return;//skip completed
+ }
+
+ }
+ }
+ }
+
+ /**
+ * Skips whitespaces..
+ */
+ private static int getEventType(XmlPullParser xmlPuller)throws XmlPullParserException, IOException{
+ int eventType = xmlPuller.next();
+ while(eventType == XmlPullParser.TEXT && xmlPuller.isWhitespace()){
+ eventType = xmlPuller.next();
+ }
+ return eventType;
+ }
+ private static void throwException(String file, int eventType){
+ throw new IllegalArgumentException(String.format("Xml file: %s malformed with error: %d.", file, eventType));
+ }
+
+ public int describeContents() {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(name);
+ dest.writeInt(gamemod);
+ dest.writeList(basic);
+
+ }
+
+ public void readFromParcel(Parcel src){
+ name = src.readString();
+ gamemod = src.readInt();
+ basic = src.readArrayList(ArrayList.class.getClassLoader());
+ }
+
+ public static final Parcelable.Creator<Scheme> CREATOR = new Parcelable.Creator<Scheme>() {
+ public Scheme createFromParcel(Parcel source) {
+ return new Scheme(source);
+ }
+ public Scheme[] newArray(int size) {
+ return new Scheme[size];
+ }
+
+ };
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/Team.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,345 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+import org.xmlpull.v1.XmlSerializer;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Xml;
+
+public class Team implements Parcelable{
+
+ public static final String DIRECTORY_TEAMS = "teams";
+ private static final Integer[] TEAM_COLORS = {
+ 0xd12b42, /* red */
+ 0x4980c1, /* blue */
+ 0x6ab530, /* green */
+ 0xbc64c4, /* purple */
+ 0xe76d14, /* orange */
+ 0x3fb6e6, /* cyan */
+ 0xe3e90c, /* yellow */
+ 0x61d4ac, /* mint */
+ 0xf1c3e1, /* pink */
+ /* add new colors here */
+ };
+
+// private static final Integer[] TEAM_COLORS = {
+// 0xff0000, /* red */
+// 0x00ff00, /* blue */
+// 0x0000ff, /* green */
+// };
+
+ private static final int STATE_START = 0;
+ private static final int STATE_ROOT = 1;
+ private static final int STATE_HOG_ROOT = 2;
+
+ public String name, grave, flag, voice, fort, hash;
+
+ public static int maxNumberOfHogs = 0;
+ public static int maxNumberOfTeams = 0;
+
+ static{
+ maxNumberOfHogs = PascalExports.HWgetMaxNumberOfHogs();
+ maxNumberOfTeams = PascalExports.HWgetMaxNumberOfTeams();
+ }
+ public String[] hats = new String[maxNumberOfHogs];
+ public String[] hogNames = new String[maxNumberOfHogs];
+ public int[] levels = new int[maxNumberOfHogs];
+
+ public int hogCount = 4;
+ public int color = TEAM_COLORS[0];
+
+ public Team(){
+ }
+
+ public Team(Parcel in){
+ readFromParcel(in);
+ }
+
+ public boolean equals(Object o){
+ if(super.equals(o)) return true;
+ else if(o instanceof Team){
+ Team t = (Team)o;
+ boolean ret = name.equals(t.name);
+ ret &= grave.equals(t.grave);
+ ret &= flag.equals(t.flag);
+ ret &= voice.equals(t.voice);
+ ret &= fort.equals(t.fort);
+ ret &= hash.equals(t.hash);
+ return ret;
+ }else{
+ return false;
+ }
+ }
+
+ public void setRandomColor(int[] illegalcolors){
+ Integer[] colorsToPickFrom = TEAM_COLORS;
+ if(illegalcolors != null){
+ ArrayList<Integer> colors = new ArrayList<Integer>();
+ for(int color : TEAM_COLORS){
+ boolean validColor = true;
+ for(int illegal : illegalcolors){
+ if(color == illegal) validColor = false;
+ }
+ if(validColor) colors.add(color);
+ }
+ if(colors.size() != 0) colorsToPickFrom = colors.toArray(new Integer[1]);
+ }
+ int index = (int)Math.round(Math.random()*(colorsToPickFrom.length-1));
+ color = colorsToPickFrom[index];
+ }
+
+
+ public void sendToEngine(EngineProtocolNetwork epn, int hogCount, int health) throws IOException{
+ epn.sendToEngine(String.format("eaddteam %s %d %s", hash, color, name));
+ epn.sendToEngine(String.format("egrave %s", grave));
+ epn.sendToEngine(String.format("efort %s", fort));
+ epn.sendToEngine(String.format("evoicepack %s", voice));
+ epn.sendToEngine(String.format("eflag %s", flag));
+
+ for(int i = 0; i < hogCount; i++){
+ epn.sendToEngine(String.format("eaddhh %d %d %s", levels[i], health, hogNames[i]));
+ epn.sendToEngine(String.format("ehat %s", hats[i]));
+ }
+ }
+
+ /*
+ * XML METHODS
+ */
+
+ /**
+ * Read the xml file path and convert it to a Team object
+ * @param path absolute path to the xml file
+ * @return
+ */
+ public static Team getTeamFromXml(String path){
+ try {
+ XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
+ XmlPullParser xmlPuller = xmlPullFactory.newPullParser();
+
+ BufferedReader br = new BufferedReader(new FileReader(path), 1024);
+ xmlPuller.setInput(br);
+ Team team = new Team();
+ int hogCounter = 0;
+
+ int eventType = xmlPuller.getEventType();
+ int state = STATE_START;
+ while(eventType != XmlPullParser.END_DOCUMENT){
+ switch(state){
+ case STATE_START:
+ if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().equals("team")) state = STATE_ROOT;
+ else if(eventType != XmlPullParser.START_DOCUMENT) throwException(path, eventType);
+ break;
+ case STATE_ROOT:
+ if(eventType == XmlPullParser.START_TAG){
+ if(xmlPuller.getName().toLowerCase().equals("name")){
+ team.name = getXmlText(xmlPuller, "name");
+ }else if(xmlPuller.getName().toLowerCase().equals("flag")){
+ team.flag= getXmlText(xmlPuller, "flag");
+ }else if(xmlPuller.getName().toLowerCase().equals("voice")){
+ team.voice = getXmlText(xmlPuller, "voice");
+ }else if(xmlPuller.getName().toLowerCase().equals("grave")){
+ team.grave = getXmlText(xmlPuller, "grave");
+ }else if(xmlPuller.getName().toLowerCase().equals("fort")){
+ team.fort = getXmlText(xmlPuller, "fort");
+ }else if(xmlPuller.getName().toLowerCase().equals("hash")){
+ team.hash = getXmlText(xmlPuller, "hash");
+ }else if(xmlPuller.getName().toLowerCase().equals("hog")){
+ state = STATE_HOG_ROOT;
+ }else throwException(xmlPuller.getName(), eventType);
+ }else if(eventType == XmlPullParser.END_TAG) state = STATE_START;
+ else throwException(xmlPuller.getText(), eventType);
+ break;
+ case STATE_HOG_ROOT:
+ if(eventType == XmlPullParser.START_TAG){
+ if(xmlPuller.getName().toLowerCase().equals("name")){
+ team.hogNames[hogCounter] = getXmlText(xmlPuller, "name");
+ }else if(xmlPuller.getName().toLowerCase().equals("hat")){
+ team.hats[hogCounter] = getXmlText(xmlPuller, "hat");
+ }else if(xmlPuller.getName().toLowerCase().equals("level")){
+ team.levels[hogCounter] = Integer.parseInt(getXmlText(xmlPuller, "level"));
+ }else throwException(xmlPuller.getText(), eventType);
+ }else if(eventType == XmlPullParser.END_TAG){
+ hogCounter++;
+ state = STATE_ROOT;
+ }else throwException(xmlPuller.getText(), eventType);
+ break;
+ }
+ eventType = getEventType(xmlPuller);
+ }//end while(eventtype != END_DOCUMENT
+ return team;
+ } catch (NumberFormatException e){
+ e.printStackTrace();
+ } catch (XmlPullParserException e) {
+ e.printStackTrace();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ private static String getXmlText(XmlPullParser xmlPuller, String parentTag)throws XmlPullParserException, IOException{
+ if(getEventType(xmlPuller) == XmlPullParser.TEXT){
+ String txt = xmlPuller.getText();
+ if(getEventType(xmlPuller) == XmlPullParser.END_TAG && xmlPuller.getName().toLowerCase().equals(parentTag)){
+ return txt;
+ }
+ }
+ throw new XmlPullParserException("malformed xml file on string read from tag: " + parentTag);
+ }
+
+ /**
+ * Skips whitespaces..
+ */
+ private static int getEventType(XmlPullParser xmlPuller)throws XmlPullParserException, IOException{
+ int eventType = xmlPuller.next();
+ while(eventType == XmlPullParser.TEXT && xmlPuller.isWhitespace()){
+ eventType = xmlPuller.next();
+ }
+ return eventType;
+ }
+
+ private static void throwException(String file, int eventType){
+ throw new IllegalArgumentException(String.format("Xml file: %s malformed with error: %d.", file, eventType));
+ }
+
+ public void writeToXml(OutputStream os){
+ XmlSerializer serializer = Xml.newSerializer();
+ try{
+ serializer.setOutput(os, "UTF-8");
+ serializer.startDocument("UTF-8", true);
+ serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
+
+ serializer.startTag(null, "team");
+ serializer.startTag(null, "name");
+ serializer.text(name);
+ serializer.endTag(null, "name");
+ serializer.startTag(null, "flag");
+ serializer.text(flag);
+ serializer.endTag(null, "flag");
+ serializer.startTag(null, "fort");
+ serializer.text(fort);
+ serializer.endTag(null, "fort");
+ serializer.startTag(null, "grave");
+ serializer.text(grave);
+ serializer.endTag(null, "grave");
+ serializer.startTag(null, "voice");
+ serializer.text(voice);
+ serializer.endTag(null, "voice");
+ serializer.startTag(null, "hash");
+ serializer.text(hash);
+ serializer.endTag(null, "hash");
+
+ for(int i = 0; i < maxNumberOfHogs; i++){
+ serializer.startTag(null, "hog");
+ serializer.startTag(null, "name");
+ serializer.text(hogNames[i]);
+ serializer.endTag(null, "name");
+ serializer.startTag(null, "hat");
+ serializer.text(hats[i]);
+ serializer.endTag(null, "hat");
+ serializer.startTag(null, "level");
+ serializer.text(String.valueOf(levels[i]));
+ serializer.endTag(null, "level");
+
+ serializer.endTag(null, "hog");
+ }
+ serializer.endTag(null, "team");
+ serializer.endDocument();
+ serializer.flush();
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ }finally{
+ try {
+ os.close();
+ } catch (IOException e) {}
+ }
+ }
+ /*
+ * END XML METHODS
+ */
+
+
+
+ /*
+ * PARCABLE METHODS
+ */
+
+ public int describeContents() {
+ return 0;
+ }
+
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(name);
+ dest.writeString(grave);
+ dest.writeString(flag);
+ dest.writeString(voice);
+ dest.writeString(fort);
+ dest.writeString(hash);
+ dest.writeStringArray(hats);
+ dest.writeStringArray(hogNames);
+ dest.writeIntArray(levels);
+ dest.writeInt(color);
+ dest.writeInt(hogCount);
+ }
+
+
+ public void readFromParcel(Parcel src){
+ name = src.readString();
+ grave = src.readString();
+ flag = src.readString();
+ voice = src.readString();
+ fort = src.readString();
+ hash = src.readString();
+ src.readStringArray(hats);
+ src.readStringArray(hogNames);
+ src.readIntArray(levels);
+ color = src.readInt();
+ hogCount = src.readInt();
+ }
+
+ public static final Parcelable.Creator<Team> CREATOR = new Parcelable.Creator<Team>() {
+ public Team createFromParcel(Parcel source) {
+ return new Team(source);
+ }
+ public Team[] newArray(int size) {
+ return new Team[size];
+ }
+
+ };
+
+ /*
+ * END PARCABLE METHODS
+ */
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/EngineProtocol/Weapon.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,212 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.EngineProtocol;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+import android.content.Context;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class Weapon implements Parcelable{
+
+ public static final String DIRECTORY_WEAPON = "weapons";
+
+ private String name;
+ private String QT;
+ private String prob;
+ private String delay;
+ private String crate;
+ private static int maxWeapons;
+
+ static{
+ //maxWeapons = PascalExports.HWgetNumberOfWeapons();
+ }
+
+ public Weapon(String _name, String _QT, String _prob, String _delay, String _crate){
+ name = _name;
+
+ //Incase there's a newer ammoStore which is bigger we append with zeros
+ StringBuffer sb = new StringBuffer();
+ while(_QT.length() + sb.length() < maxWeapons){
+ sb.append('0');
+ }
+
+ QT = String.format("e%s %s%s", "ammloadt", _QT, sb);
+ prob = String.format("e%s %s%s", "ammprob", _prob, sb);
+ delay = String.format("e%s %s%s", "ammdelay", _delay, sb);
+ crate = String.format("e%s %s%s", "ammreinf", _crate, sb);
+ }
+
+ public Weapon(Parcel in){
+ readFromParcel(in);
+ }
+
+ public String toString(){
+ return name;
+ }
+
+ public void sendToEngine(EngineProtocolNetwork epn, int teamsCount) throws IOException{
+ epn.sendToEngine(QT);//command prefix is already in string
+ epn.sendToEngine(prob);
+ epn.sendToEngine(delay);
+ epn.sendToEngine(crate);
+
+ for(int i = 0; i < teamsCount; i++){
+ epn.sendToEngine("eammstore");
+ }
+ }
+
+ public static final int STATE_START = 0;
+ public static final int STATE_ROOT = 1;
+ public static final int STATE_NAME = 2;
+ public static final int STATE_QT = 3;
+ public static final int STATE_PROBABILITY = 4;
+ public static final int STATE_DELAY = 5;
+ public static final int STATE_CRATE = 6;
+
+ public static ArrayList<Weapon> getWeapons(Context c) throws IllegalArgumentException{
+ String dir = c.getFilesDir().getAbsolutePath() + '/' + DIRECTORY_WEAPON + '/';
+ String[] files = new File(dir).list();
+ if(files == null) files = new String[]{};
+ Arrays.sort(files);
+
+ ArrayList<Weapon> weapons = new ArrayList<Weapon>();
+
+ try {
+ XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
+ XmlPullParser xmlPuller = xmlPullFactory.newPullParser();
+
+ for(String file : files){
+ BufferedReader br = new BufferedReader(new FileReader(dir + file), 1024);
+ xmlPuller.setInput(br);
+ String name = null;
+ String qt = null;
+ String prob = null;
+ String delay = null;
+ String crate = null;
+
+ int eventType = xmlPuller.getEventType();
+ int state = STATE_START;
+ while(eventType != XmlPullParser.END_DOCUMENT){
+ switch(state){
+ case STATE_START:
+ if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().equals("weapon")) state = STATE_ROOT;
+ else if(eventType != XmlPullParser.START_DOCUMENT) throwException(file, eventType);
+ break;
+ case STATE_ROOT:
+ if(eventType == XmlPullParser.START_TAG){
+ if(xmlPuller.getName().toLowerCase().equals("qt")) state = STATE_QT;
+ else if(xmlPuller.getName().toLowerCase().equals("name")) state = STATE_NAME;
+ else if(xmlPuller.getName().toLowerCase().equals("probability")) state = STATE_PROBABILITY;
+ else if(xmlPuller.getName().toLowerCase().equals("delay")) state = STATE_DELAY;
+ else if(xmlPuller.getName().toLowerCase().equals("crate")) state = STATE_CRATE;
+ else throwException(file, eventType);
+ }else if(eventType == XmlPullParser.END_TAG) state = STATE_START;
+ else throwException(xmlPuller.getText(), eventType);
+ break;
+ case STATE_NAME:
+ if(eventType == XmlPullParser.TEXT) name = xmlPuller.getText().trim();
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_QT:
+ if(eventType == XmlPullParser.TEXT) qt = xmlPuller.getText().trim();
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_PROBABILITY:
+ if(eventType == XmlPullParser.TEXT) prob = xmlPuller.getText().trim();
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_DELAY:
+ if(eventType == XmlPullParser.TEXT) delay = xmlPuller.getText().trim();
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ case STATE_CRATE:
+ if(eventType == XmlPullParser.TEXT) crate = xmlPuller.getText().trim();
+ else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
+ else throwException(file, eventType);
+ break;
+ }
+ eventType = xmlPuller.next();
+ while(eventType == XmlPullParser.TEXT && xmlPuller.isWhitespace()){//Skip whitespaces
+ eventType = xmlPuller.next();
+ }
+ }//end while(eventtype != END_DOCUMENT
+ weapons.add(new Weapon(name, qt, prob, delay, crate));
+ }//end for(string file : files
+ return weapons;
+
+ } catch (XmlPullParserException e) {
+ e.printStackTrace();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return new ArrayList<Weapon>();//TODO handle correctly
+ }
+
+ private static void throwException(String file, int eventType){
+ throw new IllegalArgumentException(String.format("Xml file: %s malformed with eventType: %d.", file, eventType));
+ }
+
+ public int describeContents() {
+ return 0;
+ }
+
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(name);
+ dest.writeString(QT);
+ dest.writeString(prob);
+ dest.writeString(delay);
+ dest.writeString(crate);
+ }
+
+ private void readFromParcel(Parcel src){
+ name = src.readString();
+ QT = src.readString();
+ prob = src.readString();
+ delay = src.readString();
+ crate = src.readString();
+ }
+
+ public static final Parcelable.Creator<Weapon> CREATOR = new Parcelable.Creator<Weapon>() {
+ public Weapon createFromParcel(Parcel source) {
+ return new Weapon(source);
+ }
+ public Weapon[] newArray(int size) {
+ return new Weapon[size];
+ }
+
+ };
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/MainActivity.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,68 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid;
+
+import org.hedgewars.hedgeroid.Downloader.DownloadActivity;
+import org.hedgewars.hedgeroid.Downloader.DownloadService;
+import org.hedgewars.mobile.R;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.Toast;
+
+public class MainActivity extends Activity {
+
+ Button downloader, startGame;
+
+ public void onCreate(Bundle sis){
+ super.onCreate(sis);
+ setContentView(R.layout.main);
+
+ downloader = (Button)findViewById(R.id.downloader);
+ startGame = (Button)findViewById(R.id.startGame);
+
+ downloader.setOnClickListener(downloadClicker);
+ startGame.setOnClickListener(startGameClicker);
+ }
+
+
+
+ private OnClickListener downloadClicker = new OnClickListener(){
+ public void onClick(View v){
+ startActivityForResult(new Intent(getApplicationContext(), DownloadActivity.class), 0);
+ }
+ };
+
+ private OnClickListener startGameClicker = new OnClickListener(){
+ public void onClick(View v){
+ if(PreferenceManager.getDefaultSharedPreferences(MainActivity.this).getBoolean(DownloadService.PREF_DOWNLOADED, false))
+ startActivity(new Intent(getApplicationContext(), StartGameActivity.class));
+ else {
+ Toast.makeText(MainActivity.this, R.string.download_userexplain, Toast.LENGTH_LONG).show();
+ startActivityForResult(new Intent(getApplicationContext(), DownloadActivity.class), 0);
+ }
+ }
+ };
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/SDLActivity.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,565 @@
+package org.hedgewars.hedgeroid;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.egl.EGLSurface;
+
+import org.hedgewars.hedgeroid.EngineProtocol.EngineProtocolNetwork;
+import org.hedgewars.hedgeroid.EngineProtocol.GameConfig;
+import org.hedgewars.hedgeroid.EngineProtocol.PascalExports;
+import org.hedgewars.hedgeroid.TouchInterface.TouchInterface;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.PixelFormat;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioTrack;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+
+/**
+ * SDL Activity
+ */
+public class SDLActivity extends Activity {
+
+ // Main components
+ public static SDLActivity mSingleton;
+ public static SDLSurface mSurface;
+
+ // Audio
+ private static Thread mAudioThread;
+ private static AudioTrack mAudioTrack;
+
+ // Load the .so
+ static {
+ System.loadLibrary("SDL");
+ System.loadLibrary("SDL_image");
+ System.loadLibrary("mikmod");
+ System.loadLibrary("SDL_net");
+ System.loadLibrary("SDL_mixer");
+ System.loadLibrary("SDL_ttf");
+ System.loadLibrary("lua5.1");
+ System.loadLibrary("hwengine");
+ System.loadLibrary("main");
+ }
+
+ // Setup
+ protected void onCreate(Bundle savedInstanceState) {
+ // Log.v("SDL", "onCreate()");
+ super.onCreate(savedInstanceState);
+
+ // So we can call stuff from static callbacks
+ mSingleton = this;
+
+ // Set up the surface
+ GameConfig config = getIntent().getParcelableExtra("config");
+ mSurface = new SDLSurface(getApplication(), config);
+ setContentView(mSurface);
+ SurfaceHolder holder = mSurface.getHolder();
+ holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
+ }
+
+ // Events
+ protected void onPause() {
+ // Log.v("SDL", "onPause()");
+ super.onPause();
+
+ }
+
+ protected void onResume() {
+ // Log.v("SDL", "onResume()");
+ super.onResume();
+ }
+
+ public void onBackPressed(){
+ nativeQuit();
+ super.onBackPressed();
+ }
+
+ // Messages from the SDLMain thread
+ static int COMMAND_CHANGE_TITLE = 1;
+
+ // Handler for the messages
+ Handler commandHandler = new Handler() {
+ public void handleMessage(Message msg) {
+ if (msg.arg1 == COMMAND_CHANGE_TITLE) {
+ setTitle((String) msg.obj);
+ }
+ }
+ };
+
+ // Send a message from the SDLMain thread
+ void sendCommand(int command, Object data) {
+ Message msg = commandHandler.obtainMessage();
+ msg.arg1 = command;
+ msg.obj = data;
+ commandHandler.sendMessage(msg);
+ }
+
+ // C functions we call
+ public static native void nativeInit(String[] argv);
+
+ public static native void nativeQuit();
+
+ public static native void onNativeResize(int x, int y, int format);
+
+ public static native void onNativeKeyDown(int keycode);
+
+ public static native void onNativeKeyUp(int keycode);
+
+ public static native void onNativeTouch(int action, int pointer, float x, float y,
+ float p);
+
+ public static native void onNativeAccel(float x, float y, float z);
+
+ public static native void nativeRunAudioThread();
+
+ // Java functions called from C
+
+ public static boolean createGLContext(int majorVersion, int minorVersion) {
+ return mSurface.initEGL(majorVersion, minorVersion);
+ }
+
+ public static void flipBuffers() {
+ mSurface.flipEGL();
+ }
+
+ public static void setActivityTitle(String title) {
+ // Called from SDLMain() thread and can't directly affect the view
+ mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
+ }
+
+ // Audio
+ private static Object buf;
+
+ public static Object audioInit(int sampleRate, boolean is16Bit,
+ boolean isStereo, int desiredFrames) {
+ int channelConfig = isStereo ? AudioFormat.CHANNEL_CONFIGURATION_STEREO
+ : AudioFormat.CHANNEL_CONFIGURATION_MONO;
+ int audioFormat = is16Bit ? AudioFormat.ENCODING_PCM_16BIT
+ : AudioFormat.ENCODING_PCM_8BIT;
+ int frameSize = (isStereo ? 2 : 1) * (is16Bit ? 2 : 1);
+
+ Log.v("SDL", "SDL audio: wanted " + (isStereo ? "stereo" : "mono")
+ + " " + (is16Bit ? "16-bit" : "8-bit") + " "
+ + ((float) sampleRate / 1000f) + "kHz, " + desiredFrames
+ + " frames buffer");
+
+ // Let the user pick a larger buffer if they really want -- but ye
+ // gods they probably shouldn't, the minimums are horrifyingly high
+ // latency already
+ desiredFrames = Math.max(
+ desiredFrames,
+ (AudioTrack.getMinBufferSize(sampleRate, channelConfig,
+ audioFormat) + frameSize - 1)
+ / frameSize);
+
+ mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
+ channelConfig, audioFormat, desiredFrames * frameSize,
+ AudioTrack.MODE_STREAM);
+
+ audioStartThread();
+
+ Log.v("SDL",
+ "SDL audio: got "
+ + ((mAudioTrack.getChannelCount() >= 2) ? "stereo"
+ : "mono")
+ + " "
+ + ((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit"
+ : "8-bit") + " "
+ + ((float) mAudioTrack.getSampleRate() / 1000f)
+ + "kHz, " + desiredFrames + " frames buffer");
+
+ if (is16Bit) {
+ buf = new short[desiredFrames * (isStereo ? 2 : 1)];
+ } else {
+ buf = new byte[desiredFrames * (isStereo ? 2 : 1)];
+ }
+ return buf;
+ }
+
+ public static void audioStartThread() {
+ mAudioThread = new Thread(new Runnable() {
+ public void run() {
+ mAudioTrack.play();
+ nativeRunAudioThread();
+ }
+ });
+
+ // I'd take REALTIME if I could get it!
+ mAudioThread.setPriority(Thread.MAX_PRIORITY);
+ mAudioThread.start();
+ }
+
+ public static void audioWriteShortBuffer(short[] buffer) {
+ for (int i = 0; i < buffer.length;) {
+ int result = mAudioTrack.write(buffer, i, buffer.length - i);
+ if (result > 0) {
+ i += result;
+ } else if (result == 0) {
+ try {
+ Thread.sleep(1);
+ } catch (InterruptedException e) {
+ // Nom nom
+ }
+ } else {
+ Log.w("SDL", "SDL audio: error return from write(short)");
+ return;
+ }
+ }
+ }
+
+ public static void audioWriteByteBuffer(byte[] buffer) {
+ for (int i = 0; i < buffer.length;) {
+ int result = mAudioTrack.write(buffer, i, buffer.length - i);
+ if (result > 0) {
+ i += result;
+ } else if (result == 0) {
+ try {
+ Thread.sleep(1);
+ } catch (InterruptedException e) {
+ // Nom nom
+ }
+ } else {
+ Log.w("SDL", "SDL audio: error return from write(short)");
+ return;
+ }
+ }
+ }
+
+ public static void audioQuit() {
+ if (mAudioThread != null) {
+ try {
+ mAudioThread.join();
+ } catch (Exception e) {
+ Log.v("SDL", "Problem stopping audio thread: " + e);
+ }
+ mAudioThread = null;
+
+ // Log.v("SDL", "Finished waiting for audio thread");
+ }
+
+ if (mAudioTrack != null) {
+ mAudioTrack.stop();
+ mAudioTrack = null;
+ }
+ }
+}
+
+/**
+ * Simple nativeInit() runnable
+ */
+class SDLMain implements Runnable {
+ private int surfaceWidth, surfaceHeight;
+ private GameConfig config;
+
+ public SDLMain(int width, int height, GameConfig _config) {
+ config = _config;
+ surfaceWidth = width;
+ surfaceHeight = height;
+ }
+
+ public void run() {
+ //Set up the IPC socket server to communicate with the engine
+ EngineProtocolNetwork ipc = new EngineProtocolNetwork(config);
+
+ String path = Utils.getDownloadPath(SDLActivity.mSingleton);//This represents the data directory
+ path = path.substring(0, path.length()-1);//remove the trailing '/'
+
+
+ // Runs SDL_main() with added parameters
+ SDLActivity.nativeInit(new String[] { String.valueOf(ipc.port),
+ String.valueOf(surfaceWidth), String.valueOf(surfaceHeight),
+ "0", "null", "xeli", "1", "1", "1", path, "" });
+
+ try {
+ ipc.quitIPC();
+ ipc.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ //Log.v("SDL", "SDL thread terminated");
+ SDLActivity.mSingleton.finish();
+ }
+}
+
+/**
+ * SDLSurface. This is what we draw on, so we need to know when it's created in
+ * order to do anything useful.
+ *
+ * Because of this, that's where we set up the SDL thread
+ */
+class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
+ View.OnKeyListener, SensorEventListener {
+
+ // This is what SDL runs in. It invokes SDL_main(), eventually
+ private Thread mSDLThread;
+
+ // EGL private objects
+ private EGLContext mEGLContext;
+ private EGLSurface mEGLSurface;
+ private EGLDisplay mEGLDisplay;
+
+ // Sensors
+ private static SensorManager mSensorManager;
+
+ private GameConfig config;
+
+ // Startup
+ public SDLSurface(Context context, GameConfig _config) {
+ super(context);
+ getHolder().addCallback(this);
+
+ setFocusable(true);
+ setFocusableInTouchMode(true);
+ requestFocus();
+ setOnKeyListener(this);
+ setOnTouchListener(TouchInterface.getTouchInterface());
+
+ mSensorManager = (SensorManager) context.getSystemService("sensor");
+
+ config = _config;
+ }
+
+ // Called when we have a valid drawing surface
+ public void surfaceCreated(SurfaceHolder holder) {
+ Log.v("SDL", "surfaceCreated()");
+
+ //enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+ }
+
+ // Called when we lose the surface
+ public void surfaceDestroyed(SurfaceHolder holder) {
+ Log.v("SDL", "surfaceDestroyed()");
+
+ // Send a quit message to the application
+ //SDLActivity.nativeQuit();
+ PascalExports.HWterminate(true);
+
+ // Now wait for the SDL thread to quit
+ if (mSDLThread != null) {
+ try {
+ mSDLThread.join();
+ } catch (Exception e) {
+ Log.v("SDL", "Problem stopping thread: " + e);
+ }
+ mSDLThread = null;
+
+ Log.v("SDL", "Finished waiting for SDL thread");
+ }
+
+ //enableSensor(Sensor.TYPE_ACCELEROMETER, false);
+ }
+
+ // Called when the surface is resized
+ public void surfaceChanged(SurfaceHolder holder, int format, int width,
+ int height) {
+ Log.d("SDL", "surfaceChanged()" + width + " + " + height);
+
+ int sdlFormat = 0x85151002; // SDL_PIXELFORMAT_RGB565 by default
+ switch (format) {
+ case PixelFormat.A_8:
+ Log.v("SDL", "pixel format A_8");
+ break;
+ case PixelFormat.LA_88:
+ Log.v("SDL", "pixel format LA_88");
+ break;
+ case PixelFormat.L_8:
+ Log.v("SDL", "pixel format L_8");
+ break;
+ case PixelFormat.RGBA_4444:
+ Log.v("SDL", "pixel format RGBA_4444");
+ sdlFormat = 0x85421002; // SDL_PIXELFORMAT_RGBA4444
+ break;
+ case PixelFormat.RGBA_5551:
+ Log.v("SDL", "pixel format RGBA_5551");
+ sdlFormat = 0x85441002; // SDL_PIXELFORMAT_RGBA5551
+ break;
+ case PixelFormat.RGBA_8888:
+ Log.v("SDL", "pixel format RGBA_8888");
+ sdlFormat = 0x86462004; // SDL_PIXELFORMAT_RGBA8888
+ break;
+ case PixelFormat.RGBX_8888:
+ Log.v("SDL", "pixel format RGBX_8888");
+ sdlFormat = 0x86262004; // SDL_PIXELFORMAT_RGBX8888
+ break;
+ case PixelFormat.RGB_332:
+ Log.v("SDL", "pixel format RGB_332");
+ sdlFormat = 0x84110801; // SDL_PIXELFORMAT_RGB332
+ break;
+ case PixelFormat.RGB_565:
+ Log.v("SDL", "pixel format RGB_565");
+ sdlFormat = 0x85151002; // SDL_PIXELFORMAT_RGB565
+ break;
+ case PixelFormat.RGB_888:
+ Log.v("SDL", "pixel format RGB_888");
+ // Not sure this is right, maybe SDL_PIXELFORMAT_RGB24 instead?
+ sdlFormat = 0x86161804; // SDL_PIXELFORMAT_RGB888
+ break;
+ default:
+ Log.v("SDL", "pixel format unknown " + format);
+ break;
+ }
+ SDLActivity.onNativeResize(width, height, sdlFormat);
+
+ // Now start up the C app thread
+ if (mSDLThread == null) {
+ mSDLThread = new Thread(new SDLMain(width, height, config),
+ "SDLThread");
+ mSDLThread.start();
+ }
+ }
+
+ // unused
+ public void onDraw(Canvas canvas) {
+ }
+
+ // EGL functions
+ public boolean initEGL(int majorVersion, int minorVersion) {
+ Log.v("SDL", "Starting up OpenGL ES " + majorVersion + "."
+ + minorVersion);
+
+ try {
+ EGL10 egl = (EGL10) EGLContext.getEGL();
+
+ EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+
+ int[] version = new int[2];
+ egl.eglInitialize(dpy, version);
+
+ int EGL_OPENGL_ES_BIT = 1;
+ int EGL_OPENGL_ES2_BIT = 4;
+ int renderableType = 0;
+ if (majorVersion == 2) {
+ renderableType = EGL_OPENGL_ES2_BIT;
+ } else if (majorVersion == 1) {
+ renderableType = EGL_OPENGL_ES_BIT;
+ }
+ int[] configSpec = {
+ // EGL10.EGL_DEPTH_SIZE, 16,
+ EGL10.EGL_RENDERABLE_TYPE, renderableType, EGL10.EGL_NONE };
+ EGLConfig[] configs = new EGLConfig[1];
+ int[] num_config = new int[1];
+ if (!egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config)
+ || num_config[0] == 0) {
+ Log.e("SDL", "No EGL config available");
+ return false;
+ }
+ EGLConfig config = configs[0];
+
+ EGLContext ctx = egl.eglCreateContext(dpy, config,
+ EGL10.EGL_NO_CONTEXT, null);
+ if (ctx == EGL10.EGL_NO_CONTEXT) {
+ Log.e("SDL", "Couldn't create context");
+ return false;
+ }
+
+ EGLSurface surface = egl.eglCreateWindowSurface(dpy, config, this,
+ null);
+ if (surface == EGL10.EGL_NO_SURFACE) {
+ Log.e("SDL", "Couldn't create surface");
+ return false;
+ }
+
+ if (!egl.eglMakeCurrent(dpy, surface, surface, ctx)) {
+ Log.e("SDL", "Couldn't make context current");
+ return false;
+ }
+
+ mEGLContext = ctx;
+ mEGLDisplay = dpy;
+ mEGLSurface = surface;
+
+ } catch (Exception e) {
+ Log.v("SDL", e + "");
+ for (StackTraceElement s : e.getStackTrace()) {
+ Log.v("SDL", s.toString());
+ }
+ }
+
+ return true;
+ }
+
+ // EGL buffer flip
+ public void flipEGL() {
+ try {
+ EGL10 egl = (EGL10) EGLContext.getEGL();
+
+ egl.eglWaitNative(EGL10.EGL_NATIVE_RENDERABLE, null);
+
+ // drawing here
+
+ egl.eglWaitGL();
+
+ egl.eglSwapBuffers(mEGLDisplay, mEGLSurface);
+
+ } catch (Exception e) {
+ Log.v("SDL", "flipEGL(): " + e);
+ for (StackTraceElement s : e.getStackTrace()) {
+ Log.v("SDL", s.toString());
+ }
+
+ }
+ }
+
+ // Key events
+ public boolean onKey(View v, int keyCode, KeyEvent event) {
+ if(keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) return false;
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ Log.v("SDL", "key down: " + keyCode);
+ if(keyCode == KeyEvent.KEYCODE_BACK){//TODO ask user to quit or not
+ PascalExports.HWterminate(true);
+ //SDLActivity.mSingleton.finish();
+ }else{
+ SDLActivity.onNativeKeyDown(keyCode);
+ }
+
+ return true;
+ } else if (event.getAction() == KeyEvent.ACTION_UP) {
+ Log.v("SDL", "key up: " + keyCode);
+ SDLActivity.onNativeKeyUp(keyCode);
+ return true;
+ }
+
+ return false;
+ }
+
+ // Sensor events
+ public void enableSensor(int sensortype, boolean enabled) {
+ // TODO: This uses getDefaultSensor - what if we have >1 accels?
+ if (enabled) {
+ mSensorManager.registerListener(this,
+ mSensorManager.getDefaultSensor(sensortype),
+ SensorManager.SENSOR_DELAY_GAME, null);
+ } else {
+ mSensorManager.unregisterListener(this,
+ mSensorManager.getDefaultSensor(sensortype));
+ }
+ }
+
+ public void onAccuracyChanged(Sensor sensor, int accuracy) {
+ // TODO
+ }
+
+ public void onSensorChanged(SensorEvent event) {
+ if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+ SDLActivity.onNativeAccel(event.values[0], event.values[1],
+ event.values[2]);
+ }
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/StartGameActivity.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,211 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid;
+
+import org.hedgewars.hedgeroid.EngineProtocol.FrontendDataUtils;
+import org.hedgewars.hedgeroid.EngineProtocol.GameConfig;
+import org.hedgewars.hedgeroid.EngineProtocol.Map;
+import org.hedgewars.hedgeroid.EngineProtocol.Scheme;
+import org.hedgewars.hedgeroid.EngineProtocol.Team;
+import org.hedgewars.hedgeroid.EngineProtocol.Weapon;
+import org.hedgewars.mobile.R;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemSelectedListener;
+import android.widget.ArrayAdapter;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.Spinner;
+import android.widget.Toast;
+
+public class StartGameActivity extends Activity {
+
+ public static final int ACTIVITY_TEAM_SELECTOR = 0;
+
+ private GameConfig config = null;
+ private ImageButton start, back, team;
+ private Spinner maps, gameplay, gamescheme, weapons, themes;
+ private ImageView themeIcon, mapPreview, teamCount;
+
+ public void onCreate(Bundle savedInstanceState){
+ super.onCreate(savedInstanceState);
+
+ //SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
+ //Copy all the xml files to the device TODO only do first time launch of the app...
+ Utils.resRawToFilesDir(this,R.array.schemes, Scheme.DIRECTORY_SCHEME);
+ Utils.resRawToFilesDir(this, R.array.weapons, Weapon.DIRECTORY_WEAPON);
+ Scheme.parseBasicFlags(this);
+
+ config = new GameConfig();
+
+ setContentView(R.layout.starting_game);
+
+ back = (ImageButton) findViewById(R.id.btnBack);
+ team = (ImageButton) findViewById(R.id.btnTeams);
+ start = (ImageButton) findViewById(R.id.btnStart);
+
+ maps = (Spinner) findViewById(R.id.spinMaps);
+ gameplay = (Spinner) findViewById(R.id.spinGameplay);
+ gamescheme = (Spinner) findViewById(R.id.spinGamescheme);
+ weapons = (Spinner) findViewById(R.id.spinweapons);
+ themes = (Spinner) findViewById(R.id.spinTheme);
+
+ themeIcon = (ImageView) findViewById(R.id.imgTheme);
+ mapPreview = (ImageView) findViewById(R.id.mapPreview);
+ teamCount = (ImageView) findViewById(R.id.imgTeamsCount);
+
+ start.setOnClickListener(startClicker);
+ back.setOnClickListener(backClicker);
+ team.setOnClickListener(teamClicker);
+
+ ArrayAdapter<?> adapter = new ArrayAdapter<Map>(this, R.layout.listview_item, FrontendDataUtils.getMaps(this));
+ adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ maps.setAdapter(adapter);
+ maps.setOnItemSelectedListener(mapsClicker);
+
+ adapter = new ArrayAdapter<String>(this, R.layout.listview_item, FrontendDataUtils.getGameplay(this));
+ adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ gameplay.setAdapter(adapter);
+ gameplay.setOnItemSelectedListener(gameplayClicker);
+
+ adapter = new ArrayAdapter<Scheme>(this, R.layout.listview_item, FrontendDataUtils.getSchemes(this));
+ adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ gamescheme.setAdapter(adapter);
+ gamescheme.setOnItemSelectedListener(schemeClicker);
+
+ adapter = new ArrayAdapter<Weapon>(this, R.layout.listview_item, FrontendDataUtils.getWeapons(this));
+ adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ weapons.setAdapter(adapter);
+ weapons.setOnItemSelectedListener(weaponClicker);
+
+ adapter = new ArrayAdapter<String>(this, R.layout.listview_item, FrontendDataUtils.getThemes(this));
+ adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ themes.setAdapter(adapter);
+ themes.setOnItemSelectedListener(themesClicker);
+
+ }
+
+ private void startTeamsActivity(){
+ Intent i = new Intent(StartGameActivity.this, TeamSelectionActivity.class);
+ i.putParcelableArrayListExtra("teams", config.teams);
+ startActivityForResult(i, ACTIVITY_TEAM_SELECTOR);
+ }
+
+ public void onActivityResult(int requestCode, int resultCode, Intent data){
+ switch(requestCode){
+ case ACTIVITY_TEAM_SELECTOR:
+ if(resultCode == Activity.RESULT_OK){
+ Parcelable[] parcelables = (Parcelable[])data.getParcelableArrayExtra("teams");
+ config.teams.clear();
+ for(Parcelable t : parcelables){
+ config.teams.add((Team)t);
+ }
+ teamCount.getDrawable().setLevel(config.teams.size());
+ }
+ break;
+ }
+ }
+
+
+ private OnItemSelectedListener themesClicker = new OnItemSelectedListener(){
+
+ public void onItemSelected(AdapterView<?> arg0, View view, int position, long rowId) {
+ String themeName = (String) arg0.getAdapter().getItem(position);
+ Drawable themeIconDrawable = Drawable.createFromPath(Utils.getDownloadPath(StartGameActivity.this) + "Themes/" + themeName + "/icon@2X.png");
+ themeIcon.setImageDrawable(themeIconDrawable);
+ config.theme = themeName;
+ }
+
+ public void onNothingSelected(AdapterView<?> arg0) {
+ }
+
+ };
+
+ private OnItemSelectedListener mapsClicker = new OnItemSelectedListener(){
+
+ public void onItemSelected(AdapterView<?> arg0, View view, int position,long rowId) {
+ Map map = (Map)arg0.getAdapter().getItem(position);
+ mapPreview.setImageDrawable(map.getDrawable());
+ config.map = map;
+ }
+
+ public void onNothingSelected(AdapterView<?> arg0) {
+ }
+
+ };
+
+ private OnItemSelectedListener weaponClicker = new OnItemSelectedListener(){
+ public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
+ config.weapon = (Weapon)arg0.getAdapter().getItem(arg2);
+ }
+ public void onNothingSelected(AdapterView<?> arg0) {
+
+ }
+ };
+ private OnItemSelectedListener schemeClicker = new OnItemSelectedListener(){
+ public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
+ config.scheme = (Scheme)arg0.getAdapter().getItem(arg2);
+ }
+ public void onNothingSelected(AdapterView<?> arg0) {
+
+ }
+ };
+ private OnItemSelectedListener gameplayClicker = new OnItemSelectedListener(){
+ public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
+ //config = ()arg0.getAdapter().getItem(arg2);
+ }
+ public void onNothingSelected(AdapterView<?> arg0) {
+
+ }
+ };
+
+ private OnClickListener startClicker = new OnClickListener(){
+ public void onClick(View v) {
+ if(config.teams.size() < 2){
+ Toast.makeText(StartGameActivity.this, R.string.not_enough_teams, Toast.LENGTH_LONG).show();
+ startTeamsActivity();
+ }
+ else{
+ Intent i = new Intent(StartGameActivity.this, SDLActivity.class);
+ i.putExtra("config", config);
+ startActivity(i);}
+ }
+ };
+
+ private OnClickListener backClicker = new OnClickListener(){
+ public void onClick(View v) {
+ finish();
+ }
+ };
+
+ private OnClickListener teamClicker = new OnClickListener(){
+ public void onClick(View v) {
+ startTeamsActivity();
+ }
+ };
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/TeamCreatorActivity.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,357 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import org.hedgewars.hedgeroid.EngineProtocol.FrontendDataUtils;
+import org.hedgewars.hedgeroid.EngineProtocol.Team;
+import org.hedgewars.mobile.R;
+
+import android.app.Activity;
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+import android.media.MediaPlayer;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnFocusChangeListener;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemSelectedListener;
+import android.widget.ArrayAdapter;
+import android.widget.EditText;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.ScrollView;
+import android.widget.SimpleAdapter;
+import android.widget.Spinner;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class TeamCreatorActivity extends Activity {
+
+ private TextView name;
+ private Spinner difficulty, grave, flag, voice, fort;
+ private ImageView imgFort;
+ private ArrayList<ImageButton> hogDice = new ArrayList<ImageButton>();
+ private ArrayList<Spinner> hogHat = new ArrayList<Spinner>();
+ private ArrayList<EditText> hogName = new ArrayList<EditText>();
+ private ImageButton back, save, voiceButton;
+ private ScrollView scroller;
+ private MediaPlayer mp = null;
+ private boolean settingsChanged = false;
+ private boolean saved = false;
+
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.team_creation);
+
+ name = (TextView) findViewById(R.id.txtName);
+ difficulty = (Spinner) findViewById(R.id.spinType);
+ grave = (Spinner) findViewById(R.id.spinGrave);
+ flag = (Spinner) findViewById(R.id.spinFlag);
+ voice = (Spinner) findViewById(R.id.spinVoice);
+ fort = (Spinner) findViewById(R.id.spinFort);
+
+ imgFort = (ImageView) findViewById(R.id.imgFort);
+
+ back = (ImageButton) findViewById(R.id.btnBack);
+ save = (ImageButton) findViewById(R.id.btnSave);
+ voiceButton = (ImageButton) findViewById(R.id.btnPlay);
+
+ scroller = (ScrollView) findViewById(R.id.scroller);
+
+ save.setOnClickListener(saveClicker);
+ back.setOnClickListener(backClicker);
+
+ LinearLayout ll = (LinearLayout) findViewById(R.id.HogsContainer);
+ for (int i = 0; i < ll.getChildCount(); i++) {
+ RelativeLayout team_creation_entry = (RelativeLayout) ll
+ .getChildAt(i);
+
+ hogHat.add((Spinner) team_creation_entry
+ .findViewById(R.id.spinTeam1));
+ hogDice.add((ImageButton) team_creation_entry
+ .findViewById(R.id.btnTeam1));
+ hogName.add((EditText) team_creation_entry
+ .findViewById(R.id.txtTeam1));
+ }
+ ArrayList<HashMap<String, ?>> gravesData = FrontendDataUtils
+ .getGraves(this);
+ SimpleAdapter sa = new SimpleAdapter(this, gravesData,
+ R.layout.spinner_textimg_entry, new String[] { "txt", "img" },
+ new int[] { R.id.spinner_txt, R.id.spinner_img });
+
+ sa.setViewBinder(viewBinder);
+ grave.setAdapter(sa);
+ grave.setOnFocusChangeListener(focusser);
+
+ ArrayList<HashMap<String, ?>> flagsData = FrontendDataUtils
+ .getFlags(this);
+ sa = new SimpleAdapter(this, flagsData, R.layout.spinner_textimg_entry,
+ new String[] { "txt", "img" }, new int[] { R.id.spinner_txt,
+ R.id.spinner_img });
+ sa.setViewBinder(viewBinder);
+ flag.setAdapter(sa);
+ flag.setOnFocusChangeListener(focusser);
+
+ ArrayList<HashMap<String, ?>> typesData = FrontendDataUtils
+ .getTypes(this);
+ sa = new SimpleAdapter(this, typesData, R.layout.spinner_textimg_entry,
+ new String[] { "txt", "img" }, new int[] { R.id.spinner_txt,
+ R.id.spinner_img });
+ difficulty.setAdapter(sa);
+ difficulty.setOnFocusChangeListener(focusser);
+
+ ArrayList<HashMap<String, ?>> hatsData = FrontendDataUtils
+ .getHats(this);
+ sa = new SimpleAdapter(this, hatsData, R.layout.spinner_textimg_entry,
+ new String[] { "txt", "img" }, new int[] { R.id.spinner_txt,
+ R.id.spinner_img });
+ sa.setViewBinder(viewBinder);
+ for (Spinner spin : hogHat) {
+ spin.setAdapter(sa);
+ }
+
+ ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
+ R.layout.listview_item, FrontendDataUtils.getVoices(this));
+ voice.setAdapter(adapter);
+ voice.setOnFocusChangeListener(focusser);
+ voiceButton.setOnClickListener(voiceClicker);
+
+ adapter = new ArrayAdapter<String>(this, R.layout.listview_item,
+ FrontendDataUtils.getForts(this));
+ fort.setAdapter(adapter);
+ fort.setOnItemSelectedListener(fortSelector);
+ fort.setOnFocusChangeListener(focusser);
+
+ Team t = this.getIntent().getParcelableExtra("team");
+ if (t != null) {
+ name.setText(t.name);
+ int position = ((ArrayAdapter<String>) voice.getAdapter())
+ .getPosition(t.voice);
+ voice.setSelection(position);
+
+ position = ((ArrayAdapter<String>) fort.getAdapter())
+ .getPosition(t.fort);
+ fort.setSelection(position);
+
+ position = 0;
+ for (HashMap<String, ?> hashmap : typesData) {
+ if (hashmap.get("txt").equals(t.levels[0])) {
+ difficulty.setSelection(position);
+ break;
+ }
+ }
+
+ position = 0;
+ for (HashMap<String, ?> hashmap : gravesData) {
+ if (hashmap.get("txt").equals(t.grave)) {
+ grave.setSelection(position);
+ break;
+ }
+ }
+
+ position = 0;
+ for (HashMap<String, ?> hashmap : typesData) {
+ if (hashmap.get("txt").equals(t.flag)) {
+ flag.setSelection(position);
+ break;
+ }
+ }
+
+ for (int i = 0; i < Team.maxNumberOfHogs; i++) {
+ position = 0;
+ for (HashMap<String, ?> hashmap : hatsData) {
+ if (hashmap.get("txt").equals(t.hats[i])) {
+ hogHat.get(i).setSelection(position);
+ }
+ }
+
+ hogName.get(i).setText(t.hogNames[i]);
+ }
+ }
+ }
+
+ public void onDestroy() {
+ super.onDestroy();
+ if (mp != null) {
+ mp.release();
+ mp = null;
+ }
+ }
+
+ private OnFocusChangeListener focusser = new OnFocusChangeListener() {
+ public void onFocusChange(View v, boolean hasFocus) {
+ settingsChanged = true;
+ }
+
+ };
+
+ public void onBackPressed() {
+ onFinishing();
+ super.onBackPressed();
+
+ }
+
+ private OnClickListener backClicker = new OnClickListener() {
+ public void onClick(View v) {
+ onFinishing();
+ finish();
+ }
+ };
+
+ private void onFinishing() {
+ if (settingsChanged) {
+ setResult(RESULT_OK);
+ } else {
+ setResult(RESULT_CANCELED);
+ }
+ }
+
+ private OnClickListener saveClicker = new OnClickListener() {
+ public void onClick(View v) {
+ Toast.makeText(TeamCreatorActivity.this, R.string.saved, Toast.LENGTH_SHORT).show();
+ saved = true;
+ Team team = new Team();
+ team.name = name.getText().toString();
+ HashMap<String, Object> hashmap = (HashMap<String, Object>) flag
+ .getSelectedItem();
+
+ team.flag = (String) hashmap.get("txt");
+ team.fort = fort.getSelectedItem().toString();
+ hashmap = (HashMap<String, Object>) grave.getSelectedItem();
+ team.grave = hashmap.get("txt").toString();
+ team.hash = "0";
+ team.voice = voice.getSelectedItem().toString();
+
+ hashmap = ((HashMap<String, Object>) difficulty.getSelectedItem());
+ String levelString = hashmap.get("txt").toString();
+ int levelInt;
+ if (levelString.equals(getString(R.string.human))) {
+ levelInt = 0;
+ } else if (levelString.equals(getString(R.string.bot5))) {
+ levelInt = 1;
+ } else if (levelString.equals(getString(R.string.bot4))) {
+ levelInt = 2;
+ } else if (levelString.equals(getString(R.string.bot3))) {
+ levelInt = 3;
+ } else if (levelString.equals(getString(R.string.bot2))) {
+ levelInt = 4;
+ } else {
+ levelInt = 5;
+ }
+
+ for (int i = 0; i < hogName.size(); i++) {
+ team.hogNames[i] = hogName.get(i).getText().toString();
+ hashmap = (HashMap<String, Object>) hogHat.get(i)
+ .getSelectedItem();
+ team.hats[i] = hashmap.get("txt").toString();
+ team.levels[i] = levelInt;
+ }
+ try {
+ File teamsDir = new File(getFilesDir().getAbsolutePath() + '/'
+ + Team.DIRECTORY_TEAMS);
+ if (!teamsDir.exists())
+ teamsDir.mkdir();
+ FileOutputStream fos = new FileOutputStream(String.format(
+ "%s/%s.xml", teamsDir.getAbsolutePath(), team.name));
+ team.writeToXml(fos);
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ }
+ }
+
+ };
+
+ private OnItemSelectedListener fortSelector = new OnItemSelectedListener() {
+ @SuppressWarnings("unchecked")
+ public void onItemSelected(AdapterView<?> arg0, View arg1,
+ int position, long arg3) {
+ settingsChanged = true;
+ String fortName = (String) arg0.getAdapter().getItem(position);
+ Drawable fortIconDrawable = Drawable.createFromPath(Utils
+ .getDownloadPath(TeamCreatorActivity.this)
+ + "Forts/"
+ + fortName + "L.png");
+ imgFort.setImageDrawable(fortIconDrawable);
+ scroller.fullScroll(ScrollView.FOCUS_DOWN);// Scroll the scrollview
+ // to the bottom, work
+ // around for scollview
+ // invalidation (scrolls
+ // back to top)
+ }
+
+ public void onNothingSelected(AdapterView<?> arg0) {
+ }
+
+ };
+
+ private OnClickListener voiceClicker = new OnClickListener() {
+ public void onClick(View v) {
+ try {
+ File dir = new File(String.format("%sSounds/voices/%s",
+ Utils.getDownloadPath(TeamCreatorActivity.this),
+ voice.getSelectedItem()));
+ String file = "";
+ File[] dirs = dir.listFiles();
+ File f = dirs[(int) Math.round(Math.random() * dirs.length)];
+ if (f.getName().endsWith(".ogg"))
+ file = f.getAbsolutePath();
+
+ if (mp == null)
+ mp = new MediaPlayer();
+ else
+ mp.reset();
+ mp.setDataSource(file);
+ mp.prepare();
+ mp.start();
+ } catch (IllegalArgumentException e) {
+ e.printStackTrace();
+ } catch (IllegalStateException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ };
+
+ private SimpleAdapter.ViewBinder viewBinder = new SimpleAdapter.ViewBinder() {
+
+ public boolean setViewValue(View view, Object data,
+ String textRepresentation) {
+ if (view instanceof ImageView && data instanceof Bitmap) {
+ ImageView v = (ImageView) view;
+ v.setImageBitmap((Bitmap) data);
+ return true;
+ } else {
+ return false;
+ }
+ }
+ };
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/TeamSelectionActivity.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,290 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import org.hedgewars.hedgeroid.EngineProtocol.FrontendDataUtils;
+import org.hedgewars.hedgeroid.EngineProtocol.Team;
+import org.hedgewars.mobile.R;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.ContextMenu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.RelativeLayout;
+import android.widget.SimpleAdapter;
+import android.widget.SimpleAdapter.ViewBinder;
+import android.widget.TextView;
+
+public class TeamSelectionActivity extends Activity{
+
+ private static final int ACTIVITY_TEAMCREATION = 0;
+
+ private ImageButton addTeam, back;
+ private ListView availableTeams, selectedTeams;
+ private ArrayList<HashMap<String, Object>> availableTeamsList, selectedTeamsList;
+ private TextView txtInfo;
+
+ public void onCreate(Bundle savedInstanceState){
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.team_selector);
+
+ addTeam = (ImageButton) findViewById(R.id.btnAdd);
+ back = (ImageButton) findViewById(R.id.btnBack);
+ txtInfo = (TextView) findViewById(R.id.txtInfo);
+
+ addTeam.setOnClickListener(addTeamClicker);
+ back.setOnClickListener(backClicker);
+
+ availableTeams = (ListView) findViewById(R.id.availableTeams);
+ availableTeamsList = FrontendDataUtils.getTeams(this);
+ SimpleAdapter adapter = new SimpleAdapter(this, availableTeamsList, R.layout.team_selection_entry_simple, new String[]{"txt", "img"}, new int[]{R.id.txtName, R.id.imgDifficulty});
+ availableTeams.setAdapter(adapter);
+ registerForContextMenu(availableTeams);
+ availableTeams.setOnItemClickListener(availableClicker);
+
+ selectedTeams = (ListView) findViewById(R.id.selectedTeams);
+ selectedTeamsList = new ArrayList<HashMap<String, Object>>();
+ ArrayList<HashMap<String, ?>> toBeRemoved = new ArrayList<HashMap<String, ?>>();
+ ArrayList<Team> teamsStartGame = getIntent().getParcelableArrayListExtra("teams");
+ for(HashMap<String, Object> hashmap : availableTeamsList){
+ for(Team t : teamsStartGame){
+ if(((Team)hashmap.get("team")).equals(t)){
+ toBeRemoved.add(hashmap);
+ selectedTeamsList.add(FrontendDataUtils.teamToHashMap(t));//create a new hashmap to ensure all variables are entered into the map
+ }
+ }
+ }
+ for(HashMap<String, ?> hashmap : toBeRemoved) availableTeamsList.remove(hashmap);
+
+ adapter = new SimpleAdapter(this, selectedTeamsList, R.layout.team_selection_entry, new String[]{"txt", "img", "color", "count"}, new int[]{R.id.txtName, R.id.imgDifficulty, R.id.teamColor, R.id.teamCount});
+ adapter.setViewBinder(viewBinder);
+ selectedTeams.setAdapter(adapter);
+ selectedTeams.setOnItemClickListener(selectedClicker);
+
+ txtInfo.setText(String.format(getResources().getString(R.string.teams_info_template), selectedTeams.getChildCount()));
+ }
+
+ private ViewBinder viewBinder = new ViewBinder(){
+ public boolean setViewValue(View view, Object data, String textRepresentation) {
+ switch(view.getId()){
+ case R.id.teamColor:
+ setTeamColor(view, (Integer)data);
+ return true;
+ case R.id.teamCount:
+ setTeamHogCount((ImageView)view, (Integer)data);
+ return true;
+ default:
+ return false;
+ }
+ }
+ };
+
+ public void onActivityResult(int requestCode, int resultCode, Intent data){
+ if(requestCode == ACTIVITY_TEAMCREATION){
+ if(resultCode == Activity.RESULT_OK){
+ updateListViews();
+ }
+ }else{
+ super.onActivityResult(requestCode, resultCode, data);
+ }
+ }
+
+ private void updateListViews(){
+ unregisterForContextMenu(availableTeams);
+ availableTeamsList = FrontendDataUtils.getTeams(this);
+ ArrayList<HashMap<String, Object>> toBeRemoved = new ArrayList<HashMap<String, Object>>();
+ for(HashMap<String, Object> hashmap : selectedTeamsList){
+ String name = (String)hashmap.get("txt");
+
+ for(HashMap<String, Object> hash : availableTeamsList){
+ if(name.equals((String)hash.get("txt"))){
+ toBeRemoved.add(hash);
+ }
+ }
+ }
+ for(HashMap<String, Object> hash: toBeRemoved) availableTeamsList.remove(hash);
+
+ SimpleAdapter adapter = new SimpleAdapter(this, availableTeamsList, R.layout.team_selection_entry, new String[]{"txt", "img"}, new int[]{R.id.txtName, R.id.imgDifficulty});
+ availableTeams.setAdapter(adapter);
+ registerForContextMenu(availableTeams);
+ availableTeams.setOnItemClickListener(availableClicker);
+
+
+ }
+
+ private void setTeamColor(int position, int color){
+ View iv = ((RelativeLayout)selectedTeams.getChildAt(position)).findViewById(R.id.teamCount);
+ setTeamColor(iv, color);
+ }
+ private void setTeamColor(View iv, int color){
+ iv.setBackgroundColor(0xFF000000 + color);
+ }
+
+ private void setTeamHogCount(int position, int count){
+ ImageView iv = (ImageView)((RelativeLayout)selectedTeams.getChildAt(position)).findViewById(R.id.teamCount);
+ setTeamHogCount(iv, count);
+ }
+
+ private void setTeamHogCount(ImageView iv, int count){
+
+ switch(count){
+ case 0:
+ iv.setImageResource(R.drawable.teamcount0);
+ break;
+ case 1:
+ iv.setImageResource(R.drawable.teamcount1);
+ break;
+ case 2:
+ iv.setImageResource(R.drawable.teamcount2);
+ break;
+ case 3:
+ iv.setImageResource(R.drawable.teamcount3);
+ break;
+ case 4:
+ iv.setImageResource(R.drawable.teamcount4);
+ break;
+ case 5:
+ iv.setImageResource(R.drawable.teamcount5);
+ break;
+ case 6:
+ iv.setImageResource(R.drawable.teamcount6);
+ break;
+ case 7:
+ iv.setImageResource(R.drawable.teamcount7);
+ break;
+ case 8:
+ iv.setImageResource(R.drawable.teamcount8);
+ break;
+ case 9:
+ iv.setImageResource(R.drawable.teamcount9);
+ break;
+ }
+ }
+
+ public void onBackPressed(){
+ returnTeams();
+ super.onBackPressed();
+ }
+
+ private OnClickListener addTeamClicker = new OnClickListener(){
+ public void onClick(View v) {
+ startActivityForResult(new Intent(TeamSelectionActivity.this, TeamCreatorActivity.class), ACTIVITY_TEAMCREATION);
+ }
+ };
+
+ private OnClickListener backClicker = new OnClickListener(){
+ public void onClick(View v){
+ returnTeams();
+ finish();
+ }
+ };
+
+ private OnItemClickListener availableClicker = new OnItemClickListener(){
+ public void onItemClick(AdapterView<?> arg0, View arg1, int position,long arg3) {
+ selectAvailableTeamsItem(position);
+ }
+ };
+ private OnItemClickListener selectedClicker = new OnItemClickListener(){
+ public void onItemClick(AdapterView<?> arg0, View arg1, int position,long arg3) {
+ availableTeamsList.add((HashMap<String, Object>) selectedTeamsList.get(position));
+ selectedTeamsList.remove(position);
+ ((SimpleAdapter)availableTeams.getAdapter()).notifyDataSetChanged();
+ ((SimpleAdapter)selectedTeams.getAdapter()).notifyDataSetChanged();
+
+ txtInfo.setText(String.format(getResources().getString(R.string.teams_info_template), selectedTeamsList.size()));
+ }
+
+ };
+
+ public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuinfo){
+ menu.add(ContextMenu.NONE, 0, ContextMenu.NONE, R.string.select);
+ menu.add(ContextMenu.NONE, 2, ContextMenu.NONE, R.string.edit);
+ menu.add(ContextMenu.NONE, 1, ContextMenu.NONE, R.string.delete);
+
+ }
+ public boolean onContextItemSelected(MenuItem item){
+ AdapterView.AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo) item.getMenuInfo();
+ int position = menuInfo.position;
+ switch(item.getItemId()){
+ case 0://select
+ selectAvailableTeamsItem(position);
+ return true;
+ case 1://delete
+ File f = new File(String.format("%s/%s/%s.xml", TeamSelectionActivity.this.getFilesDir(), Team.DIRECTORY_TEAMS, availableTeamsList.get(position).get("txt")));
+ f.delete();
+ availableTeamsList.remove(position);
+ ((SimpleAdapter)availableTeams.getAdapter()).notifyDataSetChanged();
+ return true;
+ case 2://edit
+ Intent i = new Intent(TeamSelectionActivity.this, TeamCreatorActivity.class);
+ Team t = (Team)availableTeamsList.get(position).get("team");
+ i.putExtra("team", t);
+ startActivityForResult(i, ACTIVITY_TEAMCREATION);
+ return true;
+ }
+ return false;
+ }
+
+ private void selectAvailableTeamsItem(int position){
+ HashMap<String, Object> hash = (HashMap<String, Object>) availableTeamsList.get(position);
+ Team t = (Team)hash.get("team");
+ int[] illegalcolors = new int[selectedTeamsList.size()];
+ for(int i = 0; i < selectedTeamsList.size(); i++){
+ illegalcolors[i] = ((Team)selectedTeamsList.get(i).get("team")).color;
+ }
+ t.setRandomColor(illegalcolors);
+ hash.put("color", t.color);
+ hash.put("count", t.hogCount);
+
+ selectedTeamsList.add(hash);
+ availableTeamsList.remove(position);
+ ((SimpleAdapter)availableTeams.getAdapter()).notifyDataSetChanged();
+ ((SimpleAdapter)selectedTeams.getAdapter()).notifyDataSetChanged();
+
+ txtInfo.setText(String.format(getResources().getString(R.string.teams_info_template), selectedTeamsList.size()));
+ }
+
+ private void returnTeams(){
+ int teamsCount = selectedTeamsList.size();
+ Intent i = new Intent();
+ Parcelable[] teams = new Parcelable[teamsCount];
+ for(int x = 0 ; x < teamsCount; x++){
+ teams[x] = (Team)selectedTeamsList.get(x).get("team");
+ }
+ i.putExtra("teams", teams);
+ setResult(Activity.RESULT_OK, i);
+
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/TextImageAdapter.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,76 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.hedgewars.mobile.R;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.SimpleAdapter;
+import android.widget.TextView;
+
+
+public class TextImageAdapter extends SimpleAdapter {
+
+ private Context context;
+ private ArrayList<Map<String, ?>> data;
+
+ public TextImageAdapter(Context _context, ArrayList<Map<String, ?>> _data, int resource, String[] from, int[] to) {
+ super(_context, _data, resource, from, to);
+ context = _context;
+ data = _data;
+ }
+
+ public static TextImageAdapter createAdapter(Context c, String[] txt, String[] img, String[] from, int[] to){
+ if(txt.length != img.length) throw new IllegalArgumentException("txt and img parameters not equal");
+
+ ArrayList<Map<String, ?>> data = new ArrayList<Map<String, ?>>(txt.length);
+
+ for(int i = 0; i < txt.length; i++){
+ HashMap<String, Object> map = new HashMap<String, Object>();
+ map.put("txt", txt[i]);
+ map.put("img", BitmapFactory.decodeFile(img[i]));
+ data.add(map);
+ }
+ return new TextImageAdapter(c, data, R.layout.spinner_textimg_entry, from, to);
+ }
+
+ public View getView(int position, View convertView, ViewGroup parent){
+ if(convertView == null){
+ LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ convertView = inflater.inflate(R.layout.spinner_textimg_entry, parent);
+ }
+ TextView tv = (TextView) convertView.findViewById(R.id.spinner_txt);
+ ImageView img = (ImageView) convertView.findViewById(R.id.spinner_img);
+
+ tv.setText((String)data.get(position).get("txt"));
+ img.setImageBitmap((Bitmap)data.get(position).get("img"));
+
+ return convertView;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/TouchInterface/TouchInterface.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,108 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+package org.hedgewars.hedgeroid.TouchInterface;
+
+import org.hedgewars.hedgeroid.SDLActivity;
+
+import android.os.Build;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnTouchListener;
+
+public class TouchInterface{
+
+ public static OnTouchListener getTouchInterface(){
+ OnTouchListener toucher;
+ if(Build.VERSION.SDK_INT < 5){//8 == Build.VERSION_CODES.FROYO
+ toucher = new TouchInterfaceST();
+ }else{
+ toucher = new TouchInterfaceMT();
+ }
+
+ return toucher;
+ }
+}
+/**
+ * Touch interface with multitouch
+ */
+class TouchInterfaceMT implements OnTouchListener {
+
+ private boolean firstEvent = true;
+
+ public boolean onTouch(View v, MotionEvent event) {
+ //dumpEvent(event);
+
+ if(firstEvent){
+ firstEvent = false;
+ SDLActivity.onNativeTouch(-1, -1, v.getWidth(), v.getHeight(), 1);
+ }
+
+ int action = event.getAction();
+ int actionCode = action & MotionEvent.ACTION_MASK;
+
+ for (int i = 0; i < event.getPointerCount(); i++) {
+ SDLActivity.onNativeTouch(actionCode, event.getPointerId(i), (int)event.getX(i), (int)event.getY(i), event.getPressure(i));
+// Log.d("Android", String.format("x=%f, y=%f, pntr=%d", event.getX(i), event.getY(i), event.getPointerId(i)));
+ }
+ return true;
+ }
+
+ /** Show an event in the LogCat view, for debugging */
+ private void dumpEvent(MotionEvent event) {
+ String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,
+ "POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };
+ StringBuilder sb = new StringBuilder();
+ int action = event.getAction();
+ int actionCode = action & MotionEvent.ACTION_MASK;
+ sb.append("event ACTION_" ).append(names[actionCode]);
+ if (actionCode == MotionEvent.ACTION_POINTER_DOWN
+ || actionCode == MotionEvent.ACTION_POINTER_UP) {
+ sb.append("(pid " ).append(
+ action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
+ sb.append(")" );
+ }
+ sb.append("[" );
+ for (int i = 0; i < event.getPointerCount(); i++) {
+ sb.append("#" ).append(i);
+ sb.append("(pid " ).append(event.getPointerId(i));
+ sb.append(")=" ).append((int) event.getX(i));
+ sb.append("," ).append((int) event.getY(i));
+ if (i + 1 < event.getPointerCount())
+ sb.append(";" );
+ }
+ sb.append("]" );
+ Log.d("HW_APP_TOUCH", sb.toString());
+ }
+
+}
+
+/**
+ * Touch interface without multitouch
+ */
+class TouchInterfaceST implements OnTouchListener {
+
+ public boolean onTouch(View v, MotionEvent event) {
+ return false;
+ }
+
+
+
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/Utils.java Thu Oct 20 22:54:34 2011 +0200
@@ -0,0 +1,215 @@
+/*
+ * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
+ * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+package org.hedgewars.hedgeroid;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+
+import org.hedgewars.mobile.R;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.os.Build;
+import android.os.Environment;
+import android.widget.Toast;
+
+public class Utils {
+
+
+ /**
+ * get the path to which we should download all the data files
+ * @param c context
+ * @return absolute path
+ */
+ public static String getDownloadPath(Context c){
+ if(Build.VERSION.SDK_INT < 8){//8 == Build.VERSION_CODES.FROYO
+ return PreFroyoSDCardDir.getDownloadPath(c);
+ }else{
+ return FroyoSDCardDir.getDownloadPath(c);
+ }
+ }
+
+ static class FroyoSDCardDir{
+ public static String getDownloadPath(Context c){
+ File f = c.getExternalCacheDir();
+ if(f != null){
+ return f.getAbsolutePath() + "/Data/";
+ }else{
+ Toast.makeText(c, R.string.sdcard_not_mounted, Toast.LENGTH_LONG).show();
+ return null;
+ }
+ }
+ }
+
+ static class PreFroyoSDCardDir{
+ public static String getDownloadPath(Context c){
+ if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
+ if(Environment.getExternalStorageDirectory() != null)
+ return Environment.getExternalStorageDirectory().getAbsolutePath() + "/Hedgewars/";
+ }
+ Toast.makeText(c, R.string.sdcard_not_mounted, Toast.LENGTH_LONG).show();
+ return null;
+ }
+ }
+
+ /**
+ * Get files from dirName, dir name is relative to {@link getDownloadPath}
+ * @param dirName
+ * @param c context
+ * @return string of files
+ */
+ public static String[] getFileNamesFromRelativeDir(Context c, String dirName){
+ String prefix = getDownloadPath(c);
+ File f = new File(prefix + dirName);
+
+ if(f.exists() && f.isDirectory()) return f.list();
+ else throw new IllegalArgumentException("File not a directory or doesn't exist dirName = " + f.getAbsolutePath());
+ }
+
+ /**
+ * Return a File array with all the files from dirName
+ * @param c
+ * @param dirName
+ * @return
+ */
+ public static File[] getFilesFromRelativeDir(Context c, String dirName){
+ String prefix = getDownloadPath(c);
+ File f = new File(prefix + dirName);
+
+ if(f.exists() && f.isDirectory()) return f.listFiles();
+ else throw new IllegalArgumentException("File not a directory or doesn't exist dirName = " + f.getAbsolutePath());
+ }
+
+ /**
+ * Checks if this directory has a file with suffix suffix
+ * @param f - directory
+ * @return
+ */
+ public static boolean hasFileWithSuffix(File f, String suffix){
+ if(f.isDirectory()){
+ for(String s : f.list()){
+ if(s.endsWith(suffix)) return true;
+ }
+ return false;
+ }else{
+ return false;
+ }
+ }
+
+ /**
+ * Gives back all dirs which contain a file with suffix fileSuffix
+ * @param c
+ * @param path
+ * @param fileSuffix
+ * @return
+ */
+ public static String[] getDirsWithFileSuffix(Context c, String path, String fileSuffix){
+ File[] files = getFilesFromRelativeDir(c,path);
+ String[] validFiles = new String[files.length];
+ int validCounter = 0;
+
+ for(File f : files){
+ if(hasFileWithSuffix(f, fileSuffix)) validFiles[validCounter++] = f.getName();
+ }
+ String[] ret = new String[validCounter];
+ System.arraycopy(validFiles, 0, ret, 0, validCounter);
+ return ret;
+ }
+
+ /**
+ * Get all files from directory dir which have the given suffix
+ * @param c
+ * @param dir
+ * @param suffix
+ * @param removeSuffix
+ * @return
+ */
+ public static ArrayList<String> getFilesFromDirWithSuffix(Context c, String dir, String suffix, boolean removeSuffix){
+ String[] files = Utils.getFileNamesFromRelativeDir(c, dir);
+ ArrayList<String> ret = new ArrayList<String>();
+ for(String s : files){
+ if(s.endsWith(suffix)){
+ if(removeSuffix) ret.add(s.substring(0, s.length()-suffix.length()));
+ else ret.add(s);
+ }
+ }
+ return ret;
+ }
+
+ /**
+ * Moves resources pointed to by sourceResId (from @res/raw/) to the app's private data directory
+ * @param c
+ * @param sourceResId
+ * @param directory
+ */
+ public static void resRawToFilesDir(Context c, int sourceResId, String directory){
+ byte[] buffer = new byte[1024];
+ InputStream bis = null;
+ BufferedOutputStream bos = null;
+ File schemesDirFile = new File(c.getFilesDir().getAbsolutePath() + '/' + directory);
+ schemesDirFile.mkdirs();
+ String schemesDirPath = schemesDirFile.getAbsolutePath() + '/';
+
+ //Get an array with the resource files ID
+ TypedArray ta = c.getResources().obtainTypedArray(sourceResId);
+ int[] resIds = new int[ta.length()];
+ for(int i = 0; i < ta.length(); i++){
+ resIds[i] = ta.getResourceId(i, 0);
+ }
+
+ for(int id : resIds){
+ String fileName = c.getResources().getResourceEntryName(id);
+ File f = new File(schemesDirPath + fileName);
+ try {
+ if(!f.createNewFile()){
+ f.delete();
+ f.createNewFile();
+ }
+
+ bis = c.getResources().openRawResource(id);
+ bos = new BufferedOutputStream(new FileOutputStream(f), 1024);
+ int read = 0;
+ while((read = bis.read(buffer)) != -1){
+ bos.write(buffer, 0, read);
+ }
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ }finally{
+ if(bis != null)
+ try {
+ bis.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ if(bos != null)
+ try {
+ bos.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/Downloader/DownloadActivity.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,180 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.Downloader;
-
-import org.hedgewars.mobile.MainActivity;
-import org.hedgewars.mobile.R;
-
-import android.app.Activity;
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.ServiceConnection;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.IBinder;
-import android.os.Message;
-import android.os.Messenger;
-import android.os.RemoteException;
-import android.preference.PreferenceManager;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.Button;
-import android.widget.ProgressBar;
-import android.widget.TextView;
-import android.widget.Toast;
-
-public class DownloadActivity extends Activity{
- private Messenger messageService;
- private boolean boundToService = false;
-
- private TextView progress_sub;
- private ProgressBar progress;
- private Button positive, negative;
-
- public static final int MSG_START = 0;
- public static final int MSG_UPDATE = 1;
- public static final int MSG_DONE = 2;
- public static final int MSG_FAILED = 3;
- private Handler.Callback messageCallback = new Handler.Callback() {
-
- public boolean handleMessage(Message msg) {
- switch(msg.what){
- case MSG_START:
- progress.setMax(msg.arg1);
- progress_sub.setText(String.format("%dkb/%dkb\n%s", 0, msg.arg1, ""));
- positive.setText(R.string.download_background);
- positive.setOnClickListener(backgroundClicker);
- negative.setText(R.string.download_cancel);
- negative.setOnClickListener(cancelClicker);
- break;
- case MSG_UPDATE:
- progress_sub.setText(String.format("%d%% - %dkb/%dkb\n%s",(msg.arg1*100)/msg.arg2, msg.arg1, msg.arg2, msg.obj));
- progress.setProgress(msg.arg1);
- break;
- case MSG_DONE:
- progress.setProgress(progress.getMax());
- progress_sub.setText(R.string.download_done);
-
- positive.setText(R.string.download_back);
- positive.setOnClickListener(doneClicker);
-
- negative.setVisibility(View.INVISIBLE);
- break;
- case MSG_FAILED:
- progress.setProgress(progress.getMax());
- progress_sub.setText(R.string.download_failed);
- positive.setText(R.string.download_back);
- positive.setOnClickListener(doneClicker);
-
- negative.setText(R.string.download_tryagain);
- negative.setOnClickListener(tryAgainClicker);
- break;
- }
- return false;
- }
- };
- private Handler messageHandler = new Handler(messageCallback);
- private Messenger messenger = new Messenger(messageHandler);
-
- public void onCreate(Bundle savedInstanceState){
- super.onCreate(savedInstanceState);
- setContentView(R.layout.download);
-
- progress_sub = (TextView)findViewById(R.id.progressbar_sub);
- progress = (ProgressBar)findViewById(R.id.progressbar);
-
- positive = (Button) findViewById(R.id.background);
- negative = (Button) findViewById(R.id.cancelDownload);
- positive.setOnClickListener(backgroundClicker);
- negative.setOnClickListener(cancelClicker);
-
- }
-
- private OnClickListener backgroundClicker = new OnClickListener(){
- public void onClick(View v){
- finish();
- }
- };
- private OnClickListener cancelClicker = new OnClickListener(){
- public void onClick(View v){
- Intent i = new Intent(getApplicationContext(), DownloadService.class);
- i.putExtra("taskID", DownloadService.TASKID_CANCEL);
- startService(i);
- finish();
- }
- };
- private OnClickListener doneClicker = new OnClickListener(){
- public void onClick(View v){
- finish();
- startActivity(new Intent(getApplicationContext(), MainActivity.class));
- }
- };
-
- private OnClickListener tryAgainClicker = new OnClickListener(){
- public void onClick(View v){
- bindToService(DownloadService.TASKID_RETRY);
- }
- };
-
- public void onStart(){
- super.onStart();
- bindToService(DownloadService.TASKID_START);
- }
-
- public void onStop(){
- super.onStop();
- unBindFromService();
- }
-
- private ServiceConnection connection = new ServiceConnection(){
-
- public void onServiceConnected(ComponentName name, IBinder service) {
- messageService = new Messenger(service);
-
- try{
- Message msg = Message.obtain(null, DownloadService.MSG_REGISTER_CLIENT);
- msg.replyTo = messenger;
- messageService.send(msg);
-
- }catch (RemoteException e){}
- }
-
- public void onServiceDisconnected(ComponentName name) {
- messageService = null;
- }
-
- };
-
- private void bindToService(int taskId){
- Intent i = new Intent(getApplicationContext(), DownloadService.class);
- i.putExtra("taskID", taskId);
- startService(i);
- bindService(new Intent(getApplicationContext(), DownloadService.class), connection, Context.BIND_AUTO_CREATE);
- boundToService = true;
- }
-
- private void unBindFromService(){
- if(boundToService){
- boundToService = false;
- unbindService(connection);
- }
- }
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/Downloader/DownloadAsyncTask.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,212 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.Downloader;
-
-import java.io.BufferedInputStream;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipInputStream;
-
-import android.os.AsyncTask;
-import android.util.Log;
-/**
- * This is an AsyncTask which will download a zip from an URL and unzip it to a specified path
- *
- * a typical call to start the task would be new DownloadAsyncTask().execute(getExternalStorage(), "www.hedgewars.org/data.zip");
- * @author Xeli
- *
- */
-public class DownloadAsyncTask extends AsyncTask<String, Object, Long> {
-
- private final static String URL_WITHOUT_SUFFIX = "http://hedgewars.googlecode.com/files/data_5631.";
- //private final static String URL_WITHOUT_SUFFIX = "http://www.xelification.com/tmp/firebutton.";
- private final static String URL_ZIP_SUFFIX = "zip";
- private final static String URL_HASH_SUFFIX = "hash";
-
- private DownloadService service;
- private long lastUpdateMillis = 0;
-
- public DownloadAsyncTask(DownloadService _service){
- service = _service;
- }
-
- /**
- *
- * @param params - 2 Strings, first is the path where the unzipped files will be stored, second is the URL to download from
- */
- protected Long doInBackground(String... params) {
- HttpURLConnection conn = null;
- MessageDigest digester = null;
- String rootZipDest = params[0];
-
- File rootDest = new File(rootZipDest);//TODO check for nullpointer, it hints to the absence of an sdcard
- rootDest.mkdir();
-
- try {
- URL url = new URL(URL_WITHOUT_SUFFIX + URL_ZIP_SUFFIX);
- conn = (HttpURLConnection)url.openConnection();
- } catch (IOException e) {
- e.printStackTrace();
- return -1l;
- }
-
- String contentType = conn.getContentType();
-
- if(contentType == null || contentType.contains("zip")){ //Seeing as we provide the url if the contentType is unknown lets assume zips
- int bytesDecompressed = 0;
- ZipEntry entry = null;
- ZipInputStream input = null;
- int kbytesToProcess = conn.getContentLength()/1024;
-
- byte[] buffer = new byte[1024];
- service.start(kbytesToProcess);
-
- try {
- digester = MessageDigest.getInstance("MD5");
-
- } catch (NoSuchAlgorithmException e1) {
- e1.printStackTrace();
- }
-
- try{
- input = new ZipInputStream(conn.getInputStream());
- entry = input.getNextEntry();
- }catch(IOException e){
- e.printStackTrace();
- if(conn != null) conn.disconnect();
- return -1l;
- }
-
- while(entry != null){
- if(isCancelled()) break;
-
- String fileName = entry.getName();
- File f = new File(rootZipDest + fileName);
- bytesDecompressed += entry.getCompressedSize();
-
- if(entry.isDirectory()){
- f.mkdir();
- }else{
- if(f.exists()){
- f.delete();
- }
-
- FileOutputStream output = null;
- try {
- f.createNewFile();
- output = new FileOutputStream(f);
-
- int count = 0;
- while((count = input.read(buffer)) != -1){
- output.write(buffer, 0, count);
- digester.update(buffer, 0, count);
- if(System.currentTimeMillis() - lastUpdateMillis > 1000){
- lastUpdateMillis = System.currentTimeMillis();
- publishProgress(bytesDecompressed, kbytesToProcess, fileName);
- }
- }
- output.flush();
- input.closeEntry();
- } catch (FileNotFoundException e) {
- e.printStackTrace();
- if(conn != null) conn.disconnect();
- return -1l;
- } catch (IOException e) {
- e.printStackTrace();
- if(conn != null) conn.disconnect();
- return -1l;
- }finally{
- try {
- if( output != null) output.close();
- } catch (IOException e) {}
- }
- }
- try{
- entry = input.getNextEntry();
- }catch(IOException e){
- e.printStackTrace();
- if(conn != null) conn.disconnect();
- return -1l;
- }
- }//end while(entry != null)
-
- try {
- input.close();
- } catch (IOException e) {}
- }//end if contentType == "zip"
-
- if(conn != null) conn.disconnect();
-
- if(checkMD5(digester))return 0l;
- else return -1l;
- }
-
- //TODO proper result handling
- protected void onPostExecute(Long result){
- service.done(result > -1l);
- }
-
- protected void onProgressUpdate(Object...objects){
- service.update((Integer)objects[0], (Integer)objects[1], (String)objects[2]);
- }
-
- private boolean checkMD5(MessageDigest digester){
- if(digester != null) {
- byte[] messageDigest = digester.digest();
-
- try {
- URL url = new URL(URL_WITHOUT_SUFFIX + URL_HASH_SUFFIX);
- HttpURLConnection conn = (HttpURLConnection)url.openConnection();
-
- byte[] buffer = new byte[1024];//size is large enough to hold the entire hash
- BufferedInputStream bis = new BufferedInputStream(conn.getInputStream());
- int bytesRead = bis.read(buffer);
- if(bytesRead > -1){
- String hash = new String(buffer, 0, bytesRead);
- StringBuffer sb = new StringBuffer();
- Integer tmp = 0;
- for(int i = 0; i < messageDigest.length; i++){
- tmp = 0xFF & messageDigest[i];
- if(tmp < 0xF) sb.append('0');
- sb.append(Integer.toHexString(tmp));
- }
- sb.append('\n');//add newline to become identical with the hash file
-
- return hash.equals(sb.toString());
- }
- return false;
- } catch (IOException e) {
- e.printStackTrace();
- return false;
- }
- }else{
- return false;
- }
-
- }
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/Downloader/DownloadService.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,199 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.Downloader;
-
-import java.util.ArrayList;
-
-import org.hedgewars.mobile.MainActivity;
-import org.hedgewars.mobile.R;
-import org.hedgewars.mobile.Utils;
-
-import android.app.Notification;
-import android.app.NotificationManager;
-import android.app.PendingIntent;
-import android.app.Service;
-import android.content.Intent;
-import android.os.Handler;
-import android.os.IBinder;
-import android.os.Message;
-import android.os.Messenger;
-import android.os.RemoteException;
-import android.preference.PreferenceManager;
-import android.util.Log;
-import android.widget.RemoteViews;
-
-public class DownloadService extends Service {
-
- public static final String PREF_DOWNLOADED = "downloaded";
- public static final int MSG_CANCEL = 0;
- public static final int MSG_REGISTER_CLIENT = 1;
- public static final int MSG_UNREGISTER_CLIENT = 2;
-
- public static final int NOTIFICATION_PROCESSING = 0;
- public static final int NOTIFICATION_DONE = 1;
-
- private DownloadAsyncTask downloadTask;
- private final Messenger messenger = new Messenger(new DownloadHandler());
- private NotificationManager nM;
- private RemoteViews contentView;
- private Notification notification;
-
- private ArrayList<Messenger> clientList = new ArrayList<Messenger>();
- private Message onRegisterMessage = null;
-
-
- class DownloadHandler extends Handler{
-
- public void handleMessage(Message msg){
- switch(msg.what){
- case MSG_CANCEL:
- downloadTask.cancel(false);
- break;
- case MSG_REGISTER_CLIENT:
- clientList.add(msg.replyTo);
- if(onRegisterMessage != null){
- try {
- msg.replyTo.send(Message.obtain(onRegisterMessage));
- } catch (RemoteException e) {
- e.printStackTrace();
- }
- }
- break;
- case MSG_UNREGISTER_CLIENT:
- clientList.remove(msg.replyTo);
- break;
- }
- }
- }
-
- public final static int TASKID_START = 0;
- public final static int TASKID_CANCEL = 1;
- public final static int TASKID_RETRY = 2;
-
- public int onStartCommand(Intent intent, int flags, int startId){
- switch(intent.getIntExtra("taskID", TASKID_START)){
- case TASKID_RETRY:
- if(downloadTask != null){
- downloadTask.cancel(false);
- downloadTask = null;
- }
- case TASKID_START:
- nM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
-
- notification = new Notification(R.drawable.statusbar, getString(R.string.notification_title), System.currentTimeMillis());
- //notification.flags |= Notification.FLAG_ONGOING_EVENT;// | Notification.FLAG_NO_CLEAR | Notification.FLAG_FOREGROUND_SERVICE;
- notification.flags |= Notification.FLAG_ONGOING_EVENT;
-
- contentView = new RemoteViews(getPackageName(), R.layout.notification);
- contentView.setProgressBar(R.id.notification_progress, 100, 34, false);
- notification.contentView = contentView;
-
- PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, DownloadActivity.class), Intent.FLAG_ACTIVITY_NEW_TASK);
- notification.contentIntent = contentIntent;
-
- //nM.notify(NOTIFICATION_PROCESSING, notification);
- startForeground(NOTIFICATION_PROCESSING, notification);
-
- if(downloadTask == null){
- downloadTask = new DownloadAsyncTask(this);
- downloadTask.execute(Utils.getDownloadPath(this));
- }
- break;
- case TASKID_CANCEL:
- downloadTask.cancel(false);
- stopService();
- break;
- }
- return 0;
- }
-
- public void onDestroy(){
- Log.e("bla", "onDestroy");
- downloadTask.cancel(false);
- }
-
- public IBinder onBind(Intent intent) {
- return messenger.getBinder();
- }
-
- /*
- * Thread safe method to let clients know the processing is starting and will process int max kbytes
- */
- public void start(int max){
- onRegisterMessage = Message.obtain(null, DownloadActivity.MSG_START, max, -1);
- sendMessageToClients(onRegisterMessage);
- }
-
- /*
- * periodically gets called by the ASyncTask, we can't tell for sure when it's called
- */
- public void update(int progress, int max, String fileName){
- progress = (progress/1024);
- updateNotification(progress, max, fileName);
-
- sendMessageToClients(Message.obtain(null, DownloadActivity.MSG_UPDATE, progress, max, fileName));
- }
-
- /*
- * Call back from the ASync task when the task has either run into an error or finished otherwise
- */
- public void done(boolean succesful){
- if(succesful){
- PreferenceManager.getDefaultSharedPreferences(this).edit().putBoolean(DownloadService.PREF_DOWNLOADED, true).commit();
- sendMessageToClients(Message.obtain(null, DownloadActivity.MSG_DONE));
- }else sendMessageToClients(Message.obtain(null, DownloadActivity.MSG_FAILED));
- stopService();//stopService clears all notifications and thus must be called before we show the ready notification
- showDoneNotification();
- }
-
- private void stopService(){
- nM.cancelAll();
- stopForeground(true);
- stopSelf();
- }
-
- private void updateNotification(int progress, int max, String fileName){
-
- contentView.setProgressBar(R.id.notification_progress, max, progress, false);
- contentView.setTextViewText(R.id.progressbar_sub, String.format("%dkb/%dkb (Compressed sizes)", progress, max));
- nM.notify(NOTIFICATION_PROCESSING, notification);
- }
-
- private void showDoneNotification(){
- nM.cancelAll();
- stopForeground(true);
-
- String title = getString(R.string.notification_title);
-
- notification = new Notification(R.drawable.icon, title, System.currentTimeMillis());
- notification.flags |= Notification.FLAG_AUTO_CANCEL;
- PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), Intent.FLAG_ACTIVITY_NEW_TASK);
- notification.setLatestEventInfo(this, title, getString(R.string.notification_done), contentIntent);
- nM.notify(NOTIFICATION_DONE, notification);
- }
- private void sendMessageToClients(Message msg){
- for(Messenger m : clientList){
- try {
- m.send(Message.obtain(msg));
- } catch (RemoteException e) {}//TODO should we catch this properly?
- }
- }
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/EngineProtocolNetwork.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,159 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.net.UnknownHostException;
-
-public class EngineProtocolNetwork extends Thread{
-
- public static final String GAMEMODE_LOCAL = "TL";
- public static final String GAMEMODE_DEMO = "TD";
- public static final String GAMEMODE_NET = "TN";
- public static final String GAMEMODE_SAVE = "TS";
-
- public static final int BUFFER_SIZE = 255; //From iOS code which got it from the origional frontend
-
- public static final int MODE_GENLANDPREVIEW = 0;
- public static final int MODE_GAME = 1;
-
- private ServerSocket serverSocket;
- private InputStream input;
- private OutputStream output;
- public int port;
- private final GameConfig config;
- private boolean clientQuit = false;
-
- public EngineProtocolNetwork(GameConfig _config){
- config = _config;
- try {
- serverSocket = new ServerSocket(0);
- port = serverSocket.getLocalPort();
- Thread ipcThread = new Thread(this, "IPC - Thread");
- ipcThread.start();
- } catch (UnknownHostException e) {
- e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
-
- public void run(){
- //if(mode == MODE_GENLANDPREVIEW) genLandPreviewIPC();
- /*else if (mode == MODE_GAME)*/ gameIPC();
- }
-
- private void gameIPC(){
- Socket sock = null;
- try{
- sock = serverSocket.accept();
- input = sock.getInputStream();
- output = sock.getOutputStream();
-
- int msgSize = 0;
- byte[] buffer = new byte[BUFFER_SIZE];
-
- while(!clientQuit){
- msgSize = 0;
-
- input.read(buffer, 0, 1);
- msgSize = buffer[0];
-
- input.read(buffer, 0, msgSize);
- System.out.println("IPC" + (char)buffer[0] + " : " + new String(buffer, 1,msgSize-1, "US_ASCII"));
- switch(buffer[0]){
- case 'C'://game init
- config.sendToEngine(this);
- break;
- case '?'://ping - pong
- sendToEngine("!");
- break;
- case 'e'://Send protocol version
- System.out.println(new String(buffer));
- break;
- case 'i'://game statistics
- switch(buffer[1]){
- case 'r'://winning team
- break;
- case 'D'://best shot
- break;
- case 'k'://best hedgehog
- break;
- case 'K'://# hogs killed
- break;
- case 'H'://team health graph
- break;
- case 'T':// local team stats
- break;
- case 'P'://teams ranking
- break;
- case 's'://self damage
- break;
- case 'S'://friendly fire
- break;
- case 'B'://turn skipped
- break;
- default:
- }
- break;
- case 'E'://error - quits game
- System.out.println(new String(buffer));
- return;
- case 'q'://game ended remove save file
-
- return;
- case 'Q'://game ended but not finished
-
- return;
- }
-
- }
- }catch(IOException e){
- e.printStackTrace();
- }finally{
- try {
- if(sock != null) sock.close();
- } catch (IOException e) {}
- try{
- if(serverSocket != null) serverSocket.close();
- } catch (IOException e) {}
- }
- }
-
- public void sendToEngine(String s){
- int length = s.length();
-
- try {
- output.write(length);
- output.write(s.getBytes(), 0, length);
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
-
- public void quitIPC(){
- clientQuit = true;
- }
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/FrontendDataUtils.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,215 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-
-import org.hedgewars.mobile.R;
-import org.hedgewars.mobile.Utils;
-import org.hedgewars.mobile.EngineProtocol.Map.MapType;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
-
-public class FrontendDataUtils {
-
-
- public static ArrayList<Map> getMaps(Context c){
- File[] files = Utils.getFilesFromRelativeDir(c,"Maps");
- ArrayList<Map> ret = new ArrayList<Map>();
-
- for(File f : files){
- if(Utils.hasFileWithSuffix(f, ".lua")){
- ret.add(new Map(f,MapType.TYPE_MISSION, c));
- }else{
- ret.add(new Map(f, MapType.TYPE_DEFAULT,c));
- }
- }
- Collections.sort(ret);
-
- return ret;
- }
-
- public static String[] getGameplay(Context c){
- String[] files = Utils.getFileNamesFromRelativeDir(c, "Scripts/Multiplayer");
- int retCounter = 0;
-
- for(int i = 0; i < files.length; i++){
- if(files[i].endsWith(".lua")){
- files[i] = files[i].replace('_', ' ').substring(0, files[i].length()-4); //replace _ by a space and removed the last four characters (.lua)
- retCounter++;
- }else files[i] = null;
- }
- String[] ret = new String[retCounter];
- retCounter = 0;
- for(String s : files){
- if(s != null) ret[retCounter++] = s;
- }
- Arrays.sort(ret);
-
- return ret;
- }
-
- public static String[] getThemes(Context c){
- return Utils.getDirsWithFileSuffix(c, "Themes", "icon.png");
- }
-
- public static ArrayList<Scheme> getSchemes(Context c){
- return Scheme.getSchemes(c);
- }
-
- public static ArrayList<Weapon> getWeapons(Context c){
- return Weapon.getWeapons(c);
- }
-
- public static ArrayList<HashMap<String, ?>> getGraves(Context c){
- String pathPrefix = Utils.getDownloadPath(c) + "Graphics/Graves/";
- ArrayList<String> names = Utils.getFilesFromDirWithSuffix(c, "Graphics/Graves", ".png", true);
- ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(names.size());
-
- for(String s : names){
- HashMap<String, Object> map = new HashMap<String, Object>();
- map.put("txt", s);
- Bitmap b = BitmapFactory.decodeFile(pathPrefix + s + ".png");//create a full path - decode to to a bitmap
- int width = b.getWidth();
- if(b.getHeight() > width){//some pictures contain more 'frames' underneath each other, if so we only use the first frame
- Bitmap tmp = Bitmap.createBitmap(b, 0, 0, width, width);
- b.recycle();
- b = tmp;
- }
- map.put("img", b);
- data.add(map);
- }
- return data;
- }
-
- public static ArrayList<HashMap<String, ?>> getFlags(Context c){
- String pathPrefix = Utils.getDownloadPath(c) + "Graphics/Flags/";
- ArrayList<String> names = Utils.getFilesFromDirWithSuffix(c, "Graphics/Flags", ".png", true);
- ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(names.size());
-
- for(String s : names){
- HashMap<String, Object> map = new HashMap<String, Object>();
- map.put("txt", s);
- Bitmap b = BitmapFactory.decodeFile(pathPrefix + s + ".png");//create a full path - decode to to a bitmap
- map.put("img", b);
- data.add(map);
- }
- return data;
- }
-
- public static ArrayList<String> getVoices(Context c){
- File[] files = Utils.getFilesFromRelativeDir(c, "Sounds/voices");
- ArrayList<String> ret = new ArrayList<String>();
-
- for(File f : files){
- if(f.isDirectory()) ret.add(f.getName());
- }
- return ret;
- }
-
- public static ArrayList<String> getForts(Context c){
- return Utils.getFilesFromDirWithSuffix(c, "Forts", "L.png", true);
- }
- public static ArrayList<HashMap<String, ?>> getTypes(Context c){
- ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(6);
- String[] levels = {c.getString(R.string.human), c.getString(R.string.bot5), c.getString(R.string.bot4), c.getString(R.string.bot3), c.getString(R.string.bot2), c.getString(R.string.bot1)};
- int[] images = {R.drawable.human, R.drawable.bot5, R.drawable.bot4, R.drawable.bot3, R.drawable.bot2, R.drawable.bot1};
-
- for(int i = 0; i < levels.length; i++){
- HashMap<String, Object> map = new HashMap<String, Object>();
- map.put("txt", levels[i]);
- map.put("img", images[i]);
- data.add(map);
- }
-
- return data;
- }
-
- public static ArrayList<HashMap<String, ?>> getHats(Context c){
- ArrayList<String> files = Utils.getFilesFromDirWithSuffix(c, "Graphics/Hats", ".png", true);
- String pathPrefix = Utils.getDownloadPath(c) + "Graphics/Hats/";
- int size = files.size();
- ArrayList<HashMap<String, ?>> data = new ArrayList<HashMap<String, ?>>(size);
-
- HashMap<String, Object> hashmap;
- for(String s : files){
- hashmap = new HashMap<String, Object>();
- hashmap.put("txt", s);
- Bitmap b = BitmapFactory.decodeFile(pathPrefix + s + ".png");//create a full path - decode to to a bitmap
- b = Bitmap.createBitmap(b, 0,0,b.getWidth()/2, b.getWidth()/2);
- hashmap.put("img", b);
- data.add(hashmap);
- }
-
- return data;
- }
-
- public static ArrayList<HashMap<String, Object>> getTeams(Context c){
- ArrayList<HashMap<String, Object>> ret = new ArrayList<HashMap<String, Object>>();
-
- File teamsDir = new File(c.getFilesDir().getAbsolutePath() + '/' + Team.DIRECTORY_TEAMS);
- File[] teamFileNames = teamsDir.listFiles();
- if(teamFileNames != null){
- for(File s : teamFileNames){
- Team t = Team.getTeamFromXml(s.getAbsolutePath());
- if(t != null){
- ret.add(teamToHashMap(t));
- }
- }
- }
- return ret;
- }
-
- public static HashMap<String, Object> teamToHashMap(Team t){
- HashMap<String, Object> hashmap = new HashMap<String, Object>();
- hashmap.put("team", t);
- hashmap.put("txt", t.name);
- hashmap.put("color", t.color);
- hashmap.put("count", t.hogCount);
- switch(t.levels[0]){
- case 0:
- hashmap.put("img", R.drawable.human);
- break;
- case 1:
- hashmap.put("img", R.drawable.bot5);
- break;
- case 2:
- hashmap.put("img", R.drawable.bot4);
- break;
- case 3:
- hashmap.put("img", R.drawable.bot3);
- break;
- case 4:
- hashmap.put("img", R.drawable.bot2);
- break;
- default:
- case 5:
- hashmap.put("img", R.drawable.bot1);
- break;
- }
- return hashmap;
- }
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/GameConfig.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,117 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.UUID;
-
-import android.os.Parcel;
-import android.os.Parcelable;
-import android.util.Log;
-
-public class GameConfig implements Parcelable{
-
- public GameMode mode = GameMode.MODE_LOCAL;
- public Map map = null;
- public String theme = null;
- public Scheme scheme = null;
- public Weapon weapon = null;
-
- public String mission = null;
- public String seed = null;
-
- public ArrayList<Team> teams = new ArrayList<Team>();
-
- public GameConfig(){
-
- }
-
- public GameConfig(Parcel in){
- readFromParcel(in);
- }
-
-
-
- public void sendToEngine(EngineProtocolNetwork epn) throws IOException{
- Log.d("HW_Frontend", "Sending Gameconfig...");
- int teamCount = 4;
- epn.sendToEngine("TL"); //Write game mode
- if(mission != null) epn.sendToEngine(mission);
-
- //seed info
- epn.sendToEngine(String.format("eseed {%s}", UUID.randomUUID().toString()));
-
- map.sendToEngine(epn);
- //dimensions of the map
- //templatefilter_command
- //mapgen_command
- //mazesize_command
-
- epn.sendToEngine(String.format("etheme %s", theme));
-
- scheme.sendToEngine(epn);
-
- weapon.sendToEngine(epn, teamCount);
-
- for(Team t : teams){
- if(t != null)t.sendToEngine(epn, teamCount, 50);
- }
- }
-
- public int describeContents() {
- return 0;
- }
-
- public void writeToParcel(Parcel dest, int flags) {
- dest.writeString(mode.name());
- dest.writeParcelable(map, flags);
- dest.writeString(theme);
- dest.writeParcelable(scheme, flags);
- dest.writeParcelable(weapon, flags);
- dest.writeString(mission);
- dest.writeString(seed);
- dest.writeParcelableArray((Team[])teams.toArray(new Team[1]), 0);
- }
-
- private void readFromParcel(Parcel src){
- mode = GameMode.valueOf(src.readString());
- map = src.readParcelable(Map.class.getClassLoader());
- theme = src.readString();
- scheme = src.readParcelable(Scheme.class.getClassLoader());
- weapon = src.readParcelable(Weapon.class.getClassLoader());
- mission = src.readString();
- seed = src.readString();
- Parcelable[] parcelables = src.readParcelableArray(Team[].class.getClassLoader());
- for(Parcelable team : parcelables){
- teams.add((Team)team);
- }
-
- }
-
- public static final Parcelable.Creator<GameConfig> CREATOR = new Parcelable.Creator<GameConfig>() {
- public GameConfig createFromParcel(Parcel source) {
- return new GameConfig(source);
- }
- public GameConfig[] newArray(int size) {
- return new GameConfig[size];
- }
- };
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/GameMode.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,24 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.EngineProtocol;
-
-public enum GameMode {
- MODE_LOCAL, MODE_DEMO, MODE_NET, MODE_SAVE
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/Grave.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile.EngineProtocol;
-
-public class Grave{
-
- public final String name;
- public final String path;
-
- public Grave(String _name, String _path) {
- name = _name;
- path = _path;
- }
-
- public String toString(){
- return name;
- }
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/Map.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,160 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.File;
-import java.io.IOException;
-
-import android.content.Context;
-import android.graphics.drawable.Drawable;
-import android.os.Parcel;
-import android.os.Parcelable;
-
-public class Map implements Comparable<Map>, Parcelable{
-
- private static final String MISSION_PREFIX = "Mission: ";
-
- private String name;
- private String path;
- private String previewPath;
- private MapType type;
-
- public Map(File mapDir, MapType _type, Context c){
- type = _type;
-
- name = mapDir.getName();
- path = mapDir.getAbsolutePath();
- previewPath = path + "/preview.png";
-
- /*switch(type){
- case TYPE_DEFAULT:
-
- break;
- case TYPE_GENERATED:
- //TODO
- break;
- case TYPE_MISSION:
- name = MISSION_PREFIX + mapDir.getName();
- path = mapDir.getAbsolutePath();
- break;
- }*/
-
-
- }
-
- public Map(Parcel in){
- readFromParcel(in);
- }
-
- public String toString(){
- switch(type){
- default:
- case TYPE_DEFAULT:
- return name;
- case TYPE_GENERATED:
- return "bla";
- case TYPE_MISSION:
- return MISSION_PREFIX + name;
- }
- }
-
- public void sendToEngine(EngineProtocolNetwork epn) throws IOException{
- epn.sendToEngine(String.format("emap %s",name));
- }
-
- public MapType getType(){
- return type;
- }
-
- public Drawable getDrawable(){
- switch(type){
- case TYPE_MISSION:
- case TYPE_DEFAULT:
- return Drawable.createFromPath(previewPath);
- case TYPE_GENERATED:
-
- default:
- return null;
- }
- }
-
- public int compareTo(Map another) {
- switch(type){
- case TYPE_GENERATED:
- switch(another.getType()){
- case TYPE_GENERATED:
- return name.compareTo(another.name);
- case TYPE_MISSION:
- return -1;
- case TYPE_DEFAULT:
- return -1;
- }
- case TYPE_MISSION:
- switch(another.getType()){
- case TYPE_GENERATED:
- return 1;
- case TYPE_MISSION:
- return name.compareTo(another.name);
- case TYPE_DEFAULT:
- return -1;
- }
- case TYPE_DEFAULT:
- switch(another.getType()){
- case TYPE_GENERATED:
- return 1;
- case TYPE_MISSION:
- return 1;
- case TYPE_DEFAULT:
- return name.compareTo(another.name);
- }
- }
- return 0;//default case this should never happen
- }
-
- public enum MapType{
- TYPE_DEFAULT, TYPE_MISSION, TYPE_GENERATED
- }
-
- public int describeContents() {
- return 0;
- }
-
- public void writeToParcel(Parcel dest, int flags) {
- dest.writeString(name);
- dest.writeString(path);
- dest.writeString(previewPath);
- dest.writeString(type.name());
- }
-
- private void readFromParcel(Parcel src){
- name = src.readString();
- path = src.readString();
- previewPath = src.readString();
- type = MapType.valueOf(src.readString());
- }
- public static final Parcelable.Creator<Map> CREATOR = new Parcelable.Creator<Map>() {
- public Map createFromParcel(Parcel source) {
- return new Map(source);
- }
- public Map[] newArray(int size) {
- return new Map[size];
- }
-
- };
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/PascalExports.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.EngineProtocol;
-
-public class PascalExports {
-
- static{
- System.loadLibrary("SDL");
- System.loadLibrary("SDL_image");
- System.loadLibrary("mikmod");
- System.loadLibrary("SDL_net");
- System.loadLibrary("SDL_mixer");
- System.loadLibrary("SDL_ttf");
- System.loadLibrary("lua5.1");
- System.loadLibrary("hwengine");
- }
-
- public static native int HWversionInfoNetProto();
- public static native String HWversionInfoVersion();
- public static native int HWgetNumberOfWeapons();
- public static native int HWgetMaxNumberOfTeams();
- public static native int HWgetMaxNumberOfHogs();
- public static native int HWterminate(boolean b);
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/Scheme.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,358 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.FilenameFilter;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlPullParserFactory;
-
-import android.content.Context;
-import android.os.Parcel;
-import android.os.Parcelable;
-
-public class Scheme implements Parcelable{
-
- public static final String DIRECTORY_SCHEME = "schemes";
-
- private String name;
- //private ArrayList<Integer> basic;
- private Integer gamemod;
- private ArrayList<Integer> basic;;
- private static ArrayList<LinkedHashMap<String, ?>> basicflags = new ArrayList<LinkedHashMap<String, ?>>();
-
- public Scheme(String _name, ArrayList<Integer> _basic, int _gamemod){
- name = _name;
- gamemod = _gamemod;
- basic = _basic;
-
- }
-
- public Scheme(Parcel in){
- readFromParcel(in);
- }
-
- public void sendToEngine(EngineProtocolNetwork epn)throws IOException{
- epn.sendToEngine(String.format("e$gmflags %d", gamemod));
-
- for(int pos = 0; pos < basic.size(); pos++){
- LinkedHashMap<String, ?> basicflag = basicflags.get(pos);
-
- String command = (String)basicflag.get("command");
- Integer value = basic.get(pos);
- Boolean checkOverMax = (Boolean) basicflag.get("checkOverMax");
- Boolean times1000 = (Boolean) basicflag.get("times1000");
- Integer max = (Integer) basicflag.get("max");
-
- if(checkOverMax && value >= max) value = max;
- if(times1000) value *= 1000;
-
- epn.sendToEngine(String.format("%s %d", command, value));
- }
- }
- public String toString(){
- return name;
- }
-
-
- public static final int STATE_START = 0;
- public static final int STATE_ROOT = 1;
- public static final int STATE_NAME = 2;
- public static final int STATE_BASICFLAGS = 3;
- public static final int STATE_GAMEMOD = 4;
- public static final int STATE_BASICFLAG_INTEGER = 5;
- public static final int STATE_GAMEMOD_TRUE = 6;
- public static final int STATE_GAMEMOD_FALSE = 7;
-
- public static ArrayList<Scheme> getSchemes(Context c) throws IllegalArgumentException{
- String dir = c.getFilesDir().getAbsolutePath() + '/' + DIRECTORY_SCHEME + '/';
- String[] files = new File(dir).list(fnf);
- if(files == null) files = new String[]{};
- Arrays.sort(files);
- ArrayList<Scheme> schemes = new ArrayList<Scheme>();
-
- try {
- XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
- XmlPullParser xmlPuller = xmlPullFactory.newPullParser();
-
- for(String file : files){
- BufferedReader br = new BufferedReader(new FileReader(dir + file), 1024);
- xmlPuller.setInput(br);
- String name = null;
- ArrayList<Integer> basic = new ArrayList<Integer>();
- Integer gamemod = 0;
- int mask = 0x000000004;
-
- int eventType = xmlPuller.getEventType();
- int state = STATE_START;
- while(eventType != XmlPullParser.END_DOCUMENT){
- switch(state){
- case STATE_START:
- if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().equals("scheme")) state = STATE_ROOT;
- else if(eventType != XmlPullParser.START_DOCUMENT) throwException(file, eventType);
- break;
- case STATE_ROOT:
- if(eventType == XmlPullParser.START_TAG){
- if(xmlPuller.getName().equals("basicflags")) state = STATE_BASICFLAGS;
- else if(xmlPuller.getName().toLowerCase().equals("gamemod")) state = STATE_GAMEMOD;
- else if(xmlPuller.getName().toLowerCase().equals("name")) state = STATE_NAME;
- else throwException(file, eventType);
- }else if(eventType == XmlPullParser.END_TAG) state = STATE_START;
- else throwException(xmlPuller.getText(), eventType);
- break;
- case STATE_BASICFLAGS:
- if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().toLowerCase().equals("integer")) state = STATE_BASICFLAG_INTEGER;
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_GAMEMOD:
- if(eventType == XmlPullParser.START_TAG){
- if(xmlPuller.getName().toLowerCase().equals("true")) state = STATE_GAMEMOD_TRUE;
- else if(xmlPuller.getName().toLowerCase().equals("false")) state = STATE_GAMEMOD_FALSE;
- else throwException(file, eventType);
- }else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_NAME:
- if(eventType == XmlPullParser.TEXT) name = xmlPuller.getText().trim();
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_BASICFLAG_INTEGER:
- if(eventType == XmlPullParser.TEXT) basic.add(Integer.parseInt(xmlPuller.getText().trim()));
- else if(eventType == XmlPullParser.END_TAG) state = STATE_BASICFLAGS;
- else throwException(file, eventType);
- break;
- case STATE_GAMEMOD_FALSE:
- if(eventType == XmlPullParser.TEXT) gamemod <<= 1;
- else if(eventType == XmlPullParser.END_TAG) state = STATE_GAMEMOD;
- else throwException(file, eventType);
- break;
- case STATE_GAMEMOD_TRUE:
- if(eventType == XmlPullParser.TEXT){
- gamemod |= mask;
- gamemod <<= 1;
- }else if(eventType == XmlPullParser.END_TAG) state = STATE_GAMEMOD;
- else throwException(file, eventType);
- break;
- }
- eventType = getEventType(xmlPuller);
- }//end while(eventtype != END_DOCUMENT
- schemes.add(new Scheme(name, basic, gamemod));
- }//end for(string file : files
- return schemes;
- } catch (XmlPullParserException e) {
- e.printStackTrace();
- } catch (FileNotFoundException e) {
- e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- }
- return new ArrayList<Scheme>();//TODO handle correctly
- }
-
- private static FilenameFilter fnf = new FilenameFilter(){
- public boolean accept(File dir, String filename) {
- return filename.toLowerCase().startsWith("scheme_");
- }
- };
-
- /**
- * This method will parse the basic flags from a prespecified xml file.
- * I use a raw xml file rather than one parsed by aatp at compile time
- * to keep it generic with other frontends, ie in the future we could
- * use one provided by the Data folder.
- */
- public static void parseBasicFlags(Context c){
- String filename = String.format("%s/%s/basicflags", c.getFilesDir().getAbsolutePath(), DIRECTORY_SCHEME);
-
- XmlPullParser xmlPuller = null;
- BufferedReader br = null;
- try {
- XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
- xmlPuller = xmlPullFactory.newPullParser();
- br = new BufferedReader(new FileReader(filename), 1024);
- xmlPuller.setInput(br);
-
- int eventType = getEventType(xmlPuller);
- boolean continueParsing = true;
- do{
- switch(eventType){
-
- case XmlPullParser.START_TAG:
- if(xmlPuller.getName().toLowerCase().equals("flag")){
- basicflags.add(parseFlag(xmlPuller));
- }else if(xmlPuller.getName().toLowerCase().equals("basicflags")){
- eventType = getEventType(xmlPuller);
- }else{
- skipCurrentTag(xmlPuller);
- eventType = getEventType(xmlPuller);
- }
- break;
- case XmlPullParser.START_DOCUMENT://ignore all tags not being "flag"
- case XmlPullParser.END_TAG:
- case XmlPullParser.TEXT:
- default:
- continueParsing = true;
- case XmlPullParser.END_DOCUMENT:
- continueParsing = false;
- }
- }while(continueParsing);
-
- }catch(IOException e){
- e.printStackTrace();
- }catch (XmlPullParserException e) {
- e.printStackTrace();
- }finally{
- if(br != null)
- try {
- br.close();
- } catch (IOException e) {}
- }
-
- }
-
- /*
- * * Parses a Tag structure from xml as example we use
- *<flag>
- * <checkOverMax>
- * <boolean>false</boolean>
- * </checkOverMax>
- *</flag>
- *
- * It returns a LinkedHashMap with key/value pairs
- */
- private static LinkedHashMap<String, Object> parseFlag(XmlPullParser xmlPuller)throws XmlPullParserException, IOException{
- LinkedHashMap<String, Object> hash = new LinkedHashMap<String, Object>();
-
- int eventType = xmlPuller.getEventType();//Get the event type which triggered this method
- if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().toLowerCase().equals("flag")){//valid start of flag tag
- String lcKey = null;
- String lcType = null;
- String value = null;
-
- eventType = getEventType(xmlPuller);//<checkOverMax>
- while(eventType == XmlPullParser.START_TAG){
- lcKey = xmlPuller.getName();//checkOverMax
- if(getEventType(xmlPuller) == XmlPullParser.START_TAG){//<boolean>
- lcType = xmlPuller.getName().toLowerCase();
- if(getEventType(xmlPuller) == XmlPullParser.TEXT){
- value = xmlPuller.getText();
- if(getEventType(xmlPuller) == XmlPullParser.END_TAG && //</boolean>
- getEventType(xmlPuller) == XmlPullParser.END_TAG){//</checkOverMax>
- if(lcType.equals("boolean")) hash.put(lcKey, new Boolean(value));
- else if(lcType.equals("string"))hash.put(lcKey, value);
- else if(lcType.equals("integer")){
- try{
- hash.put(lcKey, new Integer(value));
- }catch (NumberFormatException e){
- throw new XmlPullParserException("Wrong integer value in xml file");
- }
- }else{
- throwException("basicflags", eventType);
- }
- }//</boolean> / </checkOverMax>
- }//if TEXT
- }//if boolean
- eventType = getEventType(xmlPuller);//start new loop
- }
- eventType = getEventType(xmlPuller);//</flag>
- }
-
- return hash;
- }
-
- private static void skipCurrentTag(XmlPullParser xmlPuller) throws XmlPullParserException, IOException{
- int eventType = xmlPuller.getEventType();
- if(eventType != XmlPullParser.START_TAG)return;
- String tag = xmlPuller.getName().toLowerCase();
-
- while(true){
- eventType = getEventType(xmlPuller);//getNext()
- switch(eventType){
- case XmlPullParser.START_DOCUMENT://we're inside of a start tag so START_ or END_DOCUMENT is just wrong
- case XmlPullParser.END_DOCUMENT:
- throw new XmlPullParserException("invalid xml file");
- case XmlPullParser.START_TAG://if we get a new tag recursively handle it
- skipCurrentTag(xmlPuller);
- break;
- case XmlPullParser.TEXT:
- break;
- case XmlPullParser.END_TAG:
- if(!xmlPuller.getName().toLowerCase().equals(tag)){//if the end tag doesn't match the start tag
- throw new XmlPullParserException("invalid xml file");
- }else{
- return;//skip completed
- }
-
- }
- }
- }
-
- /**
- * Skips whitespaces..
- */
- private static int getEventType(XmlPullParser xmlPuller)throws XmlPullParserException, IOException{
- int eventType = xmlPuller.next();
- while(eventType == XmlPullParser.TEXT && xmlPuller.isWhitespace()){
- eventType = xmlPuller.next();
- }
- return eventType;
- }
- private static void throwException(String file, int eventType){
- throw new IllegalArgumentException(String.format("Xml file: %s malformed with error: %d.", file, eventType));
- }
-
- public int describeContents() {
- // TODO Auto-generated method stub
- return 0;
- }
-
- public void writeToParcel(Parcel dest, int flags) {
- dest.writeString(name);
- dest.writeInt(gamemod);
- dest.writeList(basic);
-
- }
-
- public void readFromParcel(Parcel src){
- name = src.readString();
- gamemod = src.readInt();
- basic = src.readArrayList(ArrayList.class.getClassLoader());
- }
-
- public static final Parcelable.Creator<Scheme> CREATOR = new Parcelable.Creator<Scheme>() {
- public Scheme createFromParcel(Parcel source) {
- return new Scheme(source);
- }
- public Scheme[] newArray(int size) {
- return new Scheme[size];
- }
-
- };
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/Team.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,345 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.BufferedReader;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.ArrayList;
-
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlPullParserFactory;
-import org.xmlpull.v1.XmlSerializer;
-
-import android.os.Parcel;
-import android.os.Parcelable;
-import android.util.Xml;
-
-public class Team implements Parcelable{
-
- public static final String DIRECTORY_TEAMS = "teams";
- private static final Integer[] TEAM_COLORS = {
- 0xd12b42, /* red */
- 0x4980c1, /* blue */
- 0x6ab530, /* green */
- 0xbc64c4, /* purple */
- 0xe76d14, /* orange */
- 0x3fb6e6, /* cyan */
- 0xe3e90c, /* yellow */
- 0x61d4ac, /* mint */
- 0xf1c3e1, /* pink */
- /* add new colors here */
- };
-
-// private static final Integer[] TEAM_COLORS = {
-// 0xff0000, /* red */
-// 0x00ff00, /* blue */
-// 0x0000ff, /* green */
-// };
-
- private static final int STATE_START = 0;
- private static final int STATE_ROOT = 1;
- private static final int STATE_HOG_ROOT = 2;
-
- public String name, grave, flag, voice, fort, hash;
-
- public static int maxNumberOfHogs = 0;
- public static int maxNumberOfTeams = 0;
-
- static{
- maxNumberOfHogs = PascalExports.HWgetMaxNumberOfHogs();
- maxNumberOfTeams = PascalExports.HWgetMaxNumberOfTeams();
- }
- public String[] hats = new String[maxNumberOfHogs];
- public String[] hogNames = new String[maxNumberOfHogs];
- public int[] levels = new int[maxNumberOfHogs];
-
- public int hogCount = 4;
- public int color = TEAM_COLORS[0];
-
- public Team(){
- }
-
- public Team(Parcel in){
- readFromParcel(in);
- }
-
- public boolean equals(Object o){
- if(super.equals(o)) return true;
- else if(o instanceof Team){
- Team t = (Team)o;
- boolean ret = name.equals(t.name);
- ret &= grave.equals(t.grave);
- ret &= flag.equals(t.flag);
- ret &= voice.equals(t.voice);
- ret &= fort.equals(t.fort);
- ret &= hash.equals(t.hash);
- return ret;
- }else{
- return false;
- }
- }
-
- public void setRandomColor(int[] illegalcolors){
- Integer[] colorsToPickFrom = TEAM_COLORS;
- if(illegalcolors != null){
- ArrayList<Integer> colors = new ArrayList<Integer>();
- for(int color : TEAM_COLORS){
- boolean validColor = true;
- for(int illegal : illegalcolors){
- if(color == illegal) validColor = false;
- }
- if(validColor) colors.add(color);
- }
- if(colors.size() != 0) colorsToPickFrom = colors.toArray(new Integer[1]);
- }
- int index = (int)Math.round(Math.random()*(colorsToPickFrom.length-1));
- color = colorsToPickFrom[index];
- }
-
-
- public void sendToEngine(EngineProtocolNetwork epn, int hogCount, int health) throws IOException{
- epn.sendToEngine(String.format("eaddteam %s %d %s", hash, color, name));
- epn.sendToEngine(String.format("egrave %s", grave));
- epn.sendToEngine(String.format("efort %s", fort));
- epn.sendToEngine(String.format("evoicepack %s", voice));
- epn.sendToEngine(String.format("eflag %s", flag));
-
- for(int i = 0; i < hogCount; i++){
- epn.sendToEngine(String.format("eaddhh %d %d %s", levels[i], health, hogNames[i]));
- epn.sendToEngine(String.format("ehat %s", hats[i]));
- }
- }
-
- /*
- * XML METHODS
- */
-
- /**
- * Read the xml file path and convert it to a Team object
- * @param path absolute path to the xml file
- * @return
- */
- public static Team getTeamFromXml(String path){
- try {
- XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
- XmlPullParser xmlPuller = xmlPullFactory.newPullParser();
-
- BufferedReader br = new BufferedReader(new FileReader(path), 1024);
- xmlPuller.setInput(br);
- Team team = new Team();
- int hogCounter = 0;
-
- int eventType = xmlPuller.getEventType();
- int state = STATE_START;
- while(eventType != XmlPullParser.END_DOCUMENT){
- switch(state){
- case STATE_START:
- if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().equals("team")) state = STATE_ROOT;
- else if(eventType != XmlPullParser.START_DOCUMENT) throwException(path, eventType);
- break;
- case STATE_ROOT:
- if(eventType == XmlPullParser.START_TAG){
- if(xmlPuller.getName().toLowerCase().equals("name")){
- team.name = getXmlText(xmlPuller, "name");
- }else if(xmlPuller.getName().toLowerCase().equals("flag")){
- team.flag= getXmlText(xmlPuller, "flag");
- }else if(xmlPuller.getName().toLowerCase().equals("voice")){
- team.voice = getXmlText(xmlPuller, "voice");
- }else if(xmlPuller.getName().toLowerCase().equals("grave")){
- team.grave = getXmlText(xmlPuller, "grave");
- }else if(xmlPuller.getName().toLowerCase().equals("fort")){
- team.fort = getXmlText(xmlPuller, "fort");
- }else if(xmlPuller.getName().toLowerCase().equals("hash")){
- team.hash = getXmlText(xmlPuller, "hash");
- }else if(xmlPuller.getName().toLowerCase().equals("hog")){
- state = STATE_HOG_ROOT;
- }else throwException(xmlPuller.getName(), eventType);
- }else if(eventType == XmlPullParser.END_TAG) state = STATE_START;
- else throwException(xmlPuller.getText(), eventType);
- break;
- case STATE_HOG_ROOT:
- if(eventType == XmlPullParser.START_TAG){
- if(xmlPuller.getName().toLowerCase().equals("name")){
- team.hogNames[hogCounter] = getXmlText(xmlPuller, "name");
- }else if(xmlPuller.getName().toLowerCase().equals("hat")){
- team.hats[hogCounter] = getXmlText(xmlPuller, "hat");
- }else if(xmlPuller.getName().toLowerCase().equals("level")){
- team.levels[hogCounter] = Integer.parseInt(getXmlText(xmlPuller, "level"));
- }else throwException(xmlPuller.getText(), eventType);
- }else if(eventType == XmlPullParser.END_TAG){
- hogCounter++;
- state = STATE_ROOT;
- }else throwException(xmlPuller.getText(), eventType);
- break;
- }
- eventType = getEventType(xmlPuller);
- }//end while(eventtype != END_DOCUMENT
- return team;
- } catch (NumberFormatException e){
- e.printStackTrace();
- } catch (XmlPullParserException e) {
- e.printStackTrace();
- } catch (FileNotFoundException e) {
- e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- }
- return null;
- }
-
- private static String getXmlText(XmlPullParser xmlPuller, String parentTag)throws XmlPullParserException, IOException{
- if(getEventType(xmlPuller) == XmlPullParser.TEXT){
- String txt = xmlPuller.getText();
- if(getEventType(xmlPuller) == XmlPullParser.END_TAG && xmlPuller.getName().toLowerCase().equals(parentTag)){
- return txt;
- }
- }
- throw new XmlPullParserException("malformed xml file on string read from tag: " + parentTag);
- }
-
- /**
- * Skips whitespaces..
- */
- private static int getEventType(XmlPullParser xmlPuller)throws XmlPullParserException, IOException{
- int eventType = xmlPuller.next();
- while(eventType == XmlPullParser.TEXT && xmlPuller.isWhitespace()){
- eventType = xmlPuller.next();
- }
- return eventType;
- }
-
- private static void throwException(String file, int eventType){
- throw new IllegalArgumentException(String.format("Xml file: %s malformed with error: %d.", file, eventType));
- }
-
- public void writeToXml(OutputStream os){
- XmlSerializer serializer = Xml.newSerializer();
- try{
- serializer.setOutput(os, "UTF-8");
- serializer.startDocument("UTF-8", true);
- serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
-
- serializer.startTag(null, "team");
- serializer.startTag(null, "name");
- serializer.text(name);
- serializer.endTag(null, "name");
- serializer.startTag(null, "flag");
- serializer.text(flag);
- serializer.endTag(null, "flag");
- serializer.startTag(null, "fort");
- serializer.text(fort);
- serializer.endTag(null, "fort");
- serializer.startTag(null, "grave");
- serializer.text(grave);
- serializer.endTag(null, "grave");
- serializer.startTag(null, "voice");
- serializer.text(voice);
- serializer.endTag(null, "voice");
- serializer.startTag(null, "hash");
- serializer.text(hash);
- serializer.endTag(null, "hash");
-
- for(int i = 0; i < maxNumberOfHogs; i++){
- serializer.startTag(null, "hog");
- serializer.startTag(null, "name");
- serializer.text(hogNames[i]);
- serializer.endTag(null, "name");
- serializer.startTag(null, "hat");
- serializer.text(hats[i]);
- serializer.endTag(null, "hat");
- serializer.startTag(null, "level");
- serializer.text(String.valueOf(levels[i]));
- serializer.endTag(null, "level");
-
- serializer.endTag(null, "hog");
- }
- serializer.endTag(null, "team");
- serializer.endDocument();
- serializer.flush();
-
- } catch (IOException e) {
- e.printStackTrace();
- }finally{
- try {
- os.close();
- } catch (IOException e) {}
- }
- }
- /*
- * END XML METHODS
- */
-
-
-
- /*
- * PARCABLE METHODS
- */
-
- public int describeContents() {
- return 0;
- }
-
- public void writeToParcel(Parcel dest, int flags) {
- dest.writeString(name);
- dest.writeString(grave);
- dest.writeString(flag);
- dest.writeString(voice);
- dest.writeString(fort);
- dest.writeString(hash);
- dest.writeStringArray(hats);
- dest.writeStringArray(hogNames);
- dest.writeIntArray(levels);
- dest.writeInt(color);
- dest.writeInt(hogCount);
- }
-
-
- public void readFromParcel(Parcel src){
- name = src.readString();
- grave = src.readString();
- flag = src.readString();
- voice = src.readString();
- fort = src.readString();
- hash = src.readString();
- src.readStringArray(hats);
- src.readStringArray(hogNames);
- src.readIntArray(levels);
- color = src.readInt();
- hogCount = src.readInt();
- }
-
- public static final Parcelable.Creator<Team> CREATOR = new Parcelable.Creator<Team>() {
- public Team createFromParcel(Parcel source) {
- return new Team(source);
- }
- public Team[] newArray(int size) {
- return new Team[size];
- }
-
- };
-
- /*
- * END PARCABLE METHODS
- */
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/EngineProtocol/Weapon.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,212 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.EngineProtocol;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlPullParserFactory;
-
-import android.content.Context;
-import android.os.Parcel;
-import android.os.Parcelable;
-
-public class Weapon implements Parcelable{
-
- public static final String DIRECTORY_WEAPON = "weapons";
-
- private String name;
- private String QT;
- private String prob;
- private String delay;
- private String crate;
- private static int maxWeapons;
-
- static{
- //maxWeapons = PascalExports.HWgetNumberOfWeapons();
- }
-
- public Weapon(String _name, String _QT, String _prob, String _delay, String _crate){
- name = _name;
-
- //Incase there's a newer ammoStore which is bigger we append with zeros
- StringBuffer sb = new StringBuffer();
- while(_QT.length() + sb.length() < maxWeapons){
- sb.append('0');
- }
-
- QT = String.format("e%s %s%s", "ammloadt", _QT, sb);
- prob = String.format("e%s %s%s", "ammprob", _prob, sb);
- delay = String.format("e%s %s%s", "ammdelay", _delay, sb);
- crate = String.format("e%s %s%s", "ammreinf", _crate, sb);
- }
-
- public Weapon(Parcel in){
- readFromParcel(in);
- }
-
- public String toString(){
- return name;
- }
-
- public void sendToEngine(EngineProtocolNetwork epn, int teamsCount) throws IOException{
- epn.sendToEngine(QT);//command prefix is already in string
- epn.sendToEngine(prob);
- epn.sendToEngine(delay);
- epn.sendToEngine(crate);
-
- for(int i = 0; i < teamsCount; i++){
- epn.sendToEngine("eammstore");
- }
- }
-
- public static final int STATE_START = 0;
- public static final int STATE_ROOT = 1;
- public static final int STATE_NAME = 2;
- public static final int STATE_QT = 3;
- public static final int STATE_PROBABILITY = 4;
- public static final int STATE_DELAY = 5;
- public static final int STATE_CRATE = 6;
-
- public static ArrayList<Weapon> getWeapons(Context c) throws IllegalArgumentException{
- String dir = c.getFilesDir().getAbsolutePath() + '/' + DIRECTORY_WEAPON + '/';
- String[] files = new File(dir).list();
- if(files == null) files = new String[]{};
- Arrays.sort(files);
-
- ArrayList<Weapon> weapons = new ArrayList<Weapon>();
-
- try {
- XmlPullParserFactory xmlPullFactory = XmlPullParserFactory.newInstance();
- XmlPullParser xmlPuller = xmlPullFactory.newPullParser();
-
- for(String file : files){
- BufferedReader br = new BufferedReader(new FileReader(dir + file), 1024);
- xmlPuller.setInput(br);
- String name = null;
- String qt = null;
- String prob = null;
- String delay = null;
- String crate = null;
-
- int eventType = xmlPuller.getEventType();
- int state = STATE_START;
- while(eventType != XmlPullParser.END_DOCUMENT){
- switch(state){
- case STATE_START:
- if(eventType == XmlPullParser.START_TAG && xmlPuller.getName().equals("weapon")) state = STATE_ROOT;
- else if(eventType != XmlPullParser.START_DOCUMENT) throwException(file, eventType);
- break;
- case STATE_ROOT:
- if(eventType == XmlPullParser.START_TAG){
- if(xmlPuller.getName().toLowerCase().equals("qt")) state = STATE_QT;
- else if(xmlPuller.getName().toLowerCase().equals("name")) state = STATE_NAME;
- else if(xmlPuller.getName().toLowerCase().equals("probability")) state = STATE_PROBABILITY;
- else if(xmlPuller.getName().toLowerCase().equals("delay")) state = STATE_DELAY;
- else if(xmlPuller.getName().toLowerCase().equals("crate")) state = STATE_CRATE;
- else throwException(file, eventType);
- }else if(eventType == XmlPullParser.END_TAG) state = STATE_START;
- else throwException(xmlPuller.getText(), eventType);
- break;
- case STATE_NAME:
- if(eventType == XmlPullParser.TEXT) name = xmlPuller.getText().trim();
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_QT:
- if(eventType == XmlPullParser.TEXT) qt = xmlPuller.getText().trim();
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_PROBABILITY:
- if(eventType == XmlPullParser.TEXT) prob = xmlPuller.getText().trim();
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_DELAY:
- if(eventType == XmlPullParser.TEXT) delay = xmlPuller.getText().trim();
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- case STATE_CRATE:
- if(eventType == XmlPullParser.TEXT) crate = xmlPuller.getText().trim();
- else if(eventType == XmlPullParser.END_TAG) state = STATE_ROOT;
- else throwException(file, eventType);
- break;
- }
- eventType = xmlPuller.next();
- while(eventType == XmlPullParser.TEXT && xmlPuller.isWhitespace()){//Skip whitespaces
- eventType = xmlPuller.next();
- }
- }//end while(eventtype != END_DOCUMENT
- weapons.add(new Weapon(name, qt, prob, delay, crate));
- }//end for(string file : files
- return weapons;
-
- } catch (XmlPullParserException e) {
- e.printStackTrace();
- } catch (FileNotFoundException e) {
- e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- }
- return new ArrayList<Weapon>();//TODO handle correctly
- }
-
- private static void throwException(String file, int eventType){
- throw new IllegalArgumentException(String.format("Xml file: %s malformed with eventType: %d.", file, eventType));
- }
-
- public int describeContents() {
- return 0;
- }
-
- public void writeToParcel(Parcel dest, int flags) {
- dest.writeString(name);
- dest.writeString(QT);
- dest.writeString(prob);
- dest.writeString(delay);
- dest.writeString(crate);
- }
-
- private void readFromParcel(Parcel src){
- name = src.readString();
- QT = src.readString();
- prob = src.readString();
- delay = src.readString();
- crate = src.readString();
- }
-
- public static final Parcelable.Creator<Weapon> CREATOR = new Parcelable.Creator<Weapon>() {
- public Weapon createFromParcel(Parcel source) {
- return new Weapon(source);
- }
- public Weapon[] newArray(int size) {
- return new Weapon[size];
- }
-
- };
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/MainActivity.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile;
-
-import org.hedgewars.mobile.Downloader.DownloadActivity;
-import org.hedgewars.mobile.Downloader.DownloadService;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.os.Bundle;
-import android.preference.PreferenceManager;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.Button;
-import android.widget.Toast;
-
-public class MainActivity extends Activity {
-
- Button downloader, startGame;
-
- public void onCreate(Bundle sis){
- super.onCreate(sis);
- setContentView(R.layout.main);
-
- downloader = (Button)findViewById(R.id.downloader);
- startGame = (Button)findViewById(R.id.startGame);
-
- downloader.setOnClickListener(downloadClicker);
- startGame.setOnClickListener(startGameClicker);
- }
-
-
-
- private OnClickListener downloadClicker = new OnClickListener(){
- public void onClick(View v){
- startActivityForResult(new Intent(getApplicationContext(), DownloadActivity.class), 0);
- }
- };
-
- private OnClickListener startGameClicker = new OnClickListener(){
- public void onClick(View v){
- if(PreferenceManager.getDefaultSharedPreferences(MainActivity.this).getBoolean(DownloadService.PREF_DOWNLOADED, false))
- startActivity(new Intent(getApplicationContext(), StartGameActivity.class));
- else {
- Toast.makeText(MainActivity.this, R.string.download_userexplain, Toast.LENGTH_LONG).show();
- startActivityForResult(new Intent(getApplicationContext(), DownloadActivity.class), 0);
- }
- }
- };
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/SDLActivity.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,565 +0,0 @@
-package org.hedgewars.mobile;
-
-import javax.microedition.khronos.egl.EGL10;
-import javax.microedition.khronos.egl.EGLConfig;
-import javax.microedition.khronos.egl.EGLContext;
-import javax.microedition.khronos.egl.EGLDisplay;
-import javax.microedition.khronos.egl.EGLSurface;
-
-import org.hedgewars.mobile.EngineProtocol.EngineProtocolNetwork;
-import org.hedgewars.mobile.EngineProtocol.GameConfig;
-import org.hedgewars.mobile.EngineProtocol.PascalExports;
-import org.hedgewars.mobile.TouchInterface.TouchInterface;
-
-import android.app.Activity;
-import android.content.Context;
-import android.graphics.Canvas;
-import android.graphics.PixelFormat;
-import android.hardware.Sensor;
-import android.hardware.SensorEvent;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
-import android.media.AudioFormat;
-import android.media.AudioManager;
-import android.media.AudioTrack;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.Message;
-import android.util.Log;
-import android.view.KeyEvent;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-import android.view.View;
-
-/**
- * SDL Activity
- */
-public class SDLActivity extends Activity {
-
- // Main components
- public static SDLActivity mSingleton;
- public static SDLSurface mSurface;
-
- // Audio
- private static Thread mAudioThread;
- private static AudioTrack mAudioTrack;
-
- // Load the .so
- static {
- System.loadLibrary("SDL");
- System.loadLibrary("SDL_image");
- System.loadLibrary("mikmod");
- System.loadLibrary("SDL_net");
- System.loadLibrary("SDL_mixer");
- System.loadLibrary("SDL_ttf");
- System.loadLibrary("lua5.1");
- System.loadLibrary("hwengine");
- System.loadLibrary("main");
- }
-
- // Setup
- protected void onCreate(Bundle savedInstanceState) {
- // Log.v("SDL", "onCreate()");
- super.onCreate(savedInstanceState);
-
- // So we can call stuff from static callbacks
- mSingleton = this;
-
- // Set up the surface
- GameConfig config = getIntent().getParcelableExtra("config");
- mSurface = new SDLSurface(getApplication(), config);
- setContentView(mSurface);
- SurfaceHolder holder = mSurface.getHolder();
- holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
- }
-
- // Events
- protected void onPause() {
- // Log.v("SDL", "onPause()");
- super.onPause();
-
- }
-
- protected void onResume() {
- // Log.v("SDL", "onResume()");
- super.onResume();
- }
-
- public void onBackPressed(){
- nativeQuit();
- super.onBackPressed();
- }
-
- // Messages from the SDLMain thread
- static int COMMAND_CHANGE_TITLE = 1;
-
- // Handler for the messages
- Handler commandHandler = new Handler() {
- public void handleMessage(Message msg) {
- if (msg.arg1 == COMMAND_CHANGE_TITLE) {
- setTitle((String) msg.obj);
- }
- }
- };
-
- // Send a message from the SDLMain thread
- void sendCommand(int command, Object data) {
- Message msg = commandHandler.obtainMessage();
- msg.arg1 = command;
- msg.obj = data;
- commandHandler.sendMessage(msg);
- }
-
- // C functions we call
- public static native void nativeInit(String[] argv);
-
- public static native void nativeQuit();
-
- public static native void onNativeResize(int x, int y, int format);
-
- public static native void onNativeKeyDown(int keycode);
-
- public static native void onNativeKeyUp(int keycode);
-
- public static native void onNativeTouch(int action, int pointer, float x, float y,
- float p);
-
- public static native void onNativeAccel(float x, float y, float z);
-
- public static native void nativeRunAudioThread();
-
- // Java functions called from C
-
- public static boolean createGLContext(int majorVersion, int minorVersion) {
- return mSurface.initEGL(majorVersion, minorVersion);
- }
-
- public static void flipBuffers() {
- mSurface.flipEGL();
- }
-
- public static void setActivityTitle(String title) {
- // Called from SDLMain() thread and can't directly affect the view
- mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
- }
-
- // Audio
- private static Object buf;
-
- public static Object audioInit(int sampleRate, boolean is16Bit,
- boolean isStereo, int desiredFrames) {
- int channelConfig = isStereo ? AudioFormat.CHANNEL_CONFIGURATION_STEREO
- : AudioFormat.CHANNEL_CONFIGURATION_MONO;
- int audioFormat = is16Bit ? AudioFormat.ENCODING_PCM_16BIT
- : AudioFormat.ENCODING_PCM_8BIT;
- int frameSize = (isStereo ? 2 : 1) * (is16Bit ? 2 : 1);
-
- Log.v("SDL", "SDL audio: wanted " + (isStereo ? "stereo" : "mono")
- + " " + (is16Bit ? "16-bit" : "8-bit") + " "
- + ((float) sampleRate / 1000f) + "kHz, " + desiredFrames
- + " frames buffer");
-
- // Let the user pick a larger buffer if they really want -- but ye
- // gods they probably shouldn't, the minimums are horrifyingly high
- // latency already
- desiredFrames = Math.max(
- desiredFrames,
- (AudioTrack.getMinBufferSize(sampleRate, channelConfig,
- audioFormat) + frameSize - 1)
- / frameSize);
-
- mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
- channelConfig, audioFormat, desiredFrames * frameSize,
- AudioTrack.MODE_STREAM);
-
- audioStartThread();
-
- Log.v("SDL",
- "SDL audio: got "
- + ((mAudioTrack.getChannelCount() >= 2) ? "stereo"
- : "mono")
- + " "
- + ((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit"
- : "8-bit") + " "
- + ((float) mAudioTrack.getSampleRate() / 1000f)
- + "kHz, " + desiredFrames + " frames buffer");
-
- if (is16Bit) {
- buf = new short[desiredFrames * (isStereo ? 2 : 1)];
- } else {
- buf = new byte[desiredFrames * (isStereo ? 2 : 1)];
- }
- return buf;
- }
-
- public static void audioStartThread() {
- mAudioThread = new Thread(new Runnable() {
- public void run() {
- mAudioTrack.play();
- nativeRunAudioThread();
- }
- });
-
- // I'd take REALTIME if I could get it!
- mAudioThread.setPriority(Thread.MAX_PRIORITY);
- mAudioThread.start();
- }
-
- public static void audioWriteShortBuffer(short[] buffer) {
- for (int i = 0; i < buffer.length;) {
- int result = mAudioTrack.write(buffer, i, buffer.length - i);
- if (result > 0) {
- i += result;
- } else if (result == 0) {
- try {
- Thread.sleep(1);
- } catch (InterruptedException e) {
- // Nom nom
- }
- } else {
- Log.w("SDL", "SDL audio: error return from write(short)");
- return;
- }
- }
- }
-
- public static void audioWriteByteBuffer(byte[] buffer) {
- for (int i = 0; i < buffer.length;) {
- int result = mAudioTrack.write(buffer, i, buffer.length - i);
- if (result > 0) {
- i += result;
- } else if (result == 0) {
- try {
- Thread.sleep(1);
- } catch (InterruptedException e) {
- // Nom nom
- }
- } else {
- Log.w("SDL", "SDL audio: error return from write(short)");
- return;
- }
- }
- }
-
- public static void audioQuit() {
- if (mAudioThread != null) {
- try {
- mAudioThread.join();
- } catch (Exception e) {
- Log.v("SDL", "Problem stopping audio thread: " + e);
- }
- mAudioThread = null;
-
- // Log.v("SDL", "Finished waiting for audio thread");
- }
-
- if (mAudioTrack != null) {
- mAudioTrack.stop();
- mAudioTrack = null;
- }
- }
-}
-
-/**
- * Simple nativeInit() runnable
- */
-class SDLMain implements Runnable {
- private int surfaceWidth, surfaceHeight;
- private GameConfig config;
-
- public SDLMain(int width, int height, GameConfig _config) {
- config = _config;
- surfaceWidth = width;
- surfaceHeight = height;
- }
-
- public void run() {
- //Set up the IPC socket server to communicate with the engine
- EngineProtocolNetwork ipc = new EngineProtocolNetwork(config);
-
- String path = Utils.getDownloadPath(SDLActivity.mSingleton);//This represents the data directory
- path = path.substring(0, path.length()-1);//remove the trailing '/'
-
-
- // Runs SDL_main() with added parameters
- SDLActivity.nativeInit(new String[] { String.valueOf(ipc.port),
- String.valueOf(surfaceWidth), String.valueOf(surfaceHeight),
- "0", "null", "xeli", "1", "1", "1", path, "" });
-
- try {
- ipc.quitIPC();
- ipc.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- //Log.v("SDL", "SDL thread terminated");
- SDLActivity.mSingleton.finish();
- }
-}
-
-/**
- * SDLSurface. This is what we draw on, so we need to know when it's created in
- * order to do anything useful.
- *
- * Because of this, that's where we set up the SDL thread
- */
-class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
- View.OnKeyListener, SensorEventListener {
-
- // This is what SDL runs in. It invokes SDL_main(), eventually
- private Thread mSDLThread;
-
- // EGL private objects
- private EGLContext mEGLContext;
- private EGLSurface mEGLSurface;
- private EGLDisplay mEGLDisplay;
-
- // Sensors
- private static SensorManager mSensorManager;
-
- private GameConfig config;
-
- // Startup
- public SDLSurface(Context context, GameConfig _config) {
- super(context);
- getHolder().addCallback(this);
-
- setFocusable(true);
- setFocusableInTouchMode(true);
- requestFocus();
- setOnKeyListener(this);
- setOnTouchListener(TouchInterface.getTouchInterface());
-
- mSensorManager = (SensorManager) context.getSystemService("sensor");
-
- config = _config;
- }
-
- // Called when we have a valid drawing surface
- public void surfaceCreated(SurfaceHolder holder) {
- Log.v("SDL", "surfaceCreated()");
-
- //enableSensor(Sensor.TYPE_ACCELEROMETER, true);
- }
-
- // Called when we lose the surface
- public void surfaceDestroyed(SurfaceHolder holder) {
- Log.v("SDL", "surfaceDestroyed()");
-
- // Send a quit message to the application
- //SDLActivity.nativeQuit();
- PascalExports.HWterminate(true);
-
- // Now wait for the SDL thread to quit
- if (mSDLThread != null) {
- try {
- mSDLThread.join();
- } catch (Exception e) {
- Log.v("SDL", "Problem stopping thread: " + e);
- }
- mSDLThread = null;
-
- Log.v("SDL", "Finished waiting for SDL thread");
- }
-
- //enableSensor(Sensor.TYPE_ACCELEROMETER, false);
- }
-
- // Called when the surface is resized
- public void surfaceChanged(SurfaceHolder holder, int format, int width,
- int height) {
- Log.d("SDL", "surfaceChanged()" + width + " + " + height);
-
- int sdlFormat = 0x85151002; // SDL_PIXELFORMAT_RGB565 by default
- switch (format) {
- case PixelFormat.A_8:
- Log.v("SDL", "pixel format A_8");
- break;
- case PixelFormat.LA_88:
- Log.v("SDL", "pixel format LA_88");
- break;
- case PixelFormat.L_8:
- Log.v("SDL", "pixel format L_8");
- break;
- case PixelFormat.RGBA_4444:
- Log.v("SDL", "pixel format RGBA_4444");
- sdlFormat = 0x85421002; // SDL_PIXELFORMAT_RGBA4444
- break;
- case PixelFormat.RGBA_5551:
- Log.v("SDL", "pixel format RGBA_5551");
- sdlFormat = 0x85441002; // SDL_PIXELFORMAT_RGBA5551
- break;
- case PixelFormat.RGBA_8888:
- Log.v("SDL", "pixel format RGBA_8888");
- sdlFormat = 0x86462004; // SDL_PIXELFORMAT_RGBA8888
- break;
- case PixelFormat.RGBX_8888:
- Log.v("SDL", "pixel format RGBX_8888");
- sdlFormat = 0x86262004; // SDL_PIXELFORMAT_RGBX8888
- break;
- case PixelFormat.RGB_332:
- Log.v("SDL", "pixel format RGB_332");
- sdlFormat = 0x84110801; // SDL_PIXELFORMAT_RGB332
- break;
- case PixelFormat.RGB_565:
- Log.v("SDL", "pixel format RGB_565");
- sdlFormat = 0x85151002; // SDL_PIXELFORMAT_RGB565
- break;
- case PixelFormat.RGB_888:
- Log.v("SDL", "pixel format RGB_888");
- // Not sure this is right, maybe SDL_PIXELFORMAT_RGB24 instead?
- sdlFormat = 0x86161804; // SDL_PIXELFORMAT_RGB888
- break;
- default:
- Log.v("SDL", "pixel format unknown " + format);
- break;
- }
- SDLActivity.onNativeResize(width, height, sdlFormat);
-
- // Now start up the C app thread
- if (mSDLThread == null) {
- mSDLThread = new Thread(new SDLMain(width, height, config),
- "SDLThread");
- mSDLThread.start();
- }
- }
-
- // unused
- public void onDraw(Canvas canvas) {
- }
-
- // EGL functions
- public boolean initEGL(int majorVersion, int minorVersion) {
- Log.v("SDL", "Starting up OpenGL ES " + majorVersion + "."
- + minorVersion);
-
- try {
- EGL10 egl = (EGL10) EGLContext.getEGL();
-
- EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
-
- int[] version = new int[2];
- egl.eglInitialize(dpy, version);
-
- int EGL_OPENGL_ES_BIT = 1;
- int EGL_OPENGL_ES2_BIT = 4;
- int renderableType = 0;
- if (majorVersion == 2) {
- renderableType = EGL_OPENGL_ES2_BIT;
- } else if (majorVersion == 1) {
- renderableType = EGL_OPENGL_ES_BIT;
- }
- int[] configSpec = {
- // EGL10.EGL_DEPTH_SIZE, 16,
- EGL10.EGL_RENDERABLE_TYPE, renderableType, EGL10.EGL_NONE };
- EGLConfig[] configs = new EGLConfig[1];
- int[] num_config = new int[1];
- if (!egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config)
- || num_config[0] == 0) {
- Log.e("SDL", "No EGL config available");
- return false;
- }
- EGLConfig config = configs[0];
-
- EGLContext ctx = egl.eglCreateContext(dpy, config,
- EGL10.EGL_NO_CONTEXT, null);
- if (ctx == EGL10.EGL_NO_CONTEXT) {
- Log.e("SDL", "Couldn't create context");
- return false;
- }
-
- EGLSurface surface = egl.eglCreateWindowSurface(dpy, config, this,
- null);
- if (surface == EGL10.EGL_NO_SURFACE) {
- Log.e("SDL", "Couldn't create surface");
- return false;
- }
-
- if (!egl.eglMakeCurrent(dpy, surface, surface, ctx)) {
- Log.e("SDL", "Couldn't make context current");
- return false;
- }
-
- mEGLContext = ctx;
- mEGLDisplay = dpy;
- mEGLSurface = surface;
-
- } catch (Exception e) {
- Log.v("SDL", e + "");
- for (StackTraceElement s : e.getStackTrace()) {
- Log.v("SDL", s.toString());
- }
- }
-
- return true;
- }
-
- // EGL buffer flip
- public void flipEGL() {
- try {
- EGL10 egl = (EGL10) EGLContext.getEGL();
-
- egl.eglWaitNative(EGL10.EGL_NATIVE_RENDERABLE, null);
-
- // drawing here
-
- egl.eglWaitGL();
-
- egl.eglSwapBuffers(mEGLDisplay, mEGLSurface);
-
- } catch (Exception e) {
- Log.v("SDL", "flipEGL(): " + e);
- for (StackTraceElement s : e.getStackTrace()) {
- Log.v("SDL", s.toString());
- }
-
- }
- }
-
- // Key events
- public boolean onKey(View v, int keyCode, KeyEvent event) {
- if(keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) return false;
- if (event.getAction() == KeyEvent.ACTION_DOWN) {
- Log.v("SDL", "key down: " + keyCode);
- if(keyCode == KeyEvent.KEYCODE_BACK){//TODO ask user to quit or not
- PascalExports.HWterminate(true);
- //SDLActivity.mSingleton.finish();
- }else{
- SDLActivity.onNativeKeyDown(keyCode);
- }
-
- return true;
- } else if (event.getAction() == KeyEvent.ACTION_UP) {
- Log.v("SDL", "key up: " + keyCode);
- SDLActivity.onNativeKeyUp(keyCode);
- return true;
- }
-
- return false;
- }
-
- // Sensor events
- public void enableSensor(int sensortype, boolean enabled) {
- // TODO: This uses getDefaultSensor - what if we have >1 accels?
- if (enabled) {
- mSensorManager.registerListener(this,
- mSensorManager.getDefaultSensor(sensortype),
- SensorManager.SENSOR_DELAY_GAME, null);
- } else {
- mSensorManager.unregisterListener(this,
- mSensorManager.getDefaultSensor(sensortype));
- }
- }
-
- public void onAccuracyChanged(Sensor sensor, int accuracy) {
- // TODO
- }
-
- public void onSensorChanged(SensorEvent event) {
- if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
- SDLActivity.onNativeAccel(event.values[0], event.values[1],
- event.values[2]);
- }
- }
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/StartGameActivity.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,210 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile;
-
-import org.hedgewars.mobile.EngineProtocol.FrontendDataUtils;
-import org.hedgewars.mobile.EngineProtocol.GameConfig;
-import org.hedgewars.mobile.EngineProtocol.Map;
-import org.hedgewars.mobile.EngineProtocol.Scheme;
-import org.hedgewars.mobile.EngineProtocol.Team;
-import org.hedgewars.mobile.EngineProtocol.Weapon;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.graphics.drawable.Drawable;
-import android.os.Bundle;
-import android.os.Parcelable;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.AdapterView;
-import android.widget.AdapterView.OnItemSelectedListener;
-import android.widget.ArrayAdapter;
-import android.widget.ImageButton;
-import android.widget.ImageView;
-import android.widget.Spinner;
-import android.widget.Toast;
-
-public class StartGameActivity extends Activity {
-
- public static final int ACTIVITY_TEAM_SELECTOR = 0;
-
- private GameConfig config = null;
- private ImageButton start, back, team;
- private Spinner maps, gameplay, gamescheme, weapons, themes;
- private ImageView themeIcon, mapPreview, teamCount;
-
- public void onCreate(Bundle savedInstanceState){
- super.onCreate(savedInstanceState);
-
- //SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
- //Copy all the xml files to the device TODO only do first time launch of the app...
- Utils.resRawToFilesDir(this,R.array.schemes, Scheme.DIRECTORY_SCHEME);
- Utils.resRawToFilesDir(this, R.array.weapons, Weapon.DIRECTORY_WEAPON);
- Scheme.parseBasicFlags(this);
-
- config = new GameConfig();
-
- setContentView(R.layout.starting_game);
-
- back = (ImageButton) findViewById(R.id.btnBack);
- team = (ImageButton) findViewById(R.id.btnTeams);
- start = (ImageButton) findViewById(R.id.btnStart);
-
- maps = (Spinner) findViewById(R.id.spinMaps);
- gameplay = (Spinner) findViewById(R.id.spinGameplay);
- gamescheme = (Spinner) findViewById(R.id.spinGamescheme);
- weapons = (Spinner) findViewById(R.id.spinweapons);
- themes = (Spinner) findViewById(R.id.spinTheme);
-
- themeIcon = (ImageView) findViewById(R.id.imgTheme);
- mapPreview = (ImageView) findViewById(R.id.mapPreview);
- teamCount = (ImageView) findViewById(R.id.imgTeamsCount);
-
- start.setOnClickListener(startClicker);
- back.setOnClickListener(backClicker);
- team.setOnClickListener(teamClicker);
-
- ArrayAdapter<?> adapter = new ArrayAdapter<Map>(this, R.layout.listview_item, FrontendDataUtils.getMaps(this));
- adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
- maps.setAdapter(adapter);
- maps.setOnItemSelectedListener(mapsClicker);
-
- adapter = new ArrayAdapter<String>(this, R.layout.listview_item, FrontendDataUtils.getGameplay(this));
- adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
- gameplay.setAdapter(adapter);
- gameplay.setOnItemSelectedListener(gameplayClicker);
-
- adapter = new ArrayAdapter<Scheme>(this, R.layout.listview_item, FrontendDataUtils.getSchemes(this));
- adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
- gamescheme.setAdapter(adapter);
- gamescheme.setOnItemSelectedListener(schemeClicker);
-
- adapter = new ArrayAdapter<Weapon>(this, R.layout.listview_item, FrontendDataUtils.getWeapons(this));
- adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
- weapons.setAdapter(adapter);
- weapons.setOnItemSelectedListener(weaponClicker);
-
- adapter = new ArrayAdapter<String>(this, R.layout.listview_item, FrontendDataUtils.getThemes(this));
- adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
- themes.setAdapter(adapter);
- themes.setOnItemSelectedListener(themesClicker);
-
- }
-
- private void startTeamsActivity(){
- Intent i = new Intent(StartGameActivity.this, TeamSelectionActivity.class);
- i.putParcelableArrayListExtra("teams", config.teams);
- startActivityForResult(i, ACTIVITY_TEAM_SELECTOR);
- }
-
- public void onActivityResult(int requestCode, int resultCode, Intent data){
- switch(requestCode){
- case ACTIVITY_TEAM_SELECTOR:
- if(resultCode == Activity.RESULT_OK){
- Parcelable[] parcelables = (Parcelable[])data.getParcelableArrayExtra("teams");
- config.teams.clear();
- for(Parcelable t : parcelables){
- config.teams.add((Team)t);
- }
- teamCount.getDrawable().setLevel(config.teams.size());
- }
- break;
- }
- }
-
-
- private OnItemSelectedListener themesClicker = new OnItemSelectedListener(){
-
- public void onItemSelected(AdapterView<?> arg0, View view, int position, long rowId) {
- String themeName = (String) arg0.getAdapter().getItem(position);
- Drawable themeIconDrawable = Drawable.createFromPath(Utils.getDownloadPath(StartGameActivity.this) + "Themes/" + themeName + "/icon@2X.png");
- themeIcon.setImageDrawable(themeIconDrawable);
- config.theme = themeName;
- }
-
- public void onNothingSelected(AdapterView<?> arg0) {
- }
-
- };
-
- private OnItemSelectedListener mapsClicker = new OnItemSelectedListener(){
-
- public void onItemSelected(AdapterView<?> arg0, View view, int position,long rowId) {
- Map map = (Map)arg0.getAdapter().getItem(position);
- mapPreview.setImageDrawable(map.getDrawable());
- config.map = map;
- }
-
- public void onNothingSelected(AdapterView<?> arg0) {
- }
-
- };
-
- private OnItemSelectedListener weaponClicker = new OnItemSelectedListener(){
- public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
- config.weapon = (Weapon)arg0.getAdapter().getItem(arg2);
- }
- public void onNothingSelected(AdapterView<?> arg0) {
-
- }
- };
- private OnItemSelectedListener schemeClicker = new OnItemSelectedListener(){
- public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
- config.scheme = (Scheme)arg0.getAdapter().getItem(arg2);
- }
- public void onNothingSelected(AdapterView<?> arg0) {
-
- }
- };
- private OnItemSelectedListener gameplayClicker = new OnItemSelectedListener(){
- public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
- //config = ()arg0.getAdapter().getItem(arg2);
- }
- public void onNothingSelected(AdapterView<?> arg0) {
-
- }
- };
-
- private OnClickListener startClicker = new OnClickListener(){
- public void onClick(View v) {
- if(config.teams.size() < 2){
- Toast.makeText(StartGameActivity.this, R.string.not_enough_teams, Toast.LENGTH_LONG).show();
- startTeamsActivity();
- }
- else{
- Intent i = new Intent(StartGameActivity.this, SDLActivity.class);
- i.putExtra("config", config);
- startActivity(i);}
- }
- };
-
- private OnClickListener backClicker = new OnClickListener(){
- public void onClick(View v) {
- finish();
- }
- };
-
- private OnClickListener teamClicker = new OnClickListener(){
- public void onClick(View v) {
- startTeamsActivity();
- }
- };
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/TeamCreatorActivity.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,356 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-
-import org.hedgewars.mobile.EngineProtocol.FrontendDataUtils;
-import org.hedgewars.mobile.EngineProtocol.Team;
-
-import android.app.Activity;
-import android.graphics.Bitmap;
-import android.graphics.drawable.Drawable;
-import android.media.MediaPlayer;
-import android.os.Bundle;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.view.View.OnFocusChangeListener;
-import android.widget.AdapterView;
-import android.widget.AdapterView.OnItemSelectedListener;
-import android.widget.ArrayAdapter;
-import android.widget.EditText;
-import android.widget.ImageButton;
-import android.widget.ImageView;
-import android.widget.LinearLayout;
-import android.widget.RelativeLayout;
-import android.widget.ScrollView;
-import android.widget.SimpleAdapter;
-import android.widget.Spinner;
-import android.widget.TextView;
-import android.widget.Toast;
-
-public class TeamCreatorActivity extends Activity {
-
- private TextView name;
- private Spinner difficulty, grave, flag, voice, fort;
- private ImageView imgFort;
- private ArrayList<ImageButton> hogDice = new ArrayList<ImageButton>();
- private ArrayList<Spinner> hogHat = new ArrayList<Spinner>();
- private ArrayList<EditText> hogName = new ArrayList<EditText>();
- private ImageButton back, save, voiceButton;
- private ScrollView scroller;
- private MediaPlayer mp = null;
- private boolean settingsChanged = false;
- private boolean saved = false;
-
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.team_creation);
-
- name = (TextView) findViewById(R.id.txtName);
- difficulty = (Spinner) findViewById(R.id.spinType);
- grave = (Spinner) findViewById(R.id.spinGrave);
- flag = (Spinner) findViewById(R.id.spinFlag);
- voice = (Spinner) findViewById(R.id.spinVoice);
- fort = (Spinner) findViewById(R.id.spinFort);
-
- imgFort = (ImageView) findViewById(R.id.imgFort);
-
- back = (ImageButton) findViewById(R.id.btnBack);
- save = (ImageButton) findViewById(R.id.btnSave);
- voiceButton = (ImageButton) findViewById(R.id.btnPlay);
-
- scroller = (ScrollView) findViewById(R.id.scroller);
-
- save.setOnClickListener(saveClicker);
- back.setOnClickListener(backClicker);
-
- LinearLayout ll = (LinearLayout) findViewById(R.id.HogsContainer);
- for (int i = 0; i < ll.getChildCount(); i++) {
- RelativeLayout team_creation_entry = (RelativeLayout) ll
- .getChildAt(i);
-
- hogHat.add((Spinner) team_creation_entry
- .findViewById(R.id.spinTeam1));
- hogDice.add((ImageButton) team_creation_entry
- .findViewById(R.id.btnTeam1));
- hogName.add((EditText) team_creation_entry
- .findViewById(R.id.txtTeam1));
- }
- ArrayList<HashMap<String, ?>> gravesData = FrontendDataUtils
- .getGraves(this);
- SimpleAdapter sa = new SimpleAdapter(this, gravesData,
- R.layout.spinner_textimg_entry, new String[] { "txt", "img" },
- new int[] { R.id.spinner_txt, R.id.spinner_img });
-
- sa.setViewBinder(viewBinder);
- grave.setAdapter(sa);
- grave.setOnFocusChangeListener(focusser);
-
- ArrayList<HashMap<String, ?>> flagsData = FrontendDataUtils
- .getFlags(this);
- sa = new SimpleAdapter(this, flagsData, R.layout.spinner_textimg_entry,
- new String[] { "txt", "img" }, new int[] { R.id.spinner_txt,
- R.id.spinner_img });
- sa.setViewBinder(viewBinder);
- flag.setAdapter(sa);
- flag.setOnFocusChangeListener(focusser);
-
- ArrayList<HashMap<String, ?>> typesData = FrontendDataUtils
- .getTypes(this);
- sa = new SimpleAdapter(this, typesData, R.layout.spinner_textimg_entry,
- new String[] { "txt", "img" }, new int[] { R.id.spinner_txt,
- R.id.spinner_img });
- difficulty.setAdapter(sa);
- difficulty.setOnFocusChangeListener(focusser);
-
- ArrayList<HashMap<String, ?>> hatsData = FrontendDataUtils
- .getHats(this);
- sa = new SimpleAdapter(this, hatsData, R.layout.spinner_textimg_entry,
- new String[] { "txt", "img" }, new int[] { R.id.spinner_txt,
- R.id.spinner_img });
- sa.setViewBinder(viewBinder);
- for (Spinner spin : hogHat) {
- spin.setAdapter(sa);
- }
-
- ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
- R.layout.listview_item, FrontendDataUtils.getVoices(this));
- voice.setAdapter(adapter);
- voice.setOnFocusChangeListener(focusser);
- voiceButton.setOnClickListener(voiceClicker);
-
- adapter = new ArrayAdapter<String>(this, R.layout.listview_item,
- FrontendDataUtils.getForts(this));
- fort.setAdapter(adapter);
- fort.setOnItemSelectedListener(fortSelector);
- fort.setOnFocusChangeListener(focusser);
-
- Team t = this.getIntent().getParcelableExtra("team");
- if (t != null) {
- name.setText(t.name);
- int position = ((ArrayAdapter<String>) voice.getAdapter())
- .getPosition(t.voice);
- voice.setSelection(position);
-
- position = ((ArrayAdapter<String>) fort.getAdapter())
- .getPosition(t.fort);
- fort.setSelection(position);
-
- position = 0;
- for (HashMap<String, ?> hashmap : typesData) {
- if (hashmap.get("txt").equals(t.levels[0])) {
- difficulty.setSelection(position);
- break;
- }
- }
-
- position = 0;
- for (HashMap<String, ?> hashmap : gravesData) {
- if (hashmap.get("txt").equals(t.grave)) {
- grave.setSelection(position);
- break;
- }
- }
-
- position = 0;
- for (HashMap<String, ?> hashmap : typesData) {
- if (hashmap.get("txt").equals(t.flag)) {
- flag.setSelection(position);
- break;
- }
- }
-
- for (int i = 0; i < Team.maxNumberOfHogs; i++) {
- position = 0;
- for (HashMap<String, ?> hashmap : hatsData) {
- if (hashmap.get("txt").equals(t.hats[i])) {
- hogHat.get(i).setSelection(position);
- }
- }
-
- hogName.get(i).setText(t.hogNames[i]);
- }
- }
- }
-
- public void onDestroy() {
- super.onDestroy();
- if (mp != null) {
- mp.release();
- mp = null;
- }
- }
-
- private OnFocusChangeListener focusser = new OnFocusChangeListener() {
- public void onFocusChange(View v, boolean hasFocus) {
- settingsChanged = true;
- }
-
- };
-
- public void onBackPressed() {
- onFinishing();
- super.onBackPressed();
-
- }
-
- private OnClickListener backClicker = new OnClickListener() {
- public void onClick(View v) {
- onFinishing();
- finish();
- }
- };
-
- private void onFinishing() {
- if (settingsChanged) {
- setResult(RESULT_OK);
- } else {
- setResult(RESULT_CANCELED);
- }
- }
-
- private OnClickListener saveClicker = new OnClickListener() {
- public void onClick(View v) {
- Toast.makeText(TeamCreatorActivity.this, R.string.saved, Toast.LENGTH_SHORT).show();
- saved = true;
- Team team = new Team();
- team.name = name.getText().toString();
- HashMap<String, Object> hashmap = (HashMap<String, Object>) flag
- .getSelectedItem();
-
- team.flag = (String) hashmap.get("txt");
- team.fort = fort.getSelectedItem().toString();
- hashmap = (HashMap<String, Object>) grave.getSelectedItem();
- team.grave = hashmap.get("txt").toString();
- team.hash = "0";
- team.voice = voice.getSelectedItem().toString();
-
- hashmap = ((HashMap<String, Object>) difficulty.getSelectedItem());
- String levelString = hashmap.get("txt").toString();
- int levelInt;
- if (levelString.equals(getString(R.string.human))) {
- levelInt = 0;
- } else if (levelString.equals(getString(R.string.bot5))) {
- levelInt = 1;
- } else if (levelString.equals(getString(R.string.bot4))) {
- levelInt = 2;
- } else if (levelString.equals(getString(R.string.bot3))) {
- levelInt = 3;
- } else if (levelString.equals(getString(R.string.bot2))) {
- levelInt = 4;
- } else {
- levelInt = 5;
- }
-
- for (int i = 0; i < hogName.size(); i++) {
- team.hogNames[i] = hogName.get(i).getText().toString();
- hashmap = (HashMap<String, Object>) hogHat.get(i)
- .getSelectedItem();
- team.hats[i] = hashmap.get("txt").toString();
- team.levels[i] = levelInt;
- }
- try {
- File teamsDir = new File(getFilesDir().getAbsolutePath() + '/'
- + Team.DIRECTORY_TEAMS);
- if (!teamsDir.exists())
- teamsDir.mkdir();
- FileOutputStream fos = new FileOutputStream(String.format(
- "%s/%s.xml", teamsDir.getAbsolutePath(), team.name));
- team.writeToXml(fos);
- } catch (FileNotFoundException e) {
- e.printStackTrace();
- }
- }
-
- };
-
- private OnItemSelectedListener fortSelector = new OnItemSelectedListener() {
- @SuppressWarnings("unchecked")
- public void onItemSelected(AdapterView<?> arg0, View arg1,
- int position, long arg3) {
- settingsChanged = true;
- String fortName = (String) arg0.getAdapter().getItem(position);
- Drawable fortIconDrawable = Drawable.createFromPath(Utils
- .getDownloadPath(TeamCreatorActivity.this)
- + "Forts/"
- + fortName + "L.png");
- imgFort.setImageDrawable(fortIconDrawable);
- scroller.fullScroll(ScrollView.FOCUS_DOWN);// Scroll the scrollview
- // to the bottom, work
- // around for scollview
- // invalidation (scrolls
- // back to top)
- }
-
- public void onNothingSelected(AdapterView<?> arg0) {
- }
-
- };
-
- private OnClickListener voiceClicker = new OnClickListener() {
- public void onClick(View v) {
- try {
- File dir = new File(String.format("%sSounds/voices/%s",
- Utils.getDownloadPath(TeamCreatorActivity.this),
- voice.getSelectedItem()));
- String file = "";
- File[] dirs = dir.listFiles();
- File f = dirs[(int) Math.round(Math.random() * dirs.length)];
- if (f.getName().endsWith(".ogg"))
- file = f.getAbsolutePath();
-
- if (mp == null)
- mp = new MediaPlayer();
- else
- mp.reset();
- mp.setDataSource(file);
- mp.prepare();
- mp.start();
- } catch (IllegalArgumentException e) {
- e.printStackTrace();
- } catch (IllegalStateException e) {
- e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- };
-
- private SimpleAdapter.ViewBinder viewBinder = new SimpleAdapter.ViewBinder() {
-
- public boolean setViewValue(View view, Object data,
- String textRepresentation) {
- if (view instanceof ImageView && data instanceof Bitmap) {
- ImageView v = (ImageView) view;
- v.setImageBitmap((Bitmap) data);
- return true;
- } else {
- return false;
- }
- }
- };
-
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/TeamSelectionActivity.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,289 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
-
-import org.hedgewars.mobile.EngineProtocol.FrontendDataUtils;
-import org.hedgewars.mobile.EngineProtocol.Team;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.os.Bundle;
-import android.os.Parcelable;
-import android.view.ContextMenu;
-import android.view.MenuItem;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.AdapterView;
-import android.widget.AdapterView.AdapterContextMenuInfo;
-import android.widget.AdapterView.OnItemClickListener;
-import android.widget.ImageButton;
-import android.widget.ImageView;
-import android.widget.ListView;
-import android.widget.RelativeLayout;
-import android.widget.SimpleAdapter;
-import android.widget.SimpleAdapter.ViewBinder;
-import android.widget.TextView;
-
-public class TeamSelectionActivity extends Activity{
-
- private static final int ACTIVITY_TEAMCREATION = 0;
-
- private ImageButton addTeam, back;
- private ListView availableTeams, selectedTeams;
- private ArrayList<HashMap<String, Object>> availableTeamsList, selectedTeamsList;
- private TextView txtInfo;
-
- public void onCreate(Bundle savedInstanceState){
- super.onCreate(savedInstanceState);
-
- setContentView(R.layout.team_selector);
-
- addTeam = (ImageButton) findViewById(R.id.btnAdd);
- back = (ImageButton) findViewById(R.id.btnBack);
- txtInfo = (TextView) findViewById(R.id.txtInfo);
-
- addTeam.setOnClickListener(addTeamClicker);
- back.setOnClickListener(backClicker);
-
- availableTeams = (ListView) findViewById(R.id.availableTeams);
- availableTeamsList = FrontendDataUtils.getTeams(this);
- SimpleAdapter adapter = new SimpleAdapter(this, availableTeamsList, R.layout.team_selection_entry_simple, new String[]{"txt", "img"}, new int[]{R.id.txtName, R.id.imgDifficulty});
- availableTeams.setAdapter(adapter);
- registerForContextMenu(availableTeams);
- availableTeams.setOnItemClickListener(availableClicker);
-
- selectedTeams = (ListView) findViewById(R.id.selectedTeams);
- selectedTeamsList = new ArrayList<HashMap<String, Object>>();
- ArrayList<HashMap<String, ?>> toBeRemoved = new ArrayList<HashMap<String, ?>>();
- ArrayList<Team> teamsStartGame = getIntent().getParcelableArrayListExtra("teams");
- for(HashMap<String, Object> hashmap : availableTeamsList){
- for(Team t : teamsStartGame){
- if(((Team)hashmap.get("team")).equals(t)){
- toBeRemoved.add(hashmap);
- selectedTeamsList.add(FrontendDataUtils.teamToHashMap(t));//create a new hashmap to ensure all variables are entered into the map
- }
- }
- }
- for(HashMap<String, ?> hashmap : toBeRemoved) availableTeamsList.remove(hashmap);
-
- adapter = new SimpleAdapter(this, selectedTeamsList, R.layout.team_selection_entry, new String[]{"txt", "img", "color", "count"}, new int[]{R.id.txtName, R.id.imgDifficulty, R.id.teamColor, R.id.teamCount});
- adapter.setViewBinder(viewBinder);
- selectedTeams.setAdapter(adapter);
- selectedTeams.setOnItemClickListener(selectedClicker);
-
- txtInfo.setText(String.format(getResources().getString(R.string.teams_info_template), selectedTeams.getChildCount()));
- }
-
- private ViewBinder viewBinder = new ViewBinder(){
- public boolean setViewValue(View view, Object data, String textRepresentation) {
- switch(view.getId()){
- case R.id.teamColor:
- setTeamColor(view, (Integer)data);
- return true;
- case R.id.teamCount:
- setTeamHogCount((ImageView)view, (Integer)data);
- return true;
- default:
- return false;
- }
- }
- };
-
- public void onActivityResult(int requestCode, int resultCode, Intent data){
- if(requestCode == ACTIVITY_TEAMCREATION){
- if(resultCode == Activity.RESULT_OK){
- updateListViews();
- }
- }else{
- super.onActivityResult(requestCode, resultCode, data);
- }
- }
-
- private void updateListViews(){
- unregisterForContextMenu(availableTeams);
- availableTeamsList = FrontendDataUtils.getTeams(this);
- ArrayList<HashMap<String, Object>> toBeRemoved = new ArrayList<HashMap<String, Object>>();
- for(HashMap<String, Object> hashmap : selectedTeamsList){
- String name = (String)hashmap.get("txt");
-
- for(HashMap<String, Object> hash : availableTeamsList){
- if(name.equals((String)hash.get("txt"))){
- toBeRemoved.add(hash);
- }
- }
- }
- for(HashMap<String, Object> hash: toBeRemoved) availableTeamsList.remove(hash);
-
- SimpleAdapter adapter = new SimpleAdapter(this, availableTeamsList, R.layout.team_selection_entry, new String[]{"txt", "img"}, new int[]{R.id.txtName, R.id.imgDifficulty});
- availableTeams.setAdapter(adapter);
- registerForContextMenu(availableTeams);
- availableTeams.setOnItemClickListener(availableClicker);
-
-
- }
-
- private void setTeamColor(int position, int color){
- View iv = ((RelativeLayout)selectedTeams.getChildAt(position)).findViewById(R.id.teamCount);
- setTeamColor(iv, color);
- }
- private void setTeamColor(View iv, int color){
- iv.setBackgroundColor(0xFF000000 + color);
- }
-
- private void setTeamHogCount(int position, int count){
- ImageView iv = (ImageView)((RelativeLayout)selectedTeams.getChildAt(position)).findViewById(R.id.teamCount);
- setTeamHogCount(iv, count);
- }
-
- private void setTeamHogCount(ImageView iv, int count){
-
- switch(count){
- case 0:
- iv.setImageResource(R.drawable.teamcount0);
- break;
- case 1:
- iv.setImageResource(R.drawable.teamcount1);
- break;
- case 2:
- iv.setImageResource(R.drawable.teamcount2);
- break;
- case 3:
- iv.setImageResource(R.drawable.teamcount3);
- break;
- case 4:
- iv.setImageResource(R.drawable.teamcount4);
- break;
- case 5:
- iv.setImageResource(R.drawable.teamcount5);
- break;
- case 6:
- iv.setImageResource(R.drawable.teamcount6);
- break;
- case 7:
- iv.setImageResource(R.drawable.teamcount7);
- break;
- case 8:
- iv.setImageResource(R.drawable.teamcount8);
- break;
- case 9:
- iv.setImageResource(R.drawable.teamcount9);
- break;
- }
- }
-
- public void onBackPressed(){
- returnTeams();
- super.onBackPressed();
- }
-
- private OnClickListener addTeamClicker = new OnClickListener(){
- public void onClick(View v) {
- startActivityForResult(new Intent(TeamSelectionActivity.this, TeamCreatorActivity.class), ACTIVITY_TEAMCREATION);
- }
- };
-
- private OnClickListener backClicker = new OnClickListener(){
- public void onClick(View v){
- returnTeams();
- finish();
- }
- };
-
- private OnItemClickListener availableClicker = new OnItemClickListener(){
- public void onItemClick(AdapterView<?> arg0, View arg1, int position,long arg3) {
- selectAvailableTeamsItem(position);
- }
- };
- private OnItemClickListener selectedClicker = new OnItemClickListener(){
- public void onItemClick(AdapterView<?> arg0, View arg1, int position,long arg3) {
- availableTeamsList.add((HashMap<String, Object>) selectedTeamsList.get(position));
- selectedTeamsList.remove(position);
- ((SimpleAdapter)availableTeams.getAdapter()).notifyDataSetChanged();
- ((SimpleAdapter)selectedTeams.getAdapter()).notifyDataSetChanged();
-
- txtInfo.setText(String.format(getResources().getString(R.string.teams_info_template), selectedTeamsList.size()));
- }
-
- };
-
- public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuinfo){
- menu.add(ContextMenu.NONE, 0, ContextMenu.NONE, R.string.select);
- menu.add(ContextMenu.NONE, 2, ContextMenu.NONE, R.string.edit);
- menu.add(ContextMenu.NONE, 1, ContextMenu.NONE, R.string.delete);
-
- }
- public boolean onContextItemSelected(MenuItem item){
- AdapterView.AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo) item.getMenuInfo();
- int position = menuInfo.position;
- switch(item.getItemId()){
- case 0://select
- selectAvailableTeamsItem(position);
- return true;
- case 1://delete
- File f = new File(String.format("%s/%s/%s.xml", TeamSelectionActivity.this.getFilesDir(), Team.DIRECTORY_TEAMS, availableTeamsList.get(position).get("txt")));
- f.delete();
- availableTeamsList.remove(position);
- ((SimpleAdapter)availableTeams.getAdapter()).notifyDataSetChanged();
- return true;
- case 2://edit
- Intent i = new Intent(TeamSelectionActivity.this, TeamCreatorActivity.class);
- Team t = (Team)availableTeamsList.get(position).get("team");
- i.putExtra("team", t);
- startActivityForResult(i, ACTIVITY_TEAMCREATION);
- return true;
- }
- return false;
- }
-
- private void selectAvailableTeamsItem(int position){
- HashMap<String, Object> hash = (HashMap<String, Object>) availableTeamsList.get(position);
- Team t = (Team)hash.get("team");
- int[] illegalcolors = new int[selectedTeamsList.size()];
- for(int i = 0; i < selectedTeamsList.size(); i++){
- illegalcolors[i] = ((Team)selectedTeamsList.get(i).get("team")).color;
- }
- t.setRandomColor(illegalcolors);
- hash.put("color", t.color);
- hash.put("count", t.hogCount);
-
- selectedTeamsList.add(hash);
- availableTeamsList.remove(position);
- ((SimpleAdapter)availableTeams.getAdapter()).notifyDataSetChanged();
- ((SimpleAdapter)selectedTeams.getAdapter()).notifyDataSetChanged();
-
- txtInfo.setText(String.format(getResources().getString(R.string.teams_info_template), selectedTeamsList.size()));
- }
-
- private void returnTeams(){
- int teamsCount = selectedTeamsList.size();
- Intent i = new Intent();
- Parcelable[] teams = new Parcelable[teamsCount];
- for(int x = 0 ; x < teamsCount; x++){
- teams[x] = (Team)selectedTeamsList.get(x).get("team");
- }
- i.putExtra("teams", teams);
- setResult(Activity.RESULT_OK, i);
-
- }
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/TextImageAdapter.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,76 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.hedgewars.mobile.R;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ImageView;
-import android.widget.SimpleAdapter;
-import android.widget.TextView;
-
-
-public class TextImageAdapter extends SimpleAdapter {
-
- private Context context;
- private ArrayList<Map<String, ?>> data;
-
- public TextImageAdapter(Context _context, ArrayList<Map<String, ?>> _data, int resource, String[] from, int[] to) {
- super(_context, _data, resource, from, to);
- context = _context;
- data = _data;
- }
-
- public static TextImageAdapter createAdapter(Context c, String[] txt, String[] img, String[] from, int[] to){
- if(txt.length != img.length) throw new IllegalArgumentException("txt and img parameters not equal");
-
- ArrayList<Map<String, ?>> data = new ArrayList<Map<String, ?>>(txt.length);
-
- for(int i = 0; i < txt.length; i++){
- HashMap<String, Object> map = new HashMap<String, Object>();
- map.put("txt", txt[i]);
- map.put("img", BitmapFactory.decodeFile(img[i]));
- data.add(map);
- }
- return new TextImageAdapter(c, data, R.layout.spinner_textimg_entry, from, to);
- }
-
- public View getView(int position, View convertView, ViewGroup parent){
- if(convertView == null){
- LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
- convertView = inflater.inflate(R.layout.spinner_textimg_entry, parent);
- }
- TextView tv = (TextView) convertView.findViewById(R.id.spinner_txt);
- ImageView img = (ImageView) convertView.findViewById(R.id.spinner_img);
-
- tv.setText((String)data.get(position).get("txt"));
- img.setImageBitmap((Bitmap)data.get(position).get("img"));
-
- return convertView;
- }
-}
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/TouchInterface/TouchInterface.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-package org.hedgewars.mobile.TouchInterface;
-
-import org.hedgewars.mobile.SDLActivity;
-
-import android.os.Build;
-import android.util.Log;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.View.OnTouchListener;
-
-public class TouchInterface{
-
- public static OnTouchListener getTouchInterface(){
- OnTouchListener toucher;
- if(Build.VERSION.SDK_INT < 5){//8 == Build.VERSION_CODES.FROYO
- toucher = new TouchInterfaceST();
- }else{
- toucher = new TouchInterfaceMT();
- }
-
- return toucher;
- }
-}
-/**
- * Touch interface with multitouch
- */
-class TouchInterfaceMT implements OnTouchListener {
-
- private boolean firstEvent = true;
-
- public boolean onTouch(View v, MotionEvent event) {
- //dumpEvent(event);
-
- if(firstEvent){
- firstEvent = false;
- SDLActivity.onNativeTouch(-1, -1, v.getWidth(), v.getHeight(), 1);
- }
-
- int action = event.getAction();
- int actionCode = action & MotionEvent.ACTION_MASK;
-
- for (int i = 0; i < event.getPointerCount(); i++) {
- SDLActivity.onNativeTouch(actionCode, event.getPointerId(i), (int)event.getX(i), (int)event.getY(i), event.getPressure(i));
-// Log.d("Android", String.format("x=%f, y=%f, pntr=%d", event.getX(i), event.getY(i), event.getPointerId(i)));
- }
- return true;
- }
-
- /** Show an event in the LogCat view, for debugging */
- private void dumpEvent(MotionEvent event) {
- String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,
- "POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };
- StringBuilder sb = new StringBuilder();
- int action = event.getAction();
- int actionCode = action & MotionEvent.ACTION_MASK;
- sb.append("event ACTION_" ).append(names[actionCode]);
- if (actionCode == MotionEvent.ACTION_POINTER_DOWN
- || actionCode == MotionEvent.ACTION_POINTER_UP) {
- sb.append("(pid " ).append(
- action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
- sb.append(")" );
- }
- sb.append("[" );
- for (int i = 0; i < event.getPointerCount(); i++) {
- sb.append("#" ).append(i);
- sb.append("(pid " ).append(event.getPointerId(i));
- sb.append(")=" ).append((int) event.getX(i));
- sb.append("," ).append((int) event.getY(i));
- if (i + 1 < event.getPointerCount())
- sb.append(";" );
- }
- sb.append("]" );
- Log.d("HW_APP_TOUCH", sb.toString());
- }
-
-}
-
-/**
- * Touch interface without multitouch
- */
-class TouchInterfaceST implements OnTouchListener {
-
- public boolean onTouch(View v, MotionEvent event) {
- return false;
- }
-
-
-
-}
-
--- a/project_files/Android-build/SDL-android-project/src/org/hedgewars/mobile/Utils.java Sun Oct 09 20:41:17 2011 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,213 +0,0 @@
-/*
- * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
- * Copyright (c) 2011 Richard Deurwaarder <xeli@xelification.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-package org.hedgewars.mobile;
-
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.os.Build;
-import android.os.Environment;
-import android.widget.Toast;
-
-public class Utils {
-
-
- /**
- * get the path to which we should download all the data files
- * @param c context
- * @return absolute path
- */
- public static String getDownloadPath(Context c){
- if(Build.VERSION.SDK_INT < 8){//8 == Build.VERSION_CODES.FROYO
- return PreFroyoSDCardDir.getDownloadPath(c);
- }else{
- return FroyoSDCardDir.getDownloadPath(c);
- }
- }
-
- static class FroyoSDCardDir{
- public static String getDownloadPath(Context c){
- File f = c.getExternalCacheDir();
- if(f != null){
- return f.getAbsolutePath() + "/Data/";
- }else{
- Toast.makeText(c, R.string.sdcard_not_mounted, Toast.LENGTH_LONG).show();
- return null;
- }
- }
- }
-
- static class PreFroyoSDCardDir{
- public static String getDownloadPath(Context c){
- if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
- if(Environment.getExternalStorageDirectory() != null)
- return Environment.getExternalStorageDirectory().getAbsolutePath() + "/Hedgewars/";
- }
- Toast.makeText(c, R.string.sdcard_not_mounted, Toast.LENGTH_LONG).show();
- return null;
- }
- }
-
- /**
- * Get files from dirName, dir name is relative to {@link getDownloadPath}
- * @param dirName
- * @param c context
- * @return string of files
- */
- public static String[] getFileNamesFromRelativeDir(Context c, String dirName){
- String prefix = getDownloadPath(c);
- File f = new File(prefix + dirName);
-
- if(f.exists() && f.isDirectory()) return f.list();
- else throw new IllegalArgumentException("File not a directory or doesn't exist dirName = " + f.getAbsolutePath());
- }
-
- /**
- * Return a File array with all the files from dirName
- * @param c
- * @param dirName
- * @return
- */
- public static File[] getFilesFromRelativeDir(Context c, String dirName){
- String prefix = getDownloadPath(c);
- File f = new File(prefix + dirName);
-
- if(f.exists() && f.isDirectory()) return f.listFiles();
- else throw new IllegalArgumentException("File not a directory or doesn't exist dirName = " + f.getAbsolutePath());
- }
-
- /**
- * Checks if this directory has a file with suffix suffix
- * @param f - directory
- * @return
- */
- public static boolean hasFileWithSuffix(File f, String suffix){
- if(f.isDirectory()){
- for(String s : f.list()){
- if(s.endsWith(suffix)) return true;
- }
- return false;
- }else{
- return false;
- }
- }
-
- /**
- * Gives back all dirs which contain a file with suffix fileSuffix
- * @param c
- * @param path
- * @param fileSuffix
- * @return
- */
- public static String[] getDirsWithFileSuffix(Context c, String path, String fileSuffix){
- File[] files = getFilesFromRelativeDir(c,path);
- String[] validFiles = new String[files.length];
- int validCounter = 0;
-
- for(File f : files){
- if(hasFileWithSuffix(f, fileSuffix)) validFiles[validCounter++] = f.getName();
- }
- String[] ret = new String[validCounter];
- System.arraycopy(validFiles, 0, ret, 0, validCounter);
- return ret;
- }
-
- /**
- * Get all files from directory dir which have the given suffix
- * @param c
- * @param dir
- * @param suffix
- * @param removeSuffix
- * @return
- */
- public static ArrayList<String> getFilesFromDirWithSuffix(Context c, String dir, String suffix, boolean removeSuffix){
- String[] files = Utils.getFileNamesFromRelativeDir(c, dir);
- ArrayList<String> ret = new ArrayList<String>();
- for(String s : files){
- if(s.endsWith(suffix)){
- if(removeSuffix) ret.add(s.substring(0, s.length()-suffix.length()));
- else ret.add(s);
- }
- }
- return ret;
- }
-
- /**
- * Moves resources pointed to by sourceResId (from @res/raw/) to the app's private data directory
- * @param c
- * @param sourceResId
- * @param directory
- */
- public static void resRawToFilesDir(Context c, int sourceResId, String directory){
- byte[] buffer = new byte[1024];
- InputStream bis = null;
- BufferedOutputStream bos = null;
- File schemesDirFile = new File(c.getFilesDir().getAbsolutePath() + '/' + directory);
- schemesDirFile.mkdirs();
- String schemesDirPath = schemesDirFile.getAbsolutePath() + '/';
-
- //Get an array with the resource files ID
- TypedArray ta = c.getResources().obtainTypedArray(sourceResId);
- int[] resIds = new int[ta.length()];
- for(int i = 0; i < ta.length(); i++){
- resIds[i] = ta.getResourceId(i, 0);
- }
-
- for(int id : resIds){
- String fileName = c.getResources().getResourceEntryName(id);
- File f = new File(schemesDirPath + fileName);
- try {
- if(!f.createNewFile()){
- f.delete();
- f.createNewFile();
- }
-
- bis = c.getResources().openRawResource(id);
- bos = new BufferedOutputStream(new FileOutputStream(f), 1024);
- int read = 0;
- while((read = bis.read(buffer)) != -1){
- bos.write(buffer, 0, read);
- }
-
- } catch (IOException e) {
- e.printStackTrace();
- }finally{
- if(bis != null)
- try {
- bis.close();
- } catch (IOException e) {
- e.printStackTrace();
- }
- if(bos != null)
- try {
- bos.close();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- }
- }
-}