Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -603,88 +603,124 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
             temperament_lower = temperament.lower()
             
-            # 重新設計基礎分數，降低起始點以留出調整空間
+            # 基礎分數保持現有架構，但調整分數
             base_scores = {
                 "High": {
                     "beginner": 0.12,
-                    "intermediate": 0.45,  # 降低基礎分數
-                    "advanced": 0.60      # 降低基礎分數
+                    "intermediate": 0.55,    # 從 0.65 降低，留出更多調整空間
+                    "advanced": 0.75         # 從 1.0 降低，確保需要根據特徵調整
                 },
                 "Moderate": {
                     "beginner": 0.35,
-                    "intermediate": 0.55,
-                    "advanced": 0.70
+                    "intermediate": 0.65,    # 適當降低
+                    "advanced": 0.82         # 適當降低
                 },
                 "Low": {
                     "beginner": 0.72,
-                    "intermediate": 0.65,
-                    "advanced": 0.75
+                    "intermediate": 0.80,
+                    "advanced": 0.88         # 仍然保持較高，但有調整空間
                 }
             }
             
             score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
-            
-            # 計算品種複雜度分數
-            def calculate_complexity_score(temperament: str) -> float:
-                complexity_factors = {
-                    'aggressive': 0.3,
-                    'stubborn': 0.25,
-                    'independent': 0.2,
-                    'protective': 0.2,
-                    'dominant': 0.2,
-                    'strong-willed': 0.15,
-                    'energetic': 0.15
+            temperament_adjustments = 0.0
+        
+            if user_experience == "beginner":
+                # 保持原有的 beginner 邏輯，因為它運作良好
+                difficult_traits = {
+                    'stubborn': -0.15,
+                    'independent': -0.12,
+                    'dominant': -0.12,
+                    'strong-willed': -0.10,
+                    'protective': -0.08,
+                    'aloof': -0.08,
+                    'energetic': -0.06
                 }
                 
-                complexity = sum(value for trait, value in complexity_factors.items() 
-                                if trait in temperament_lower)
-                return min(1.0, complexity)
-            
-            complexity = calculate_complexity_score(temperament)
-            
-            # 根據經驗等級調整複雜度的影響
-            experience_multipliers = {
-                "beginner": 1.5,      # 新手受複雜度影響最大
-                "intermediate": 0.8,   # 中級玩家受中等影響
-                "advanced": 0.4       # 資深玩家受影響較小但仍然存在
-            }
-            
-            # 應用複雜度調整
-            complexity_impact = complexity * experience_multipliers[user_experience]
-            score = score * (1 - complexity_impact)
-            
-            # 特徵評估（保持動態性）
-            positive_trait_limit = {
-                "beginner": 0.1,
-                "intermediate": 0.15,
-                "advanced": 0.2
-            }
-            
-            negative_trait_impact = {
-                "beginner": 1.5,
-                "intermediate": 1.0,
-                "advanced": 0.7
-            }
-            
-            # 累積特徵影響
-            positive_impact = 0
-            negative_impact = 0
-            
-            # 計算特徵影響
-            for trait in temperament_lower.split():
-                if trait in ['gentle', 'friendly', 'patient', 'calm']:
-                    positive_impact += 0.05
-                if trait in ['aggressive', 'nervous', 'unpredictable']:
-                    negative_impact += 0.08 * negative_trait_impact[user_experience]
-            
-            # 限制正面特徵影響
-            positive_impact = min(positive_trait_limit[user_experience], positive_impact)
-            
-            # 應用特徵調整
-            final_score = score + positive_impact - negative_impact
+                easy_traits = {
+                    'gentle': 0.08,
+                    'friendly': 0.08,
+                    'eager to please': 0.08,
+                    'patient': 0.06,
+                    'adaptable': 0.06,
+                    'calm': 0.05
+                }
+                
+                for trait, penalty in difficult_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += penalty * 1.2
+                
+                for trait, bonus in easy_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += bonus
+                        
+            elif user_experience == "intermediate":
+                # 重新設計 intermediate 的評估邏輯
+                challenging_traits = {
+                    'aggressive': -0.18,     # 加重危險特徵的懲罰
+                    'stubborn': -0.12,
+                    'dominant': -0.10,
+                    'protective': -0.08,
+                    'independent': -0.08,
+                    'energetic': -0.06
+                }
+                
+                manageable_traits = {
+                    'intelligent': 0.06,
+                    'trainable': 0.06,
+                    'adaptable': 0.05,
+                    'patient': 0.04
+                }
+                
+                # 計算特徵影響
+                negative_impact = 0
+                positive_impact = 0
+                
+                for trait, penalty in challenging_traits.items():
+                    if trait in temperament_lower:
+                        negative_impact += penalty
+                
+                for trait, bonus in manageable_traits.items():
+                    if trait in temperament_lower:
+                        positive_impact += bonus
+                
+                # 限制正面特徵的累積效果
+                temperament_adjustments = negative_impact + min(0.12, positive_impact)
+                
+            else:  # advanced
+                # 重新設計 advanced 的評估邏輯
+                risk_traits = {
+                    'aggressive': -0.15,     # 即使是 advanced 也要懲罰危險特徵
+                    'nervous': -0.12,
+                    'unpredictable': -0.12,
+                    'territorial': -0.10
+                }
+                
+                skill_traits = {
+                    'intelligent': 0.04,
+                    'trainable': 0.04,
+                    'independent': 0.03,
+                    'protective': 0.03
+                }
+                
+                # 分開計算正面和負面影響
+                negative_impact = 0
+                positive_impact = 0
+                
+                for trait, penalty in risk_traits.items():
+                    if trait in temperament_lower:
+                        negative_impact += penalty
+                
+                for trait, bonus in skill_traits.items():
+                    if trait in temperament_lower:
+                        positive_impact += bonus
+                
+                # 更嚴格地限制調整範圍
+                temperament_adjustments = negative_impact + min(0.10, positive_impact)
             
-            # 確保分數在合理範圍內
-            return max(0.2, min(0.95, final_score))
+            # 確保最終分數在合理範圍內
+            final_score = max(0.2, min(0.95, score + temperament_adjustments))
+            return final_score
 
 
         def calculate_health_score(breed_name: str) -> float: