def _post(request, char_id):
char = get_char_or_raise(request, char_id)
for element_name, abr in STATS_NAMES:
basestats_list = CharBaseStats.objects.filter(char=char,
stat=element_name)
if len(basestats_list) == 0:
basestats = CharBaseStats()
else:
basestats = basestats_list[0]
basestats.char = char
basestats.stat = element_name
basestats.total_value = (
safe_int(request.POST.get('points_%s' % abr, 0), 0) +
safe_int(request.POST.get('scrolled_%s' % abr, 0), 0))
basestats.scrolled_value = safe_int(
request.POST.get('scrolled_%s' % abr, 0), 0)
assert 0 <= basestats.total_value and basestats.total_value <= 3000
assert 0 <= basestats.scrolled_value and basestats.scrolled_value <= 101
basestats.save()
allow_point_distribution = request.POST.get('choose_stats', False)
char.allow_points_distribution = allow_point_distribution
char.save()
return char
def choose_set(request):
structure = get_structure()
set_stats = {}
set_id = safe_int(request.POST.get('id', None))
set_reference = request.POST.get('name', None)
set_reference = set_reference.split(' ', 1)
if set_id == None:
set_id = safe_int(set_reference[0])
set_name = set_reference[1]
s = None
if set_id:
s = structure.get_set_by_id(set_id)
if not s and set_name:
s = structure.get_set_by_name(set_name)
if not s:
return HttpResponseJson(json.dumps(set_stats))
set_stats['name'] = s.name
set_stats['id'] = s.id
set_stats['ankama_id'] = s.ankama_id
for lang in NON_EN_LANGUAGES:
set_stats['translated_name_%s' % lang] = s.localized_names.get(
lang, '')
stats_per_num_items = {}
for num_items in range(2, 8 + 1):
for stat, value in s.bonus_per_num_items.get(num_items,
{}).iteritems():
stats_per_num_items.setdefault(STAT_KEY_TO_NAME[stat],
{})[num_items] = value
stats = []
for stat_name in sorted(
stats_per_num_items,
key=lambda stat: STAT_ORDER[structure.get_stat_by_name(stat).key]):
stats.append((stat_name, stats_per_num_items[stat_name]))
set_stats['stats'] = stats
items = []
for item_id in s.items:
item = structure.get_item_by_id(item_id)
item_name = item.name
items.append({'name': item_name, 'id': item_id})
result = {'set': set_stats, 'items': items}
return HttpResponseJson(json.dumps(result))
def delete_item_post(request):
item_id = safe_int(request.POST.get('itemId', None))
if not item_id:
return HttpResponseText('not ok')
worked = _delete_item(item_id)
if not worked:
return HttpResponseText('not ok')
return HttpResponseText('ok')
def delete_set_post(request):
set_id = safe_int(request.POST.get('setId', None))
if not set_id:
return HttpResponseText('not ok')
worked = _delete_set(set_id)
if not worked:
return HttpResponseText('not ok')
return HttpResponseText('ok')
def stats_post(request, char_id):
char = get_char_or_raise(request, char_id)
stats_weight = {}
for stat in get_structure().get_stats_list():
stats_weight[stat.key] = safe_int(
request.POST.get('weight_%s' % stat.key, 0), 0)
set_stats_weights(char, stats_weight)
return HttpResponseJson(json.dumps(get_stats_weights(char)))
def set_wizard_sliders(char, slider_dict):
weights = get_stats_weights(char)
for slider_key in SLIDER_RANGES:
form_field_name = 'slider_%s' % slider_key
slider_value_string = slider_dict.get(form_field_name, None)
new_slider_value = safe_int(slider_value_string)
if new_slider_value is not None:
set_weights_from_slider_value(slider_key, new_slider_value, weights)
_post_process_weights(weights)
set_stats_weights(char, weights)
remove_cache_for_char(char.id)
def update_item_post(request):
item = json.loads(request.POST.get('item', None))
if item == None:
return HttpResponseText('not ok')
item_id = safe_int(item['id'])
if item_id:
new_item, new_weapon = _convert_json_item_to_item(item)
old_item = get_structure().get_item_by_id(item_id)
update_item(old_item, new_item, new_weapon, True)
return HttpResponseText('ok')
else:
_insert_item(item)
return HttpResponseText('ok')
def min_stats_post(request, char_id):
char = get_char_or_raise(request, char_id)
structure = get_structure()
minimum_values = {}
for stat in get_structure().get_stats_list():
minimum = safe_int(request.POST.get('min_%s' % stat.key, ''))
if minimum is not None:
minimum_values[stat.name] = minimum
minimum = safe_int(request.POST.get('min_hp'))
if minimum is not None:
minimum_values['HP'] = minimum
adv_stats = structure.get_adv_mins()
minimum_values['adv_mins'] = {}
for stat in adv_stats:
minimum = safe_int(request.POST.get('min_%s' % stat['key'], ''))
if minimum is not None:
minimum_values['adv_mins'][stat['name']] = minimum
set_min_stats(char, minimum_values)
return HttpResponseJson(json.dumps(_get_initial_data(char)))
def _get_state_from_post(request):
where_to_go = 'solution' if request.POST.get('byhand', None) else 'wizard'
aspects_set = set()
for aspect in ALL_ASPECTS:
if on_off_to_bool(request.POST.get('check_%s' % aspect, 'off')):
aspects_set.add(aspect)
return {
'proj_name': request.POST.get('project', 'NoName'),
'char_name': request.POST.get('charname', 'NoName'),
'char_level': safe_int(request.POST.get('level', 200), 200),
'char_class': request.POST.get('class', 'NoName'),
'char_build_aspects_set': aspects_set,
'where_to_go': where_to_go
}
def update_set_post(request):
s = json.loads(request.POST.get('set', None))
if s == None:
return HttpResponseText('not ok')
set_id = safe_int(s['id'])
if set_id:
new_set = _convert_json_set_to_set(s)
worked = update_set(set_id, new_set)
if worked:
return HttpResponseText('ok')
else:
return HttpResponseText('not ok')
else:
_insert_set(s)
return HttpResponseText('ok')
def wizard_post(request, char_id):
char = get_char_or_raise(request, char_id)
minimum_values = get_min_stats(char)
for stat_name in STATS_WITH_CONFIG_MINS:
minimum = safe_int(request.POST.get('min_%s' % stat_name, ''))
minimum_values[stat_name] = minimum
set_min_stats(char, minimum_values)
weapon_to_lock = request.POST.get('weapon', None)
if weapon_to_lock:
set_item_included(char, weapon_to_lock, 'weapon', True)
else:
inclusions = get_inclusions_dict(char)
weapon = inclusions.get('weapon')
if weapon:
set_item_included(char, weapon, 'weapon', False)
options = get_options(char)
options.update(parse_options_post(request))
set_options(char, options)
for (red, item) in DOFUS_OPTIONS.iteritems():
forbidden = request.POST.get(red) is None
s = get_structure()
item_id = s.get_item_by_name(item).id
set_excluded(char, item_id, forbidden)
set_wizard_sliders(char, request.POST)
scroll = request.POST.get('scrolling', 'leave')
if scroll == 'fully':
_full_scroll_char(char)
elif scroll == 'clean':
_clean_scroll_char(char)
return HttpResponseRedirect(
reverse('chardata.fashion_action.fashion', args=(char.id, )))
def _convert_json_item_to_item(json_item):
structure = get_structure()
item = Item()
item.name = json_item['name']
item.ankama_id = json_item['ankama_id']
item.ankama_type = json_item['ankama_type']
item.level = json_item['level']
item.removed = json_item['removed']
item.dofus_touch = json_item['dofus_touch']
item.type = structure.get_type_id_by_name(json_item['type'])
if json_item['set']:
item_set = json_item['set']
if '[DT]' in item_set:
set_reference = item_set.split(' ', 2)
item.set = safe_int(set_reference[1])
else:
item.set = structure.get_set_id_by_name(item_set)
item.weird_conditions = json_item['weird_conditions']
for stat in json_item['stats']:
if stat['stat'] == '' or stat['stat'] == None:
continue
_add_to_old_stat(item,
structure.get_stat_by_name(stat['stat']).id,
int(stat['value']))
for cond in json_item['conditions']:
if cond['stat'] == '' or cond['stat'] == None:
continue
new_value = (int(cond['value']) -
1 if cond['min_max'] == '<' else int(cond['value']) + 1)
_add_to_old_cond(item,
structure.get_stat_by_name(cond['stat']).id,
cond['min_max'] == '>', new_value)
for lang, extras in json_item['extras'].iteritems():
for extra in extras:
if extra == '':
continue
_add_to_old_extra(item, lang, extra)
for lang in NON_EN_LANGUAGES:
name_translated = json_item['translated_name_%s' % lang]
if not name_translated.startswith('[!]'):
item.localized_names[lang] = name_translated
weapon = None
if json_item['type'] == 'Weapon':
weapon = Weapon()
weapon.ap = int(json_item['ap'])
weapon.crit_chance = int(json_item['crit_chance'])
weapon.crit_bonus = int(json_item['crit_bonus'])
# item.is_one_handed = json_item['one_handed']
weapon.weapon_type = structure.get_weapon_type_by_name(
json_item['weapon_type']).id
for hit in json_item['hits']:
if hit['min_hit'] == '':
continue
index = int(hit['index'])
weapon.hits_dict[index] = DamageDigest(
int(hit['min_hit']), int(hit['max_hit']),
ELEMENT_NAME_TO_KEY[hit['stat']], hit['steals'], hit['heals'])
return item, weapon
def choose_item(request):
structure = get_structure()
item_id = safe_int(request.POST.get('id', None))
item_reference = request.POST.get('name', None)
item_name = None
if item_reference:
if '[DT]' in item_reference:
item_reference = item_reference.split(' ', 2)
if item_id == None:
item_id = safe_int(item_reference[1])
item_name = item_reference[2]
dofus_touch = True
else:
item_reference = item_reference.split(' ', 1)
if item_id == None:
item_id = safe_int(item_reference[0])
item_name = item_reference[1]
dofus_touch = False
item = None
if item_id:
item = structure.get_item_by_id(item_id)
dofus_touch = item.dofus_touch
if not item and item_name:
item = structure.get_item_by_name(item_name, dofus_touch)
if not item:
return HttpResponseJson(json.dumps({}))
item_stats = {}
item_stats['name'] = item.name
item_stats['id'] = item.id
item_stats['ankama_id'] = item.ankama_id
item_stats['ankama_type'] = item.ankama_type
item_stats['level'] = item.level
item_stats['type'] = structure.get_type_name_by_id(item.type)
item_stats['removed'] = item.removed
item_stats['dofus_touch'] = item.dofus_touch
if item.set:
item_stats['set'] = structure.get_set_by_id(item.set).name
item_stats['weird_conditions'] = item.weird_conditions
stats = []
for stat, value in sorted(item.stats,
key=lambda stats: STAT_ORDER[
structure.get_stat_by_id(stats[0]).key]):
stats.append((structure.get_stat_by_id(stat).name, value))
item_stats['stats'] = stats
conditions = {}
if item.min_stats_to_equip:
for stat, value in item.min_stats_to_equip:
conditions[structure.get_stat_by_id(stat).name] = ('>', value - 1)
if item.max_stats_to_equip:
for stat, value in item.max_stats_to_equip:
conditions[structure.get_stat_by_id(stat).name] = ('<', value + 1)
item_stats['conditions'] = conditions
item_stats['extras'] = {
lang: item.localized_extras.get(lang, [])
for lang in LANGUAGES
}
if item_stats['type'] == 'Weapon':
weapon = structure.get_weapon_by_name(item.name, dofus_touch)
# item_stats['one_handed'] = item.is_one_handed
item_stats['ap'] = weapon.ap
item_stats['crit_chance'] = weapon.crit_chance
item_stats['crit_bonus'] = weapon.crit_bonus
item_stats['weapon_type'] = structure.get_weapon_type_by_id(
weapon.weapon_type).name
hits = {}
for key, value in weapon.hits_dict.iteritems():
hits[key] = (value.min_dam, value.max_dam,
ELEMENT_KEY_TO_NAME[value.element], value.steals,
value.heals)
item_stats['hits'] = hits
for lang in NON_EN_LANGUAGES:
item_stats['translated_name_%s' % lang] = item.localized_names.get(
lang, '')
or_items = []
# Handle artificial items(Gelano, Turquoise Dofus)
for alt_item in structure.get_items_by_or_name(item.or_name, dofus_touch):
if alt_item.id != item.id:
or_items.append({'id': alt_item.id, 'name': alt_item.name})
result = {'item': item_stats, 'or_items': or_items}
return HttpResponseJson(json.dumps(result))
