def get_sharing_link(request, char_id):
char = get_char_or_raise(request, char_id)
char.link_shared = True
char.save()
return HttpResponseText(generate_link(char))
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 hide_sharing_link(request, char_id):
char = get_char_or_raise(request, char_id)
char.link_shared = False
char.save()
return HttpResponseText('hid')
def _page(request, char_id, is_new_char):
char = get_char_or_raise(request, char_id)
stats = _get_stats(char)
stats['distrib'] = char.allow_points_distribution
lower_soft_caps = {}
for stat, lis in SOFT_CAPS[char.char_class].iteritems():
new_list = []
for entry in lis:
if entry is not None:
new_list.append(entry + 1)
else:
new_list.append(None)
lower_soft_caps[stat] = new_list
return set_response(
request, 'chardata/chardata.html', {
'char_id': char_id,
'is_new_char': json.dumps(is_new_char),
'stats_json': json.dumps(stats),
'advanced': True,
'soft_caps': SOFT_CAPS[char.char_class],
'lower_soft_caps': lower_soft_caps,
'theme': get_theme(request)
}, char)
def exclusions(request, char_id):
char = get_char_or_raise(request, char_id)
s = get_structure()
language = get_supported_language()
sets_names = s.get_set_names(language)
sets_names_dicts = {set_name: None for set_name in sets_names}
all_items = s.get_all_unique_items_ids_with_type()
all_items_names = s.get_all_unique_items_names_with_ids(language)
all_names = sets_names_dicts.copy()
all_names.update(all_items_names)
complete_sets = s.get_complete_sets_list(language)
exclusions = get_all_exclusions_with_names(char, language)
return set_response(
request, 'chardata/exclusions.html', {
'char_id': char_id,
'advanced': True,
'type_columns': TYPE_COLUMNS,
'all_items_json': json.dumps(all_items),
'all_items_names_json': json.dumps(all_names),
'sets_with_items_json': json.dumps(complete_sets),
'exclusions': json.dumps(exclusions)
}, char)
def stats(request, char_id):
char = get_char_or_raise(request, char_id)
return set_response(
request, 'chardata/stats.html', {
'char_id': char_id,
'advanced': True,
'default_weights_json': json.dumps(get_stats_weights(char))
}, char)
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 delete_projects(request):
projects_json = request.POST.get('projects', None)
projects = json.loads(projects_json)
for proj_id in projects:
char = get_char_or_raise(request, proj_id)
char.deleted = True
char.save()
if 'char_id' in request.session:
del request.session['char_id']
return HttpResponseText('ok')
def options(request, char_id):
char = get_char_or_raise(request, char_id)
options = get_options(char)
return set_response(request, 'chardata/options.html', {
'advanced': True,
'options': json.dumps(options),
'char_id': char_id
}, char)
def exclusions_post(request, char_id):
char = get_char_or_raise(request, char_id)
exclusions_string = request.POST.get('exclusions', None)
if exclusions_string is None:
raise ValidationError('Exclusions list not received.')
exclusions = json.loads(exclusions_string)
actual_exclusions = [int(iditem) for iditem in exclusions]
set_exclusions_list_and_check_inclusions(char, actual_exclusions)
return HttpResponseJson(json.dumps(get_all_exclusions_ids(char)))
def remove_item(request, char_id):
char = get_char_or_raise(request, char_id)
slot = request.POST.get('slot', None)
assert slot in SLOTS
result = get_solution(char)
result.switch_item(None, slot)
set_solution(char, result)
remove_cache_for_char(char_id)
return HttpResponseText('ok')
def switch_item(request, char_id):
char = get_char_or_raise(request, char_id)
item_name = request.POST.get('itemName', None)
slot = request.POST.get('slot', None)
assert slot in SLOTS
structure = get_structure()
result = get_solution(char)
result.switch_item(structure.get_item_by_id(int(item_name)), slot)
set_solution(char, result)
remove_cache_for_char(char_id)
return HttpResponseText('ok')
def solution(request, char_id, empty=False):
char = get_char_or_raise(request, char_id)
solution = get_solution(char)
if solution is None:
if not empty:
return fashion(request, char_id)
else:
input_ = {}
input_['options'] = get_options(request, char_id)
input_['base_stats_by_attr'] = get_base_stats_by_attr(request, char_id)
input_['char_level'] = char.level
set_minimal_solution(char, ModelResultMinimal.generate_empty_solution(input_))
return _solution(request, char_id, False)
def inclusions(request, char_id):
char = get_char_or_raise(request, char_id)
structure = get_structure()
types_list = structure.get_types_list()
items_by_type = {}
items_by_type_and_name = {}
for item_type in types_list:
items_by_type[item_type] = {}
items_by_type_and_name[item_type] = {}
for item_type in items_by_type:
for item in structure.get_unique_items_by_type_and_level(
item_type, char.level):
item_name = structure.get_item_name_in_language(
item, get_supported_language())
items_by_type[item_type][item.id] = item_name
items_by_type_and_name[item_type][item_name] = item.id
images_urls = {}
for item_slot in SLOT_NAME_TO_TYPE:
images_urls[item_slot] = static('chardata/%s.png' %
SLOT_NAME_TO_TYPE[item_slot])
inclusions = get_inclusions_dict(char)
for slot in SLOTS:
inclusions.setdefault(slot, '')
return set_response(
request, 'chardata/inclusions.html', {
'char_id':
char_id,
'advanced':
True,
'types':
items_by_type,
'types_json':
jsonpickle.encode(items_by_type, unpicklable=False),
'names_and_types_json':
jsonpickle.encode(items_by_type_and_name, unpicklable=False),
'inclusions_json':
json.dumps(inclusions),
'images_json':
json.dumps(images_urls),
'slot_to_type_json':
json.dumps(SLOT_NAME_TO_TYPE),
'ajax_loader':
json.dumps(get_ajax_loader_URL(request))
}, char)
def get_options(request, char_id):
char = get_char_or_raise(request, char_id)
options = {}
if char.options:
options = pickle.loads(char.options)
model_options = {
'ap_exo': options.get('ap_exo', False),
'range_exo': options.get('range_exo', False),
'mp_exo': options.get('mp_exo', False),
'dofus': options.get('dofus', True),
'dragoturkey': options.get('dragoturkey', True),
'seemyool': options.get('seemyool', True),
'rhineetle': options.get('rhineetle', True)
}
return model_options
def inclusions_post(request, char_id):
char = get_char_or_raise(request, char_id)
inclusions = {}
for slot in SLOTS:
inclusions[slot] = request.POST.get(slot, '')
set_inclusions_dict_and_check_exclusions(char, inclusions)
inclusions = get_inclusions_dict(char)
for slot in SLOTS:
inclusions.setdefault(slot, '')
return HttpResponseJson(json.dumps(inclusions))
def min_stats(request, char_id):
char = get_char_or_raise(request, char_id)
initial_data = _get_initial_data(char)
structure = get_structure()
stats = []
for stat in structure.get_stats_list():
stat_to_add = {}
stat_to_add['key'] = stat.key
stat_to_add['name'] = _(stat.name)
stats.append(stat_to_add)
stats = [
stat
for stat in sorted(stats, key=lambda stat: STAT_ORDER[stat['key']])
]
fixed_fields = []
ap = {}
ap['key'] = 'ap'
ap['name'] = _('AP')
fixed_fields.append(ap)
mp = {}
mp['key'] = 'mp'
mp['name'] = _('MP')
fixed_fields.append(mp)
rangestat = {}
rangestat['key'] = 'range'
rangestat['name'] = _('Range')
fixed_fields.append(rangestat)
adv_min_fields = structure.get_adv_mins()
return set_response(
request, 'chardata/min_stats.html', {
'advanced': True,
'char_id': char_id,
'stats_order': json.dumps(stats),
'stats_fixed': json.dumps(fixed_fields),
'stats_adv': json.dumps(adv_min_fields),
'initial_data': json.dumps(initial_data),
'crit_targets': CRIT_TARGETS,
'agility_targets': AGI_TARGETS
}, char)
def save_project(request, char_id=0):
char = get_char_or_raise(request, char_id)
state = _get_state_from_post(request)
remove_invalid_inclusions(char, state['char_level'])
_save_state_to_char(state, char)
# TODO: Make clear we are resetting weights and mins.
set_char_aspects(char, state['char_build_aspects_set'],
request.POST.get('reapply') == 'reapply')
char.save()
if char_id > 0:
remove_cache_for_char(char_id)
return HttpResponseJson(json.dumps(_get_state_from_char(char)))
def setup(request, char_id=0):
too_many_projects_problem = False
is_new_char = (char_id == 0)
if is_new_char:
char = Char()
char.name = ''
char.level = 200
char.char_name = ''
char.char_class = ''
char.char_build = ''
else:
char = get_char_or_raise(request, char_id)
if is_anon_cant_create(request) and is_new_char:
can_create = False
login_problem = True
else:
can_create = True
login_problem = False
if (is_new_char and request.user is not None
and not request.user.is_anonymous() and can_create):
chars = Char.objects.filter(owner=request.user)
chars = chars.exclude(deleted=True)
if len(
chars
) >= MAXIMUM_NUMBER_OF_PROJECTS and request.user.email not in TESTER_USERS:
can_create = False
too_many_projects_problem = True
classes = list(_get_class_to_name().keys())
return set_response(
request, 'chardata/projdetails.html', {
'classes': sorted(classes),
'class_to_name': _get_class_to_name(),
'can_create': can_create,
'login_problem': login_problem,
'too_many_projects_problem': too_many_projects_problem,
'state': json.dumps(_get_state_from_char(char)),
'char_id': char_id,
'aspect_to_name': _get_json_aspect_to_name(),
'is_new_char_json': json.dumps(is_new_char),
'questionmark': json.dumps(get_questionmark_URL(request)),
'is_new_char': is_new_char
}, char)
def get_items_of_type(request, char_id):
char = get_char_or_raise(request, char_id)
page = int(request.POST.get('page', None))
search_term = request.POST.get('search_term', None)
slot = request.POST.get('slot', None)
itype = SLOT_NAME_TO_TYPE[slot]
structure = get_structure()
cache_key = ('%s-%s-%s' % (char_id, structure.get_type_id_by_name(itype), search_term))
cache_key = re.sub(r"\s+", '_', cache_key)
items = cache.get(cache_key)
if items == None:
items = _order_items(itype, char, search_term)
cache.set(cache_key, items, 300)
max_page = math.ceil(len(items) / 10.0)
items_to_return = items[(page - 1) * 10 : page * 10]
itemResults = []
for item in items_to_return:
if item.name in structure.or_items:
for or_item in structure.get_or_item_by_name(item.name):
result_item = ModelResultItem(or_item)
evolve_result_item(result_item)
itemResults.append(result_item)
else:
result_item = ModelResultItem(item)
evolve_result_item(result_item)
itemResults.append(result_item)
response = {'items': itemResults,
'violations': None,
'page': page,
'max_page': max_page,
'differences': None}
json_response = jsonpickle.encode(response, unpicklable=False)
return HttpResponseJson(json_response)
def wizard(request, char_id):
char = get_char_or_raise(request, char_id)
wizard_data = Data(char)
constant_data = ConstantData(char)
wizard_pic = 'chardata/designs/wizard/%s/myWizard%s%d.png' % (
char.char_class, char.char_class, 1 + (int(char_id) % 6))
return set_response(
request, 'chardata/wizard.html', {
'char_id':
char_id,
'wizard_pic':
wizard_pic,
'constant_data':
jsonpickle.encode(constant_data, unpicklable=False),
'wizard_data':
jsonpickle.encode(wizard_data, unpicklable=False),
'triangle_url':
jsonpickle.encode(get_triangle_URL(request), unpicklable=False)
}, char)
def options_post(request, char_id):
char = get_char_or_raise(request, char_id)
options = parse_options_post(request)
set_options(char, options)
too_high = get_dofus_not_for_char(char)
forbidden_dofus = []
allowed_dofus = []
for (red, item) in DOFUS_OPTIONS.iteritems():
if red not in too_high:
forbidden = request.POST.get(red) is None
structure = get_structure()
item_id = structure.get_item_by_name(item).id
if forbidden:
forbidden_dofus.append(int(item_id))
else:
allowed_dofus.append(int(item_id))
add_items_to_exclusions(char, forbidden_dofus)
remove_items_from_exclusions(char, allowed_dofus)
return HttpResponseJson(json.dumps(get_options(char)))
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 set_item_forbidden(request, char_id):
char = get_char_or_raise(request, char_id)
slot = request.POST.get('slot', None)
item_name = request.POST.get('equip', None)
forbidden = request.POST.get('forbidden', None)
structure = get_structure()
item = structure.get_item_by_name(item_name)
if item is None:
or_item = structure.get_or_item_by_name(item_name)
item_id = or_item[0].id
else:
item_id = structure.get_item_by_name(item_name).id
if forbidden == 'true':
set_excluded(char, item_id, True)
elif forbidden == 'false':
set_excluded(char, item_id, False)
return HttpResponseText('char_id %s, slot %s, equip %s, forbidden %s'
% (char_id, slot, item_name, str(forbidden)))
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 set_item_locked(request, char_id):
char = get_char_or_raise(request, char_id)
slot = request.POST.get('slot', None)
item_name = request.POST.get('equip', None)
locked = request.POST.get('locked', None)
assert slot in SLOTS
structure = get_structure()
item = structure.get_item_by_name(item_name)
if item is None:
or_item = structure.get_or_item_by_name(item_name)
item_id = or_item[0].id
else:
item_id = structure.get_item_by_name(item_name).id
if locked == 'true':
set_item_included(char, item_id, slot, True)
elif locked == 'false':
set_item_included(char, item_id, slot, False)
return HttpResponseText('char_id %s, slot %s, equip %s, locked %s'
% (char_id, slot, item_name, str(locked)))
def spells(request, char_id=0):
char = get_char_or_raise(request, char_id)
return _spells(request, char, False, char_id)
def get_items_to_exchange(request, char_id):
char = get_char_or_raise(request, char_id)
slot = request.POST.get('slot', None)
page = int(request.POST.get('page', 1))
search_term = request.POST.get('search_term', None)
order_by_stats = request.POST.get('order_by_stat', True)
assert slot in SLOTS
assert int(page) >= 0
structure = get_structure()
item_type = structure.get_type_id_by_name(SLOT_NAME_TO_TYPE.get(slot))
cache_key = ('%s-%s-%s-%s' % (char_id, item_type, search_term, order_by_stats))
cache_key = re.sub(r"\s+", '_', cache_key)
items_to_exchange = cache.get(cache_key)
if items_to_exchange == None:
if slot == 'weapon' and order_by_stats == 'false':
items_to_exchange = _order_by_hits(structure.get_type_name_by_id(item_type), char,
search_term)
else:
items_to_exchange = _order_items(structure.get_type_name_by_id(item_type), char,
search_term)
cache.set(cache_key, items_to_exchange, 300)
max_page = math.ceil(len(items_to_exchange) / 10.0)
items_to_return = items_to_exchange[(page - 1) * 10 : page * 10]
violations = {}
differences = {}
itemResults = []
weapon_info = {}
for item in items_to_return:
if item.name in structure.or_items:
for or_item in structure.get_or_item_by_name(item.name):
result_item = ModelResultItem(or_item)
result_item.set_slot(slot)
evolve_result_item(result_item)
itemResults.append(result_item)
vlist = []
for vio in check_if_violates(or_item, slot, char):
vlist.append(vio)
violations[or_item.name] = vlist
differences[or_item.name] = _get_difference(or_item, slot, char)
if slot == 'weapon':
weapon_info[or_item.name] = _get_weapon_info(or_item, char)
else:
result_item = ModelResultItem(item)
result_item.set_slot(slot)
evolve_result_item(result_item)
itemResults.append(result_item)
vlist = []
for vio in check_if_violates(item, slot, char):
vlist.append(vio)
violations[item.name] = vlist
differences[item.name] = _get_difference(item, slot, char)
if slot == 'weapon':
weapon_info[item.name] = _get_weapon_info(item, char)
response = {'items': itemResults,
'violations': violations,
'page': page,
'max_page': max_page,
'weapon_info': weapon_info,
'differences': differences}
json_response = jsonpickle.encode(response, unpicklable=False)
return HttpResponseJson(json_response)
def get_resetted_sliders(request, char_id):
char = get_char_or_raise(request, char_id)
reapply_weights(char)
all_sliders = get_wizard_sliders(char)
all_sliders_json = jsonpickle.encode(all_sliders)
return HttpResponseJson(all_sliders_json)
def fashion(request, char_id, spells=False):
char = get_char_or_raise(request, char_id)
remove_cache_for_char(char_id)
if char.stats_weight:
weights = get_stats_weights(char)
load_error = True
for _, value in weights.iteritems():
if value != 0:
load_error = False
break
else:
load_error = True
if load_error:
return error(
request, 'characteristics weights',
reverse('chardata.stats_weights_view.stats', args=(char_id, )),
char_id, char)
min_stats = get_min_stats_digested(char)
model_options = get_options(request, char_id)
inclusions_dic = get_inclusions_dict(char)
exclusions = get_all_exclusions_ids(char)
base_stats_by_attr = get_base_stats_by_attr(request, char_id)
if char.allow_points_distribution:
stat_points_to_distribute = 5 * (char.level - 1)
else:
stat_points_to_distribute = 0
# TODO: Sanity check input.
model_input = ModelInput(char.level,
base_stats_by_attr, min_stats, inclusions_dic,
set(exclusions), weights, model_options,
char.char_class, stat_points_to_distribute)
solved_status = None
stats = None
result = None
memoized_result = MEMORY.get(model_input)
if memoized_result is not None:
solved_status, stats, result = memoized_result
else:
model = borrow_model()
model.setup(model_input)
model.run(2)
solved_status = model.get_solved_status()
if solved_status == 'Optimal':
stats = model.get_stats()
result = model.get_result_minimal()
return_model(model)
MEMORY.put(model_input, (model.get_solved_status(), stats, result))
if result is None:
return HttpResponseRedirect(
reverse('chardata.views.infeasible', args=(char.id, )))
if char.allow_points_distribution:
set_stats(char, stats)
set_minimal_solution(char, result)
if spells:
return HttpResponseRedirect(
reverse('chardata.spells_view.spells', args=(char.id, )))
return HttpResponseRedirect(
reverse('chardata.solution_view.solution', args=(char.id, )))
