Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -601,58 +601,67 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
 
 
         def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
-            # 基礎分數矩陣 
+            # 首先建立基礎分數矩陣，確保不同難度和經驗等級有明顯差異
             base_scores = {
                 "High": {
-                    "beginner": 0.3,      # 高難度品種對新手較難
-                    "intermediate": 0.6,   
-                    "advanced": 0.8       # 即使是高手也要留有調整空間
+                    "beginner": 0.2,        # 高難度品種對新手極具挑戰
+                    "intermediate": 0.5,     # 中級玩家有一定掌握能力
+                    "advanced": 0.7         # 專家也需要謹慎對待
                 },
                 "Moderate": {
-                    "beginner": 0.5,
-                    "intermediate": 0.7,
-                    "advanced": 0.85
+                    "beginner": 0.4,
+                    "intermediate": 0.65,
+                    "advanced": 0.8
                 },
                 "Low": {
-                    "beginner": 0.7,
-                    "intermediate": 0.8,
-                    "advanced": 0.9
+                    "beginner": 0.6,
+                    "intermediate": 0.75,
+                    "advanced": 0.85
                 }
             }
             
+            # 獲取基礎分數
             base_score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            # 根據經驗等級有不同的特徵評估標準
-            trait_scores = {
-                "beginner": {
-                    'positive': {'friendly': 0.1, 'gentle': 0.1, 'patient': 0.08},
-                    'negative': {'aggressive': -0.2, 'stubborn': -0.15, 'dominant': -0.15}
-                },
-                "intermediate": {
-                    'positive': {'intelligent': 0.08, 'trainable': 0.08, 'adaptable': 0.06},
-                    'negative': {'aggressive': -0.15, 'stubborn': -0.1, 'dominant': -0.1}
-                },
-                "advanced": {
-                    'positive': {'intelligent': 0.06, 'independent': 0.06, 'protective': 0.05},
-                    'negative': {'aggressive': -0.1, 'nervous': -0.08, 'unpredictable': -0.08}
-                }
+            # 品種特性評估
+            temperament_lower = temperament.lower()
+            
+            # 計算品種難度係數
+            difficulty_traits = {
+                'aggressive': 0.3,
+                'dominant': 0.25,
+                'stubborn': 0.25,
+                'independent': 0.2,
+                'protective': 0.2,
+                'strong-willed': 0.15
             }
             
-            temperament_lower = temperament.lower()
-            current_traits = trait_scores[user_experience]
+            difficulty_score = sum(value for trait, value in difficulty_traits.items() 
+                                 if trait in temperament_lower)
             
-            # 計算特徵調整
-            trait_adjustment = 0
-            for trait, value in current_traits['positive'].items():
-                if trait in temperament_lower:
-                    trait_adjustment += value
-                    
-            for trait, value in current_traits['negative'].items():
-                if trait in temperament_lower:
-                    trait_adjustment += value
+            # 根據經驗等級調整難度的影響
+            experience_modifiers = {
+                "beginner": 1.2,      # 新手受難度影響最大
+                "intermediate": 0.8,   # 中級玩家受中等影響
+                "advanced": 0.5       # 專家受較小影響但仍然存在
+            }
+            
+            # 應用經驗調整
+            difficulty_impact = difficulty_score * experience_modifiers[user_experience]
+            adjusted_score = base_score * (1 - difficulty_impact)
+            
+            # 特殊品種類型的額外調整
+            breed_type_penalties = {
+                'terrier': {'beginner': -0.15, 'intermediate': -0.08, 'advanced': -0.04},
+                'working': {'beginner': -0.2, 'intermediate': -0.1, 'advanced': -0.05},
+                'guard': {'beginner': -0.25, 'intermediate': -0.12, 'advanced': -0.06}
+            }
             
-            final_score = max(0.2, min(0.95, base_score + trait_adjustment))
-            return final_score
+            for breed_type, penalties in breed_type_penalties.items():
+                if breed_type in temperament_lower:
+                    adjusted_score += penalties[user_experience]
+            
+            return max(0.2, min(0.95, adjusted_score))
 
 
         def calculate_health_score(breed_name: str) -> float:
@@ -867,68 +876,44 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
         }
         
-         # 2. 計算品種加分
-        breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-
-        # 3. 如果有孩童，計算安全分數，但不直接修改基礎分數
+        # 2. 計算品種加分
         if user_prefs.has_children:
-            family_safety = calculate_family_safety_score(breed_info, user_prefs.children_age)
-            
-            # 創建安全性調整係數
-            safety_adjustments = {
-                'toddler': 0.6,      # 對幼童最嚴格
-                'school_age': 0.75,   # 學齡兒童較寬鬆
-                'teenager': 0.85      # 青少年最寬鬆
-            }
-            
-            # 調整權重而不是直接修改分數
-            safety_weight = safety_adjustments[user_prefs.children_age]
-            
-            # 修改最終加權計算方式
+            scores['family_safety'] = calculate_family_safety_score(breed_info, user_prefs.children_age)
             weights = {
-                'space': 0.22,      
-                'exercise': 0.15,   
-                'grooming': 0.10,   
-                'experience': 0.18, 
-                'health': 0.10,     
-                'noise': 0.05
+                'space': 0.22,
+                'exercise': 0.15,
+                'grooming': 0.10,
+                'experience': 0.20,
+                'health': 0.10,
+                'noise': 0.08,
+                'family_safety': 0.15
             }
-            
-            # 加入安全性權重
-            final_score = (
-                sum(score * weights[category] for category, score in scores.items()) * safety_weight +
-                family_safety * (1 - safety_weight)
-            )
-            
-            # 品種加分也要考慮安全性
-            breed_bonus *= family_safety
-            
         else:
-            # 原有的權重
             weights = {
-                'space': 0.28,      
-                'exercise': 0.18,   
-                'grooming': 0.12,   
-                'experience': 0.22, 
-                'health': 0.12,     
-                'noise': 0.08      
+                'space': 0.28,
+                'exercise': 0.18,
+                'grooming': 0.12,
+                'experience': 0.22,
+                'health': 0.12,
+                'noise': 0.08
             }
-            final_score = sum(score * weights[category] for category, score in scores.items())
 
-        # 4. 應用品種加分
-        final_score *= (1 + breed_bonus * 0.2)
+        # 3. 計算加權分數
+        weighted_score = sum(score * weights[category] for category, score in scores.items())
+
+        # 4. 加入品種加分影響（限制在合理範圍內）
+        breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+        final_score = weighted_score * (1 + breed_bonus * 0.2)
 
         # 5. 最終分數調整
         def amplify_score(score):
-            adjusted = (score - 0.25) * 1.8
-            amplified = pow(adjusted, 2.2) / 3.5 + score
-            if amplified > 0.85:
-                amplified = 0.85 + (amplified - 0.85) * 0.6
+            adjusted = (score - 0.3) * 1.6
+            amplified = pow(adjusted, 2.5) / 4.0 + score
             return max(0.45, min(0.95, amplified))
 
         final_score = amplify_score(final_score)
-
-        # 6. 回傳結果
+        
+        # 6. 整理回傳結果
         scores = {k: round(v, 4) for k, v in scores.items()}
         scores['overall'] = round(final_score, 4)