Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -601,155 +601,90 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
 
 
         def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
-            """
-            計算使用者經驗與品種需求的匹配分數
-            
-            參數說明:
-            care_level: 品種的照顧難度 ("High", "Moderate", "Low")
-            user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
-            temperament: 品種的性格特徵描述
+            temperament_lower = temperament.lower()
             
-            返回:
-            float: 0.2-1.0 之間的匹配分數
-            """
-            # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
+            # 重新設計基礎分數，降低起始點以留出調整空間
             base_scores = {
                 "High": {
-                    "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
-                    "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
-                    "advanced": 1.0       # 資深者能完全勝任
+                    "beginner": 0.12,
+                    "intermediate": 0.45,  # 降低基礎分數
+                    "advanced": 0.60      # 降低基礎分數
                 },
                 "Moderate": {
-                    "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
-                    "intermediate": 0.82, # 中級玩家有很好的勝任能力
-                    "advanced": 1.0      # 資深者完全勝任
+                    "beginner": 0.35,
+                    "intermediate": 0.55,
+                    "advanced": 0.70
                 },
                 "Low": {
-                    "beginner": 0.72,    # 低難度品種適合新手
-                    "intermediate": 0.92, # 中級玩家幾乎完全勝任
-                    "advanced": 1.0      # 資深者完全勝任
+                    "beginner": 0.72,
+                    "intermediate": 0.65,
+                    "advanced": 0.75
                 }
             }
             
-            # 取得基礎分數
             score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            # 性格特徵評估 - 根據經驗等級調整權重
-            temperament_lower = temperament.lower()
-            temperament_adjustments = 0.0
-            
-            if user_experience == "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      # 輕微懲罰高能量
-                }
-                
-                # 新手友善的特徵 - 提供更多獎勵
-                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
-                        
-                # 品種特殊調整
-                if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
-                    temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
-                    
-            elif user_experience == "intermediate":
-                base_scores = {
-                    "High": {"intermediate": 0.65},
-                    "Moderate": {"intermediate": 0.75},
-                    "Low": {"intermediate": 0.85}
-                }
-                score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
-                
-                # 中級玩家特徵評估 - 參考 beginner 的邏輯結構
-                challenging_traits = {
-                    'stubborn': -0.10,       # 仍然需要扣分，但比 beginner 輕
-                    'independent': -0.08,    
-                    'dominant': -0.08,       
-                    'protective': -0.06,     
-                    'aggressive': -0.12,     # 仍然嚴重扣分
-                    'nervous': -0.08
+            # 計算品種複雜度分數
+            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
                 }
                 
-                positive_traits = {
-                    'intelligent': 0.06,
-                    'trainable': 0.06,
-                    'adaptable': 0.05,
-                    'calm': 0.04,
-                    'friendly': 0.04
-                }
-                
-                # 計算特徵調整
-                for trait, penalty in challenging_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += penalty
-                        
-                for trait, bonus in positive_traits.items():
-                    if trait in temperament_lower:
-                        if temperament_adjustments + bonus <= 0.12:  # 限制正面特徵累積
-                            temperament_adjustments += bonus
+                complexity = sum(value for trait, value in complexity_factors.items() 
+                                if trait in temperament_lower)
+                return min(1.0, complexity)
             
-            else:  # advanced
-                base_scores = {
-                    "High": {"advanced": 0.75},     # 降低基礎分數
-                    "Moderate": {"advanced": 0.82},
-                    "Low": {"advanced": 0.88}
-                }
-                score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
-                
-                # 即使是進階玩家也需要考慮的風險特徵
-                risk_traits = {
-                    'aggressive': -0.15,     # 最嚴重的風險特徵
-                    'nervous': -0.12,
-                    'unpredictable': -0.12,
-                    'territorial': -0.10,
-                    'dominant': -0.08,
-                    'strong-willed': -0.06
-                }
-                
-                # 進階玩家可以處理的特徵，但仍需謹慎
-                manageable_traits = {
-                    'intelligent': 0.05,
-                    'trainable': 0.04,
-                    'independent': 0.03,
-                    'protective': 0.02
-                }
-                
-                # 先計算風險特徵
-                for trait, penalty in risk_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += penalty
-                
-                # 再加上可控制特徵，但有限制
-                positive_adjustment = 0
-                for trait, bonus in manageable_traits.items():
-                    if trait in temperament_lower:
-                        positive_adjustment += bonus
-                temperament_adjustments += min(0.10, positive_adjustment)  # 限制正面特徵的總影響
+            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
             
-            # 確���最終分數在合理範圍內
-            final_score = max(0.2, min(1.0, score + temperament_adjustments))
-            return final_score
+            # 確保分數在合理範圍內
+            return max(0.2, min(0.95, final_score))
 
 
         def calculate_health_score(breed_name: str) -> float: