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 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 set_stats_weights(char, weights):
for stat_key, stat_weight in weights.iteritems():
if stat_key in DEPRECATED_STATS:
continue
if stat_key == 'meleeness':
continue
assert stat_key in STAT_KEY_TO_NAME, '%s is not a stat' % stat_key
assert type(stat_weight) == int, '%s is not an int' % stat_weight
assert abs(int(stat_weight)) <= 5000, \
('stat_weight is %d, magnitude above 5k' % stat_weight)
char.stats_weight = pickle.dumps(weights)
char.save()
remove_cache_for_char(char.id)
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 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, )))