`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)
++        # Update ranks after sorting
--        return Response(serializer.data)
++        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()
++        })