mirror of
https://github.com/0O0o0oOoO00/Alas.git
synced 2026-05-14 07:39:25 +08:00
466 lines
14 KiB
Python
466 lines
14 KiB
Python
import json
|
|
from typing import Dict
|
|
|
|
import requests
|
|
import adbutils
|
|
from pydantic import BaseModel
|
|
|
|
from module.base.retry import retry
|
|
from module.luahook.exception import CrackerError
|
|
|
|
|
|
class CrackApi:
|
|
class ShipProperties(BaseModel):
|
|
armor: float = -1
|
|
speed: float = -1
|
|
antiaircraft: float = -1
|
|
oxy_recovery_bench: float = -1
|
|
torpedo: float = -1
|
|
hit: float = -1
|
|
sonarRange: float = -1
|
|
attack_duration: float = -1
|
|
raid_distance: float = -1
|
|
oxy_recovery_surface: float = -1
|
|
oxy_recovery: float = -1
|
|
dodge: float = -1
|
|
luck: float = -1
|
|
reload: float = -1
|
|
oxy_cost: float = -1
|
|
durability: float = -1
|
|
air: float = -1
|
|
oxy_max: float = -1
|
|
cannon: float = -1
|
|
antisub: float = -1
|
|
|
|
class FakePlayerInfo(BaseModel):
|
|
name: str = ""
|
|
level: str = ""
|
|
id: str = ""
|
|
|
|
class ShipInfo(BaseModel):
|
|
config_id: int
|
|
emotion: int
|
|
rarity: int
|
|
level: int
|
|
exp: int
|
|
curr_star: int
|
|
|
|
class GlobalSpeedupRate(BaseModel):
|
|
rate: float
|
|
|
|
class BetterGlobalSpeedupRate(BaseModel):
|
|
rate: float
|
|
|
|
class ExerciseMorePowerRate(BaseModel):
|
|
rate: float
|
|
|
|
class ChapterAutoClearStepInterval(BaseModel):
|
|
interval: float
|
|
|
|
class AutoRetireKeepWhiteFlagshipCount(BaseModel):
|
|
count: int
|
|
|
|
def __init__(self, base_url, timeout=10):
|
|
self.api_url = base_url
|
|
self.timeout = timeout
|
|
|
|
@retry(tries=3, delay=3, logger=None)
|
|
def get(self, path, **kwargs):
|
|
args = []
|
|
for k, v in kwargs.items():
|
|
if v is None:
|
|
continue
|
|
args.append(f'{k}={v}')
|
|
if args:
|
|
url = f'{self.api_url}/{path}?{"&".join(args)}'
|
|
else:
|
|
url = f'{self.api_url}/{path}'
|
|
try:
|
|
response = requests.get(url, headers={
|
|
"Connection": "close",
|
|
}, timeout=self.timeout)
|
|
except requests.exceptions.Timeout:
|
|
raise CrackerError('CrackApi request timeout')
|
|
except Exception as e:
|
|
raise CrackerError(f'CrackApi request error: {e}')
|
|
if response.status_code != 200:
|
|
raise CrackerError(f'CrackApi response error: {response.status_code}')
|
|
return response
|
|
|
|
@retry(tries=3, delay=3, logger=None)
|
|
def post(self, path, data=None):
|
|
url = f'{self.api_url}/{path}'
|
|
if data is not None and isinstance(data, dict):
|
|
data_str = json.dumps(data)
|
|
else:
|
|
data_str = data
|
|
try:
|
|
response = requests.post(url, data=data_str, headers={
|
|
"Connection": "close",
|
|
}, timeout=self.timeout)
|
|
except requests.exceptions.Timeout:
|
|
raise CrackerError('CrackApi request timeout')
|
|
except Exception as e:
|
|
raise CrackerError(f'CrackApi request error: {e}')
|
|
if response.status_code != 200:
|
|
raise CrackerError(f'CrackApi response error: {response.status_code}')
|
|
|
|
def get_coin(self) -> int:
|
|
response = self.get('get_coin')
|
|
return int(response.text)
|
|
|
|
def get_oil(self) -> int:
|
|
response = self.get('get_oil')
|
|
return int(response.text)
|
|
|
|
def get_gems(self) -> int:
|
|
response = self.get('get_gems')
|
|
return int(response.text)
|
|
|
|
def get_level(self) -> int:
|
|
response = self.get('get_level')
|
|
return int(response.text)
|
|
|
|
def get_exp(self) -> int:
|
|
response = self.get('get_exp')
|
|
return int(response.text)
|
|
|
|
def get_merit(self) -> int:
|
|
response = self.get('get_merit')
|
|
return int(response.text)
|
|
|
|
def get_guild_coin(self) -> int:
|
|
response = self.get('get_guild_coin')
|
|
return int(response.text)
|
|
|
|
def get_design_prt(self) -> int:
|
|
response = self.get('get_design_prt')
|
|
return int(response.text)
|
|
|
|
def get_core_data(self) -> str:
|
|
response = self.get('get_core_data')
|
|
return response.text
|
|
|
|
def get_medal(self) -> int:
|
|
response = self.get('get_medal')
|
|
return int(response.text)
|
|
|
|
def get_pt(self) -> int:
|
|
response = self.get('get_pt')
|
|
return int(response.text)
|
|
|
|
def get_specialized_core(self) -> int:
|
|
response = self.get('get_specialized_core')
|
|
return int(response.text)
|
|
|
|
def get_curr_action_points(self) -> int:
|
|
response = self.get('get_curr_action_points')
|
|
return int(response.text)
|
|
|
|
def scan_dock(self) -> Dict[int, ShipInfo]:
|
|
response = self.get('scan_dock')
|
|
json_data = json.loads(response.text)
|
|
res = {}
|
|
for k, v in json_data.items():
|
|
res[int(k)] = CrackApi.ShipInfo(**v)
|
|
return res
|
|
|
|
def scan_storage(self) -> Dict[int, int]:
|
|
response = self.get('scan_storage')
|
|
json_data = json.loads(response.text)
|
|
res = {}
|
|
for k, v in json_data.items():
|
|
res[int(k)] = int(v)
|
|
return res
|
|
|
|
def get_ship_info(self, ship_id: int) -> ShipInfo:
|
|
response = self.get('get_ship_info', id=ship_id)
|
|
json_data = json.loads(response.text)
|
|
return CrackApi.ShipInfo(**json_data)
|
|
|
|
def get_storage_item_count(self, item_id: int) -> int:
|
|
response = self.get('get_storage_item_count', id=item_id)
|
|
return int(response.text)
|
|
|
|
def enable_gg_factor(self):
|
|
self.post('enable_gg_factor')
|
|
|
|
def disable_gg_factor(self):
|
|
self.post('disable_gg_factor')
|
|
|
|
def update_gg_factor(self, gg_factor: float):
|
|
self.post('update_gg_factor', data={'factor': gg_factor})
|
|
|
|
def disable_all(self):
|
|
self.post('disable_all')
|
|
|
|
def disable_all_without_pause(self):
|
|
self.post('disable_all_without_pause')
|
|
|
|
def enable_global_ship_properties_crack(self):
|
|
self.post('enable_global_ship_properties_crack')
|
|
|
|
def disable_global_ship_properties_crack(self):
|
|
self.post('disable_global_ship_properties_crack')
|
|
|
|
def update_global_ship_properties(self, ship_properties: ShipProperties):
|
|
self.post('update_global_ship_properties', data=ship_properties.json())
|
|
|
|
def enable_fast_stage_move(self):
|
|
self.post("enable_fast_stage_move")
|
|
|
|
def enable_fast_stage_move_without_pause(self):
|
|
self.post("enable_fast_stage_move_without_pause")
|
|
|
|
def disable_fast_stage_move(self):
|
|
self.post("disable_fast_stage_move")
|
|
|
|
def disable_fast_stage_move_without_pause(self):
|
|
self.post("disable_fast_stage_move_without_pause")
|
|
|
|
def enable_remove_hard_mode_ship_properties_limit(self):
|
|
self.post("enable_remove_hard_mode_ship_properties_limit")
|
|
|
|
def disable_remove_hard_mode_ship_properties_limit(self):
|
|
self.post("disable_remove_hard_mode_ship_properties_limit")
|
|
|
|
def enable_remove_hard_mode_ship_type_limit(self):
|
|
self.post("enable_remove_hard_mode_ship_type_limit")
|
|
|
|
def disable_remove_hard_mode_ship_type_limit(self):
|
|
self.post("disable_remove_hard_mode_ship_type_limit")
|
|
|
|
def enable_remove_hard_mode_limit(self):
|
|
self.post("enable_remove_hard_mode_limit")
|
|
|
|
def disable_remove_hard_mode_limit(self):
|
|
self.post("disable_remove_hard_mode_limit")
|
|
|
|
def enable_fake_player(self):
|
|
self.post("enable_fake_player")
|
|
|
|
def disable_fake_player(self):
|
|
self.post("disable_fake_player")
|
|
|
|
def update_fake_player_info(self, fake_player_info: FakePlayerInfo):
|
|
self.post("update_fake_player_info", data=fake_player_info.json())
|
|
|
|
def enable_no_bb_animation(self):
|
|
self.post("enable_no_bb_animation")
|
|
|
|
def disable_no_bb_animation(self):
|
|
self.post("disable_no_bb_animation")
|
|
|
|
def enable_no_emotion_warning(self):
|
|
self.post("enable_no_emotion_warning")
|
|
|
|
def disable_no_emotion_warning(self):
|
|
self.post("disable_no_emotion_warning")
|
|
|
|
def enable_no_emotion_warning_without_pause(self):
|
|
self.post("enable_no_emotion_warning_without_pause")
|
|
|
|
def disable_no_emotion_warning_without_pause(self):
|
|
self.post("disable_no_emotion_warning_without_pause")
|
|
|
|
def enable_opsi_fast_move(self):
|
|
self.post("enable_opsi_fast_move")
|
|
|
|
def disable_opsi_fast_move(self):
|
|
self.post("disable_opsi_fast_move")
|
|
|
|
def enable_global_speedup(self):
|
|
self.post("enable_global_speedup")
|
|
|
|
def update_global_speedup_rate(self, rate: GlobalSpeedupRate):
|
|
self.post("update_global_speedup_rate", data=rate.json())
|
|
|
|
def disable_global_speedup(self):
|
|
self.post("disable_global_speedup")
|
|
|
|
def enable_better_global_speedup(self):
|
|
self.post("enable_better_global_speedup")
|
|
|
|
def enable_better_global_speedup_without_pause(self):
|
|
self.post("enable_better_global_speedup_without_pause")
|
|
|
|
def update_better_global_speedup_rate(self, rate: BetterGlobalSpeedupRate):
|
|
self.post("update_better_global_speedup_rate", data=rate.json())
|
|
|
|
def update_better_global_speedup_rate_without_pause(self, rate: BetterGlobalSpeedupRate):
|
|
self.post("update_better_global_speedup_rate_without_pause", data=rate.json())
|
|
|
|
def disable_better_global_speedup(self):
|
|
self.post("disable_better_global_speedup")
|
|
|
|
def disable_better_global_speedup_without_pause(self):
|
|
self.post("disable_better_global_speedup_without_pause")
|
|
|
|
def is_alive(self):
|
|
self.post("is_alive")
|
|
|
|
def enable_exercise_more_power(self):
|
|
self.post("enable_exercise_more_power")
|
|
|
|
def update_exercise_more_power_rate(self, rate: ExerciseMorePowerRate):
|
|
self.post("update_exercise_more_power_rate", data=rate.json())
|
|
|
|
def disable_exercise_more_power(self):
|
|
self.post("disable_exercise_more_power")
|
|
|
|
def enable_exercise_god_mode(self):
|
|
self.post("enable_exercise_god_mode")
|
|
|
|
def disable_exercise_god_mode(self):
|
|
self.post("disable_exercise_god_mode")
|
|
|
|
def enable_fast_wave(self):
|
|
self.post("enable_fast_wave")
|
|
|
|
def disable_fast_wave(self):
|
|
self.post("disable_fast_wave")
|
|
|
|
def enable_monster_kill_self(self):
|
|
self.post("enable_monster_kill_self")
|
|
|
|
def disable_monster_kill_self(self):
|
|
self.post("disable_monster_kill_self")
|
|
|
|
def enable_skip_battle_celebrate(self):
|
|
self.post("enable_skip_battle_celebrate")
|
|
|
|
def enable_skip_battle_celebrate_without_pause(self):
|
|
self.post("enable_skip_battle_celebrate_without_pause")
|
|
|
|
def disable_skip_battle_celebrate(self):
|
|
self.post("disable_skip_battle_celebrate")
|
|
|
|
def disable_skip_battle_celebrate_without_pause(self):
|
|
self.post("disable_skip_battle_celebrate_without_pause")
|
|
|
|
def enable_no_damage(self):
|
|
self.post("enable_no_damage")
|
|
|
|
def disable_no_damage(self):
|
|
self.post("disable_no_damage")
|
|
|
|
def enable_opsi_force_auto(self):
|
|
self.post("enable_opsi_force_auto")
|
|
|
|
def disable_opsi_force_auto(self):
|
|
self.post("disable_opsi_force_auto")
|
|
|
|
def enable_opsi_no_map_fog(self):
|
|
self.post("enable_opsi_no_map_fog")
|
|
|
|
def disable_opsi_no_map_fog(self):
|
|
self.post("disable_opsi_no_map_fog")
|
|
|
|
def enable_hooked_lua_function_trace(self):
|
|
self.post("enable_hooked_lua_function_trace")
|
|
|
|
def disable_hooked_lua_function_trace(self):
|
|
self.post("disable_hooked_lua_function_trace")
|
|
|
|
def enable_skip_ship_gain_show(self):
|
|
self.post("enable_skip_ship_gain_show")
|
|
|
|
def disable_skip_ship_gain_show(self):
|
|
self.post("disable_skip_ship_gain_show")
|
|
|
|
def enable_chapter_force_enable_auto_fight(self):
|
|
self.post("enable_chapter_force_enable_auto_fight")
|
|
|
|
def disable_chapter_force_enable_auto_fight(self):
|
|
self.post("disable_chapter_force_enable_auto_fight")
|
|
|
|
def enable_chapter_skip_precombat(self):
|
|
self.post("enable_chapter_skip_precombat")
|
|
|
|
def disable_chapter_skip_precombat(self):
|
|
self.post("disable_chapter_skip_precombat")
|
|
|
|
def enable_chapter_auto_next_battle(self):
|
|
self.post("enable_chapter_auto_next_battle")
|
|
|
|
def disable_chapter_auto_next_battle(self):
|
|
self.post("disable_chapter_auto_next_battle")
|
|
|
|
def enable_chapter_auto_ambush(self):
|
|
self.post("enable_chapter_auto_ambush")
|
|
|
|
def disable_chapter_auto_ambush(self):
|
|
self.post("disable_chapter_auto_ambush")
|
|
|
|
def set_chapter_auto_clear_step_interval(self, param: ChapterAutoClearStepInterval):
|
|
self.post("set_chapter_auto_clear_step_interval", data=param.json())
|
|
|
|
def enable_chapter_auto_clear(self):
|
|
self.post("enable_chapter_auto_clear")
|
|
|
|
def disable_chapter_auto_clear(self):
|
|
self.post("disable_chapter_auto_clear")
|
|
|
|
def enable_skip_story(self):
|
|
self.post("enable_skip_story")
|
|
|
|
def disable_skip_story(self):
|
|
self.post("disable_skip_story")
|
|
|
|
def enable_infinite_battle(self):
|
|
self.post("enable_infinite_battle")
|
|
|
|
def disable_infinite_battle(self):
|
|
self.post("disable_infinite_battle")
|
|
|
|
def enable_skip_air_strike_animation(self):
|
|
self.post("enable_skip_air_strike_animation")
|
|
|
|
def disable_skip_air_strike_animation(self):
|
|
self.post("disable_skip_air_strike_animation")
|
|
|
|
def enable_auto_once_again(self):
|
|
self.post("enable_auto_once_again")
|
|
|
|
def disable_auto_once_again(self):
|
|
self.post("disable_auto_once_again")
|
|
|
|
def set_white_flagship_keep_count(self, param: AutoRetireKeepWhiteFlagshipCount):
|
|
self.post("set_white_flagship_keep_count", data=param.json())
|
|
|
|
def enable_auto_retire(self):
|
|
self.post("enable_auto_retire")
|
|
|
|
def disable_auto_retire(self):
|
|
self.post("disable_auto_retire")
|
|
|
|
def enable_skip_enemy_scan(self):
|
|
self.post("enable_skip_enemy_scan")
|
|
|
|
def disable_skip_enemy_scan(self):
|
|
self.post("disable_skip_enemy_scan")
|
|
|
|
def enable_skip_battle_result(self):
|
|
self.post("enable_skip_battle_result")
|
|
|
|
def disable_skip_battle_result(self):
|
|
self.post("disable_skip_battle_result")
|
|
|
|
def enable_skip_enter_battle(self):
|
|
self.post("enable_skip_enter_battle")
|
|
|
|
def disable_skip_enter_battle(self):
|
|
self.post("disable_skip_enter_battle")
|
|
|
|
def enable_skip_enter_battle_without_pause(self):
|
|
self.post("enable_skip_enter_battle_without_pause")
|
|
|
|
def disable_skip_enter_battle_without_pause(self):
|
|
self.post("disable_skip_enter_battle_without_pause")
|
|
|
|
def init(self):
|
|
self.post("init")
|
|
|
|
def init_without_pause(self):
|
|
self.post("init_without_pause")
|