Files
AVA2/src/scripting/python_runtime.cpp
T
shenleiandClaude Opus 5.5 5597842d90 Add touch input router for mobile (step 3)
Route each finger to UI, the attack button, a floating lower-left joystick or
the camera (drag rotate, pinch zoom, tap = world click). Touch mode is default
on Android/iOS and available on desktop via --touch / AVA2_TOUCH=1; it disables
SDL touch-to-mouse and drives app.ENABLE_MOBILE_HUD. The joystick feeds the
original camera-relative movement path and the attack button sets the same
attack-key state as player.SetAttackKeyState. New `touch` Python module; the
mobile HUD joystick and combat wheel become display-only.

Tests: ava2.touch_router, ava2.touch_game (GameWindow + mobile HUD).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 19:46:24 +09:00

380 lines
18 KiB
C++

#include "pet_skill_state.h"
#include "eter_ui/PythonWindowManager.h"
#include "src/eter_image/GrpImageInstance.h"
#include "src/eter_image/GrpExpandedImageInstance.h"
#include "src/eter_image/GrpMarkInstance.h"
#include "python_runtime.h"
#include "python_minimap.h"
#include "quest_state.h"
#include "guild_state.h"
#include "battlepass_state.h"
#include "drop_item_state.h"
#include "dungeon_info_state.h"
#include "switchbot_state.h"
#include "messenger_state.h"
#include "cube_renewal_state.h"
#include "shop_search_state.h"
#include "python_net.h"
#include "python_app.h"
#include "python_dbg.h"
#include "python_touch.h"
#include "python_system.h"
#include "python_wndmgr.h"
#include "python_gameplay_modules.h"
#include "python_ime.h"
#include "python_grp.h"
#include "python_native_modules.h"
#include "python_event_manager.h"
#include "python_chat.h"
#include "../upstream/ava2-client/UserInterface/Locale_inc.h"
#include <Python.h>
#include <algorithm>
#include <fstream>
#include <cctype>
#include <stdexcept>
#include <vector>
namespace ava2 {
namespace {
std::filesystem::path pack_root;
std::filesystem::path resolve(const char* name) {
std::string normalized(name);std::replace(normalized.begin(),normalized.end(),'\\','/');
std::filesystem::path rel(normalized);
if(rel.is_absolute()) throw std::invalid_argument("pack path must be relative");
for(const auto& part:rel) if(part=="..") throw std::invalid_argument("pack traversal rejected");
std::vector<std::filesystem::path> mounts{pack_root};
// The bundle keeps scripts in root/ and the other virtual packs beside it.
if (pack_root.filename()=="root" && std::filesystem::is_regular_file(pack_root.parent_path()/"asset_manifest.json"))
mounts.push_back(pack_root.parent_path());
for (const auto& mount:mounts) {
auto current=mount;
bool missing=false;
for(const auto& part:rel) {
if(part=="." || part.empty()) continue;
if(!std::filesystem::is_directory(current)) {missing=true;break;}
auto wanted=part.string();std::transform(wanted.begin(),wanted.end(),wanted.begin(),[](unsigned char c){return std::tolower(c);});
bool found=false;std::filesystem::path match;
for(const auto& entry:std::filesystem::directory_iterator(current)) {
auto candidate=entry.path().filename().string();std::transform(candidate.begin(),candidate.end(),candidate.begin(),[](unsigned char c){return std::tolower(c);});
if(candidate==wanted) {if(found) throw std::runtime_error("ambiguous case-insensitive pack path");match=entry.path();found=true;}
}
if(!found) {missing=true;break;}
current=match;
}
if(missing) continue;
auto canonical=std::filesystem::canonical(current);auto relative=canonical.lexically_relative(mount);
if(relative.empty() || *relative.begin()=="..") throw std::runtime_error("pack path escapes mount");
return canonical;
}
throw std::runtime_error("pack path not found");
}
PyObject* pack_exist(PyObject*,PyObject* args) {
const char* name=nullptr;if(!PyArg_ParseTuple(args,"s",&name)) return nullptr;
try { return PyInt_FromLong(std::filesystem::is_regular_file(resolve(name))); } catch(...) { return PyInt_FromLong(0); }
}
PyObject* pack_get(PyObject*,PyObject* args) {
const char* name=nullptr;if(!PyArg_ParseTuple(args,"s",&name)) return nullptr;
try {
auto path=resolve(name);auto size=std::filesystem::file_size(path);if(size>64*1024*1024) throw std::runtime_error("pack file too large");
std::ifstream stream(path,std::ios::binary);std::string data(size,'\0');if(!stream.read(data.data(),data.size())) throw std::runtime_error("pack read failed");
return PyString_FromStringAndSize(data.data(),data.size());
} catch(const std::exception& e) { PyErr_SetString(PyExc_IOError,e.what());return nullptr; }
}
void initpack() {
static PyMethodDef methods[]={{"Exist",pack_exist,METH_VARARGS,nullptr},{"Get",pack_get,METH_VARARGS,nullptr},{nullptr,nullptr,0,nullptr}};
Py_InitModule("pack",methods);
}
}
std::string ReadPackedText(const std::string& name) {
auto path=resolve(name.c_str());
auto size=std::filesystem::file_size(path);
if(size>64*1024*1024) throw std::runtime_error("pack text too large");
std::ifstream file(path,std::ios::binary); std::string text(size,'\0');
if(!file.read(text.data(),text.size())) throw std::runtime_error("pack text read failed");
return text;
}
PythonRuntime::PythonRuntime(const std::filesystem::path& stdlib,const std::filesystem::path& root) {
if(Py_IsInitialized()) throw std::logic_error("one embedded Python runtime allowed");
ResetPythonAppState();
GetPetSkillState()=PetSkillState{};
ResetSkillDescriptions();
ResetShopState();
GetQuestState().records.clear();
GetGuildState()=GuildState{};
GetShopSearchItems().clear();
GetMessengerState().Reset();
GetCubeRenewalState().Reset();
GetBattlePassState().Reset();
GetDropItemState().Reset();
GetDungeonInfoState()=DungeonInfoState{};
GetSwitchbotState()=SwitchbotState{};
if(!std::filesystem::is_regular_file(stdlib)) throw std::runtime_error("python27.zip missing");
pack_root=std::filesystem::canonical(root);
static bool registered=false;
if(!registered) {
if(PyImport_AppendInittab("pack",initpack)!=0 ||
PyImport_AppendInittab("app",initapp)!=0 ||
PyImport_AppendInittab("dbg",initdbg)!=0 ||
PyImport_AppendInittab("touch",inittouch)!=0 ||
PyImport_AppendInittab("systemSetting",initsystemSetting)!=0 ||
PyImport_AppendInittab("wndMgr",initwndMgr)!=0 ||
PyImport_AppendInittab("item",initItem)!=0 ||
PyImport_AppendInittab("player",initPlayer)!=0 ||
PyImport_AppendInittab("chrmgr",initchrmgr)!=0 ||
PyImport_AppendInittab("chr",initchr)!=0 ||
PyImport_AppendInittab("chat",initChat)!=0 ||
PyImport_AppendInittab("snd",initsnd)!=0 ||
PyImport_AppendInittab("background",initBackground)!=0 ||
PyImport_AppendInittab("ime",initime)!=0 ||
PyImport_AppendInittab("grp",initgrp)!=0 ||
PyImport_AppendInittab("grpImage",initgrpImage)!=0 ||
PyImport_AppendInittab("grpText",initgrpText)!=0 ||
PyImport_AppendInittab("grpThing",initgrpThing)!=0 ||
PyImport_AppendInittab("nonplayer",initNonPlayer)!=0 ||
PyImport_AppendInittab("exchange",initTrade)!=0 ||
PyImport_AppendInittab("textTail",initTextTail)!=0 ||
PyImport_AppendInittab("miniMap",initMiniMap)!=0 ||
PyImport_AppendInittab("profiler",initProfiler)!=0 ||
PyImport_AppendInittab("event",initEvent)!=0 ||
PyImport_AppendInittab("effect",initeffect)!=0 ||
PyImport_AppendInittab("fly",initfly)!=0 ||
PyImport_AppendInittab("eventMgr",initeventmgr)!=0 ||
PyImport_AppendInittab("shop",initshop)!=0 ||
PyImport_AppendInittab("skill",initskill)!=0 ||
PyImport_AppendInittab("skillpet",initskillpet)!=0 ||
PyImport_AppendInittab("quest",initquest)!=0 ||
PyImport_AppendInittab("messenger",initMessenger)!=0 ||
PyImport_AppendInittab("sash",initSash)!=0 ||
PyImport_AppendInittab("ServerStateChecker",initServerStateChecker)!=0 ||
PyImport_AppendInittab("playerLoad",initPlayerSettingsModule)!=0 ||
PyImport_AppendInittab("switchbot",initSwitchbot)!=0 ||
PyImport_AppendInittab("wiki",initWiki)!=0 ||
PyImport_AppendInittab("combat_zone",initCombatZoneSystem)!=0 ||
PyImport_AppendInittab("managerBankLogs",initBankManager)!=0 ||
PyImport_AppendInittab("dropitem",intdropitem)!=0 ||
PyImport_AppendInittab("drop_item",intdropitem)!=0 ||
PyImport_AppendInittab("safebox",initsafebox)!=0 ||
PyImport_AppendInittab("guild",initguild)!=0 ||
PyImport_AppendInittab("dungeon_info",intdungeoninfo)!=0 ||
PyImport_AppendInittab("renderTarget",initRenderTarget)!=0 ||
PyImport_AppendInittab("cuberenewal",intcuberenewal)!=0 ||
PyImport_AppendInittab("cube_renewal",intcuberenewal)!=0 ||
PyImport_AppendInittab("battlepass",intbattlepass)!=0 ||
PyImport_AppendInittab("privateShopSearch",initprivateShopSearch)!=0 ||
PyImport_AppendInittab("udp",initudp)!=0 ||
PyImport_AppendInittab("impMgr",initModuleNameManager)!=0)
throw std::runtime_error("native module registration failed");
register_python_net();
registered=true;
}
Py_FrozenFlag=1;Py_IgnoreEnvironmentFlag=1;Py_NoSiteFlag=1;Py_DontWriteBytecodeFlag=1;
CResourceManager::SetResourceRoot(std::filesystem::absolute(root));
m_resourceManager = std::make_unique<CResourceManager>();
Py_Initialize();
m_windowManager = std::make_unique<UI::CWindowManager>();
auto* builtins=PyImport_ImportModule("__builtin__");
if(builtins) {
PyModule_AddIntConstant(builtins, "__DEBUG__", 1);
PyModule_AddIntConstant(builtins, "__USE_CYTHON__", 0);
PyModule_AddIntConstant(builtins, "__USE_EXTRA_CYTHON__", 0);
PyModule_AddStringConstant(builtins, "__COMMAND_LINE__", "");
PyModule_AddIntConstant(builtins, "TRUE", 1);
PyModule_AddIntConstant(builtins, "FALSE", 0);
auto* open_func = PyDict_GetItemString(PyModule_GetDict(builtins), "open");
if (open_func) {
PyDict_SetItemString(PyModule_GetDict(builtins), "old_open", open_func);
PyDict_SetItemString(PyModule_GetDict(builtins), "new_open", open_func);
}
Py_DECREF(builtins);
}
auto* path=PyList_New(0);
for(const auto& dir:{std::filesystem::absolute(stdlib),pack_root}) {
auto* value=PyString_FromString(dir.string().c_str());PyList_Append(path,value);Py_DECREF(value);
}
PySys_SetObject(const_cast<char*>("path"),path);Py_DECREF(path);
// Original scripts request mixed-case module names from lowercase pack files.
// Host-side importer only; complete system.py/app/dbg bootstrap is still pending.
try { execute(R"PY(
import sys, imp, pack, os, __builtin__
try:
import encodings
except:
pass
_orig_open = __builtin__.open
def _ava2_open(filename, mode='r', buffering=-1):
candidates = [filename]
if isinstance(filename, (str, unicode)):
f = filename.replace('\\', '/')
if len(f) >= 2 and f[1] == ':':
f = f[2:]
if f.startswith('/'):
f = f[1:]
candidates.append(f)
if f.lower() != f:
candidates.append(f.lower())
for cand in candidates:
try:
return _orig_open(cand, mode, buffering)
except (IOError, OSError):
continue
return _orig_open(filename, mode, buffering)
__builtin__.open = _ava2_open
__builtin__.old_open = _orig_open
__builtin__.new_open = _ava2_open
class _AVA2PackImporter(object):
def find_module(self, fullname, path=None):
if imp.is_builtin(fullname):
return None
if path is None and '.' not in fullname and pack.Exist(fullname + '.py'):
return self
return None
def load_module(self, fullname):
if fullname in sys.modules:
return sys.modules[fullname]
filename = fullname + '.py'
source = pack.Get(filename).replace('\r\n', '\n')
code = compile(source, filename, 'exec')
module = imp.new_module(fullname)
module.__file__ = filename
module.__loader__ = self
sys.modules[fullname] = module
try:
exec code in module.__dict__
except:
del sys.modules[fullname]
raise
return module
sys.meta_path.insert(0, _AVA2PackImporter())
)PY"); } catch(...) {
reset_python_net();
ClearPlayerPythonWindow();
GetMessengerState().Reset();
GetCubeRenewalState().Reset();
GetBattlePassState().Reset();
GetDropItemState().Reset();
GetDungeonInfoState()=DungeonInfoState{};
GetSwitchbotState()=SwitchbotState{};
// The event sets hold weak references to Python objects.
CPythonEventManager::Instance().Destroy();CPythonChat::Instance().Destroy();CPythonSystem::Instance().Clear();
CPythonEventManager::Instance().SetInterfaceWindow(nullptr);
clear_compiled_code();
Py_Finalize();
if (m_windowManager)
{
m_windowManager->Destroy();
m_windowManager.reset();
}
CPythonMiniMap::Instance().Destroy();
CGraphicExpandedImageInstance::DestroySystem();
CGraphicImageInstance::DestroySystem();
CGraphicMarkInstance::DestroySystem();
if (m_resourceManager)
{
m_resourceManager->Destroy();
m_resourceManager.reset();
}
pack_root.clear();
throw;
}
}
PythonRuntime::~PythonRuntime() {
reset_python_net();
ClearPlayerPythonWindow();
GetMessengerState().Reset();
GetCubeRenewalState().Reset();
GetBattlePassState().Reset();
GetDropItemState().Reset();
GetDungeonInfoState()=DungeonInfoState{};
GetSwitchbotState()=SwitchbotState{};
// The event sets hold weak references to Python objects.
CPythonEventManager::Instance().Destroy();CPythonChat::Instance().Destroy();CPythonSystem::Instance().Clear();
CPythonEventManager::Instance().SetInterfaceWindow(nullptr);
clear_compiled_code();
Py_Finalize();
if (m_windowManager)
{
m_windowManager->Destroy();
m_windowManager.reset();
}
CPythonMiniMap::Instance().Destroy();
CGraphicExpandedImageInstance::DestroySystem();
CGraphicImageInstance::DestroySystem();
CGraphicMarkInstance::DestroySystem();
if (m_resourceManager)
{
m_resourceManager->Destroy();
m_resourceManager.reset();
}
pack_root.clear();
}
void PythonRuntime::clear_compiled_code() {
for(auto& entry:m_compiledCode)Py_DECREF(entry.object);
m_compiledCode.clear();m_compiledBytes=0;
}
void PythonRuntime::execute(const std::string& source) {
PyObject* code=nullptr;
for(auto it=m_compiledCode.begin();it!=m_compiledCode.end();++it) {
if(it->source!=source)continue;
code=it->object;Py_INCREF(code);m_compiledCode.splice(m_compiledCode.begin(),m_compiledCode,it);break;
}
if(!code) {
code=Py_CompileString(source.c_str(),"<string>",Py_file_input);++m_compileCount;
if(!code){PyErr_Print();throw std::runtime_error("embedded Python execution failed (see traceback)");}
if(source.size()<=16u*1024u) {
Py_INCREF(code);m_compiledCode.push_front({source,code});m_compiledBytes+=source.size();
while(m_compiledCode.size()>64 || m_compiledBytes>128u*1024u) {
auto& entry=m_compiledCode.back();m_compiledBytes-=entry.source.size();Py_DECREF(entry.object);m_compiledCode.pop_back();
}
}
}
auto* module=PyImport_AddModule("__main__");
auto* globals=module ? PyModule_GetDict(module) : nullptr;
auto* result=globals ? PyEval_EvalCode(reinterpret_cast<PyCodeObject*>(code),globals,globals) : nullptr;
Py_DECREF(code);
if(!result){PyErr_Print();throw std::runtime_error("embedded Python execution failed (see traceback)");}
Py_DECREF(result);
}
}
namespace ava2 {
namespace {
PyObject* current_view() {
auto* main=PyImport_AddModule("__main__");
auto* view=PyDict_GetItemString(PyModule_GetDict(main),"view");
if(!view) throw std::runtime_error("login view has not been loaded");
return view;
}
void checked(PyObject* result) { if(!result) { PyErr_Print();throw std::runtime_error("Python view operation failed"); }Py_DECREF(result); }
}
void PythonRuntime::load_login_view(const std::filesystem::path& file) {
std::ifstream input(file,std::ios::binary);if(!input) throw std::runtime_error("login view script missing");
std::string source((std::istreambuf_iterator<char>(input)),{});execute(source);
}
void PythonRuntime::connect_view(const std::string& game,int game_port,const std::string& auth,int auth_port,const std::string& account,const std::string& password) {
checked(PyObject_CallMethod(current_view(),const_cast<char*>("Connect"),const_cast<char*>("sisiss"),game.c_str(),game_port,auth.c_str(),auth_port,account.c_str(),password.c_str()));
}
void PythonRuntime::view_action(const char* method,int value) {
checked(value<0?PyObject_CallMethod(current_view(),const_cast<char*>(method),nullptr):PyObject_CallMethod(current_view(),const_cast<char*>(method),const_cast<char*>("i"),value));
}
void PythonRuntime::pump_network() { try { pump_python_net(); } catch(...) { if(PyErr_Occurred()) PyErr_Print();throw; } }
LoginViewSnapshot PythonRuntime::view_snapshot() {
auto* result=PyObject_CallMethod(current_view(),const_cast<char*>("Snapshot"),nullptr);
if(!result) { PyErr_Print();throw std::runtime_error("cannot read login view"); }
struct Release { PyObject* p;~Release(){Py_DECREF(p);} } release{result};
char* phase=nullptr;char* message=nullptr;int selected;PyObject* slots=nullptr;
if(!PyArg_ParseTuple(result,"ssiO",&phase,&message,&selected,&slots) || !PyList_Check(slots)) { PyErr_Print();throw std::runtime_error("invalid login view snapshot"); }
LoginViewSnapshot snapshot; snapshot.phase=phase;snapshot.message=message;snapshot.selected=selected;
for(Py_ssize_t i=0;i<PyList_Size(slots);++i) {
unsigned long id;char* name;int level,job;
if(!PyArg_ParseTuple(PyList_GetItem(slots,i),"ksii",&id,&name,&level,&job)) { PyErr_Print();throw std::runtime_error("invalid character snapshot"); }
snapshot.slots.push_back({id,name,level,job});
}
return snapshot;
}
}
UI::CWindowManager* ava2::PythonRuntime::window_manager() { return m_windowManager.get(); }