`5f22d92`

backend progression, timer, api

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

SHA: 5f22d926796ab399b9dc36a58fa8e3ffacb1fc7d
Parents: 6ea57e5
Tree: 9bd94fd

3 changed files

Status	File	+	-
A	`backend/apps/trees/migrations/0006_filesystemtree_current_mole_timer_and_more.py`	53	0
M	`backend/apps/trees/models.py`	143	12
M	`backend/apps/trees/views.py`	136	5

backend/apps/trees/migrations/0006_filesystemtree_current_mole_timer_and_more.pyadded

 +# Generated by Django 5.2.3 on 2025-06-16 02:57
++
 +from django.db import migrations, models
++
++
 +class Migration(migrations.Migration):
++
 +    dependencies = [
 +        ("trees", "0005_filesystemtree_moles_killed_and_more"),
 +    ]
++
 +    operations = [
 +        migrations.AddField(
 +            model_name="filesystemtree",
 +            name="current_mole_timer",
 +            field=models.IntegerField(default=60),
 +        ),
 +        migrations.AddField(
 +            model_name="filesystemtree",
 +            name="default_mole_timer",
 +            field=models.IntegerField(default=60),
 +        ),
 +        migrations.AddField(
 +            model_name="filesystemtree",
 +            name="mole_spawned_at",
 +            field=models.DateTimeField(blank=True, null=True),
 +        ),
 +        migrations.AddField(
 +            model_name="filesystemtree",
 +            name="timer_expired_count",
 +            field=models.IntegerField(default=0),
 +        ),
 +        migrations.AddField(
 +            model_name="filesystemtree",
 +            name="timer_paused",
 +            field=models.BooleanField(default=False),
 +        ),
 +        migrations.AddField(
 +            model_name="gamesession",
 +            name="average_kill_time",
 +            field=models.FloatField(blank=True, null=True),
 +        ),
 +        migrations.AddField(
 +            model_name="gamesession",
 +            name="fastest_kill_time",
 +            field=models.FloatField(blank=True, null=True),
 +        ),
 +        migrations.AddField(
 +            model_name="gamesession",
 +            name="moles_escaped",
 +            field=models.IntegerField(default=0),
 +        ),
 +    ]

backend/apps/trees/models.pymodified

      total_commands = models.IntegerField(default=0)
      total_directories_visited = models.IntegerField(default=0)
 +    # Timer configuration
 +    default_mole_timer = models.IntegerField(default=60)  # seconds (will be calculated dynamically)
 +    current_mole_timer = models.IntegerField(default=60)  # seconds remaining
++
 +    # Mole spawn timestamp
 +    mole_spawned_at = models.DateTimeField(null=True, blank=True)
++
 +    # Timer state
 +    timer_paused = models.BooleanField(default=False)
 +    timer_expired_count = models.IntegerField(default=0)  # Track escapes
++
      # Cached tree structure
      tree_data = models.JSONField(null=True, blank=True)
              mole_dir = random.choice(candidates)
              self.mole_location = mole_dir.path
 +            # Calculate initial timer based on starting position
 +            timer, reason, distance = self.calculate_mole_timer(
 +                self.mole_location,
 +                self.player_location if self.player_location else "/home"
 +            )
++
 +            # Set initial timer
 +            self.mole_spawned_at = timezone.now()
 +            self.default_mole_timer = timer
 +            self.current_mole_timer = timer
++
 +    def calculate_mole_timer(self, mole_path, player_path):
 +        """Calculate timer based on distance between player and mole"""
 +        distance = self.calculate_path_distance(player_path, mole_path)
++
 +        # Base timer values based on distance - MORE AGGRESSIVE
 +        if distance <= 1:
 +            base_timer = 10  # Was 20 - Adjacent mole needs quick action!
 +            timer_reason = "nearby"
 +        elif distance <= 3:
 +            base_timer = 20  # Was 30 - Still close, needs urgency
 +            timer_reason = "close"
 +        elif distance <= 5:
 +            base_timer = 35  # Was 45 - Moderate distance
 +            timer_reason = "moderate distance"
 +        else:
 +            base_timer = 50  # Was 60 - Far away
 +            timer_reason = "far away"
++
 +        # Apply difficulty progression (10% reduction per 5 moles, capped at 50% reduction)
 +        difficulty_multiplier = 1.0
 +        if self.moles_killed >= 5:
 +            # Calculate 10% reduction per 5 moles
 +            reductions = min(self.moles_killed // 5, 5)  # Cap at 5 reductions (50%)
 +            difficulty_multiplier = 1.0 - (0.1 * reductions)
++
 +        # Calculate final timer
 +        final_timer = int(base_timer * difficulty_multiplier)
++
 +        # Ensure minimum timer of 10 seconds
 +        final_timer = max(final_timer, 10)
++
 +        return final_timer, timer_reason, distance
++
      def spawn_new_mole(self):
 -        """Spawn a new mole after the current one is killed"""
 +        """Spawn a new mole after the current one is killed or escapes"""
          # Get all possible spawn locations (any directory)
          all_directories = DirectoryNode.objects.filter(tree=self).exclude(path="/")
              new_mole_dir = random.choice(all_directories)
              self.mole_location = new_mole_dir.path
 +            # Calculate smart timer based on distance
 +            timer, reason, distance = self.calculate_mole_timer(
 +                self.mole_location,
 +                self.player_location
 +            )
++
 +            # Set timer for new mole
 +            self.mole_spawned_at = timezone.now()
 +            self.default_mole_timer = timer
 +            self.current_mole_timer = timer
 +            self.timer_paused = False
++
              # Update the cached tree data
              self.cache_tree()
              self.save()
 -            return True
 -        return False
 +            return True, timer, reason, distance
 +        return False, None, None, None
++
 +    def check_mole_timer(self):
 +        """Check if mole timer has expired"""
 +        if not self.mole_spawned_at or self.timer_paused:
 +            return False, self.current_mole_timer
++
 +        elapsed = (timezone.now() - self.mole_spawned_at).total_seconds()
 +        remaining = max(0, self.default_mole_timer - elapsed)
++
 +        if remaining <= 0:
 +            # Mole escaped!
 +            return True, 0
++
 +        return False, int(remaining)
++
 +    def handle_mole_escape(self):
 +        """Handle when a mole escapes due to timer expiration"""
 +        self.timer_expired_count += 1
 +        old_location = self.mole_location
++
 +        # Spawn new mole
 +        success, timer, reason, distance = self.spawn_new_mole()
 +        if success:
 +            return {
 +                'escaped': True,
 +                'old_location': old_location,
 +                'new_location': self.mole_location,
 +                'total_escapes': self.timer_expired_count,
 +                'new_timer': timer,
 +                'timer_reason': reason,
 +                'distance': distance
 +            }
 +        return None
      def get_mole_direction(self):
          """Get the relative direction from player to mole in the tree structure"""
      time_taken = models.DurationField(null=True, blank=True)
      moles_killed = models.IntegerField(default=0)
 +    # Timer stats
 +    moles_escaped = models.IntegerField(default=0)
 +    fastest_kill_time = models.FloatField(null=True, blank=True)  # seconds
 +    average_kill_time = models.FloatField(null=True, blank=True)  # seconds
++
      # Per-mole tracking
      mole_stats = models.JSONField(default=list)  # List of {mole_number, location, commands, time, distance}
          self.save()
      def record_mole_kill(self, mole_location, commands_for_mole, time_for_mole, distance_traveled):
 -        """Record statistics for a mole kill"""
 +        """Updated to track timer performance"""
 +        # Calculate actual time to kill (not total session time)
 +        if self.tree.mole_spawned_at:
 +            actual_kill_time = (timezone.now() - self.tree.mole_spawned_at).total_seconds()
++
 +            # Update fastest time
 +            if self.fastest_kill_time is None or actual_kill_time < self.fastest_kill_time:
 +                self.fastest_kill_time = actual_kill_time
++
 +            # Update average (simple running average)
 +            if self.average_kill_time is None:
 +                self.average_kill_time = actual_kill_time
 +            else:
 +                total_kills = self.moles_killed + 1
 +                self.average_kill_time = (
 +                    (self.average_kill_time * self.moles_killed + actual_kill_time)
 +                    / total_kills
 +                )
++
          self.moles_killed += 1
          self.mole_stats.append({
              'mole_number': self.moles_killed,
          self.save()
      def calculate_score(self):
 -        """Calculate a score based on performance"""
 +        """Updated scoring with timer bonuses"""
          if self.moles_killed == 0:
              return 0
 -        # Base score per mole
          base_score = 1000
 +        score = self.moles_killed * base_score
          # Calculate average performance
          total_commands = sum(stat['commands'] for stat in self.mole_stats)
          avg_commands = total_commands / self.moles_killed if self.moles_killed > 0 else 0
 -        # Score formula (rough draft)
 -        # More moles = better
 -        # Fewer commands = better
 -        # Less time = better (when we implement timing)
 -        score = self.moles_killed * base_score
+-
          # Efficiency bonus (fewer commands is better)
          if avg_commands > 0:
              efficiency_multiplier = max(0.5, min(2.0, 10 / avg_commands))
              score *= efficiency_multiplier
 +        # Timer bonus - faster kills = more points
 +        if self.average_kill_time and self.tree.default_mole_timer:
 +            # Bonus for beating the timer by a good margin
 +            time_ratio = self.average_kill_time / self.tree.default_mole_timer
 +            if time_ratio < 0.5:  # Killed in less than half the time
 +                score *= 1.5
 +            elif time_ratio < 0.75:  # Killed in less than 3/4 time
 +                score *= 1.25
++
 +        # Penalty for escapes
 +        if self.moles_escaped > 0:
 +            escape_penalty = 0.9 ** self.moles_escaped  # 10% penalty per escape
 +            score *= escape_penalty
++
          return int(score)

backend/apps/trees/views.pymodified

          tree = FileSystemTree.objects.create(name=tree_name)
          tree.generate_tree(max_depth=max_depth, directories_per_level=dirs_per_level)
 +        # Get initial timer info
 +        initial_timer = tree.default_mole_timer
 +        timer_distance = tree.calculate_path_distance(tree.player_location, tree.mole_location)
++
 +        # Determine timer reason
 +        if timer_distance <= 1:
 +            timer_reason = "nearby"
 +        elif timer_distance <= 3:
 +            timer_reason = "close"
 +        elif timer_distance <= 5:
 +            timer_reason = "moderate distance"
 +        else:
 +            timer_reason = "far away"
++
          # Create game session
          player_name = request.data.get('player_name', 'Anonymous')
          session = GameSession.objects.create(
              'tree': serializer.data,
              'session_id': session.id,
              'mole_hint': f"The mole is hiding somewhere in the filesystem!",
 -            'home_directory': tree.home_directory
 +            'home_directory': tree.home_directory,
 +            'initial_timer': initial_timer,
 +            'timer_reason': timer_reason,
 +            'timer_distance': timer_distance
          }, status=status.HTTP_201_CREATED)
      @action(detail=True, methods=['get'])
                  status=status.HTTP_404_NOT_FOUND
+             )
 +    @action(detail=True, methods=['get'])
 +    def check_timer(self, request, pk=None):
 +        """Check the current mole timer status"""
 +        tree = self.get_object()
++
 +        # Check if timer expired
 +        expired, remaining = tree.check_mole_timer()
++
 +        response_data = {
 +            'timer_remaining': remaining,
 +            'timer_expired': expired,
 +            'mole_location': tree.mole_location,
 +            'timer_paused': tree.timer_paused
 +        }
++
 +        # Handle escape if timer expired
 +        if expired:
 +            escape_data = tree.handle_mole_escape()
 +            if escape_data:
++
 +                mole_direction = tree.get_mole_direction()
++
 +                escape_data['mole_direction'] = mole_direction
++
 +                response_data.update({
 +                    'mole_escaped': True,
 +                    'escape_data': escape_data,
 +                    'mole_direction': mole_direction,  # Add this line
 +                    'message': f"The mole escaped from {escape_data['old_location']}! A new mole appeared!"
 +                })
++
 +                # Update session stats
 +                session_id = request.query_params.get('session_id')
 +                if session_id:
 +                    try:
 +                        session = GameSession.objects.get(id=session_id, tree=tree)
 +                        session.moles_escaped += 1
 +                        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)
++
 +    @action(detail=True, methods=['get'])
 +    def timer_status(self, request, pk=None):
 +        """Get detailed timer status for UI updates"""
 +        tree = self.get_object()
 +        expired, remaining = tree.check_mole_timer()
++
 +        # Calculate warning level
 +        warning_level = None
 +        if not expired and remaining > 0:
 +            if remaining <= 5:
 +                warning_level = 'critical'
 +            elif remaining <= 15:
 +                warning_level = 'alert'
 +            elif remaining <= 30:
 +                warning_level = 'warning'
++
 +        return Response({
 +            'remaining': remaining,
 +            'total': tree.default_mole_timer,
 +            'percentage': (remaining / tree.default_mole_timer * 100) if tree.default_mole_timer > 0 else 0,
 +            'warning_level': warning_level,
 +            'expired': expired,
 +            'paused': tree.timer_paused
 +        })
++
      @action(detail=True, methods=['post'])
      def execute_command(self, request, pk=None):
          """Execute a shell command in the game"""
              except GameSession.DoesNotExist:
                  pass
 +        # Check timer before executing command
 +        expired, remaining = tree.check_mole_timer()
++
          # Parse and execute command
          parts = command.split()
          cmd = parts[0] if parts else ""
              'current_path': tree.player_location,
              'mole_spawned': False,
              'mole_direction': None,
 -            'score': 0
 +            'score': 0,
 +            'timer_remaining': remaining,
 +            'timer_warnings': [],
 +            'new_timer': None,
 +            'timer_reason': None,
 +            'timer_distance': None
+         }
 +        # Add timer warnings to output
 +        if not expired and remaining > 0:
 +            if remaining <= 5:
 +                response_data['timer_warnings'].append({
 +                    'level': 'CRITICAL',
 +                    'message': f'Mole escaping from {tree.mole_location}! ({remaining}s remaining)'
 +                })
 +            elif remaining <= 15:
 +                response_data['timer_warnings'].append({
 +                    'level': 'ALERT',
 +                    'message': f'Mole burrowing soon! ({remaining}s remaining)'
 +                })
 +            elif remaining <= 30:
 +                response_data['timer_warnings'].append({
 +                    'level': 'WARNING',
 +                    'message': f'Mole detected at {tree.mole_location}! ({remaining}s remaining)'
 +                })
++
          if cmd == 'cd':
              if len(parts) < 2:
                  # cd with no args goes to home directory
          elif cmd == 'killall' and len(parts) > 1 and parts[1] == 'moles':
              if tree.check_win_condition():
 +                # Check if killed before timer expired
 +                expired, remaining = tree.check_mole_timer()
++
                  # Track old mole location for stats
                  old_mole_location = tree.mole_location
                      response_data['score'] = session.calculate_score()
                  # Spawn new mole
 -                if tree.spawn_new_mole():
 +                success, new_timer, timer_reason, timer_distance = tree.spawn_new_mole()
 +                if success:
                      mole_direction = tree.get_mole_direction()
 -                    response_data['output'] = f"🎉 You eliminated the mole! (Total moles killed: {tree.moles_killed})\n🐭 A new mole has appeared somewhere in the filesystem!"
 +                    # Include timer info in message
 +                    timer_msg = f"Timer: {new_timer}s (mole is {timer_reason})"
++
 +                    if not expired:
 +                        response_data['output'] = f"🎉 You eliminated the mole with {remaining}s to spare! (Total moles killed: {tree.moles_killed})\n🐭 A new mole has appeared! {timer_msg}"
 +                    else:
 +                        response_data['output'] = f"🎉 You eliminated the mole! (Total moles killed: {tree.moles_killed})\n🐭 A new mole has appeared! {timer_msg}"
++
                      response_data['success'] = True
                      response_data['mole_spawned'] = True
                      response_data['mole_direction'] = mole_direction
                      response_data['moles_killed'] = tree.moles_killed
 -                    response_data['new_mole_location'] = tree.mole_location  # Add this!
 +                    response_data['new_mole_location'] = tree.mole_location
 +                    response_data['new_timer'] = new_timer
 +                    response_data['timer_reason'] = timer_reason
 +                    response_data['timer_distance'] = timer_distance
                  else:
                      response_data['output'] = "🎉 You eliminated the mole! Unable to spawn new mole."
                      response_data['success'] = True