def getpassiveInformation(enjob):
gen = maplejobs.getGenerator(maplejobs.getKoJobName(enjob)).JobGenerator()
template = ichar()
#1레벨
no_enhancer = DirectVBuilder([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,1,1,1,1,1,1,1,1])
graph_bare = gen.package_bare(template, v_builder = no_enhancer)
vEhc = no_enhancer.build_enhancer(template, gen)
scheduler = policy.AdvancedGraphScheduler(graph_bare,
policy.TypebaseFetchingPolicy(priority_list = [
core.BuffSkillWrapper,
core.SummonSkillWrapper,
core.DamageSkillWrapper
]),
[rules.UniquenessRule()])
scheduler.initialize(0)
buffs = [{'name' : wrp.skill.name, 'stat' : wrp.skill.static_character_modifier.as_dict()} for wrp,tf in scheduler._buffMdfCalcZip if (not tf)]
gen.build_passive_skill_list(vEhc, template)
passive_skill_direct = [info.as_dict() for info in gen.get_passive_skill_list(vEhc, template)]
passive_skill_indirect = [info.as_dict() for info in gen.get_not_implied_skill_list(vEhc, template)]
return {"passive_direct" : passive_skill_direct, "passive_indirect" : passive_skill_indirect, "static_buff" : buffs}
def get_detailed_dpm(self, ulevel=6000, weaponstat=[4, 9]):
#TODO target을 동적으로 생성할 수 있도록.
target = self.template(maplejobs.weaponList[self.job])
gen = (self.supplier).JobGenerator()
#코어강화량 설정
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(target,
v_builder,
ulevel=ulevel,
weaponstat=weaponstat,
vEnhanceGenerateFlag="njb_style")
sche = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(priority_list=[
core.BuffSkillWrapper, core.SummonSkillWrapper,
core.DamageSkillWrapper
]), [rules.UniquenessRule()] + gen.get_predefined_rules(
rules.RuleSet.BASE)) #가져온 그래프를 토대로 스케줄러를 생성합니다.
analytics = core.Analytics() #데이터를 분석할 분석기를 생성합니다.
control = core.Simulator(
sche, target, analytics) #시뮬레이터에 스케줄러, 캐릭터, 애널리틱을 연결하고 생성합니다.
control.start_simulation(self.runtime)
return {
"data": control.get_results(),
"meta": control.get_metadata(),
"skill": control.get_skill_info(),
"graph": graph.get_network_information("merged"),
"dpm": control.getDPM(),
"detail": gen.generate.__doc__,
"loss": control.get_unrestricted_DPM() - control.getDPM()
}
def burst10(args):
preset = get_preset(args.id)
gen: JobGenerator = jobMap[preset.job].JobGenerator()
target, weapon_stat = TemplateGenerator().get_template_and_weapon_stat(
gen, str(args.ulevel), args.cdr)
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(
target,
v_builder,
options=preset.options,
ulevel=args.ulevel,
weaponstat=weapon_stat,
ability_grade=Ability_grade(4, 1),
)
sche = policy.AdvancedGraphScheduler(
graph,
policy.ListedFetchingPolicy(
skill_ids=gen.get_skill_rotation_10sec(graph)),
[rules.UniquenessRule()],
)
analytics = core.StatAnalytics()
control = core.Simulator(sche, target, analytics)
control.start_simulation(args.time * 1000)
start, end, dpm, loss = analytics.get_peak(10000)
print(preset.job, f"{dpm:,.3f}")
return analytics.get_log()
def get_dpm(self,
ulevel=6000,
level=None,
weaponstat=[4, 9],
printFlag=False,
restricted=True,
default_modifier=core.CharacterModifier()):
#TODO target을 동적으로 생성할 수 있도록.
target = self.template(maplejobs.weaponList[self.job])
if level is not None:
target.unsafe_change_level(level)
gen = (self.supplier).JobGenerator()
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(target,
v_builder,
ulevel=ulevel,
weaponstat=weaponstat,
vEnhanceGenerateFlag="njb_style")
sche = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(priority_list=[
core.BuffSkillWrapper, core.SummonSkillWrapper,
core.DamageSkillWrapper
]), [rules.UniquenessRule()] + gen.get_predefined_rules(
rules.RuleSet.BASE)) #가져온 그래프를 토대로 스케줄러를 생성합니다.
analytics = core.Analytics(printFlag=printFlag) #데이터를 분석할 분석기를 생성합니다.
if printFlag:
print(target.get_modifier())
control = core.Simulator(
sche, target, analytics) #시뮬레이터에 스케줄러, 캐릭터, 애널리틱을 연결하고 생성합니다.
control.set_default_modifier(default_modifier)
control.start_simulation(self.runtime)
control.analytics.statistics()
return control.getDPM(restricted=restricted)
def test_callback_event_handlers():
def create_graph():
X = core.BuffSkill('X', 200, 300,
cooltime=500).wrap(core.BuffSkillWrapper)
Y = core.DamageSkill('Y', 200, 50, 5).wrap(core.DamageSkillWrapper)
A = core.DamageSkill('A', 200, 50, 5).wrap(core.DamageSkillWrapper)
B = core.DamageSkill('B', 200, 50, 5).wrap(core.DamageSkillWrapper)
C = core.DamageSkill('C', 200, 50, 5).wrap(core.DamageSkillWrapper)
X.onEventElapsed(A, 370)
X.onEventEnd(B)
Y.onEventElapsed(C, 380)
return Y, [X, Y]
base_element, all_elements, collection = generate_graph_safely(
create_graph)
X, Y = all_elements
graph = policy.StorageLinkedGraph(base_element,
collection.get_storage(),
accessible_elements=all_elements)
graph.build(AbstractCharacter())
scheduler = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(
[core.BuffSkillWrapper, core.DamageSkillWrapper]), rules.RuleSet())
analytics = core.Analytics()
simulator = core.Simulator(scheduler, AbstractCharacter(), analytics)
simulator.start_simulation(1500)
answer = [(x['time'], x['sname']) for x in analytics.get_results()]
reference = [
(0, 'X'),
(200, 'Y'),
(300, 'B'),
(370, 'A'),
(400, 'Y'),
(580, 'C'),
(600, 'X'),
(780, 'C'),
(800, 'Y'),
(900, 'B'),
(970, 'A'),
(1000, 'Y'),
(1180, 'C'),
(1200, 'X'),
(1380, 'C'),
(1400, 'Y'),
(1500, 'B'),
]
for ans, ref in zip(answer, reference):
assert int(ans[0]) == int(ref[0])
assert ans[1] == ref[1]
def dpm(args):
preset = get_preset(args.id)
gen: JobGenerator = jobMap[preset.job].JobGenerator()
target, weapon_stat = TemplateGenerator().get_template_and_weapon_stat(
gen, str(args.ulevel), args.cdr)
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(
target,
v_builder,
options=preset.options,
ulevel=args.ulevel,
weaponstat=weapon_stat,
ability_grade=Ability_grade(4, 1),
)
sche = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(priority_list=[
core.BuffSkillWrapper,
core.SummonSkillWrapper,
core.DamageSkillWrapper,
]),
[rules.UniquenessRule()] +
gen.get_predefined_rules(rules.RuleSet.BASE),
)
analytics = core.StatAnalytics()
control = core.Simulator(sche, target, analytics)
control.start_simulation(args.time * 1000)
dpm = analytics.get_dpm()
print(preset.job, f"{dpm:,.3f}")
return analytics.get_log()
def burst10(args):
preset = get_preset(args.id)
template = get_template_generator("high_standard")().get_template(
args.ulevel)
target: ItemedCharacter = template(weaponList[preset.job], args.cdr)
gen: JobGenerator = jobMap[preset.job].JobGenerator()
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(
target,
v_builder,
options=preset.options,
ulevel=args.ulevel,
weaponstat=[4, 9],
ability_grade=Ability_grade(4, 1),
)
sche = policy.AdvancedGraphScheduler(
graph,
policy.ListedFetchingPolicy(
skill_ids=gen.get_skill_rotation_10sec(graph)),
[rules.UniquenessRule()],
)
analytics = core.StatAnalytics()
control = core.Simulator(sche, target, analytics)
control.start_simulation(args.time * 1000)
start, end, dpm, loss = analytics.get_peak(10000)
print(dpm)
return analytics.get_log()
def test_callback_operation():
class CallbackTestDamageSkillWrapper(core.DamageSkillWrapper):
def _init__(self, skill):
super(CallbackTestDamageSkillWrapper, self).__init__(skill)
self.callback_for_result = []
def _use(self, skill_modifier):
result = super(CallbackTestDamageSkillWrapper,
self)._use(skill_modifier)
result.callbacks = self.callback_for_result
return result
def create_graph():
X = core.DamageSkill('X', 200, 50, 5,
cooltime=500).wrap(CallbackTestDamageSkillWrapper)
Y = core.DamageSkill('Y', 200, 50,
5).wrap(CallbackTestDamageSkillWrapper)
A = core.DamageSkill('A', 200, 50, 5).wrap(core.DamageSkillWrapper)
B = core.DamageSkill('B', 200, 50, 5).wrap(core.DamageSkillWrapper)
C = core.DamageSkill('C', 200, 50, 5).wrap(core.DamageSkillWrapper)
X.callback_for_result = [
core.Callback.from_graph_element(A, core.SkillModifier(), 320),
core.Callback.from_graph_element(B, core.SkillModifier(), 390)
]
Y.callback_for_result = [
core.Callback.from_graph_element(C, core.SkillModifier(), 390)
]
return Y, [X, Y]
base_element, all_elements, collection = generate_graph_safely(
create_graph)
X, Y = all_elements
graph = policy.StorageLinkedGraph(base_element,
collection.get_storage(),
accessible_elements=all_elements)
graph.build(AbstractCharacter())
scheduler = policy.AdvancedGraphScheduler(
graph, policy.TypebaseFetchingPolicy([core.DamageSkillWrapper]),
rules.RuleSet())
analytics = core.Analytics()
simulator = core.Simulator(scheduler, AbstractCharacter(), analytics)
simulator.start_simulation(1500)
answer = [(x['time'], x['sname']) for x in analytics.get_results()]
reference = [(0, 'X'), (200, 'Y'), (320, 'A'), (390, 'B'), (400, 'Y'),
(590, 'C'), (600, 'X'), (790, 'C'), (800, 'Y'), (920, 'A'),
(990, 'B'), (1000, 'Y'), (1190, 'C'), (1200, 'X'),
(1390, 'C'), (1400, 'Y')]
for ans, ref in zip(answer, reference):
assert ans[0] == ref[0]
assert ans[1] == ref[1]
def get_detailed_dpm(
self,
spec_name: str = "8000",
cdr: int = 0,
ulevel: int = 6000,
options={}
) -> Dict[str, Any]:
gen: JobGenerator = self.supplier.JobGenerator()
target, weapon_stat = TemplateGenerator().get_template_and_weapon_stat(gen=gen, spec_name=spec_name, cdr=cdr)
# 코어강화량 설정
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(
target,
v_builder,
options=options,
ulevel=ulevel,
weaponstat=weapon_stat,
ability_grade=Ability_grade(4, 1),
)
# 가져온 그래프를 토대로 스케줄러를 생성합니다.
sche = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(
priority_list=[
core.BuffSkillWrapper,
core.SummonSkillWrapper,
core.DamageSkillWrapper,
]
),
[rules.UniquenessRule()] + gen.get_predefined_rules(rules.RuleSet.BASE),
)
# 데이터를 분석할 분석기를 생성합니다.
analytics = core.Analytics()
# 시뮬레이터에 스케줄러, 캐릭터, 애널리틱을 연결하고 생성합니다.
control = core.Simulator(
sche, target, analytics
)
control.start_simulation(self.runtime)
return {
"data": analytics.get_results(),
"meta": analytics.get_metadata(target.get_buffed_modifier()),
"skill": analytics.get_skill_info(),
"graph": graph.get_network_information("merged"),
"dpm": analytics.getDPM(),
"detail": gen.generate.__doc__,
"loss": analytics.get_unrestricted_DPM() - analytics.getDPM(),
}
def get_dpm(
self,
spec_name: str,
ulevel: int,
cdr: int = 0,
options={},
printFlag=False,
statistics=False,
restricted=True,
default_modifier=core.CharacterModifier(),
) -> float:
gen: JobGenerator = self.supplier.JobGenerator()
target, weapon_stat = TemplateGenerator().get_template_and_weapon_stat(
gen=gen, spec_name=spec_name, cdr=cdr)
v_builder = core.AlwaysMaximumVBuilder()
graph = gen.package(
target,
v_builder,
options=options,
ulevel=ulevel,
weaponstat=weapon_stat,
ability_grade=Ability_grade(4, 1),
farm=False,
)
sche = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(priority_list=[
core.BuffSkillWrapper,
core.SummonSkillWrapper,
core.DamageSkillWrapper,
]),
[rules.UniquenessRule()] +
gen.get_predefined_rules(rules.RuleSet.BASE),
) # 가져온 그래프를 토대로 스케줄러를 생성합니다.
analytics = core.Analytics(printFlag=printFlag) # 데이터를 분석할 분석기를 생성합니다.
if printFlag:
print(target.get_modifier())
control = core.Simulator(
sche, target, analytics) # 시뮬레이터에 스케줄러, 캐릭터, 애널리틱을 연결하고 생성합니다.
control.set_default_modifier(default_modifier)
control.start_simulation(self.runtime)
if statistics:
control.analytics.statistics()
return analytics.getDPM(restricted=restricted)
def get_dpm(self, ulevel = 6000, weaponstat = [4,9], level = 230, printFlag = False):
#TODO target을 동적으로 생성할 수 있도록.
target = self.template(maplejobs.weaponList[self.job])
target.level = level
gen = (self.supplier).JobGenerator()
v_builder = core.NjbStyleVBuilder(skill_core_level=25, each_enhanced_amount=17)
graph = gen.package(target, v_builder, ulevel = ulevel, weaponstat = weaponstat, vEnhanceGenerateFlag = "njb_style")
sche = policy.AdvancedGraphScheduler(graph,
policy.TypebaseFetchingPolicy(priority_list = [
core.BuffSkillWrapper,
core.SummonSkillWrapper,
core.DamageSkillWrapper
]),
[rules.UniquenessRule()]) #가져온 그래프를 토대로 스케줄러를 생성합니다.
analytics = core.Analytics(printFlag=printFlag) #데이터를 분석할 분석기를 생성합니다.
control = core.Simulator(sche, target, analytics) #시뮬레이터에 스케줄러, 캐릭터, 애널리틱을 연결하고 생성합니다.
control.start_simulation(self.runtime)
return control.getDPM()
def test_simple_scheduler():
def create_graph():
X = core.DamageSkill('X', 200, 50, 5,
cooltime=200).wrap(core.DamageSkillWrapper)
Y = core.DamageSkill('Y', 200, 50, 5).wrap(core.DamageSkillWrapper)
return Y, [X, Y]
base_element, all_elements, collection = generate_graph_safely(
create_graph)
X, Y = all_elements
graph = policy.StorageLinkedGraph(base_element,
collection.get_storage(),
accessible_elements=all_elements)
graph.build(AbstractCharacter())
scheduler = policy.AdvancedGraphScheduler(
graph, policy.TypebaseFetchingPolicy([core.DamageSkillWrapper]),
rules.RuleSet())
scheduler.initialize(1000)
ref_list = []
for i in range(10):
obj = scheduler.dequeue()
print(scheduler.get_current_time())
result = obj.do()
scheduler.spend_time(50)
ref_list.append(obj._ref)
print(f'current time {i * 50}')
print(obj)
answer_list = [X, Y, Y, Y, X, Y, Y, Y, X, Y]
# answer_list = [X, Y, Y, Y, Y, X, Y, Y, Y, Y]
for obj, ans in zip(ref_list, answer_list):
assert ans == obj
def get_instant_dpm(spec,
job,
otherspec,
useFullCore=True,
koJobFlag=False,
v_builder=None,
seed_rings=False):
'''주어진 값과 직업값으로부터 dpm을 계산해서 리턴합니다.
입력값 : CharacterModifier, job, otherspec
출력값 : float(DPM)
'''
if koJobFlag:
koJob = job
else:
koJob = maplejobs.getKoJobName(job)
if koJob is not None:
try:
gen = maplejobs.getGenerator(koJob).JobGenerator()
except Exception as e:
raise TypeError("Unsupported job type: " + str(job))
else:
raise TypeError("Unsupported job type(en): " + str(job))
template = ichar()
if otherspec is not None:
if "buffrem" in otherspec:
template.buff_rem = otherspec["buffrem"]
if "summonrem" in otherspec:
template.summonRemain = otherspec["summonrem"]
if "cooltimereduce" in otherspec:
template.cooltimeReduce = otherspec["cooltimereduce"]
template.apply_modifiers([spec])
graph = gen.package_bare(template, useFullCore=False, v_builder=v_builder)
sche = policy.AdvancedGraphScheduler(
graph,
policy.TypebaseFetchingPolicy(priority_list=[
core.BuffSkillWrapper, core.SummonSkillWrapper,
core.DamageSkillWrapper
]), [rules.UniquenessRule()]) #가져온 그래프를 토대로 스케줄러를 생성합니다.
analytics = core.Analytics() #데이터를 분석할 분석기를 생성합니다.
control = core.Simulator(sche, template,
analytics) #시뮬레이터에 스케줄러, 캐릭터, 애널리틱을 연결하고 생성합니다.
control.start_simulation(180 * 1000)
if seed_rings:
seed_ring_specs = [{
"name":
"리스크테이커",
"effect":
[[12000 + 6000 * i, MDF(patt=20 + 10 * i)] for i in range(4)]
}, {
"name":
"리스트레인트",
"effect":
[[9000 + 2000 * i, MDF(patt=25 + 25 * i)] for i in range(4)]
}, {
"name":
"웨폰퍼프",
"effect": [[
9000 + 2000 * i,
MDF(stat_main=Absolab.WeaponFactory.getWeapon(
maplejobs.weaponList[koJob], star=17,
elist=[0, 0, 0, 9]).att * (i + 1))
] for i in range(4)]
}, {
"name":
"크리데미지",
"effect":
[[9000 + 2000 * i, MDF(crit_damage=7 + 7 * i)] for i in range(4)]
}]
return_ring_dpms = []
for spec in seed_ring_specs:
enhancement = []
enhancement = [
control.analytics.deduce_increment_of_temporal_modifier(
effect[0], effect[1]) for effect in spec["effect"]
]
return_ring_dpms.append({
"name": spec["name"],
"effect": enhancement
})
return_json_object = {
"dpm": control.getDPM(),
"loss": control.get_unrestricted_DPM() - control.getDPM(),
"share": analytics.skill_share()
}
if seed_rings:
return_json_object["seedring"] = return_ring_dpms
return return_json_object
