core/difficulty/evaluator.py - main - sususer/ColonyGEN

core/difficulty/evaluator.py
104 строки4 KB
Chekr
f11
03 июн 2026, 13:53
03 июн 2026, 13:53d260831
from core.difficulty.metrics import MapMetrics
from core.difficulty.pathfinding import PathfindingAnalyzer

class DifficultyEvaluator:
    def __init__(self, game_state):
        self.state = game_state
        self.map = game_state.map

        self.metrics = MapMetrics(self.map)
        self.path = PathfindingAnalyzer(game_state)

    def evaluate(self):
        terrain = self.metrics.terrain_distribution()
        res = self.metrics.resource_stats()
        resource_access = self.metrics.resource_accessibility()
        fragmentation = self.metrics.walkable_fragmentation()
        layer_stats = self.metrics.layer_stats()

        avg_dist = self.metrics.avg_distance_to_base_resources()
        avg_cluster_dist = self.metrics.avg_distance_to_base_resource_clusters()
        reach = self.metrics.reachable_area_from_base()
        bridgeable_water_ratio = self.metrics.bridgeable_water_ratio()

        bottleneck = self.path.bottleneck_score()

        vector = {
            "mountain_ratio": terrain["mountain"],
            "water_ratio": terrain["water"],
            "forest_ratio": terrain["forest"],
            "sand_ratio": terrain["sand"],
            "plain_ratio": terrain["plain"],

            "resource_density": res["resource_density"],
            "resource_amount_density": res["resource_amount_density"],
            "resource_amount_ratio": res["resource_amount_ratio"],
            "avg_cluster_size": res["avg_cluster_size"],
            "resource_cluster_count": res["clusters"],
            "reachable_resource_ratio": resource_access["reachable_resource_ratio"],
            "reachable_resource_amount_ratio": resource_access["reachable_resource_amount_ratio"],
            "avg_reachable_resource_distance": resource_access["avg_reachable_resource_distance"],

            "avg_distance_to_resources": avg_dist,
            "avg_distance_to_resource_clusters": avg_cluster_dist,
            "reachable_area_ratio": reach,
            "walkable_component_count": fragmentation["walkable_component_count"],
            "largest_walkable_component_ratio": fragmentation["largest_walkable_component_ratio"],
            "bridgeable_water_ratio": bridgeable_water_ratio,

            "bottleneck": bottleneck,
            "terrain_entropy": self.metrics.terrain_entropy(),
            "biome_entropy": self.metrics.biome_entropy(),
            "axis_artifact_score": self.metrics.axis_artifact_score(),
            "elevation_std": layer_stats["elevation_std"],
            "moisture_std": layer_stats["moisture_std"],
            "fertility_std": layer_stats["fertility_std"],
            "hazard_std": layer_stats["hazard_std"]
        }

        score = self._compute_score(vector)

        return {
            "vector": vector,
            "difficulty_score": score,
            "difficulty_class": self._classify(score)
        }

    def _compute_score(self, v):
        score = 0

        score += v["water_ratio"] * (8 + (1 - v["bridgeable_water_ratio"]) * 22)
        score += v["mountain_ratio"] * 16
        score += v["sand_ratio"] * 4

        score += (1 - min(1.4, v["resource_amount_ratio"])) * 26
        score += (1 - min(1.0, v["resource_density"] / 0.04)) * 10
        score += (1 / max(1, v["avg_cluster_size"])) * 6
        score += (1 - v["reachable_resource_ratio"]) * 16
        score += (1 - v["reachable_resource_amount_ratio"]) * 28

        score += v["avg_reachable_resource_distance"] * 0.28
        # Cluster distance matters more than individual tile distance for gameplay
        score += v["avg_distance_to_resource_clusters"] * 0.45
        score += (1 - v["reachable_area_ratio"]) * 26
        score += (1 - v["largest_walkable_component_ratio"]) * 24
        score += min(v["walkable_component_count"], 12) * 1.0

        score += v["bottleneck"] * 30
        score += v["axis_artifact_score"] * 25
        score -= v["terrain_entropy"] * 4
        score -= v["biome_entropy"] * 3

        return max(0, min(100, score))

    def _classify(self, score):
        if score < 35:
            return "EASY"

        if score < 55:
            return "NORMAL"

        if score < 75:
            return "HARD"

        return "EXTREME"