diff --git a/polymer/eduke32/Android.mk b/polymer/eduke32/Android.mk new file mode 100644 index 000000000..56152406e --- /dev/null +++ b/polymer/eduke32/Android.mk @@ -0,0 +1,143 @@ +# Copyright (C) 2009 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.crg/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +LOCAL_PATH := $(call my-dir) + + + +include $(CLEAR_VARS) + + +LOCAL_MODULE := duke + + +LOCAL_CFLAGS := -fPIC -Wimplicit -Wdeclaration-after-statement -O2 -funswitch-loops -fomit-frame-pointer -DNDEBUG -DUSING_LTO -flto -fno-stack-protector -W -Werror-implicit-function-declaration -Wpointer-arith -Wextra -funsigned-char -fno-strict-aliasing -DNO_GCC_BUILTINS -D_FORTIFY_SOURCE=2 -fjump-tables -Wno-unused-result -Wno-char-subscripts -DUSE_LIBPNG -pthread -I/usr/lib/i386-linux-gnu/gtk-2.0/include -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/pango-1.0 -I/usr/include/gio-unix-2.0/ -I/usr/include/glib-2.0 -I/usr/lib/i386-linux-gnu/glib-2.0/include -I/usr/include/pixman-1 -DHAVE_INTTYPES -D_GNU_SOURCE=1 -D_REENTRANT -DRENDERTYPESDL=1 -Wno-strict-overflow -DUSE_OPENGL -Wno-attributes + +#Needed my jaudiolib +LOCAL_CFLAGS += -DHAVE_SDL + +LOCAL_LDLIBS += -lGLESv1_CM -lEGL + +LOCAL_LDLIBS += -llog + +LOCAL_CFLAGS += -march=armv7-a -mfloat-abi=softfp +LOCAL_LDLIBS += -Wl,--fix-cortex-a8 + + +LOCAL_C_INCLUDES := $(LOCAL_PATH)/source $(LOCAL_PATH)/source/jmact $(LOCAL_PATH)/source/jaudiolib/include $(LOCAL_PATH)/source/enet/include $(LOCAL_PATH)/build/include $(TOP_DIR)/SDL2/include $(TOP_DIR)/SDL2_mixer $(IDTECH_DIR)/libpng $(IDTECH_DIR)/TinyXML $(IDTECH_DIR)/TouchControls $(IDTECH_DIR)/ + +ANDROID_SRC = \ + source/android/android-jni.cpp \ + source/android/in_android.c + +BUILD_SRC = \ + build/src/a-c.c \ + build/src/baselayer.c \ + build/src/cache1d.c \ + build/src/compat.c \ + build/src/crc32.c \ + build/src/defs.c \ + build/src/engine.c \ + build/src/polymost.c \ + build/src/texcache.c \ + build/src/dxtfilter.c \ + build/src/hightile.c \ + build/src/textfont.c \ + build/src/smalltextfont.c \ + build/src/kplib.c \ + build/src/lz4.c \ + build/src/osd.c \ + build/src/pragmas.c \ + build/src/scriptfile.c \ + build/src/mutex.c + +GL_SRC = \ + build/src/mdsprite.c \ + build/src/glbuild_android.c \ + +SDL_SRC = \ + build/src/sdlayer.c \ + +JMACT_SRC=source/jmact/file_lib.c \ + source/jmact//control.c \ + source/jmact//keyboard.c \ + source/jmact//mouse.c \ + source/jmact//joystick.c \ + source/jmact//mathutil.c \ + source/jmact//scriplib.c \ + source/jmact//animlib.c + +GAME_SRC=source/game.c \ + source/actors.c \ + source/anim.c \ + source/common.c \ + source/config.c \ + source/demo.c \ + source/gamedef.c \ + source/gameexec.c \ + source/gamevars.c \ + source/global.c \ + source/input.c \ + source/menus.c \ + source/namesdyn.c \ + source/net.c \ + source/player.c \ + source/premap.c \ + source/savegame.c \ + source/sector.c \ + source/rts.c \ + source/osdfuncs.c \ + source/osdcmds.c \ + source/grpscan.c \ + source/sounds.c \ + source/soundsdyn.c \ + source/sdlmusic.c \ + + JAUDIO_SRC=source/jaudiolib/src/drivers.c \ + source/jaudiolib/src//fx_man.c \ + source/jaudiolib/src//multivoc.c \ + source/jaudiolib/src//mix.c \ + source/jaudiolib/src//mixst.c \ + source/jaudiolib/src//pitch.c \ + source/jaudiolib/src//formats.c \ + source/jaudiolib/src//vorbis.c \ + source/jaudiolib/src//flac.c \ + source/jaudiolib/src//xa.c \ + source/jaudiolib/src//driver_nosound.c \ + source/jaudiolib/src//driver_sdl.c + + + ENET_SRC=source/enet/src/callbacks.c \ + source/enet/src/host.c \ + source/enet/src/list.c \ + source/enet/src/packet.c \ + source/enet/src/peer.c \ + source/enet/src/protocol.c \ + source/enet/src/compress.c \ + source/enet/src/unix.c + +LOCAL_SRC_FILES = $(ANDROID_SRC) $(ENET_SRC) $(JAUDIO_SRC) $(JMACT_SRC) $(GAME_SRC) $(BUILD_SRC) $(GL_SRC) $(SDL_SRC) + + +LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lOpenSLES -lz +LOCAL_STATIC_LIBRARIES := nanogl SDL2_net libjpeg libpng +LOCAL_SHARED_LIBRARIES := touchcontrols openal SDL2 SDL2_mixer SDL2_image + +include $(BUILD_SHARED_LIBRARY) + + + + + + diff --git a/polymer/eduke32/eduke32.vcxproj b/polymer/eduke32/eduke32.vcxproj index efbd574a1..fbb293de1 100644 --- a/polymer/eduke32/eduke32.vcxproj +++ b/polymer/eduke32/eduke32.vcxproj @@ -282,6 +282,8 @@ + + @@ -392,6 +394,8 @@ + + diff --git a/polymer/eduke32/eduke32.vcxproj.filters b/polymer/eduke32/eduke32.vcxproj.filters index 0524265d5..b40b9531f 100644 --- a/polymer/eduke32/eduke32.vcxproj.filters +++ b/polymer/eduke32/eduke32.vcxproj.filters @@ -67,6 +67,12 @@ {f1025787-c43f-43de-8b46-143ea0462fc1} + + {52ce6149-4982-41a4-9adf-c7a9468421fd} + + + {d3b67b4f-6b78-43e0-88ab-f081b977499a} + @@ -417,6 +423,12 @@ eduke32\source\lunatic\headers + + eduke32\headers\android + + + eduke32\headers + @@ -734,6 +746,12 @@ eduke32\source\lunatic\source + + eduke32\source\android + + + eduke32\source\android + diff --git a/polymer/eduke32/source/android.h b/polymer/eduke32/source/android.h new file mode 100644 index 000000000..cbbbb66e0 --- /dev/null +++ b/polymer/eduke32/source/android.h @@ -0,0 +1,38 @@ +//------------------------------------------------------------------------- +/* +Copyright (C) 2010 EDuke32 developers and contributors + +This file is part of EDuke32. + +EDuke32 is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License version 2 +as published by the Free Software Foundation. + +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. +*/ +//------------------------------------------------------------------------- + +#ifndef __android_h__ +#define __android_h__ + +#ifdef __ANDROID__ +#include "compat.h" +#include "control.h" + +extern int android_screen_width; +extern int android_screen_height; + +extern void CONTROL_Android_ClearButton(int32_t whichbutton); +extern void CONTROL_Android_PollDevices(ControlInfo *info); +extern void setLastWeapon(int w); +#endif + +#endif diff --git a/polymer/eduke32/source/android/android-jni.cpp b/polymer/eduke32/source/android/android-jni.cpp new file mode 100644 index 000000000..f00e81d45 --- /dev/null +++ b/polymer/eduke32/source/android/android-jni.cpp @@ -0,0 +1,881 @@ +/* + * + * Designed by Emile Belanger + * + */ + +#include +#include +#include +#include +#include + +#include "SDL_scancode.h" + +#include "TouchControlsContainer.h" +extern "C" +{ + +//This is a new function I put into SDL2, file SDL_androidgl.c +extern void SDL_SetSwapBufferCallBack(void (*pt2Func)(void)); + +#include "in_android.h" + +#include "../GL/gl.h" +#include "../GL/nano_gl.h" + +#ifndef LOGI +#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO,"DUKE", __VA_ARGS__)) +#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "DUKE", __VA_ARGS__)) +#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR,"DUKE", __VA_ARGS__)) +#endif + +#define REND_SOFT 0 +#define REND_GL 1 + +static int curRenderer; + +int android_screen_width; +int android_screen_height; + + +#define KEY_QUICK_CMD 0x1005 +#define KEY_SHOW_KBRD 0x1008 +#define KEY_SHOW_INVEN 0x1009 +#define KEY_QUICK_SAVE 0x100A +#define KEY_QUICK_LOAD 0x100B +#define KEY_SNIPER 0x100C + +#define KEY_QUICK_KEY1 0x1011 +#define KEY_QUICK_KEY2 0x1012 +#define KEY_QUICK_KEY3 0x1013 +#define KEY_QUICK_KEY4 0x1014 + + +float gameControlsAlpha = 0.5; +bool showWeaponCycle = false; +bool turnMouseMode = true; +bool invertLook = false; +bool precisionShoot = false; +bool showSticks = true; +bool hideTouchControls = true; + +bool shooting = false; +bool sniperMode = false; + +static int controlsCreated = 0; +touchcontrols::TouchControlsContainer controlsContainer; + +touchcontrols::TouchControls *tcMenuMain=0; +touchcontrols::TouchControls *tcGameMain=0; +touchcontrols::TouchControls *tcGameWeapons=0; +touchcontrols::TouchControls *tcAutomap=0; +touchcontrols::TouchControls *tcInventory=0; +touchcontrols::TouchControls *tcGameLook=0; //Just used for whole screen look mode + + +touchcontrols::TouchJoy *touchJoyLeft; +touchcontrols::TouchJoy *touchJoyRight; +touchcontrols::WheelSelect *weaponWheel; + +extern JNIEnv* env_; + +void openGLStart() +{ + + if (curRenderer == REND_GL) + { + glPushMatrix(); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrthof (0, android_screen_width, android_screen_height, 0, 0, 1); + + //glClearColor(1.0f, 1.0f, 0.0f, 1.0f); + //glClear(GL_COLOR_BUFFER_BIT); + //LOGI("openGLStart"); + glDisable(GL_ALPHA_TEST); + glDisable(GL_DEPTH_TEST); + glDisable(GL_FOG); + glEnable(GL_TEXTURE_2D); + glEnable (GL_BLEND); + + glColor4f(1,1,1,1); + + glDisableClientState(GL_COLOR_ARRAY); + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY ); + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glDisable(GL_CULL_FACE); + + glMatrixMode(GL_MODELVIEW); + + nanoPushState(); + } + else //software mode + { + + glDisable(GL_ALPHA_TEST); + glDisableClientState(GL_COLOR_ARRAY); + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY ); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glEnable (GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_TEXTURE_2D); + glDisable(GL_CULL_FACE); + glMatrixMode(GL_MODELVIEW); + + } + +} + +void openGLEnd() +{ + + if (curRenderer == REND_GL) + { + //glPopMatrix(); + nanoPopState(); + glPopMatrix(); + } + else// Software mode + { + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + glMatrixMode(GL_MODELVIEW); + + } +} + +void gameSettingsButton(int state) +{ + + //LOGTOUCH("gameSettingsButton %d",state); + if (state == 1) + { + jclass helloWorldClass; + jmethodID mainMethod; + + helloWorldClass = env_->FindClass("com/beloko/duke/QuakeTouchControlsSettings"); + mainMethod = env_->GetStaticMethodID(helloWorldClass, "showSettings", "()V"); + env_->CallStaticVoidMethod(helloWorldClass, mainMethod); + } +} + + +void showCustomCommands() +{ + + jclass helloWorldClass; + jmethodID mainMethod; + helloWorldClass = env_->FindClass("com/beloko/duke/QuakeCustomCommands"); + mainMethod = env_->GetStaticMethodID(helloWorldClass, "showCommands", "()V"); + env_->CallStaticVoidMethod(helloWorldClass, mainMethod); +} + +void toggleKeyboard() +{ + LOGI("toggleKeyboard"); + jclass helloWorldClass; + jmethodID mainMethod; + helloWorldClass = env_->FindClass("com/beloko/duke/ShowKeyboard"); + mainMethod = env_->GetStaticMethodID(helloWorldClass, "toggleKeyboard", "()V"); + env_->CallStaticVoidMethod(helloWorldClass, mainMethod); +} + +//Because there is no Frame(), we need to check back to java each frame to see if the app hase paused + +static jclass NativeLibClass = 0; +static jmethodID checkPauseMethod = 0; +void swapBuffers() +{ + if (NativeLibClass == 0) + { + NativeLibClass = env_->FindClass("com/beloko/duke/engine/NativeLib"); + checkPauseMethod = env_->GetStaticMethodID(NativeLibClass, "swapBuffers", "()V"); + } + env_->CallStaticVoidMethod(NativeLibClass, checkPauseMethod); +} + + +void gameButton(int state,int code) +{ + if (code == gamefunc_Fire) + { + shooting = state; + PortableAction(state, code); + } + if (code == KEY_SNIPER) + { + sniperMode = state; + } + else if (code == KEY_SHOW_KBRD) + { + if (state) + toggleKeyboard(); + + PortableKeyEvent(state, SDL_SCANCODE_GRAVE,0); + } + else if (code == KEY_QUICK_CMD){ + if (state == 1) + showCustomCommands(); + } + else if (code == KEY_SHOW_INVEN){ + if (state == 1) + { + if (!tcInventory->isEnabled()) + { + tcInventory->setEnabled(true); + tcInventory->fade(0,5); + //disable weapon wheel so it does not show, enabled again after inventory cleared + tcGameWeapons->setEnabled(false); + } + else + { + tcInventory->setEnabled(false); + tcGameWeapons->setEnabled(true); + } + } + } + else if (code == KEY_QUICK_SAVE){ + LOGI("QUICK SAVE"); + PortableKeyEvent(state, SDL_SCANCODE_F6,0); + } + else if (code == KEY_QUICK_LOAD){ + LOGI("QUICK LOAD"); + PortableKeyEvent(state, SDL_SCANCODE_F9,0); + } + else + PortableAction(state, code); +} + +void automapButton(int state,int code) +{ + PortableAction(state,code); +} + +void inventoryButton(int state,int code) +{ + PortableAction(state,code); + if (state == 0) + { + tcGameWeapons->setEnabled(true); + tcInventory->setEnabled(false); + } + +} + +void menuButton(int state,int code) +{ + PortableKeyEvent(state, code,code); +} + +static int weaponWheelVisible = false; +void weaponWheelSelected(int enabled) +{ + if (enabled) + { + for (int n=0;n<10;n++) + { + weaponWheel->setSegmentEnabled(n,(PortableGetWeapons() >> n) & 0x1); + } + + tcGameWeapons->fade(0,5); //fade in + weaponWheelVisible = true; + } + else + { + tcGameWeapons->fade(1,5); + weaponWheelVisible = false; + } +} +void weaponWheelChosen(int segment) +{ + LOGI("weaponWheel %d",segment); + if (segment != -1) + { + PortableAction(1, gamefunc_Weapon_1 + segment); + PortableAction(0, gamefunc_Weapon_1 + segment); + } + else //Nothing was selected + { + if (getLastWeapon() != -1) + { + PortableAction(1, gamefunc_Weapon_1 + getLastWeapon()); + PortableAction(0, gamefunc_Weapon_1 + getLastWeapon()); + } + } +} + + +int left_double_action; +int right_double_action; + +void left_double_tap(int state) +{ + //LOGTOUCH("L double %d",state); + if (left_double_action) + PortableAction(state,left_double_action); +} + +void right_double_tap(int state) +{ + //LOGTOUCH("R double %d",state); + if (right_double_action) + PortableAction(state,right_double_action); +} + + +//To be set by android +float strafe_sens,forward_sens; +float pitch_sens,yaw_sens; + +void left_stick(float joy_x, float joy_y,float mouse_x, float mouse_y) +{ + joy_x *=10; + float strafe = joy_x*joy_x; + //float strafe = joy_x; + if (joy_x < 0) + strafe *= -1; + + PortableMove(joy_y * 15 * forward_sens,-strafe * strafe_sens); +} + +extern int crouchToggleState; //Set in anroid_in.c + +void right_stick(float joy_x, float joy_y,float mouse_x, float mouse_y) +{ + //LOGI(" mouse x = %f",mouse_x); + int invert = invertLook?-1:1; + + float scale = ((shooting && precisionShoot) || crouchToggleState)?0.3:1; + + PortableLookPitch(LOOK_MODE_MOUSE,-mouse_y * pitch_sens * invert * scale); + + if (turnMouseMode) + PortableLookYaw(LOOK_MODE_MOUSE,mouse_x*2*yaw_sens * scale); + else + PortableLookYaw(LOOK_MODE_JOYSTICK,joy_x*6*yaw_sens * scale); +} + +void mouseMove(int action,float x, float y,float dx, float dy) +{ + LOGI(" mouse dx = %f",dx); + + if (weaponWheelVisible) + return; + /* + if (abs(dx) < 0.001) + { + dx * 0.1; + } + */ + int invert = invertLook?-1:1; + float scale; + + if (sniperMode) + scale = 0.2; + else + scale = ((shooting && precisionShoot) || crouchToggleState)?0.2:1; + + + PortableLookPitch(LOOK_MODE_MOUSE,-dy * pitch_sens * invert * scale); + + PortableLookYaw(LOOK_MODE_MOUSE,dx*2*yaw_sens * scale); +} + +void setHideSticks(bool v) +{ + if (touchJoyLeft) touchJoyLeft->setHideGraphics(v); + if (touchJoyRight) touchJoyRight->setHideGraphics(v); +} + +void touchSettingsButton(int state) +{ + //We wanna pause the game when doign settings + if (state && !isPaused()) + { + PortableKeyEvent(1,SDL_SCANCODE_PAUSE,0); + PortableKeyEvent(0,SDL_SCANCODE_PAUSE,0); + } + else if (!state && isPaused()) + { + PortableKeyEvent(1,SDL_SCANCODE_PAUSE,0); + PortableKeyEvent(0,SDL_SCANCODE_PAUSE,0); + } +} + +void initControls(int width, int height,const char * graphics_path,const char *settings_file) +{ + touchcontrols::GLScaleWidth = (float)width; + touchcontrols::GLScaleHeight = (float)height; + + LOGI("initControls %d x %d,x path = %s, settings = %s",width,height,graphics_path,settings_file); + + if (!controlsCreated) + { + LOGI("creating controls"); + + touchcontrols::setGraphicsBasePath(graphics_path); + + controlsContainer.openGL_start.connect( sigc::ptr_fun(&openGLStart)); + controlsContainer.openGL_end.connect( sigc::ptr_fun(&openGLEnd)); + controlsContainer.signal_settings.connect( sigc::ptr_fun(&touchSettingsButton)); + + + tcMenuMain = new touchcontrols::TouchControls("menu",true,false); + tcGameMain = new touchcontrols::TouchControls("game",false,true,1,true); + tcGameWeapons = new touchcontrols::TouchControls("weapons",false,true,1,false); + tcAutomap = new touchcontrols::TouchControls("automap",false,true,1,false); + tcInventory = new touchcontrols::TouchControls("inventory",false,true,1,false); + tcGameLook = new touchcontrols::TouchControls("mouse",true,false); + controlsContainer.dukeHack = 1; + + tcGameMain->signal_settingsButton.connect( sigc::ptr_fun(&gameSettingsButton) ); + + //Menu + tcMenuMain->addControl(new touchcontrols::Button("down_arrow",touchcontrols::RectF(20,13,23,16),"arrow_down",SDL_SCANCODE_DOWN,true)); //Repeating buttons + tcMenuMain->addControl(new touchcontrols::Button("up_arrow",touchcontrols::RectF(20,10,23,13),"arrow_up",SDL_SCANCODE_UP,true)); + tcMenuMain->addControl(new touchcontrols::Button("left_arrow",touchcontrols::RectF(17,13,20,16),"arrow_left",SDL_SCANCODE_LEFT,true)); + tcMenuMain->addControl(new touchcontrols::Button("right_arrow",touchcontrols::RectF(23,13,26,16),"arrow_right",SDL_SCANCODE_RIGHT,true)); + tcMenuMain->addControl(new touchcontrols::Button("enter",touchcontrols::RectF(0,12,4,16),"enter",SDL_SCANCODE_RETURN)); + tcMenuMain->addControl(new touchcontrols::Button("esc",touchcontrols::RectF(0,9,4,12),"esc",SDL_SCANCODE_ESCAPE)); + + + tcMenuMain->signal_button.connect( sigc::ptr_fun(&menuButton) ); + tcMenuMain->setAlpha(0.5); + + + tcInventory->addControl(new touchcontrols::Button("jetpack", touchcontrols::RectF(4,3,7,6),"jetpack",gamefunc_Jetpack)); + tcInventory->addControl(new touchcontrols::Button("medkit", touchcontrols::RectF(7,3,10,6),"medkit",gamefunc_MedKit)); + tcInventory->addControl(new touchcontrols::Button("nightv", touchcontrols::RectF(4,6,7,9),"nightvision",gamefunc_NightVision)); + tcInventory->addControl(new touchcontrols::Button("holoduke",touchcontrols::RectF(7,6,10,9),"holoduke",gamefunc_Holo_Duke)); + tcInventory->addControl(new touchcontrols::Button("steroids",touchcontrols::RectF(4,9,7,12),"steroids",gamefunc_Steroids)); + tcMenuMain->setAlpha(1); + + + tcInventory->signal_button.connect( sigc::ptr_fun(&inventoryButton)); + + /* + //Automap + tcAutomap->addControl(new touchcontrols::Button("down_arrow",touchcontrols::RectF(2,14,4,16),"arrow_down",PORT_ACT_MAP_DOWN)); + tcAutomap->addControl(new touchcontrols::Button("up_arrow",touchcontrols::RectF(2,10,4,12),"arrow_up",PORT_ACT_MAP_UP)); + tcAutomap->addControl(new touchcontrols::Button("left_arrow",touchcontrols::RectF(0,12,2,14),"arrow_left",PORT_ACT_MAP_LEFT)); + tcAutomap->addControl(new touchcontrols::Button("right_arrow",touchcontrols::RectF(4,12,6,14),"arrow_right",PORT_ACT_MAP_RIGHT)); + tcAutomap->addControl(new touchcontrols::Button("zoom_in",touchcontrols::RectF(4,10,6,12),"zoom_in",PORT_ACT_MAP_ZOOM_IN)); + tcAutomap->addControl(new touchcontrols::Button("zoom_out",touchcontrols::RectF(4,14,6,16),"zoom_out",PORT_ACT_MAP_ZOOM_OUT)); + + tcAutomap->signal_button.connect( sigc::ptr_fun(&automapButton) ); + tcAutomap->setAlpha(0.5); + */ + + //Game + tcGameMain->setAlpha(gameControlsAlpha); + controlsContainer.editButtonAlpha = gameControlsAlpha; + tcGameMain->addControl(new touchcontrols::Button("use",touchcontrols::RectF(23,4,26,7),"use",gamefunc_Open)); + tcGameMain->addControl(new touchcontrols::Button("attack",touchcontrols::RectF(20,7,23,10),"fire2",gamefunc_Fire)); + tcGameMain->addControl(new touchcontrols::Button("jump",touchcontrols::RectF(23,7,26,10),"jump",gamefunc_Jump)); + tcGameMain->addControl(new touchcontrols::Button("crouch",touchcontrols::RectF(24,14,26,16),"crouch",gamefunc_Crouch)); + tcGameMain->addControl(new touchcontrols::Button("kick",touchcontrols::RectF(20,4,23,7),"boot",gamefunc_Quick_Kick)); + + tcGameMain->addControl(new touchcontrols::Button("quick_save",touchcontrols::RectF(24,0,26,2),"save",KEY_QUICK_SAVE)); + tcGameMain->addControl(new touchcontrols::Button("quick_load",touchcontrols::RectF(20,0,22,2),"load",KEY_QUICK_LOAD)); + tcGameMain->addControl(new touchcontrols::Button("map",touchcontrols::RectF(4,0,6,2),"map",gamefunc_Map)); + tcGameMain->addControl(new touchcontrols::Button("keyboard",touchcontrols::RectF(8,0,10,2),"keyboard",KEY_SHOW_KBRD)); + + tcGameMain->addControl(new touchcontrols::Button("show_inventory",touchcontrols::RectF(0,0,2,3),"inv",KEY_SHOW_INVEN)); + + tcGameMain->addControl(new touchcontrols::Button("next_weapon",touchcontrols::RectF(0,3,3,5),"next_weap",gamefunc_Next_Weapon)); + tcGameMain->addControl(new touchcontrols::Button("prev_weapon",touchcontrols::RectF(0,7,3,9),"prev_weap",gamefunc_Previous_Weapon)); + //tcGameMain->addControl(new touchcontrols::Button("sniper",touchcontrols::RectF(0,5,3,7),"sniper",KEY_SNIPER)); + + //quick actions binds + tcGameMain->addControl(new touchcontrols::Button("quick_key_1",touchcontrols::RectF(4,3,6,5),"quick_key_1",KEY_QUICK_KEY1,false,true)); + tcGameMain->addControl(new touchcontrols::Button("quick_key_2",touchcontrols::RectF(6,3,8,5),"quick_key_2",KEY_QUICK_KEY2,false,true)); + tcGameMain->addControl(new touchcontrols::Button("quick_key_3",touchcontrols::RectF(8,3,10,5),"quick_key_3",KEY_QUICK_KEY3,false,true)); + tcGameMain->addControl(new touchcontrols::Button("quick_key_4",touchcontrols::RectF(10,3,12,5),"quick_key_4",KEY_QUICK_KEY4,false,true)); + + //Left stick + touchJoyLeft = new touchcontrols::TouchJoy("stick",touchcontrols::RectF(0,7,8,16),"strafe_arrow"); + tcGameMain->addControl(touchJoyLeft); + touchJoyLeft->signal_move.connect(sigc::ptr_fun(&left_stick) ); + touchJoyLeft->signal_double_tap.connect(sigc::ptr_fun(&left_double_tap) ); + + //Right stick + touchJoyRight = new touchcontrols::TouchJoy("touch",touchcontrols::RectF(17,7,26,16),"look_arrow"); + tcGameMain->addControl(touchJoyRight); + touchJoyRight->signal_move.connect(sigc::ptr_fun(&right_stick) ); + touchJoyRight->signal_double_tap.connect(sigc::ptr_fun(&right_double_tap) ); + touchJoyRight->setEnabled(false); + + tcGameMain->signal_button.connect( sigc::ptr_fun(&gameButton) ); + + + //Mouse look for whole screen + touchcontrols::Mouse *mouse = new touchcontrols::Mouse("mouse",touchcontrols::RectF(3,0,26,16),""); + mouse->signal_action.connect(sigc::ptr_fun(&mouseMove)); + mouse->signal_double_tap.connect(sigc::ptr_fun(&right_double_tap) ); + + mouse->setHideGraphics(true); + tcGameLook->addControl(mouse); + + + + //Weapons + weaponWheel = new touchcontrols::WheelSelect("weapon_wheel",touchcontrols::RectF(7,2,19,14),"weapon_wheel",10); + weaponWheel->signal_selected.connect(sigc::ptr_fun(&weaponWheelChosen) ); + weaponWheel->signal_enabled.connect(sigc::ptr_fun(&weaponWheelSelected)); + tcGameWeapons->addControl(weaponWheel); + + + tcGameWeapons->setAlpha(0.9); + + controlsContainer.addControlGroup(tcMenuMain); + + controlsContainer.addControlGroup(tcInventory);//Need to be above tcGameMain incase buttons over stick + controlsContainer.addControlGroup(tcGameMain); + controlsContainer.addControlGroup(tcGameWeapons); + //controlsContainer.addControlGroup(tcAutomap); + controlsContainer.addControlGroup(tcGameLook); + controlsCreated = 1; + + tcGameMain->setXMLFile((std::string)graphics_path + "/game.xml"); + tcGameWeapons->setXMLFile((std::string)graphics_path + "/weapons.xml"); + tcAutomap->setXMLFile((std::string)graphics_path + "/automap.xml"); + tcInventory->setXMLFile((std::string)graphics_path + "/inventory.xml"); + + } + else + LOGI("NOT creating controls"); + + //controlsContainer.initGL(); +} + +int loadedGLImages=0; + +int inMenuLast = 1; +int inAutomapLast = 0; +void frameControls() +{ + //LOGI("frameControls"); + //We need to do this here now because duke loads a new gl context + if (!loadedGLImages) + { + touchJoyRight->setEnabled(false); + + controlsContainer.initGL(); + loadedGLImages = 1; + + } + + //LOGI("frameControls"); + if (PortableIsSoftwareMode()) + curRenderer = REND_SOFT; + else + curRenderer = REND_GL; + + int inMenuNew = PortableInMenu(); + if (inMenuLast != inMenuNew) + { + inMenuLast = inMenuNew; + if (!inMenuNew) + { + tcGameMain->setEnabled(true); + tcGameWeapons->setEnabled(true); + tcGameWeapons->fade(1,5); + tcMenuMain->setEnabled(false); + } + else + { + tcGameMain->setEnabled(false); + tcGameWeapons->setEnabled(false); + tcMenuMain->setEnabled(true); + } + } + + int inAutomapNew = PortableInAutomap() && !inMenuLast; //Dont show if menu comes up + if (inAutomapLast != inAutomapNew) + { + inAutomapLast = inAutomapNew; + if (inAutomapNew) + { + tcAutomap->animateIn(5); + } + else + { + tcAutomap->animateOut(5); + } + } + + setHideSticks(!showSticks); + controlsContainer.draw(); +} + + +void setTouchSettings(float alpha,float strafe,float fwd,float pitch,float yaw,int other) +{ + + gameControlsAlpha = alpha; + if (tcGameMain) + { + tcGameMain->setAlpha(gameControlsAlpha); + controlsContainer.editButtonAlpha = gameControlsAlpha; + } + + showWeaponCycle = other & 0x1?true:false; + turnMouseMode = other & 0x2?true:false; + invertLook = other & 0x4?true:false; + precisionShoot = other & 0x8?true:false; + showSticks = other & 0x1000?true:false; + + hideTouchControls = other & 0x80000000?true:false; + + + switch ((other>>4) & 0xF) + { + case 1: + left_double_action = gamefunc_Fire; + break; + case 2: + left_double_action = gamefunc_Jump; + break; + default: + left_double_action = 0; + } + + switch ((other>>8) & 0xF) + { + case 1: + right_double_action = gamefunc_Fire; + break; + case 2: + right_double_action = gamefunc_Jump; + break; + default: + right_double_action = 0; + } + + strafe_sens = strafe; + forward_sens = fwd; + pitch_sens = pitch; + yaw_sens = yaw; + +} + +int quit_now = 0; + +#define EXPORT_ME __attribute__ ((visibility("default"))) + +JNIEnv* env_; + +int argc=1; +const char * argv[32]; +std::string graphicpath; + + +std::string doom_path; + +const char * getDoomPath() +{ + return doom_path.c_str(); +} + +jint EXPORT_ME +Java_com_beloko_duke_engine_NativeLib_init( JNIEnv* env, + jobject thiz,jstring graphics_dir,jint mem_mb,jobjectArray argsArray,jint renderer,jstring doom_path_ ) +{ + env_ = env; + curRenderer = renderer; + //curRenderer = REND_SOFT; + curRenderer = REND_GL; + + argv[0] = "eduke32"; + int argCount = (env)->GetArrayLength( argsArray); + LOGI("argCount = %d",argCount); + for (int i=0; iGetObjectArrayElement( argsArray, i); + argv[argc] = (char *)(env)->GetStringUTFChars( string, 0); + LOGI("arg = %s",argv[argc]); + argc++; + } + + + + doom_path = (char *)(env)->GetStringUTFChars( doom_path_, 0); + + //Change working dir, save games etc + + chdir(getDoomPath()); + putenv("TIMIDITY_CFG=../timidity.cfg"); + + LOGI("doom_path = %s",getDoomPath()); + //argv[0] = "vavoom"; + //argv[1] = "-basedir"; + //argv[2] = "/sdcard/Beloko/Quake/FULL"; + //args[3] = "-doom"; + + + const char * p = env->GetStringUTFChars(graphics_dir,NULL); + graphicpath = std::string(p); + + + + initControls(android_screen_width,-android_screen_height,graphicpath.c_str(),(graphicpath + "/touch_controls.xml").c_str()); + //initControls(2,-2,graphicpath.c_str(),(graphicpath + "/prdoom.xml").c_str()); + + /* + if (renderer != REND_SOFT) + SDL_SetSwapBufferCallBack(frameControls); + + if (renderer == REND_SOFT)// In soft mode SDL calls swap buffer, disable so it does not flicker + SDL_SwapBufferPerformsSwap(false); + */ + + + SDL_SetSwapBufferCallBack(frameControls); + + //Now doen in java to keep context etc + //SDL_SwapBufferPerformsSwap(false); + + + PortableInit(argc,argv); + + + return 0; +} + + +jint EXPORT_ME +Java_com_beloko_duke_engine_NativeLib_frame( JNIEnv* env, + jobject thiz ) +{ + + LOGI("Java_com_beloko_duke_engine_NativeLib_frame"); + + PortableFrame(); + + frameControls(); + + return 0; +} + +__attribute__((visibility("default"))) jint JNI_OnLoad(JavaVM* vm, void* reserved) +{ + LOGI("JNI_OnLoad"); + + return JNI_VERSION_1_4; +} + + +void EXPORT_ME +Java_com_beloko_duke_engine_NativeLib_keypress(JNIEnv *env, jobject obj, + jint down, jint keycode, jint unicode) +{ + LOGI("keypress %d",keycode); + if (controlsContainer.isEditing()) + { + if (down && (keycode == SDL_SCANCODE_ESCAPE )) + controlsContainer.finishEditing(); + + } + else + PortableKeyEvent(down,keycode,unicode); + +} + + +void EXPORT_ME +Java_com_beloko_duke_engine_NativeLib_touchEvent(JNIEnv *env, jobject obj, + jint action, jint pid, jfloat x, jfloat y) +{ + //LOGI("TOUCHED"); + controlsContainer.processPointer(action,pid,x,y); +} + + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_doAction(JNIEnv *env, jobject obj, + jint state, jint action) +{ + //gamepadButtonPressed(); + if (hideTouchControls) + if (tcGameMain->isEnabled()) + tcGameMain->animateOut(30); + LOGI("doAction %d %d",state,action); + PortableAction(state,action); +} + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_analogFwd(JNIEnv *env, jobject obj, + jfloat v) +{ + PortableMoveFwd(v); +} + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_analogSide(JNIEnv *env, jobject obj, + jfloat v) +{ + PortableMoveSide(v); +} + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_analogPitch(JNIEnv *env, jobject obj, + jint mode,jfloat v) +{ + PortableLookPitch(mode, v); +} + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_analogYaw(JNIEnv *env, jobject obj, + jint mode,jfloat v) +{ + PortableLookYaw(mode, v); +} + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_setTouchSettings(JNIEnv *env, jobject obj, + jfloat alpha,jfloat strafe,jfloat fwd,jfloat pitch,jfloat yaw,int other) +{ + setTouchSettings(alpha,strafe,fwd,pitch,yaw,other); +} + +void EXPORT_ME Java_com_beloko_duke_engine_NativeLib_resetTouchSettings(JNIEnv *env, jobject obj) +{ + controlsContainer.resetDefaults(); +} + +std::string quickCommandString; +jint EXPORT_ME +Java_com_beloko_duke_engine_NativeLib_quickCommand(JNIEnv *env, jobject obj, + jstring command) +{ + const char * p = env->GetStringUTFChars(command,NULL); + quickCommandString = std::string(p) + "\n"; + env->ReleaseStringUTFChars(command, p); + PortableCommand(quickCommandString.c_str()); +} + + + + +void EXPORT_ME +Java_com_beloko_duke_engine_NativeLib_setScreenSize( JNIEnv* env, + jobject thiz, jint width, jint height) +{ + android_screen_width = width; + android_screen_height = height; +} + + +#include "SDL_main.h" +extern void SDL_Android_Init(JNIEnv* env, jclass cls); + +void Java_org_libsdl_app_SDLActivity_nativeInit(JNIEnv* env, jclass cls) +{ + /* This interface could expand with ABI negotiation, calbacks, etc. */ + SDL_Android_Init(env, cls); + SDL_SetMainReady(); + // SDL_EventState(SDL_TEXTINPUT,SDL_ENABLE); +} + + +} diff --git a/polymer/eduke32/source/android/in_android.c b/polymer/eduke32/source/android/in_android.c new file mode 100644 index 000000000..1a26a5ff0 --- /dev/null +++ b/polymer/eduke32/source/android/in_android.c @@ -0,0 +1,303 @@ +#include "sdl_inc.h" +#include "baselayer.h" +#include "keys.h" +#include "duke3d.h" +#include "common_game.h" +#include "osd.h" +#include "player.h" + +#include "jmact/keyboard.h" +#include "jmact/control.h" + +#include "../src/video/android/SDL_androidkeyboard.h" + +#include "in_android.h" + +#include + +#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO,"DUKE", __VA_ARGS__)) + + +extern int SDL_SendKeyboardKey(Uint8 state, SDL_Scancode scancode); +extern int SDL_SendKeyboardText(const char *text); + +char sdl_text[2]; +int PortableKeyEvent(int state, int code,int unicode){ + + LOGI("PortableKeyEvent %d %d %d",state,code,unicode); + + /* + if (state) + Android_OnKeyDown(code); + else + Android_OnKeyUp(code); + + return; + */ + + if (state) + SDL_SendKeyboardKey(SDL_PRESSED, code); + else + SDL_SendKeyboardKey(SDL_RELEASED, code); + + SDL_EventState(SDL_TEXTINPUT,SDL_ENABLE); + + if (code == 42) + unicode = 42; + + if (state) + { + //if (unicode < 128) + { + sdl_text[0] = unicode; + sdl_text[1] = 0; + + int posted = SDL_SendKeyboardText((const char*)sdl_text); + LOGI("posted = %d",posted); + } + } + + return 0; + +} + + +int crouchToggleState=0; + +#define BUTTONSET(x,value) (CONTROL_ButtonState |= ((uint64_t)value<<((uint64_t)(x)))) +#define BUTTONCLEAR(x) (CONTROL_ButtonState &= ~((uint64_t)1<<((uint64_t)(x)))) + +uint64_t functionSticky = 0; //To let at least one tick +uint64_t functionHeld = 0; + +void changeActionState(int state, int action) +{ + if (state) + { + //BUTTONSET(action,1); + functionSticky |= ((uint64_t)1<<((uint64_t)(action))); + functionHeld |= ((uint64_t)1<<((uint64_t)(action))); + } + else + { + //BUTTONCLEAR(action); + functionHeld &= ~((uint64_t)1<<((uint64_t)(action))); + } +} + +void PortableAction(int state, int action) +{ + LOGI("PortableAction action = %d, state = %d",action,state); + + //Special toggle for crouch, NOT when using jetpack or in water + if (!g_player[myconnectindex].ps->jetpack_on && + g_player[myconnectindex].ps->on_ground && + (sector[g_player[myconnectindex].ps->cursectnum].lotag != 2))// This means underwater! + { + + if (action == gamefunc_Crouch) + { + if (state) + { + crouchToggleState =!crouchToggleState; + } + state = crouchToggleState; + } + } + + //Check if jumping while crouched + if (action == gamefunc_Jump) + { + if (crouchToggleState) + { + crouchToggleState = 0; + changeActionState(0,gamefunc_Crouch); + } + } + + changeActionState(state,action); + LOGI("PortableAction state = 0x%016llX",CONTROL_ButtonState); +} + +// =================== FORWARD and SIDE MOVMENT ============== + +float forwardmove, sidemove; //Joystick mode + +void PortableMoveFwd(float fwd) +{ + if (fwd > 1) + fwd = 1; + else if (fwd < -1) + fwd = -1; + + forwardmove = fwd; +} + +void PortableMoveSide(float strafe) +{ + if (strafe > 1) + strafe = 1; + else if (strafe < -1) + strafe = -1; + + sidemove = strafe; +} + +void PortableMove(float fwd, float strafe) +{ + PortableMoveFwd(fwd); + PortableMoveSide(strafe); +} + +//====================================================================== + +//Look up and down +int look_pitch_mode; +float look_pitch_mouse,look_pitch_abs,look_pitch_joy; +void PortableLookPitch(int mode, float pitch) +{ + //LOGI("PortableLookPitch %d %f",mode, pitch); + look_pitch_mode = mode; + switch(mode) + { + case LOOK_MODE_MOUSE: + look_pitch_mouse += pitch; + break; + case LOOK_MODE_ABSOLUTE: + look_pitch_abs = pitch; + break; + case LOOK_MODE_JOYSTICK: + look_pitch_joy = pitch; + break; + } +} + +//left right +int look_yaw_mode; +float look_yaw_mouse,look_yaw_joy; +void PortableLookYaw(int mode, float yaw) +{ + look_yaw_mode = mode; + switch(mode) + { + case LOOK_MODE_MOUSE: + look_yaw_mouse += yaw; + break; + case LOOK_MODE_JOYSTICK: + look_yaw_joy = yaw; + break; + } +} + + + +void PortableCommand(const char * cmd){} + +extern int32_t main(int32_t argc, char *argv[]); +void PortableInit(int argc,const char ** argv){ + + main(argc,argv); +} + + +void PortableFrame(){ + //NOT USED for DUKE +} + +int PortableInMenu(){ + return ( (g_player[myconnectindex].ps->gm & MODE_MENU) || !(g_player[myconnectindex].ps->gm & MODE_GAME))?1:0; +} + +unsigned int PortableGetWeapons() +{ + return g_player[myconnectindex].ps->gotweapon; +} +int PortableInAutomap() +{ + return 0; +} + +int PortableShowKeyboard(){ + + return 0; +} + +int PortableIsSoftwareMode() +{ + if (getrendermode() >= REND_POLYMOST) + return 0; + else + return 1; + +} + + +static int lastWeapon = -1; +int getLastWeapon(){ + return lastWeapon; +} + +extern user_defs ud; + +int isPaused() +{ + return ud.pause_on; +} + +///This stuff is called from the game/engine + +void setLastWeapon(int w) +{ + LOGI("setLastWeapon %d",w); + lastWeapon = w; +} + + +void CONTROL_Android_ClearButton(int32_t whichbutton) +{ + BUTTONCLEAR(whichbutton); + functionHeld &= ~((uint64_t)1<<((uint64_t)(whichbutton))); +} + +void CONTROL_Android_PollDevices(ControlInfo *info) +{ + //LOGI("CONTROL_Android_PollDevices %f %f",forwardmove,sidemove); + + info->dz = -forwardmove * 5000; + info->dx = sidemove * 200; + + switch(look_pitch_mode) + { + case LOOK_MODE_MOUSE: + info->dpitch = look_pitch_mouse * 100000; + look_pitch_mouse = 0; + break; + case LOOK_MODE_ABSOLUTE: + //cl.viewangles[0] = look_pitch_abs * 80; + break; + case LOOK_MODE_JOYSTICK: + info->dpitch = look_pitch_joy * 2000; + break; + } + + + switch(look_yaw_mode) + { + case LOOK_MODE_MOUSE: + info->dyaw = -look_yaw_mouse * 80000; + look_yaw_mouse = 0; + break; + case LOOK_MODE_JOYSTICK: + info->dyaw = -look_yaw_joy * 4000; + break; + } + CONTROL_ButtonState = 0; + CONTROL_ButtonState |= functionSticky; + CONTROL_ButtonState |= functionHeld; + + functionSticky = 0; + + //LOGI("poll state = 0x%016llX",CONTROL_ButtonState); +} + + diff --git a/polymer/eduke32/source/android/in_android.h b/polymer/eduke32/source/android/in_android.h new file mode 100644 index 000000000..be8eb44b8 --- /dev/null +++ b/polymer/eduke32/source/android/in_android.h @@ -0,0 +1,46 @@ +#include "function.h" + + + + +#define LOOK_MODE_MOUSE 0 +#define LOOK_MODE_ABSOLUTE 1 +#define LOOK_MODE_JOYSTICK 2 + + + +#ifdef __cplusplus +extern "C" +{ +#endif +int PortableKeyEvent(int state, int code, int unicode); +void PortableAction(int state, int action); + +void PortableMove(float fwd, float strafe); +void PortableMoveFwd(float fwd); +void PortableMoveSide(float strafe); +void PortableLookPitch(int mode, float pitch); +void PortableLookYaw(int mode, float pitch); +void PortableCommand(const char * cmd); + +void PortableInit(int argc,const char ** argv); +void PortableFrame(); + +int PortableInMenu(); +int PortableShowKeyboard(); +int PortableInAutomap(); + +unsigned int PortableGetWeapons(); + +int getLastWeapon(); + +int isPaused(); + + +//check mode, so touch graphcics can adapt +int PortableIsSoftwareMode(); + + +#ifdef __cplusplus +} +#endif diff --git a/polymer/eduke32/source/config.c b/polymer/eduke32/source/config.c index 660d32580..fd8a2ebee 100644 --- a/polymer/eduke32/source/config.c +++ b/polymer/eduke32/source/config.c @@ -174,9 +174,16 @@ void CONFIG_SetDefaults(void) int32_t i; ud.config.scripthandle = -1; +#ifdef __ANDROID__ + ud.config.ScreenWidth = android_screen_width; + ud.config.ScreenHeight = android_screen_height; +#else ud.config.ScreenWidth = 1024; ud.config.ScreenHeight = 768; +#endif + ud.config.ScreenMode = 0; + #ifdef USE_OPENGL ud.config.ScreenBPP = 32; #else diff --git a/polymer/eduke32/source/jmact/control.c b/polymer/eduke32/source/jmact/control.c index 13f588dc6..e2794146c 100644 --- a/polymer/eduke32/source/jmact/control.c +++ b/polymer/eduke32/source/jmact/control.c @@ -18,6 +18,10 @@ #include "osd.h" #include "pragmas.h" +#ifdef __ANDROID__ +#include "android.h" +#endif + int32_t CONTROL_JoyPresent = FALSE; int32_t CONTROL_JoystickEnabled = FALSE; int32_t CONTROL_MousePresent = FALSE; @@ -606,6 +610,10 @@ static void CONTROL_PollDevices(ControlInfo *info) { memset(info, 0, sizeof(ControlInfo)); +#ifdef __ANDROID__ + CONTROL_Android_PollDevices(info); +#endif + if (CONTROL_MouseEnabled) { int32_t i = MAXMOUSEAXES-1; diff --git a/polymer/eduke32/source/player.c b/polymer/eduke32/source/player.c index c22e39fcc..2413a0f6b 100644 --- a/polymer/eduke32/source/player.c +++ b/polymer/eduke32/source/player.c @@ -3241,6 +3241,10 @@ static void P_ChangeWeapon(DukePlayer_t *p, int32_t weapon) if (p->holster_weapon) { +#ifdef __ANDROID__ + setLastWeapon(p->last_weapon); +#endif + p->weapon_pos = WEAPON_POS_RAISE; p->holster_weapon = 0; p->last_weapon = -1; diff --git a/polymer/eduke32/source/sdlmusic.c b/polymer/eduke32/source/sdlmusic.c index 6503c2cf9..8199d3122 100644 --- a/polymer/eduke32/source/sdlmusic.c +++ b/polymer/eduke32/source/sdlmusic.c @@ -56,7 +56,13 @@ static char **external_midi_argv; static pid_t external_midi_pid=-1; static int8_t external_midi_restart=0; #endif + +#ifdef __ANDROID__ //TODO fix +static char *external_midi_tempfn = "/sdcard/eduke32-music.mid"; +#else static char *external_midi_tempfn = "/tmp/eduke32-music.mid"; +#endif + static int32_t external_midi = 0; int32_t MUSIC_ErrorCode = MUSIC_Ok;