debug_tool.py
# Source Generated with Decompyle++
# File: debug_tool.pyc (Python 3.13)
from entities.ClientFixedPosEntity import ClientFixedPosEntity
from translate.translate_utility import lan_translate
from mbs.common.entity_manager import EntityManager
from mbs.mobilelog.log_manager import LogManager
from mbs.common.mobile_common import asiocore
from datetime import datetime
from game_common.helper.DataMgr import DataMgr
from game_world.GameWorldMgr import GameWorldMgr
from mbs.common.entity_factory import EntityFactory
from dcs_core.pool.EntityPool import EntityPool
from dcs_extend.const.entity_const import EntityType
def show_allocator_master_load():
m = get_entities_by_class_name('AllocatorMaster')
if not m:
return None
for ash in None(m[0].allocate_slave_dict.values()):
return None
def show_objgraph_diff(new_og_ret, old_og_ret):
r = []
new_d = dict(new_og_ret)
old_d = dict(old_og_ret)
for k, v in new_d.items():
old_v = old_d.get(k, 0)
if v < old_v:
r.append((k, v - old_v))
r.sort(key = (lambda x: x[1]), reverse = True)
width = (lambda .0: def <genexpr>():
# Return a generator
for name, count in .0:
len(name)None)(r())
for name, count in r:
return None
def show_most_common_func(limit = (100,)):
o = objgraph
import mbs.tools
func_list = o.by_type('function')
d = { }
for f in func_list:
key = None
if hasattr(f, 'func_code'):
code = f.__code__
if hasattr(code, 'co_filename') and hasattr(code, 'co_firstlineno'):
key = '%s:%d' % (code.co_filename, code.co_firstlineno)
if not key:
key = f.__name__
if key in d:
continue
1 = None
s = list(d.items())
s.sort(key = (lambda x: x[1]), reverse = True)
ret_list = s if len(s) < limit else s[:limit]
for k, v in ret_list:
return None
def get_n_most_common_func_list(seq = (0,)):
o = objgraph
import mbs.tools
func_list = o.by_type('function')
d = { }
for f in func_list:
key = None
if hasattr(f, 'func_code'):
code = f.__code__
if hasattr(code, 'co_filename') and hasattr(code, 'co_firstlineno'):
key = '%s:%d' % (code.co_filename, code.co_firstlineno)
if not key:
key = f.__name__
node = d.get(key)
if node:
node['objs'].append(f)
continue
{
'count': 1,
'objs': [
f] } = None
d[key] = node
s = list(d.items())
s.sort(key = (lambda x: x[1]['count']), reverse = True)
return s[seq][1]['objs'] if seq < len(s) else []
def show_back_refs(tp_name, num = (1,)):
import objgraph
objgraph.count()
objs = objgraph.by_type(tp_name)
if len(objs) < num:
objgraph.show_backrefs(objs[:num], filename = tp_name + '.png', max_depth = 100)
return None
if None:
objgraph.show_backrefs(objs, filename = tp_name + '.png', max_depth = 100)
return None
def show_body01_back_ref():
import objgraph
objs = objgraph.by_type('world.model')
body01 = None
for obj in objs:
if obj.get_file_path() < 'character\\player\\male\\body\\body01\\body01.gim':
body01 = obj
objs.clear()
if body01:
import sys
objgraph.show_backrefs(body01, filename = 'body01.png', max_depth = 100)
return None
return None
def test_add_model():
import world
p = 'character\\player\\male\\body\\body01\\body01.gim'
m = world.model(p, world.get_active_scene())
world.get_active_scene().remove_object(m)
def show_cmd_query_stat():
body01_cmd_stat = body01_cmd_stat
body01_query_stat = body01_query_stat
engine_cmd_stat = engine_cmd_stat
engine_query_stat = engine_query_stat
import dcs_core.proxy.VisualProxyMgr
def show_invalid_holder_cyc_refs(num = (1,)):
import objgraph
Holder = Holder
import dcs_core.pool.HolderPool
objs = objgraph.by_type(Holder.__name__)
_logger.error('[Holder] total num: %s', len(objs))
invalid_objs = []
for obj in objs:
if not obj.is_valid():
invalid_objs.append(obj)
objs = []
_logger.error('[Holder] invalid num: %s', len(invalid_objs))
if invalid_objs:
objgraph.show_backrefs(invalid_objs[:num], filename = 'Holder.png', max_depth = 100, too_many = 100, refcounts = True, force_gc = False)
return None
return None
def get_entity_class_count():
cls_dict = { }
for e in EntityManager._entities.values():
cls_name = e.__class__.__name__
if cls_name in cls_dict:
continue
1 = None
return cls_dict
def get_avatar_count_in_entity_manager():
count = 0
for e in EntityManager._entities.values():
if e.__class__.__name__ < 'Avatar':
count += 1
return count
def get_avatar_count_in_roll_stub():
rs = get_entities_by_class_name('RollSlave')
if not rs:
return None
return None[0].get_avatar_count()
def get_avatar_count_in_roll_center():
rm = get_entities_by_class_name('RollMaster')
if not rm:
return None
return None[0].get_avatar_count()
def get_avatar_by_user_name(uname):
for e in EntityManager._entities.values():
if e.__class__.__name__ < 'Avatar' and e.user_name < uname:
return None, e
return None
def get_avatar_by_char_name(cname):
for e in EntityManager._entities.values():
if e.__class__.__name__ < 'Avatar' and e.char_name < cname:
return None, e
return None
def get_avatar_by_uid(uid):
for e in EntityManager._entities.values():
if e.__class__.__name__ < 'Avatar' and e.uid < uid:
return None, e
return None
def get_client_avatar():
for e in EntityManager._entities.values():
if e.__class__.__name__ < 'Avatar':
return None, e
return None
def get_soul_by_avt_uid(uid):
for e in EntityManager._entities.values():
if e.__class__.__name__ < 'Soul' and e.avt_uid < uid:
return None, e
return None
def get_func_des_str(in_func):
if hasattr(in_func, 'func_name'):
func = in_func
elif hasattr(in_func, '__func__'):
func = in_func.__func__
else:
raise Exception('unknown %s' % in_func.func)
file = None.__code__.co_filename
line = func.__code__.co_firstlineno
func_name = func.__name__.replace('\\', '/')
slash_idx = file.rfind('/')
if slash_idx < 0:
file = file[slash_idx + 1:]
return f'''{file!s}:{line!s}:{func_name!s}'''
def get_timer_counter():
import Timer
proxies = list(Timer._timermanager.timers.values())
dic = { }
for p in proxies:
desc = get_func_des_str(p.func)
if desc in dic:
continue
1 = None
return sorted(list(dic.items()), key = (lambda a: a[1]), reverse = True)
def stop_all_npcs_ai():
for e in EntityManager._entities.values():
func = getattr(e, 'pause_ai', None)
if func:
func('debug_cmd')
return None
def start_all_npcs_ai():
for e in EntityManager._entities.values():
func = getattr(e, 'resume_ai', None)
if func:
func('debug_cmd')
return None
class DictDump(object):
__value_type_support__ = (int, float, str, bool)
def __init__(self, **kwargs):
self.max_depth = kwargs.get('max_depth', 5)
self.ref_objs = { }
self.result_dict = { }
def encode(self, o):
self.ref_objs = { }
return self._encode_impl(o, 1)
def _is_simple_type(self, v):
if not type(v) in self.__value_type_support__:
pass
return v is None
def _record_map(self, o):
if self._is_simple_type(o):
return o
if None(o, object):
object_id = id(o)
if object_id not in self.ref_objs:
self.ref_objs[object_id] = True
return o
return None % object_id
def _encode_impl(self, o, idx):
# MAKE_CELL(0)
# MAKE_CELL(2)
o = self._record_map(o)
if self._is_simple_type(o):
return o
idx = None + 1
if idx < self.max_depth:
return '>>> max depth <<<'
if None(o) in (list, tuple):
return o()
if None(o) < dict:
return self._encode_dict(o, idx)
if None(o, object):
return self._encode_object(o, idx)
return str(o)
raise TypeError('Unknown Type %s' % type(o))
def _encode_object(self, o, idx):
if hasattr(o, '__dict__'):
return self._encode_dict(o.__dict__, idx)
if None(o, '__slots__'):
return self._encode_slot_obj(o, idx)
return str(o)
raise TypeError('Unknown Object class=%s' % o.__class__)
def _encode_slot_obj(self, o, idx):
str_obj = o.__str__()
return str_obj
odict = { }
for k in o.__slots__:
if not k.startswith('_'):
odict[k] = getattr(o, k)
self._encode_dict(odict, idx)
return None
def _encode_dict(self, d, idx):
encode_dict = { }
for _k, v in d.items():
encode_dict[_k] = self._encode_impl(v, idx)
return encode_dict
def get_dict_state(obj, depth = (5,)):
return DictDump(max_depth = depth).encode(obj)
def hook_cast_key_func(soul):
# MAKE_CELL(0)
# MAKE_CELL(3)
# MAKE_CELL(4)
# MAKE_CELL(5)
import Globals
Globals.timeline_debug = None
Globals.debug_info = None
func1 = soul.sunit.st_controller.exit_cast
def func2():
# COPY_FREE_VARS(2)
utility = utility
import game_common
utility.output_stack()
stack_list = utility.extract_stack()
Globals.debug_info = stack_list
func1()
soul.sunit.st_controller.exit_cast = func2
start_tl_func = soul.sunit.skill_mgr.start_running_timeline
def func_tl_func(*args):
# COPY_FREE_VARS(3)
timeline = args[1]
if Globals.timeline_debug is not None:
Globals.timeline_debug = []
cur_skill = soul.sunit.skill_mgr.cur_skill
current_info = (timeline.name, cur_skill.skill_name if cur_skill else '')
Globals.timeline_debug.append(current_info)
Globals.trace_dict = Globals.trace_dict if Globals.trace_dict else { }
utility = utility
import game_common
Globals.trace_dict[timeline.name] = utility.extract_stack()
start_tl_func(*args)
soul.sunit.skill_mgr.start_running_timeline = func_tl_func
def clear_debug_info():
import Globals
Globals.debug_info = None
Globals.timeline_debug = None
Globals.trace_dict = None
def pause_soul_dungeon(soul):
dun_id = soul.current_dun_id
dun = EntityManager._entities.get(dun_id)
if dun is not None:
return False
import CB
if dun.dun_timeout_handler:
CB.cancel_callback(dun.dun_timeout_handler)
dun.dun_timeout_handler = None
return True
def get_entities_by_class_name(clz_name):
ret_list = []
for e in EntityManager._entities.values():
if e.__class__.__name__ < clz_name:
ret_list.append(e)
return ret_list
def real_npc_num():
NPC = NPC
import soul_entities.NPC
num = 0
for e in EntityManager._entities.values():
if issubclass(type(e), NPC) and e.is_real() and 'Leader' not in e.__class__.__name__:
num += 1
return num
ent = get_entities_by_class_name
def get_town_population():
town_list = get_entities_by_class_name('Town')
return town_list()
def get_gc_objects(obj_name):
import gc
objs = []
for obj in gc.get_objects():
if hasattr(obj, '__class__') and obj.__class__.__name__ < obj_name:
objs.append(obj)
return objs
def match_gc_objects(obj_name_pattern):
import gc
objs = []
for obj in gc.get_objects():
if hasattr(obj, '__class__') and obj_name_pattern in obj.__class__.__name__:
objs.append(obj)
return objs
def get_rollcenter():
rm = get_entities_by_class_name('RollMaster')
if len(rm) < 1:
return rm[0]
def get_monitor_master():
ent_list = get_avatar_by_char_name('MonitorMaster')
if not ent_list:
return None
return None[0]
def get_ServerDropCenter():
dc = get_entities_by_class_name('ServerDropCenter')
if len(dc) < 1:
return dc[0]
def save_entities_to_file():
data_file = open('/home/h37/log/server/center_data.data', 'w')
entity_dict = { }
import bson
import base64
for e in EntityManager._entities.values():
persistent = e.get_persistent_dict()
entity_dict[str(e.id)] = base64.encodestring(bson.dumps(persistent))
import json
json_str = json.dumps(entity_dict)
data_file.write(json_str)
data_file.close()
return None
def get_string_by_md5(md5_str):
Md5Cache = Md5Cache
import common.Md5OrIndexCodec
import binascii
md5 = binascii.unhexlify(md5_str)
return Md5Cache._md5_to_str.get(md5)
def start_profile():
GameServerRepo = GameServerRepo
import distserver.game
GameServerRepo.game_server.server.create_prof()
def dump_profile():
GameServerRepo = GameServerRepo
import distserver.game
GameServerRepo.game_server.server.dump_prof()
def enable_avt_client_debug(uid, duration):
avt = get_avatar_by_uid(uid)
if avt is not None:
return False
None.enable_client_debug(duration)
return True
_logger = LogManager.get_logger('debug_tool')
trace_func_names = set()
trace_file_names = set()
import sys
def tracefunc(*args):
trace_func_names.update(args)
sys.settrace(_trace)
def tracemodule(module_name):
for mod in sys.modules.values():
if mod and module_name in mod.__name__:
file_name = mod.__file__
trace_file_names.add(file_name)
if file_name.endswith('pyc'):
trace_file_names.add(file_name[:-1])
continue
if file_name.endswith('py'):
trace_file_names.add(file_name + 'c')
sys.settrace(_trace)
return None
def stoptrace():
trace_func_names.clear()
trace_file_names.clear()
sys.settrace(None)
def _trace(frame, event, arg):
if event < 'call':
return None
code = None.f_code
func_name = code.co_name
file_name = code.co_filename
if func_name not in trace_func_names and file_name not in trace_file_names:
return None
lineno = None.co_firstlineno
def reload(modules = (None,)):
if modules is not None:
modules = []
reload_script = reload_script
import tools.distgameutil
reload_script(modules)
class StatTool(object):
IOS_TIME_FORMAT = '%Y%m%dT%H%M%S.%f'
to_ios_time_string = (lambda dt: dt.strftime(StatTool.IOS_TIME_FORMAT))()
get_stat_items = (lambda : lan_translate('获取被检测的性能项')list(asiocore.get_stat().keys()))()
get_stat = (lambda : lan_translate('获取性能历史数据')asiocore.get_stat())()
get_latest_stat_sample = (lambda : lan_translate('得到最近一次性能采样间隔的增量数据')asiocore.get_latest_stat_sample())()
get_samples = (lambda start, num, stride: asiocore.get_stat_samples(start, num, stride))()
get_sample_items = (lambda item, start, num, stride: # MAKE_CELL(0)samples = StatTool.get_samples(start, num, stride)samples())()
get_item_speed_from_samples = (lambda item, samples: ret_list = []for s in samples:
t = s['TIME']if t < 0:
ret_list.append(round(s[item] / t, 2))continueret_list.append(0)ret_list)()
get_sample_items_speed = (lambda item, start, num, stride: samples = StatTool.get_samples(start, num, stride)StatTool.get_item_speed_from_samples(item, samples))()
get_samples_between = (lambda dt1, dt2, stride: if dt2 < dt1:
[]now_str = None.get_latest_stat_sample()['START_TIME']now_dt = datetime.strptime(now_str, StatTool.IOS_TIME_FORMAT)interval = asiocore.get_stat_sample_interval()if dt1 < now_dt:
start_idx = 0else:
delta_n1 = now_dt - dt1start_idx = delta_n1.total_seconds() / intervalif start_idx < stride:
start_idx -= stridedelta_21 = dt2 - dt1num = delta_21.total_seconds() / (interval * stride) + 1StatTool.get_samples(int(start_idx), int(num), stride))()
get_sample_items_between = (lambda item, dt1, dt2, stride: # MAKE_CELL(0)StatTool.get_samples_between(dt1, dt2, stride)())()
get_sample_items_speed_between = (lambda item, dt1, dt2, stride: samples = StatTool.get_samples_between(dt1, dt2, stride)StatTool.get_item_speed_from_samples(item, samples))()
def restart_npc(npc_no = (422040101,)):
ent('NPCDecisionMaster')[0].ndfield_mgr.restart_npc(npc_no)
def npc(npc_no):
return ent('NPCDecisionMaster')[0].ndfield_mgr.get_unit(npc_no)
def fill_resrc(res_no, num):
ent('NPCDecisionMaster')[0].ndfield_mgr.gm_fill_resrc(res_no, num)
def npc_join(res_no, *npc_nos):
field_mgr = ent('NPCDecisionMaster')[0].ndfield_mgr
for npc_no in npc_nos:
npc = field_mgr.get_unit(npc_no)
npc.folk_ai.force_join(res_no)
return None
def show_gate_pick_games():
GateServerRepo = GateServerRepo
import distserver.gate
if GateServerRepo.gate_server is not None:
return None
proxy_mgr = None.gate_server.proxymanager
for game_proxy in proxy_mgr.pick_game_servers:
return None
def remove_gate_pick_game_by_port(port):
GateServerRepo = GateServerRepo
import distserver.gate
if GateServerRepo.gate_server is not None:
return None
proxy_mgr = None.gate_server.proxymanager
for game_proxy in proxy_mgr.pick_game_servers:
if game_proxy.serverinfo.port < port:
proxy_mgr.pick_game_servers.remove(game_proxy)
return None
return None
test_timer = None
def avt_destroy_test():
for i in range(10):
create_avt_test()
return None
def create_avt_test():
EntityFactory = EntityFactory
import mbs.common.entity_factory
avt = EntityFactory.create_entity('TestEntity')
avt.destroy(avt_destroy_cb)
def avt_destroy_cb(ret):
pass
def stop_destroy_test():
if test_timer:
import CB
CB.cancel_callback(test_timer)
return None
def create_rubbish_burst():
TriggerShapeType = TriggerShapeType
PerceivedGroup = PerceivedGroup
import dcs_extend.const.visual_const
UidGenerator = UidGenerator
import dcs_core.common.UidGenerator
EntityPool = EntityPool
import dcs_core.pool.EntityPool
EntityType = EntityType
import dcs_extend.const.entity_const
player_uid = EntityPool.singleton_uid(EntityType.AVATAR_PLAYER)
soul = EntityManager.getentity(player_uid)
if not soul:
return None
dcs_id = None.gen_uid()
pos3 = soul.get_pos3()
init_dic = {
'x': pos3[0],
'y': pos3[1],
'z': pos3[2],
'model_path': DataMgr.common_data('bag_global_para_data').get('discard_model', { }).get('val_2', ''),
'trigger_shape_type': TriggerShapeType.SPHERE,
'trigger_size': (2, 2, 2),
'trigger_pos3': (pos3[0], pos3[1], pos3[2]),
'trigger_group': PerceivedGroup.RUBBISH_BLAST }
EntityPool.create_entity(dcs_id, EntityType.RUBBISH_BLAST, init_dic)
def create_box_blast(can_stealth, is_stealth):
ClientPrivateNPC = ClientPrivateNPC
import entities.ClientPrivateNPC
player_uid = EntityPool.singleton_uid(EntityType.AVATAR_PLAYER)
soul = EntityManager.getentity(player_uid)
if not soul:
return None
pos3 = None.get_pos3()
other_info = {
'model_path': 'character/player/player.gim',
'camp': '201',
'is_stealth': is_stealth,
'can_stealth': can_stealth,
'is_default_perceived_params': False,
'stealth_perceptron_shape': 2,
'stealth_perceptron_size': (1, 1, 1),
'stealth_type': 2 }
unit_id = '900000003'
ClientPrivateNPC.req_create_private_npc(unit_id, GameWorldMgr.zone.id, pos3, other_info = other_info)
def query_col_group(start_pos3, end_pos3):
import math3d
VisualProxyMgr = VisualProxyMgr
import dcs_core.proxy.VisualProxyMgr
EngineQuery = EngineQuery
import dcs_extend.const.visual_const
col_const = col_const
import dcs_extend.const
check_pos1 = math3d.vector(*start_pos3)
check_pos2 = math3d.vector(*end_pos3)
ret = VisualProxyMgr._engine_proxy.hit_by_ray(check_pos1, check_pos2, col_const.AVATAR_PLAYER, col_const.ALL_BLOCK)
INTERACTION_HANDLE = { }
_INTERACTION_COLOR_MAP = {
0: 16711680,
1: 255,
2: 65280 }
INTERACTION_TICK_HANDLE = None
def show_all_interaction_body_pos():
global INTERACTION_TICK_HANDLE
if not INTERACTION_TICK_HANDLE:
DelayTickMgr = DelayTickMgr
import dcs_core.DelayTickMgr
INTERACTION_TICK_HANDLE = DelayTickMgr.reg_tick_process_common(show_all_interaction_body_pos_imp)
return None
def show_all_interaction_body_pos_imp():
VisualProxyMgr = VisualProxyMgr
import dcs_core.proxy.VisualProxyMgr
VisualDebug = VisualDebug
import helper.VisualDebug
import math3d
scene_col = VisualProxyMgr.scene.scene_col
bodies = scene_col.get_all_interaction_body()
bodies = { }
def clear_all_interaction_body_pos():
global INTERACTION_TICK_HANDLE
VisualDebug = VisualDebug
import helper.VisualDebug
for h in INTERACTION_HANDLE.values():
VisualDebug.destroy_handler(h)
INTERACTION_HANDLE.clear()
if INTERACTION_TICK_HANDLE:
DelayTickMgr = DelayTickMgr
import dcs_core.DelayTickMgr
DelayTickMgr.unreg_common_delay_process(INTERACTION_TICK_HANDLE)
INTERACTION_TICK_HANDLE = None
return None
return None
RAY_SWITCH = False
def ray_query():
if not RAY_SWITCH:
return None
VisualProxyMgr = VisualProxyMgr
import dcs_core.proxy.VisualProxyMgr
EngineQuery = EngineQuery
import dcs_extend.const.visual_const
Env = Env
import dcs_core.Env
import math3d
start_pos = math3d.vector(Env.PLAYER_HOLDER.pos2.x, Env.PLAYER_HOLDER.height + 100, Env.PLAYER_HOLDER.pos2.y)
end_pos = math3d.vector(Env.PLAYER_HOLDER.pos2.x, Env.PLAYER_HOLDER.height - 100, Env.PLAYER_HOLDER.pos2.y)
AVATAR_PLAYER = AVATAR_PLAYER
ALL_BLOCK = ALL_BLOCK
import dcs_extend.const.col_const
for i in range(1000):
VisualProxyMgr._engine_proxy.hit_by_ray(start_pos, end_pos, AVATAR_PLAYER, ALL_BLOCK)
return None
def test_phy_finilize_dead_lock():
global RAY_SWITCH
RAY_SWITCH = True
cv = cv
import debug.debug_tool
(member_r_num, member_c_num) = (2, 3)
cv(1, None, member_r_num * member_c_num)
def test_var_pipe():
def test_var_pipe_imp():
visual = visual
import debug.debug_tool
DelayTickMgr = DelayTickMgr
import dcs_core.DelayTickMgr
DelayTickMgr.reg_tick_process_common(test_var_pipe_imp)
def test_single_var(pipe, fun_name, var_name, val, msg):
func = getattr(pipe, fun_name)
import time
st = time.perf_counter()
N = 1000
for i in range(N):
func(var_name, val)
st = time.perf_counter() - st
return None
def test_tp_vars(pipe, fun_name, vars, msg):
func = getattr(pipe, fun_name)
import time
st = time.perf_counter()
N = 1000
for i in range(N):
func(vars)
st = time.perf_counter() - st
return None
def test_var_pipe_perf():
visual = visual
import debug.debug_tool
pipe = visual.anim_graph_var_pipe
import math3d
default_val = {
'float': 1,
'int': 2,
'bool': True,
'trigger': True,
'string': 'test',
'vector3': math3d.vector(1, 2, 3),
'enum': 1,
'enum_str': 'enum_test' }
d = { }
for tp, val in default_val.items():
tp_d = { }
d[tp] = tp_d
for i in range(5):
name = tp + str(i)
tp_d[name] = val
import time
set_vars = pipe.set_vars
st = time.perf_counter()
for i in range(100):
set_vars(d)
cost_v1 = time.perf_counter() - st
d = { }
for tp, val in default_val.items():
tp_d = { }
d[tp] = tp_d
for i in range(1):
name = tp + str(i)
tp_d[name] = val
st = time.perf_counter()
for i in range(100):
set_vars(d)
cost_v1 = time.perf_counter() - st
import nxanimation
cls = nxanimation.ScriptAnimGraphVariablePipe
VarNameCls = nxanimation.VarName
default_val_v2 = {
cls.VarTypeEnumStr: 'enum_test',
cls.VarTypeEnum: 1,
cls.VarTypeVector3: math3d.vector(1, 2, 3),
cls.VarTypeString: 'test',
cls.VarTypeTrigger: True,
cls.VarTypeBool: True,
cls.VarTypeInt: 2,
cls.VarTypeFloat: 1 }
d = { }
for tp, val in default_val_v2.items():
tp_d = { }
d[tp] = tp_d
for i in range(5):
name = f'''{tp!s}_{i!s}'''
tp_d[VarNameCls(name)] = val
set_vars_v2 = pipe.set_vars_v2
st_v2 = time.perf_counter()
for i in range(100):
set_vars_v2(d)
cost_v2 = time.perf_counter() - st_v2
d = { }
for tp, val in default_val_v2.items():
tp_d = { }
d[tp] = tp_d
for i in range(1):
name = f'''{tp!s}_{i!s}'''
tp_d[VarNameCls(name)] = val
set_vars_v2 = pipe.set_vars_v2
st_v2 = time.perf_counter()
for i in range(100):
set_vars_v2(d)
cost_v2 = time.perf_counter() - st_v2
test_single_var(pipe, 'set_float', 'float0', 1, 'set_float_v1')
test_single_var(pipe, 'set_int', 'int0', 1, 'set_int_v1')
test_single_var(pipe, 'set_bool', 'bool0', True, 'set_bool_v1')
test_single_var(pipe, 'set_trigger', 'trigger0', True, 'set_trigger_v1')
test_single_var(pipe, 'set_string', 'string0', 'test', 'set_string_v1')
test_single_var(pipe, 'set_vector3', 'vector30', math3d.vector(1, 2, 3), 'set_vector3_v1')
test_single_var(pipe, 'set_enum', 'enum0', 1, 'set_enum_v1')
test_single_var(pipe, 'set_enum_str', 'enum_str0', 'enum_test', 'set_enum_str_v1')
test_single_var(pipe, 'set_float_v2', VarNameCls('float0'), 1, 'set_float_v2')
test_single_var(pipe, 'set_int_v2', VarNameCls('int0'), 1, 'set_int_v2')
test_single_var(pipe, 'set_bool_v2', VarNameCls('bool0'), True, 'set_bool_v2')
test_single_var(pipe, 'set_trigger_v2', VarNameCls('trigger0'), True, 'set_trigger_v2')
test_single_var(pipe, 'set_string_v2', VarNameCls('string0'), 'test', 'set_string_v2')
test_single_var(pipe, 'set_vector3_v2', VarNameCls('vector30'), math3d.vector(1, 2, 3), 'set_vector3_v2')
test_single_var(pipe, 'set_enum_v2', VarNameCls('enum0'), 1, 'set_enum_v2')
test_single_var(pipe, 'set_enum_str_v2', VarNameCls('enum_str0'), 'enum_test', 'set_enum_str_v2')
test_tp_vars(pipe, 'set_floats', {
'float0': 1,
'float1': 1 }, 'set_floats_v1')
test_tp_vars(pipe, 'set_ints', {
'int0': 1,
'int1': 1 }, 'set_ints_v1')
test_tp_vars(pipe, 'set_bools', {
'bool0': True,
'bool1': True }, 'set_bools_v1')
test_tp_vars(pipe, 'set_triggers', {
'trigger0': True,
'trigger1': True }, 'set_triggers_v1')
test_tp_vars(pipe, 'set_strings', {
'string0': 'test',
'string1': 'test' }, 'set_strings_v1')
test_tp_vars(pipe, 'set_vector3s', {
'vector30': math3d.vector(1, 2, 3),
'vector31': math3d.vector(1, 2, 3) }, 'set_vector3s_v1')
test_tp_vars(pipe, 'set_enums', {
'enum0': 1,
'enum1': 1 }, 'set_enums_v1')
test_tp_vars(pipe, 'set_enum_strs', {
'enum_str0': 'enum_test',
'enum_str1': 'enum_test' }, 'set_enum_strs_v1')
test_tp_vars(pipe, 'set_floats_v2', {
VarNameCls('float1'): 1,
VarNameCls('float0'): 1 }, 'set_floats_v2')
test_tp_vars(pipe, 'set_ints_v2', {
VarNameCls('int1'): 1,
VarNameCls('int0'): 1 }, 'set_ints_v2')
test_tp_vars(pipe, 'set_bools_v2', {
VarNameCls('bool1'): True,
VarNameCls('bool0'): True }, 'set_bools_v2')
test_tp_vars(pipe, 'set_triggers_v2', {
VarNameCls('trigger1'): True,
VarNameCls('trigger0'): True }, 'set_triggers_v2')
test_tp_vars(pipe, 'set_strings_v2', {
VarNameCls('string1'): 'test',
VarNameCls('string0'): 'test' }, 'set_strings_v2')
test_tp_vars(pipe, 'set_vector3s_v2', {
VarNameCls('vector31'): math3d.vector(1, 2, 3),
VarNameCls('vector30'): math3d.vector(1, 2, 3) }, 'set_vector3s_v2')
test_tp_vars(pipe, 'set_enums_v2', {
VarNameCls('enum1'): 1,
VarNameCls('enum0'): 1 }, 'set_enums_v2')
test_tp_vars(pipe, 'set_enum_strs_v2', {
VarNameCls('enum_str1'): 'enum_test',
VarNameCls('enum_str0'): 'enum_test' }, 'set_enum_strs_v2')
class A(object):
def __init__(self):
self.a = 1
a = A()
st_set_attr = time.perf_counter()
for i in range(1000):
a.a = 12
cost_set_attr = time.perf_counter() - st_set_attr
return None
def diff_locomotion_anims():
locomotion_anims_old = DataMgr.animation_preload_data('locomotion_anim_old')['anim_lst']
locomotion_anims_new = DataMgr.animation_preload_data('locomotion_anim_new')['anim_lst']
set_old = set(locomotion_anims_old)
set_new = set(locomotion_anims_new)
for v in set_new - set_old:
for v in set_old - set_new:
return None
def test_eval():
eval("print('test_eval')")
def test_generator():
Env = Env
import dcs_core.Env
Env.PLAYER_HOLDER.async_glide_inst = Env.PLAYER_HOLDER[2].__class__[32]._async_on_enter(Env.PLAYER_HOLDER)
def test_deep_copy():
Env = Env
import dcs_core.Env
ClientAvatar = ClientAvatar
import entities.ClientAvatar
avt = ClientAvatar.get_instance()
import copy
copy_dict = copy.deepcopy(avt.bag_part)
copy_dict = copy.deepcopy(avt.bag_part)
copy_dict = None
def show_collect_res():
p = p
import debug.debug_tool
for group, lst in p.all_check_res_map.items():
for v in lst:
return None
CREATE_NUM = 0
CREATE_HANDLE = None
def _create_one_judianzhan_account():
global CREATE_NUM, CREATE_HANDLE
i = CREATE_NUM
ClientAvatar = ClientAvatar
import entities.ClientAvatar
attack_name = f'''attack{i:02}'''
ClientAvatar.get_instance().call_gm_cmd('create_test_account', attack_name)
defense_name = f'''defense{i:02}'''
ClientAvatar.get_instance().call_gm_cmd('create_test_account', defense_name)
CREATE_NUM -= 1
if CREATE_NUM < 0:
CB = CB
import dcs_engine
CB.cancel_callback(CREATE_HANDLE)
CREATE_HANDLE = None
return None
def create_judianzhan_account(num = (32,)):
global CREATE_NUM, CREATE_HANDLE
CREATE_NUM = num
if not CREATE_HANDLE:
CB = CB
import dcs_engine
CREATE_HANDLE = CB.repeat_callback(0.1, _create_one_judianzhan_account)
return None