def get_violations_on_item(self, item):
violations = []
if item.removed:
violations.append(self._create_removed_item_violation(item))
for vio in self._check_items_stat_conditions(item):
violations.append(vio)
if item.weird_conditions['light_set']:
if not self.check_if_set_is_light():
violation = Violation()
violation.item_name = item.localized_name
violation.stat_name = _("Set bonus < 2")
violation.condition_type = 'weird_light_set'
violation.is_red = True
violation.cant_equip = False
violations.append(violation)
item_type_id = get_structure().get_type_id_by_name(item.type)
repeat = self._get_repeat_violations(item_type_id)
for vio in repeat:
if vio.item_name == item.name:
violations.append(vio)
# shield = self._get_item_shield_violation(item)
# for vio in shield:
# if vio.item_name == item.name:
# violations.append(vio)
return violations
def __init__(self, item):
if item:
structure = get_structure()
self.item_added = True
self.id = item.id
self.name = item.name
self.or_name = (item.or_name if item.or_name else item.name)
self.type = structure.get_type_name_by_id(item.type)
self.level = item.level
self.set = item.set
self.ankama_id = item.ankama_id
self.ankama_type = item.ankama_type
or_item = structure.get_or_item_by_name(item.name)
if or_item:
any_or_item = or_item[0]
self.removed = any_or_item.removed
else:
self.removed = item.removed
# self.is_one_handed = item.is_one_handed
self.slot = None
if get_supported_language() in item.localized_names:
self.localized_name = item.localized_names[get_supported_language()]
else:
self.localized_name = or_item[0].localized_names[get_supported_language()]
self.weird_conditions = item.weird_conditions
self.stats = {}
for stat_id, stat_value in item.stats:
stat = structure.get_stat_by_id(stat_id)
self.stats[stat.key] = stat_value
self.min_stats_to_equip = {}
for stat_id, stat_value in item.min_stats_to_equip:
self.min_stats_to_equip[structure.get_stat_by_id(stat_id).key] = stat_value
self.max_stats_to_equip = {}
for stat_id, stat_value in item.max_stats_to_equip:
self.max_stats_to_equip[structure.get_stat_by_id(stat_id).key] = stat_value
localized_extras = item.localized_extras.get(get_supported_language())
if localized_extras is None:
localized_extras = ['[!] ' + line for line in item.localized_extras.get('en', [])]
self.extras = localized_extras
if self.type == 'Weapon':
# Just copy?
weapon = structure.get_weapon_by_name(self.name)
self.is_mageable = weapon.is_mageable
self.non_crit_hits = weapon.non_crit_hits
self.crit_hits = weapon.crit_hits
self.crit_bonus = weapon.crit_bonus
self.crit_chance = weapon.crit_chance_percent
self.ap = weapon.ap
self.weapon_type = structure.get_weapon_type_by_id(weapon.weapon_type).name
else:
self.name = 'NoItem'
self.id = None
self.localized_name = None
self.item_added = False
def _get_min_violations(self, min_stats):
violations = []
s = get_structure()
for stat_key, min_val in min_stats.iteritems():
if stat_key != 'adv_mins':
if self.stats_total[stat_key] < min_val:
stat_name = _(s.get_stat_by_key(stat_key).name)
violation = Violation()
violation.item_name = _('project')
violation.stat_name = stat_name
violation.stat_value = min_val
violation.condition_type = 'min_eq'
violation.cant_equip = False
violations.append(violation)
else:
composite_mins = s.get_adv_mins()
for stat in composite_mins:
if stat['key'] in min_val:
char_stat = 0
for attribute in stat['stats']:
char_stat += self.stats_total[STAT_NAME_TO_KEY[attribute]]
if char_stat < min_val[stat['key']]:
violation = Violation()
violation.item_name = _('project')
violation.stat_name = stat['local_name']
violation.stat_value = min_val[stat['key']]
violation.condition_type = 'min_eq'
violation.cant_equip = False
violations.append(violation)
return violations
def _check_items_stat_conditions(self, item_result):
violations = []
s = get_structure()
if not item_result.item_added:
return violations
if item_result.min_stats_to_equip:
for stat_key, value in item_result.min_stats_to_equip.iteritems():
if self.stats_total[stat_key] < value:
stat_name = _(s.get_stat_by_key(stat_key).name)
violation = Violation()
violation.item_name = item_result.localized_name
violation.stat_name = stat_name
violation.stat_value = value
violation.is_red = True
violation.condition_type = 'min'
violation.cant_equip = False
violations.append(violation)
if item_result.max_stats_to_equip:
for stat_key, value in item_result.max_stats_to_equip.iteritems():
if self.stats_total[stat_key] > value:
stat_name = _(s.get_stat_by_key(stat_key).name)
violation = Violation()
violation.item_name = item_result.localized_name
violation.stat_name = stat_name
violation.stat_value = value
violation.is_red = True
violation.condition_type = 'max'
violation.cant_equip = False
violations.append(violation)
return violations
def add_all_sets(self):
self.sets = []
structure = get_structure()
items_of_set = Counter()
for item in self.item_list:
if item.item_added:
items_of_set[item.set] += 1
for set_number, number_of_items in items_of_set.iteritems():
if set_number and number_of_items > 1:
self._add_set(structure.get_set_by_id(set_number), number_of_items)
def __init__(self, item_set, number_of_items):
structure = get_structure()
self.name = item_set.name
self.total_number_of_items = structure.get_number_of_items_in_set_by_id(item_set.id)
self.number_of_items = number_of_items
self.bonus_per_num_items = item_set.bonus_per_num_items
self.items = []
for item_id in item_set.items:
item = structure.get_item_by_id(item_id)
self.items.append(ModelResultItem(item))
self.localized_name = item_set.localized_names[get_supported_language()]
def switch_item(self, item, slot):
result_item = ModelResultItem(item)
result_item.set_slot(slot)
to_remove = None
for candidate_item in self.item_list:
if candidate_item.slot == slot:
to_remove = candidate_item
break
self.items[SLOT_NAME_TO_TYPE.get(slot)].remove(to_remove)
self.items[SLOT_NAME_TO_TYPE.get(slot)].append(result_item)
self.item_list.remove(to_remove)
self.item_list.append(result_item)
s = get_structure()
if not self._get_repeat_violations(s.get_type_id_by_name(SLOT_NAME_TO_TYPE.get(slot))):
self.calculate_stats()
return result_item
def get_stats_gear(self):
if self.stats_gear is None:
self.stats_gear = {}
for stat in get_structure().get_stats_list():
self.stats_gear[stat.key] = 0
for result_item in self.item_list:
if result_item.item_added:
for stat_key, stat_value in result_item.stats.iteritems():
self.stats_gear[stat_key] += stat_value
for result_set in self.sets:
for stat_key, stat_value in result_set.get_bonus().iteritems():
self.stats_gear[stat_key] += stat_value
if self.input['options']['ap_exo']:
self.stats_gear['ap'] += 1
if 'range_exo' in self.input['options'] and self.input['options']['range_exo']:
self.stats_gear['range'] += 1
if self.input['options']['mp_exo'] == True:
self.stats_gear['mp'] += 1
return self.stats_gear
def model_result_from_minimal(minimal):
structure = get_structure()
if hasattr(minimal, 'stats'):
result = ModelResult(minimal.input, minimal.stats)
else:
result = ModelResult(minimal.input)
for slot, item_id in minimal.item_per_slot.iteritems():
if item_id is not None and structure.get_item_by_id(item_id):
result.add_item_at_slot(structure.get_item_by_id(item_id), slot)
else:
result.add_item_at_slot(None, slot)
open_slots = []
for slot in result.open_slots:
open_slots.append(slot)
for slot in open_slots:
result.add_item_at_slot(None, slot)
result.calculate_stats()
return result
def create_set_constraints(self):
for item_set in self.sets_list:
valid_items_in_set = []
s = get_structure()
for item in item_set.items:
if not s.get_item_by_id(item).removed:
valid_items_in_set.append(item)
restriction = self.problem.restriction_eq(
0, [(1, 'x', item)
for item in valid_items_in_set] + [(-1, 's', item_set.id)])
self.restrictions.first_set_constraints[
item_set.name] = restriction
for item_set in self.sets_list:
restrictions_list = []
for slot in xrange(1, 9):
restriction = self.problem.restriction_lt_eq(
0, [(slot, 'ss', '%d_%d' % (item_set.id, slot + 1)),
(-1, 's', item_set.id)])
restrictions_list.append(restriction)
self.restrictions.second_presence_constraints[
item_set.name] = restrictions_list
for item_set in self.sets_list:
restriction = self.problem.restriction_eq(
1, [(1, 'ss', '%d_%d' % (item_set.id, slot + 1))
for slot in xrange(0, 9)])
self.restrictions.third_set_constraints[
item_set.name] = restriction
for item_set in self.sets_list:
restrictions_list = []
for slot in xrange(0, 9):
restriction = self.problem.restriction_lt_eq(
8 + slot, [(8, 'ss', '%d_%d' % (item_set.id, slot + 1)),
(1, 's', item_set.id)])
restrictions_list.append(restriction)
self.restrictions.fourth_set_constraints[
item_set.name] = restrictions_list
def from_item_id_list(cls, item_id_list, input_, stats):
structure = get_structure()
# Determine locked slots that were honored. They might not have been if
# the locked item is now removed, for example.
locked_slots = {}
item_id_list_left = list(item_id_list)
for locked_slot, locked_id in input_['locked_equips'].iteritems():
for variation in structure.get_items_by_or_id(locked_id):
if variation.id in item_id_list_left:
item_id_list_left.remove(variation.id)
locked_slots[locked_slot] = locked_id
break
item_per_slot = {}
open_slots = set(SLOTS)
for item_id in item_id_list:
item = structure.get_item_by_id(item_id)
item_type = structure.get_type_name_by_id(item.type)
# Define slot
slot = None
for open_slot in open_slots:
if locked_slots.get(open_slot, None) == item.id:
slot = open_slot
break
if slot is None:
slot = TYPE_NAME_TO_SLOT[item_type]
slot_number = TYPE_NAME_TO_SLOT_NUMBER[item_type]
if slot_number > 1:
for i in range(1, slot_number + 1):
candidate_slot = "%s%d" % (slot, i)
if (candidate_slot in open_slots
and not locked_slots.get(candidate_slot, None)):
slot = candidate_slot
break
item_per_slot[slot] = item.id
open_slots.remove(slot)
return cls(item_per_slot, {k: input_[k] for k in input_ if k in RELEVANT_INPUT}, stats)
def _get_repeat_violations(self, item_type_id):
violations = []
s = get_structure()
item_type = s.get_type_name_by_id(item_type_id)
if len(self.items[item_type]) > 1:
dict_names = {}
for item in self.items[item_type]:
if item.item_added:
or_name = s.get_or_item_name(item.name)
dict_names.setdefault(or_name, []).append(item.name)
for (name, occurrences) in dict_names.iteritems():
if len(occurrences) > 1:
item_name = occurrences[0]
if (s.get_item_by_name(item_name).type == s.get_type_id_by_name('Dofus')
or s.get_item_by_name(item_name).set):
violation = Violation()
violation.is_red = True
violation.item_name = name
violation.condition_type = 'repeated'
violation.cant_equip = True
violations.append(violation)
return violations
def get_stats_total(self):
if self.stats_total is None:
self.stats_total = self.get_stats_gear().copy()
structure = get_structure()
main_stats = structure.get_main_stats_list()
for stat in structure.get_stats_list():
self.stats_total[stat.key] += self.input['base_stats_by_attr'].get(stat.name, 0)
if stat in main_stats:
if hasattr(self, 'stats') and self.stats is not None:
self.stats_total[stat.key] += self.stats.get(stat.key, 0)
self.stats_total['apres'] += self.stats_total['wis'] / 10
self.stats_total['mpres'] += self.stats_total['wis'] / 10
self.stats_total['apred'] += self.stats_total['wis'] / 10
self.stats_total['mpred'] += self.stats_total['wis'] / 10
self.stats_total['dodge'] += self.stats_total['agi'] / 10
self.stats_total['lock'] += self.stats_total['agi'] / 10
self.stats_total['pp'] += self.stats_total['cha'] / 10
self.stats_total['pod'] += self.stats_total['str'] * 5
self.stats_total['init'] += (self.stats_total['str']
+ self.stats_total['int']
+ self.stats_total['cha']
+ self.stats_total['agi'])
self.stats_total['hp'] = self.stats_total['vit'] + self.input['char_level'] * 5 + 50 + self.stats_total['hp']
return self.stats_total
def create_structure(self):
self.structure = get_structure()
self.items_list = self.structure.get_available_items_list()
self.sets_list = self.structure.get_sets_list()
self.stats_list = self.structure.get_stats_list()
self.main_stats_list = self.structure.get_main_stats_list()
