def _solution(request, char_id, is_guest, encoded_char_id=None):
char = get_object_or_404(Char, pk=char_id)
inclusions = get_all_inclusions_en_names(char)
exclusions = get_all_exclusions_en_names(char)
solution = get_solution(char)
solution_result = SolutionResult(solution,
inclusions,
exclusions)
params = {'char_id': char_id,
'lock_item': static('chardata/lock-icon.png'),
'switch_item': static('chardata/1412645636_Left-right.png'),
'delete_item': static('chardata/delete-icon.png'),
'add_item': static('chardata/add-icon.png'),
'ajax_loader': json.dumps(get_ajax_loader_URL(request)),
'link_external_image': json.dumps(get_external_image_URL(request)),
'is_guest': is_guest,
'is_guest_json': json.dumps(is_guest),
'encoded_char_id': encoded_char_id,
'link_shared': char.link_shared,
'owner_alias': get_alias(char.owner),
'is_dueler': chardata.smart_build.char_has_aspect(char, 'duel')}
if char.link_shared:
params['initial_link'] = generate_link(char)
params.update(solution_result.get_params())
response = set_response(request,
'chardata/solution.html',
params,
char)
return response
def _get_difference(item, slot, char):
result = get_solution(char)
current_stats = result.stats_total.copy()
result.switch_item(item, slot)
new_stats = result.stats_total.copy()
difference = {}
for (stat, _) in current_stats.iteritems():
if stat in new_stats:
if (new_stats[stat] - current_stats[stat] != 0):
difference[stat] = new_stats[stat] - current_stats[stat]
else:
difference[stat] = 0 - current_stats[stat]
for (stat, _) in new_stats.iteritems():
if stat not in current_stats:
difference[stat] = new_stats[stat]
ordered_diff = sorted(difference.iteritems(),
key=lambda x: STAT_ORDER[x[0]])
stats_lines = []
for stat_key, stat_value in ordered_diff:
stat_name = get_structure().get_stat_by_key(stat_key).name
stats_lines.append(AttributeLine(stat_value, stat_name))
return stats_lines
def _spells(request, char, is_guest, char_id, encoded_char_id=None):
char_class = char.char_class
solution = get_solution(char)
if solution is None:
return fashion(request, char_id, True)
digests = []
weapons = solution.items['Weapon']
if len(weapons) > 0:
weapon = weapons[0]
if weapon.item_added:
web_digest = _create_weapon_web_digest(weapon)
digests.append(web_digest)
for spell in DAMAGE_SPELLS[char_class] + DAMAGE_SPELLS['default']:
web_digest = _create_spell_web_digest(spell)
digests.append(web_digest)
digests_json = jsonpickle.encode(digests, unpicklable=False)
stats_json = jsonpickle.encode(solution.get_stats_total(), unpicklable=False)
return set_response(request,
'chardata/spells.html',
{'request': request,
'is_guest': is_guest,
'encoded_char_id': encoded_char_id,
'user': request.user,
'digests_json': digests_json,
'char_id': char_id,
'char_level': char.level,
'char_stats_json': stats_json},
char)
def load_a_project(request, char_id):
char = get_object_or_404(Char, pk=char_id)
if get_solution(char) is not None:
return HttpResponseRedirect(
reverse('chardata.solution_view.solution', args=(char.id, )))
return HttpResponseRedirect(
reverse('chardata.wizard_view.wizard', args=(char.id, )))
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 _order_by_hits(item_type, char, search_term):
structure = get_structure()
items = structure.get_unique_items_by_type_and_level(item_type, char.level)
search_term = search_term.lower()
search_term = strip_accents(search_term)
if search_term is not None and search_term is not '':
items = filter(lambda i: _item_contains_term(i, re.sub(r'\W+', '', search_term)),
items)
items = filter(lambda i: _hide_removed_item(i), items)
solution = get_solution(char)
sorted_items = sorted(items, key=lambda item: _get_weapon_rate(item, char, solution), reverse=True)
#print sorted_items[:5]
return sorted_items
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 compare_sets(request, sets_params):
char_strs = _process_parameters(sets_params)
chars = [
get_char_possibly_encoded_or_raise(request, char_str)
for char_str in char_strs
]
solutions = {}
is_guest = {}
links = {}
all_chars_are_shared = True
for char in chars:
solution = get_solution(char)
sol_result = SolutionResult(solution)
solutions[char.pk] = sol_result.get_params()
is_guest[char.pk] = not char_belongs_to_user(request, char)
if not char_belongs_to_user(request, char):
links[char.pk] = generate_link(char)
else:
links[char.pk] = request.build_absolute_uri(
reverse('chardata.solution_view.solution', args=(char.pk, )))
all_chars_are_shared = all_chars_are_shared and char.link_shared
char_ids = [char.pk for char in chars]
if len(char_ids) > 2:
char_ids_cols = char_ids
else:
char_ids_cols = char_ids + ['diff']
compare_link_shared = None
if all_chars_are_shared:
compare_link_shared = _generate_share_compare_link(char_ids)
get_compare_link_url = reverse(
'chardata.compare_sets_view.get_sharing_link', args=(sets_params, ))
params = {
'chars': chars,
'char_ids': char_ids,
'char_ids_cols': char_ids_cols,
'solutions': solutions,
'items_sorted': _sort_items(solutions),
'char_is_guest': is_guest,
'links': links,
'compare_link_shared': compare_link_shared,
'get_compare_link_url': get_compare_link_url
}
response = set_response(request, 'chardata/compare_sets.html', params)
return response
def compare_set_search_proj_name(request):
name_piece = request.POST.get('name[term]', None)
if (request.user is not None and not request.user.is_anonymous()):
chars = Char.objects.filter(owner=request.user)
chars = chars.exclude(deleted=True)
char_list = []
if name_piece:
name_piece = name_piece.lower()
for char in chars:
if name_piece in char.name.lower():
if get_solution(char) is not None:
char_list.append({'label': char.name, 'idx': char.id})
else:
char_list = []
return HttpResponseJson(json.dumps(char_list))
def check_if_violates(item, slot, char):
result = get_solution(char)
result.switch_item(item, slot)
minimums = get_min_stats_digested_by_key(char)
return result.get_all_project_violations(item.type, minimums)
def _get_weapon_info(weapon, char):
weapon_info = {}
structure = get_structure()
result = get_solution(char)
result_item = result.switch_item(weapon, 'weapon')
new_stats = result.stats_total.copy()
weapon_obj = structure.get_weapon_by_name(weapon.name)
if result_item.is_mageable:
result_item.mage_weapon_smartly(new_stats)
element = result_item.element_maged
else:
element = NEUTRAL
#print element
weapon_info['is_mageable'] = result_item.is_mageable
weapon_info['element'] = _(ELEMENT_KEY_TO_NAME[element])
calculated_damage = {}
for elementnew in DAMAGE_TYPES:
calculated_damage[elementnew] = calculate_damage(weapon_obj.non_crit_hits[element],
new_stats, critical_hit=False, is_spell=False)
min_noncrit_dam = 0
for damage in calculated_damage[element]:
if damage.heals:
min_noncrit_dam -= damage.min_dam
else:
min_noncrit_dam += damage.min_dam
weapon_info['min_noncrit_dam'] = min_noncrit_dam
max_noncrit_dam = 0
for damage in calculated_damage[element]:
if damage.heals:
max_noncrit_dam -= damage.max_dam
else:
max_noncrit_dam += damage.max_dam
weapon_info['max_noncrit_dam'] = max_noncrit_dam
if weapon_obj.has_crits:
calculated_crit_damage = {}
for elementnew in DAMAGE_TYPES:
calculated_crit_damage[elementnew] = calculate_damage(weapon_obj.crit_hits[element],
new_stats, critical_hit=True, is_spell=False)
min_crit_dam = 0
for damage in calculated_crit_damage[element]:
if damage.heals:
min_crit_dam -= damage.min_dam
else:
min_crit_dam += damage.min_dam
weapon_info['min_crit_dam'] = min_crit_dam
max_crit_dam = 0
for damage in calculated_crit_damage[element]:
if damage.heals:
max_crit_dam -= damage.max_dam
else:
max_crit_dam += damage.max_dam
weapon_info['max_crit_dam'] = max_crit_dam
solution = get_solution(char)
rating = _get_weapon_rate(weapon, char, solution)
weapon_info['rating'] = rating
return weapon_info
