`5b10e6b`

backend leaderboard things

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 10 months ago

SHA: 5b10e6b52205b88342c49f10f8d081d45267b2cb
Parents: 3bc2376
Tree: 4913b7a

2 changed files

Status	File	+	-
M	`backend/apps/trees/models.py`	13	2
M	`backend/apps/trees/views.py`	103	11

backend/apps/trees/models.pymodified

      def __str__(self):
          return f"{self.name} - {'Completed' if self.is_completed else 'Active'}"
 +    def complete_game(self):
 +        """Mark the game as completed and record completion time"""
 +        if not self.is_completed:
 +            self.is_completed = True
 +            self.completed_at = timezone.now()
 +            self.save()
 +            return True
 +        return False
++
      def generate_tree(self, max_depth=5, directories_per_level=3):
          """Generate a procedural Unix filesystem tree"""
          if self.seed == 0:
      def resolve_path(self, path):
          """Resolve a path that may contain ~ or be relative"""
 +        # Strip trailing slashes first (except for root)
          if path.endswith('/') and path != '/':
              path = path.rstrip('/')
+-
++
          if path == "~":
              return self.home_directory
          elif path.startswith("~/"):
      def normalize_path(self, path):
          """Normalize a path by resolving .. and . components"""
 +        # Strip trailing slashes first (except for root)
          if path.endswith('/') and path != '/':
              path = path.rstrip('/')
+-
++
          parts = path.split('/')
          resolved = []

backend/apps/trees/views.pymodified

  # apps/trees/views.py
  from django.http import HttpResponse
 +from django.db import models
  from rest_framework import viewsets, status
  from rest_framework.decorators import action
  from rest_framework.response import Response
                      "command": "score",
                      "description": "Show current score and moles killed",
                      "examples": ["score"]
 +                },
 +                {
 +                    "command": "exit",
 +                    "description": "End the game and save your score",
 +                    "examples": ["exit"]
+                 }
              ],
              "special_paths": [
                  response_data.update({
                      'mole_escaped': True,
                      'escape_data': escape_data,
 -                    'mole_direction': mole_direction,  # Add this line
 +                    'mole_direction': mole_direction,
                      'message': f"The mole escaped from {escape_data['old_location']}! A new mole appeared!"
                  })
                          session.save()
                      except GameSession.DoesNotExist:
                          pass
+-
 -                response_data.update({
 -                    'mole_escaped': True,
 -                    'escape_data': escape_data,
 -                    'message': f"The mole escaped from {escape_data['old_location']}! A new mole appeared!"
 -                })
          return Response(response_data)
                  response_data['output'] = "No active session to score."
              response_data['success'] = True
 +        elif cmd == 'exit':
 +            # Complete the game
 +            tree.complete_game()
++
 +            # Complete the session if it exists
 +            if session:
 +                session.completed_at = timezone.now()
 +                session.time_taken = session.completed_at - session.started_at
 +                session.save()
++
 +                response_data['output'] = f"Game Over! Final score: {session.calculate_score()} | Moles killed: {session.moles_killed}"
 +                response_data['score'] = session.calculate_score()
 +                response_data['game_completed'] = True
 +                response_data['session_completed'] = True
 +                response_data['final_stats'] = {
 +                    'score': session.calculate_score(),
 +                    'moles_killed': session.moles_killed,
 +                    'moles_escaped': session.moles_escaped,
 +                    'commands_used': session.commands_used,
 +                    'time_taken': str(session.time_taken),
 +                    'directories_visited': session.directories_visited
 +                }
 +            else:
 +                response_data['output'] = "Game ended. No session to record."
 +                response_data['game_completed'] = True
++
 +            response_data['success'] = True
++
          elif cmd == 'help':
              response_data['output'] = """Available commands:
  cd <directory>    - Change directory (supports ~, -, and ..)
  tree [-L depth]   - Display directory tree (use -L to limit depth)
  killall moles     - Eliminate moles (when in the same directory)
  score             - Show current score and moles killed
 +exit              - End the game and save your score
  help              - Show this help message
  Special paths:
      queryset = GameSession.objects.all()
      serializer_class = GameSessionSerializer
 +    @action(detail=False, methods=['post'])
 +    def save_player_name(self, request):
 +        """Save player name for a completed session"""
 +        session_id = request.data.get('session_id')
 +        player_name = request.data.get('player_name', 'Anonymous')
++
 +        if not session_id:
 +            return Response(
 +                {'error': 'No session ID provided'},
 +                status=status.HTTP_400_BAD_REQUEST
 +            )
++
 +        try:
 +            session = GameSession.objects.get(id=session_id)
 +            session.player_name = player_name
 +            session.save()
++
 +            # Get leaderboard position
 +            better_scores = GameSession.objects.filter(
 +                completed_at__isnull=False
 +            ).exclude(id=session_id).annotate(
 +                score=models.F('moles_killed') * 1000  # Simplified score calculation
 +            ).filter(score__gt=session.calculate_score()).count()
++
 +            return Response({
 +                'success': True,
 +                'player_name': player_name,
 +                'score': session.calculate_score(),
 +                'leaderboard_position': better_scores + 1
 +            })
 +        except GameSession.DoesNotExist:
 +            return Response(
 +                {'error': 'Session not found'},
 +                status=status.HTTP_404_NOT_FOUND
 +            )
++
      @action(detail=False, methods=['get'])
      def leaderboard(self, request):
 -        """Get the leaderboard of fastest completions"""
 +        """Get the leaderboard of top scores"""
 +        # Get top 10 completed sessions
          completed_sessions = GameSession.objects.filter(
              completed_at__isnull=False
 -        ).order_by('time_taken', 'commands_used')[:20]
 +        )[:20]  # Get more than 10 to handle sorting by score
++
 +        leaderboard_data = []
 +        for session in completed_sessions:
 +            score = session.calculate_score()
 +            leaderboard_data.append({
 +                'rank': 0,  # Will be set after sorting
 +                'player_name': session.player_name,
 +                'score': score,
 +                'moles_killed': session.moles_killed,
 +                'moles_escaped': session.moles_escaped,
 +                'commands_used': session.commands_used,
 +                'time_taken': str(session.time_taken) if session.time_taken else 'N/A',
 +                'completed_at': session.completed_at
 +            })
++
 +        # Sort by score (highest first)
 +        leaderboard_data.sort(key=lambda x: x['score'], reverse=True)
++
 +        # Keep only top 10
 +        leaderboard_data = leaderboard_data[:10]
 -        serializer = self.get_serializer(completed_sessions, many=True)
 -        return Response(serializer.data)
 +        # Update ranks after sorting
 +        for i, entry in enumerate(leaderboard_data, 1):
 +            entry['rank'] = i
++
 +        return Response({
 +            'leaderboard': leaderboard_data,
 +            'total_games': GameSession.objects.filter(completed_at__isnull=False).count()
 +        })