diff --git a/src/objective/views.py b/src/objective/views.py index 7ee6e72..ce8c715 100644 --- a/src/objective/views.py +++ b/src/objective/views.py @@ -350,104 +350,109 @@ def random_skill(request, number=None): def __construct_routine( - routine_length, + current_routine, + max_routine_length, total_difficulty_score=None, competition=True, logic=True, gymnast=None, - last_jump=None, ): """ Construit et propose des séries. Args: + current_routine (array): la série en cours de création. routine_length (int): nombre de sauts qui compose la série. - total_difficulty_score (int): score total de difficulté souhaité de la série. + total_difficulty_score (int): score total de difficulté souhaité de la série EN DIXIEME (/!\). competition (bool): indique si la série doit respecter les règles de compétition. logic (bool): indique si la série doit suivre les règles de logique (sportive). gymnast (gymnast): gymnaste. - last_jump (skill): dernier saut sélectionné pour la série. Returns: ??? (list): liste des séries correspondantes aux criètres. """ - print("Il reste " + str(routine_length) + " sauts à trouver.") + # print("Il reste " + str(max_routine_length - len(current_routine)) + " sauts à trouver.") + print("Il reste " + str(total_difficulty_score) + " dixièmes à trouver.") - current_routine = [] + if not total_difficulty_score or total_difficulty_score <= 0: + print("Total score négatif ou None !") + return - skill_list = Skill.objects.all() + if len(current_routine) == max_routine_length: + print(current_routine) + return + # print('1') + if current_routine: + skill_list = Skill.objects.filter( + departure = current_routine[-1].landing + ) # , difficulty__lte = total_difficulty_score + if len(current_routine) == (max_routine_length - 1): + skill_list = skill_list.filter(landing__longLabel="Debout") + if logic and current_routine[-1].landing == "Debout": + skill_list = skill_list.exclude(rotationType = current_routine[-1].rotationType) + else: + skill_list = Skill.objects.filter(departure__longLabel = "Debout") + # print('2') + if competition: + skill_list = skill_list.filter(is_competitive = True) + # skill_list = skill_list.exclude(position="L").exclude(position="c") + # print('3') + if logic and total_difficulty_score: + if gymnast: + max_skill_difficulty = Educative.objects.filter(cando__gymnast=gymnast).order_by( + "-difficulty" + )[:1] + else: + max_skill_difficulty = Skill.objects.values('difficulty').order_by("-difficulty")[:1][0]["difficulty"] * 10 + print("Max Skill diff.: " + str(max_skill_difficulty)) - # if last_jump: - # skill_list = Skill.objects.filter( - # departure = last_jump.landing, difficulty__lte = total_difficulty_score - # ) - # if logic and last_jump.landing == "Debout": - # skill_list = skill_list.exclude(rotationType = last_jump.rotationType) - # else: - # skill_list = Skill.objects.filter(departure__longLabel = "Debout") + if math.ceil(total_difficulty_score / max_routine_length) < max_skill_difficulty: + min_diff_skill = math.ceil(max((total_difficulty_score / max_routine_length) - 5, 0)) + print("Min diff.: " + str(min_diff_skill)) + else: + return - # if competition: - # skill_list = skill_list.filter(is_competitive = True) - - # if logic and total_difficulty_score: - # min_difficulty_score = math.ceil(max(0, ((total_difficulty_score / 10) - 5))) - - # if total_difficulty_score <= 65: - # max_difficulty_score = math.ceil(total_difficulty_score / 5) + 1 - # elif total_difficulty_score <= 120: - # max_difficulty_score = math.ceil(total_difficulty_score / 10) + 7 - # else: - # max_difficulty_score = math.ceil(total_difficulty_score / 15) + 11 - - # skill_list = skill_list.filter( - # difficulty__gte = min_difficulty_score, - # difficulty__lte = max_difficulty_score - # ) + if (math.ceil(total_difficulty_score / max_routine_length) + 2) <= max_skill_difficulty: + max_diff_skill = math.ceil(total_difficulty_score / max_routine_length) + 2 + print("Max. diff.: " + str(max_diff_skill)) + else: + print("Score demandé:" + str(total_difficulty_score)) + print("# de sauts:" + str(max_routine_length)) + print("Pré-condition:" + str((total_difficulty_score / max_routine_length) + 2)) + print("Condition: " + str(math.ceil(total_difficulty_score / max_routine_length) + 2)) + print("RETURN…") + return + skill_list = skill_list.filter( + difficulty__gte = (min_diff_skill / 10), + difficulty__lte = (max_diff_skill / 10) + ) + # print('4') # if gymnast: # skill_list = skill_list.filter(can_do__gymnast = gymnast) + # skill_list = skill_list[0:3] + for skill in skill_list: + print("On sélectionne : " + str(skill)) current_routine.append(skill) - routine_length -= 1 - if routine_length == 0: - break - current_routine.append( - __construct_routine( - routine_length, - total_difficulty_score - skill.difficulty if total_difficulty_score else None, - competition, - logic, - gymnast, - skill, - ) + + __construct_routine( + current_routine, + max_routine_length, + total_difficulty_score - (skill.difficulty * 10) if total_difficulty_score else None, + competition, + logic, + gymnast, ) - if len(current_routine) == 10: - print(current_routine) + current_routine.pop() - routine_length += 1 - # def knapSack(W, wt, val, n): - # K = [[0 for x in range(W+1)] for x in range(n+1)] - # for i in range(n+1): - # for w in range(W+1): - # if i==0 or w==0: - # K[i][w] = 0 - # elif wt[i-1] <= w: - # K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w]) - # else: - # K[i][w] = K[i-1][w] - # return K[n][W] - # val = [60, 100, 120] - # wt = [10, 20, 30] - # W = 50 - # n = len(val) - # print(knapSack(W, wt, val, n)) return current_routine def suggest_routine( request, - routine_length = 10, + max_routine_length = 2, total_difficulty_score=None, competition=True, logic=True, @@ -457,7 +462,7 @@ def suggest_routine( Args: routine_length (int): nombre de sauts qui compose la série. - total_difficulty_score (int): score total de difficulté souhaité de la série. + total_difficulty_score (int): score total de difficulté souhaité de la série EN DIXIEME (/!\). competition (bool): indique si la série doit respecter les règles de compétition. logic (bool): indique si la série doit suivre les règles de logique (sportive). gymnast (gymnast): gymnaste. @@ -468,16 +473,32 @@ def suggest_routine( >>> http://127.0.0.1:8000/routine/suggest/ """ - routines = [] - routines.append(__construct_routine( - routine_length, - total_difficulty_score, - competition, - logic, - gymnast, - None - ) - ) + # routines = [] + # routines.append(__construct_routine( + # routine_length, + # total_difficulty_score, + # competition, + # logic, + # gymnast, + # None + # ) + # ) + routine = [] + # if not total_difficulty_score: + # total_difficulty_score = 15 + + difficulty_scores = range(5, 45, 5) + for total_difficulty_score in difficulty_scores: + print("===============================================================================================") + print(total_difficulty_score) + __construct_routine( + routine, + max_routine_length, + total_difficulty_score, + competition, + logic, + gymnast, + ) # print(routines)