Weapon updates, now the equipped weapons stay with the characters into the battleScene

Assets/Resources/Items/Miscellaneous/HealthPotion.asset

@@ -1,47 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 43b6eb6d169fa44439fbdc878d83e78b, type: 3}
-  m_Name: HealthPotion
-  m_EditorClassIdentifier: 
-  itemName: Health Potion
-  description: A red liquid that restores vitality when consumed.
-  icon: {fileID: 0}
-  model3D: {fileID: 0}
-  itemType: 3
-  rarity: 0
-  goldCost: 3
-  silverCost: 0
-  copperCost: 0
-  searchTags:
-  - potion
-  - health
-  - healing
-  - consumable
-  - red
-  isConsumable: 1
-  isStackable: 1
-  maxStackSize: 10
-  healthRestoreMin: 0
-  healthRestoreMax: 0
-  healthDiceCount: 1
-  healthDiceType: 6
-  healthBonus: 1
-  manaRestoreMin: 0
-  manaRestoreMax: 0
-  manaDiceCount: 0
-  manaDiceType: 4
-  manaBonus: 0
-  temporaryStrengthBonus: 0
-  temporaryDexterityBonus: 0
-  temporaryConstitutionBonus: 0
-  temporaryWisdomBonus: 0
-  effectDuration: 0

Assets/Resources/Items/Miscellaneous/HempRope.asset

@@ -1,47 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 43b6eb6d169fa44439fbdc878d83e78b, type: 3}
-  m_Name: HempRope
-  m_EditorClassIdentifier: 
-  itemName: Hemp Rope
-  description: 50 feet of sturdy rope. Essential for any adventurer.
-  icon: {fileID: 0}
-  model3D: {fileID: 0}
-  itemType: 4
-  rarity: 0
-  goldCost: 0
-  silverCost: 8
-  copperCost: 0
-  searchTags:
-  - rope
-  - hemp
-  - utility
-  - tool
-  - climbing
-  isConsumable: 0
-  isStackable: 0
-  maxStackSize: 99
-  healthRestoreMin: 0
-  healthRestoreMax: 0
-  healthDiceCount: 0
-  healthDiceType: 6
-  healthBonus: 0
-  manaRestoreMin: 0
-  manaRestoreMax: 0
-  manaDiceCount: 0
-  manaDiceType: 4
-  manaBonus: 0
-  temporaryStrengthBonus: 0
-  temporaryDexterityBonus: 0
-  temporaryConstitutionBonus: 0
-  temporaryWisdomBonus: 0
-  effectDuration: 0

Assets/Resources/Items/Miscellaneous/ManaPotion.asset

@@ -1,47 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 43b6eb6d169fa44439fbdc878d83e78b, type: 3}
-  m_Name: ManaPotion
-  m_EditorClassIdentifier: 
-  itemName: Mana Potion
-  description: A blue liquid that restores magical energy.
-  icon: {fileID: 0}
-  model3D: {fileID: 0}
-  itemType: 3
-  rarity: 0
-  goldCost: 4
-  silverCost: 0
-  copperCost: 0
-  searchTags:
-  - potion
-  - mana
-  - magic
-  - consumable
-  - blue
-  isConsumable: 1
-  isStackable: 1
-  maxStackSize: 10
-  healthRestoreMin: 0
-  healthRestoreMax: 0
-  healthDiceCount: 0
-  healthDiceType: 6
-  healthBonus: 0
-  manaRestoreMin: 0
-  manaRestoreMax: 0
-  manaDiceCount: 1
-  manaDiceType: 4
-  manaBonus: 0
-  temporaryStrengthBonus: 0
-  temporaryDexterityBonus: 0
-  temporaryConstitutionBonus: 0
-  temporaryWisdomBonus: 0
-  effectDuration: 0

Assets/Scripts/Objects/Weapons/Club.asset → Assets/Resources/Items/Weapons/Club.asset

@@ -27,7 +27,7 @@ MonoBehaviour:
   range: 0
   weaponModifier: 0
   attackSpeed: 2
-  weaponType: 0
+  weaponType: 9
   weaponClassName: 
   weaponPrefab: {fileID: 0}
   arrowPrefab: {fileID: 0}

Assets/Scripts/Objects/Weapons/Dagger.asset → Assets/Resources/Items/Weapons/Dagger.asset

@@ -28,7 +28,7 @@ MonoBehaviour:
   range: 0
   weaponModifier: 0
   attackSpeed: 0.5
-  weaponType: 3
+  weaponType: 4
   weaponClassName: 
   weaponPrefab: {fileID: 0}
   arrowPrefab: {fileID: 0}

Assets/Resources/Items/Weapons/IronSword.asset

@@ -33,7 +33,7 @@ MonoBehaviour:
   range: 5
   weaponModifier: 1
   attackSpeed: 1
-  weaponType: 0
+  weaponType: 1
   weaponClassName: SimpleSword
   weaponPrefab: {fileID: 0}
   arrowPrefab: {fileID: 0}

Assets/Resources/Items/Weapons/SimpleBow.asset

@@ -12,27 +12,22 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 3f3fc2d34ad47104ea60fdf8fa56b9e6, type: 3}
   m_Name: SimpleBow
   m_EditorClassIdentifier: 
-  itemName: Simple Bow
-  description: A basic wooden bow with decent range. Perfect for hunting small game.
+  itemName: Basic Bow
+  description: A Simple wooden bow
   icon: {fileID: 0}
-  model3D: {fileID: 0}
+  model3D: {fileID: 5410050047777400374, guid: e0447dc7b412ede4b9090f9a3cf4fdd4, type: 3}
   itemType: 0
   rarity: 0
   goldCost: 15
   silverCost: 0
   copperCost: 0
-  searchTags:
-  - bow
-  - ranged
-  - arrow
-  - hunting
-  - wood
+  searchTags: []
   minDamage: 1
-  maxDamage: 4
-  range: 150
+  maxDamage: 6
+  range: 100
   weaponModifier: 0
-  attackSpeed: 0.8
-  weaponType: 1
-  weaponClassName: SimpleBow
+  attackSpeed: 2
+  weaponType: 2
+  weaponClassName: 
   weaponPrefab: {fileID: 0}
-  arrowPrefab: {fileID: 0}
+  arrowPrefab: {fileID: 6456274890147168025, guid: 74d688b6c70543e46a9b3ea3c4c8e787, type: 3}

Assets/Resources/Items/Weapons/SimpleSword.asset

@@ -12,10 +12,10 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 3f3fc2d34ad47104ea60fdf8fa56b9e6, type: 3}
   m_Name: SimpleSword
   m_EditorClassIdentifier: 
-  itemName: Simple Sword
-  description: A basic sword perfect for beginners. Light and easy to handle.
+  itemName: Basic Sword
+  description: A common simple sword
   icon: {fileID: 0}
-  model3D: {fileID: 0}
+  model3D: {fileID: 5410050047777400374, guid: 2e07955f8c531dc4ea65c9d6a521f306, type: 3}
   itemType: 0
   rarity: 0
   goldCost: 10
@@ -23,16 +23,12 @@ MonoBehaviour:
   copperCost: 0
   searchTags:
   - sword
-  - melee
-  - blade
-  - basic
-  - one-handed
   minDamage: 1
   maxDamage: 6
-  range: 5
+  range: 0
   weaponModifier: 0
   attackSpeed: 1
-  weaponType: 0
-  weaponClassName: SimpleSword
+  weaponType: 1
+  weaponClassName: 
   weaponPrefab: {fileID: 0}
   arrowPrefab: {fileID: 0}

Assets/Scenes/BattleScene.unity

@@ -119,6 +119,56 @@ NavMeshSettings:
     debug:
       m_Flags: 0
   m_NavMeshData: {fileID: 0}
+--- !u!1 &291472278
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 291472280}
+  - component: {fileID: 291472279}
+  m_Layer: 0
+  m_Name: BattleIntegrationSetup
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &291472279
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 291472278}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a954c9917ea5aba4d994317174682a59, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  battleSceneName: BattleScene
+  enableDebugLogs: 1
+  setupMapScene: 1
+  setupBattleScene: 1
+  createBattleContextUI: 1
+  contextTextFontSize: 18
+--- !u!4 &291472280
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 291472278}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 12.970818, y: 433.2704, z: 802.6817}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &330585543
 GameObject:
   m_ObjectHideFlags: 0
@@ -568,7 +618,8 @@ RectTransform:
   m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 0, y: 0, z: 0}
   m_ConstrainProportionsScale: 0
-  m_Children: []
+  m_Children:
+  - {fileID: 2118569126}
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
@@ -647,6 +698,7 @@ GameObject:
   m_Component:
   - component: {fileID: 754193783}
   - component: {fileID: 754193782}
+  - component: {fileID: 754193784}
   m_Layer: 0
   m_Name: BattleSetupManager
   m_TagString: Untagged
@@ -666,12 +718,6 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: be1e294acd4e3794c9f5881de5ea0530, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  playerCharacters:
-  - {fileID: 1880288660700002030, guid: 38ed18f91946ed64494b472036469aa6, type: 3}
-  - {fileID: 1880288660700002030, guid: 38ed18f91946ed64494b472036469aa6, type: 3}
-  enemyCharacters:
-  - {fileID: 1880288660700002030, guid: 99900445755b7ea45b9e778888a1023c, type: 3}
-  - {fileID: 1880288660700002030, guid: 99900445755b7ea45b9e778888a1023c, type: 3}
   groundLayerMask:
     serializedVersion: 2
     m_Bits: 256
@@ -694,6 +740,22 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &754193784
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 754193781}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a4bfbff49f49a1448852c2f92569d848, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  useEnhancedSetup: 1
+  battleContextText: {fileID: 2118569127}
+  terrainGenerator: {fileID: 0}
+  showDebugLogs: 1
 --- !u!1 &832575517
 GameObject:
   m_ObjectHideFlags: 0
@@ -1526,6 +1588,85 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2118569125
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2118569126}
+  - component: {fileID: 2118569128}
+  - component: {fileID: 2118569127}
+  m_Layer: 0
+  m_Name: BattleContextText
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &2118569126
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2118569125}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 457742904}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: -10}
+  m_SizeDelta: {x: -20, y: 90}
+  m_Pivot: {x: 0.5, y: 1}
+--- !u!114 &2118569127
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2118569125}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 18
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 1
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Battle Context Will Appear Here
+--- !u!222 &2118569128
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2118569125}
+  m_CullTransparentMesh: 1
 --- !u!1660057539 &9223372036854775807
 SceneRoots:
   m_ObjectHideFlags: 0
@@ -1543,3 +1684,4 @@ SceneRoots:
   - {fileID: 1429499005}
   - {fileID: 864824021}
   - {fileID: 865903348}
+  - {fileID: 291472280}

Assets/Scenes/MapScene2.unity

@@ -187,7 +187,7 @@ MonoBehaviour:
   explorationInitialVisible: 80
   expansionCooldown: 5
   terrainContinuityChance: 0.7
-  seed: 6668
+  seed: 6666
   mapVisualizer: {fileID: 0}
 --- !u!4 &345809425
 Transform:
@@ -355,7 +355,57 @@ MonoBehaviour:
   eventMarkerMaterial: {fileID: 0}
   eventMarkerColor: {r: 1, g: 0, b: 0, a: 1}
   maxActiveMarkers: 5
-  showSetupLogs: 1
+  showSetupLogs: 0
+--- !u!1 &731368432
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 731368434}
+  - component: {fileID: 731368433}
+  m_Layer: 0
+  m_Name: CombatIntegrationSetup
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &731368433
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 731368432}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a954c9917ea5aba4d994317174682a59, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  battleSceneName: BattleScene
+  enableDebugLogs: 1
+  setupMapScene: 1
+  setupBattleScene: 1
+  createBattleContextUI: 1
+  contextTextFontSize: 18
+--- !u!4 &731368434
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 731368432}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 12.970818, y: 433.2704, z: 802.6817}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1243674619
 GameObject:
   m_ObjectHideFlags: 0
@@ -598,6 +648,53 @@ MonoBehaviour:
   m_LightCookieSize: {x: 1, y: 1}
   m_LightCookieOffset: {x: 0, y: 0}
   m_SoftShadowQuality: 0
+--- !u!1 &1312298682
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1312298684}
+  - component: {fileID: 1312298683}
+  m_Layer: 0
+  m_Name: CombatSceneManager
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1312298683
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1312298682}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 90a1b0da6038f194b8c8bb960f5b85fb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  battleSceneName: BattleScene
+  terrainGenerator: {fileID: 0}
+  showDebugLogs: 1
+--- !u!4 &1312298684
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1312298682}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1319078984
 GameObject:
   m_ObjectHideFlags: 0
@@ -760,7 +857,7 @@ MonoBehaviour:
   baseEventChance: 0.15
   tilesPerEventCheck: 3
   availableEvents:
-  - {fileID: 11400000, guid: 3756641546a12504cbd1273f2dd7bbf3, type: 2}
+  - {fileID: 0}
   - {fileID: 11400000, guid: 7f47d27e7a16f0d4ca61a2db845dd20e, type: 2}
   showDebugLogs: 0
   forceNextEvent: 0
@@ -976,3 +1073,5 @@ SceneRoots:
   - {fileID: 1319078986}
   - {fileID: 1247461680}
   - {fileID: 684362519}
+  - {fileID: 731368434}
+  - {fileID: 1312298684}

Assets/Scripts/BattleScene/BattleSetup.cs

@@ -75,22 +75,190 @@ public class BattleSetup : MonoBehaviour
         InitiatePlayerCharacterPlacement();
     }
 
+    // Helper method to get WeaponItem from CombatDataTransfer if available
+    WeaponItem GetEnhancedWeaponItem(string characterName, bool isPlayer)
+    {
+        Debug.Log($"🔍 GetEnhancedWeaponItem called for '{characterName}', isPlayer: {isPlayer}");
+
+        if (!CombatDataTransfer.HasValidSession())
+        {
+            Debug.Log($"🔍 No valid CombatDataTransfer session");
+            return null;
+        }
+
+        var session = CombatDataTransfer.GetCurrentSession();
+        if (session == null)
+        {
+            Debug.Log($"🔍 CombatDataTransfer session is null");
+            return null;
+        }
+
+        Debug.Log($"🔍 Session has {session.playerTeam.Count} players and {session.enemies.Count} enemies");
+
+        if (isPlayer)
+        {
+            // Debug: List all available player characters
+            Debug.Log($"🔍 Available players in session:");
+            foreach (var player in session.playerTeam)
+            {
+                Debug.Log($"  - Player: '{player.characterName}', Weapon: {(player.equippedWeaponItem != null ? player.equippedWeaponItem.name : "NULL")}");
+            }
+
+            // Find player character in enhanced data (match by base name, ignoring suffixes)
+            foreach (var player in session.playerTeam)
+            {
+                if (player.characterName == characterName && player.equippedWeaponItem != null)
+                {
+                    Debug.Log($"🎯 Found enhanced WeaponItem for player {characterName}: {player.equippedWeaponItem.name}");
+                    return player.equippedWeaponItem;
+                }
+                // Also try matching without the numbered suffix (e.g., "Player 1" vs "Player")
+                if (characterName.StartsWith(player.characterName) && player.equippedWeaponItem != null)
+                {
+                    Debug.Log($"🎯 Found enhanced WeaponItem for player {characterName} (matched base name {player.characterName}): {player.equippedWeaponItem.name}");
+                    return player.equippedWeaponItem;
+                }
+            }
+
+            Debug.Log($"🔍 No matching player found for '{characterName}'");
+        }
+        else
+        {
+            // Find enemy character in enhanced data (match by base name, ignoring suffixes)
+            foreach (var enemy in session.enemies)
+            {
+                if (enemy.enemyName == characterName && enemy.preferredWeaponItem != null)
+                {
+                    Debug.Log($"🎯 Found enhanced WeaponItem for enemy {characterName}: {enemy.preferredWeaponItem.name}");
+                    return enemy.preferredWeaponItem;
+                }
+                // Also try matching the base name (e.g., "Skeleton Warrior_1" vs "Skeleton Warrior")
+                if (characterName.StartsWith(enemy.enemyType) && enemy.preferredWeaponItem != null)
+                {
+                    Debug.Log($"🎯 Found enhanced WeaponItem for enemy {characterName} (matched base type {enemy.enemyType}): {enemy.preferredWeaponItem.name}");
+                    return enemy.preferredWeaponItem;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    // Enhanced weapon equipping with WeaponItem support
+    void EquipWeapon(Character character, WeaponItem weaponItem)
+    {
+        Debug.Log($"🔧 EquipWeapon called for {character.CharacterName} with WeaponItem: {(weaponItem != null ? weaponItem.name : "null")}");
+
+        Weapon weapon = null;
+
+        if (weaponItem != null)
+        {
+            Debug.Log($"🔧 Using WeaponItem.CreateWeaponInstance() for {weaponItem.name}");
+            // Use the WeaponItem's CreateWeaponInstance method to preserve all attributes
+            weapon = weaponItem.CreateWeaponInstance(character.transform);
+            if (weapon != null)
+            {
+                weapon.SetWielder(character);
+                Debug.Log($"✅ Successfully created weapon from WeaponItem: {weapon.weaponName}");
+            }
+            else
+            {
+                Debug.LogWarning($"⚠️ WeaponItem.CreateWeaponInstance() returned null for {weaponItem.name}. Falling back to string-based creation.");
+                // Fallback to string-based weapon creation
+                EquipWeapon(character, weaponItem.weaponType.ToString());
+                return;
+            }
+        }
+        else
+        {
+            Debug.LogWarning($"No WeaponItem provided for {character.CharacterName}. Equipping with fists as fallback.");
+            EquipWeapon(character, "Fists");
+            return;
+        }
+
+        if (weapon != null)
+        {
+            // Attach weapon to the character
+            Transform attachPoint = character.transform.Find("WeaponAttachPoint");
+            if (attachPoint != null)
+            {
+                weapon.transform.SetParent(attachPoint, false);
+                weapon.transform.localPosition = Vector3.zero;
+                weapon.transform.localRotation = Quaternion.identity;
+            }
+            else
+            {
+                weapon.transform.SetParent(character.transform, false);
+                weapon.transform.localPosition = new Vector3(0.5f, 0, 0);
+            }
+
+            character.Weapon = weapon;
+            weapon.SetWielder(character);
+            Debug.Log($"✅ Successfully equipped {weapon.weaponName} to {character.CharacterName}");
+        }
+        else
+        {
+            Debug.LogError($"❌ Failed to create weapon for {character.CharacterName}");
+        }
+    }
+
+    // Fallback weapon equipping using string types (for backward compatibility)
     void EquipWeapon(Character character, string weaponType)
     {
+        Debug.Log($"🔧 EquipWeapon called for {character.CharacterName} with weaponType: '{weaponType}'");
+
         Weapon weapon = null;
+
+        // Handle null or empty weapon types
+        if (string.IsNullOrEmpty(weaponType))
+        {
+            Debug.LogWarning($"No weapon type specified for {character.CharacterName}. Equipping with fists as fallback.");
+            weaponType = "Fists";
+        }
+
+        Debug.Log($"🔧 Processing weapon type: '{weaponType}' for {character.CharacterName}");
+
         if (weaponType == "Sword")
         {
+            Debug.Log($"⚔️ Creating Sword for {character.CharacterName}");
             var weaponObj = Instantiate(SwordPrefab, character.transform);
             weapon = weaponObj.GetComponent<Weapon>();
         }
         else if (weaponType == "Bow")
         {
+            Debug.Log($"🏹 Creating Bow for {character.CharacterName}");
             var weaponObj = Instantiate(BowPrefab, character.transform);
             weapon = weaponObj.GetComponent<Weapon>();
         }
+        else if (weaponType == "Fists")
+        {
+            Debug.Log($"👊 Creating Fists for {character.CharacterName}");
+            // Create a fists weapon directly using SimpleSword as base
+            GameObject fistsObj = new GameObject("Fists");
+            fistsObj.transform.SetParent(character.transform, false);
+            SimpleSword fistsWeapon = fistsObj.AddComponent<SimpleSword>();
+
+            // Override the sword's properties to make it act like fists
+            fistsWeapon.weaponName = "Fists";
+            fistsWeapon.description = "Bare fists - a basic unarmed attack.";
+            fistsWeapon.attackSpeed = 1.0f;
+
+            weapon = fistsWeapon;
+        }
         else
         {
-            Debug.LogWarning($"Unknown weapon type: {weaponType}. No weapon equipped.");
+            Debug.LogWarning($"❓ Unknown weapon type: '{weaponType}' for {character.CharacterName}. Equipping with fists as fallback.");
+            // Create a fists weapon as fallback using SimpleSword as base
+            GameObject fistsObj = new GameObject("Fists");
+            fistsObj.transform.SetParent(character.transform, false);
+            SimpleSword fistsWeapon = fistsObj.AddComponent<SimpleSword>();
+
+            // Override the sword's properties to make it act like fists
+            fistsWeapon.weaponName = "Fists";
+            fistsWeapon.description = "Bare fists - a basic unarmed attack.";
+            fistsWeapon.attackSpeed = 1.0f;
+
+            weapon = fistsWeapon;
         }
 
         if (weapon != null)
@@ -110,6 +278,11 @@ public class BattleSetup : MonoBehaviour
 
             character.Weapon = weapon;
             weapon.SetWielder(character);
+            Debug.Log($"✅ Successfully equipped {weapon.weaponName} to {character.CharacterName}");
+        }
+        else
+        {
+            Debug.LogError($"❌ Failed to create weapon for {character.CharacterName}");
         }
     }
 
@@ -153,7 +326,22 @@ public class BattleSetup : MonoBehaviour
             var character = currentPlacingCharacterInstance.GetComponent<Character>();
             if (character != null)
             {
-                EquipWeapon(character, selection.weaponType);
+                Debug.Log($"🔍 SpawnNextPlayerCharacterForPlacement: Character '{selection.characterName}' with weapon '{selection.weaponType}'");
+
+                // Try to get enhanced weapon data first
+                WeaponItem enhancedWeapon = GetEnhancedWeaponItem(selection.characterName, true);
+                Debug.Log($"🔍 Enhanced weapon lookup for '{selection.characterName}': {(enhancedWeapon != null ? enhancedWeapon.name : "NULL")}");
+
+                if (enhancedWeapon != null)
+                {
+                    Debug.Log($"🎯 Using enhanced weapon: {enhancedWeapon.name}");
+                    EquipWeapon(character, enhancedWeapon);
+                }
+                else
+                {
+                    Debug.Log($"🔍 No enhanced weapon found, falling back to selection.weaponType: '{selection.weaponType}'");
+                    EquipWeapon(character, selection.weaponType);
+                }
                 character.CharacterName = selection.characterName + " " + (nextPlayerCharacterPrefabIndex + 1);
             }
             currentPlacingCharacterInstance.GetComponent<NavMeshAgent>().enabled = false;
@@ -386,7 +574,16 @@ public class BattleSetup : MonoBehaviour
             Character character = placedEnemy.GetComponent<Character>();
             if (character != null)
             {
-                EquipWeapon(character, selection.weaponType);
+                // Try to get enhanced weapon data first
+                WeaponItem enhancedWeapon = GetEnhancedWeaponItem(selection.characterName, false);
+                if (enhancedWeapon != null)
+                {
+                    EquipWeapon(character, enhancedWeapon);
+                }
+                else
+                {
+                    EquipWeapon(character, selection.weaponType);
+                }
                 character.CharacterName = selection.characterName + "_" + (i + 1);
             }
 

Assets/Scripts/BattleScene/EnhancedBattleSetup.cs

@@ -0,0 +1,249 @@
+using UnityEngine;
+using System.Collections.Generic;
+using UnityEngine.AI;
+
+/// <summary>
+/// Enhanced BattleSetup that works with CombatDataTransfer for richer combat initialization
+/// Extends the existing BattleSetup functionality with team data and terrain information
+/// </summary>
+public class EnhancedBattleSetup : MonoBehaviour
+{
+    [Header("Enhanced Combat Setup")]
+    [Tooltip("Enable enhanced setup using CombatDataTransfer")]
+    public bool useEnhancedSetup = true;
+
+    [Header("UI Elements")]
+    [Tooltip("UI Text to display battle context (terrain, weather, etc.)")]
+    public UnityEngine.UI.Text battleContextText;
+
+    [Header("Terrain Setup")]
+    [Tooltip("Terrain generator for setting up battle environment")]
+    public BFMTerrainGenerator terrainGenerator;
+
+    [Header("Debug")]
+    public bool showDebugLogs = true;
+
+    // Reference to original BattleSetup if needed
+    private BattleSetup originalBattleSetup;
+
+    void Start()
+    {
+        // Get reference to original BattleSetup component
+        originalBattleSetup = GetComponent<BattleSetup>();
+
+        if (useEnhancedSetup && CombatDataTransfer.HasValidSession())
+        {
+            SetupEnhancedCombat();
+        }
+        else
+        {
+            if (showDebugLogs)
+            {
+                Debug.Log("🔧 Enhanced setup disabled or no combat session - using standard BattleSetup");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Set up combat using the enhanced CombatDataTransfer system
+    /// </summary>
+    private void SetupEnhancedCombat()
+    {
+        var session = CombatDataTransfer.GetCurrentSession();
+        if (session == null)
+        {
+            Debug.LogError("❌ No combat session data available!");
+            return;
+        }
+
+        if (showDebugLogs)
+        {
+            Debug.Log("🎯 Setting up enhanced combat...");
+            CombatDataTransfer.DebugLogSession();
+        }
+
+        // Set up terrain
+        SetupBattleTerrain(session);
+
+        // Update UI with battle context
+        UpdateBattleContextUI(session);
+
+        // The original BattleSetup will handle character placement using BattleSetupData
+        // which was already populated by CombatDataTransfer.PopulateLegacyBattleSetupData()
+
+        if (showDebugLogs)
+        {
+            Debug.Log("✅ Enhanced combat setup complete");
+        }
+    }
+
+    /// <summary>
+    /// Set up the battle terrain based on combat session data
+    /// </summary>
+    private void SetupBattleTerrain(CombatDataTransfer.CombatSessionData session)
+    {
+        if (terrainGenerator == null)
+        {
+            terrainGenerator = FindFirstObjectByType<BFMTerrainGenerator>();
+        }
+
+        if (terrainGenerator != null)
+        {
+            BFMTerrainType bfmTerrain = ConvertToBFMTerrainType(session.battleTerrain);
+
+            if (showDebugLogs)
+            {
+                Debug.Log($"🌍 Setting battle terrain: {bfmTerrain} (from {session.battleTerrain})");
+            }
+
+            terrainGenerator.SetTerrainType(bfmTerrain);
+
+            // If there's a regenerate method, call it
+            // terrainGenerator.RegenerateTerrain(); // Uncomment if this method exists
+        }
+        else
+        {
+            if (showDebugLogs)
+            {
+                Debug.LogWarning("⚠️ No BFMTerrainGenerator found - terrain setup skipped");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Update UI elements with battle context information
+    /// </summary>
+    private void UpdateBattleContextUI(CombatDataTransfer.CombatSessionData session)
+    {
+        if (battleContextText != null)
+        {
+            string terrainDesc = CombatDataTransfer.GetTerrainDescription(session.battleTerrain, session.battleFeature);
+            string timeDesc = GetTimeDescription(session.timeOfDay);
+            string weatherDesc = session.weather.ToString().ToLower();
+
+            string contextDescription = $"Battle {terrainDesc}\\n{timeDesc.ToUpper()} - {weatherDesc} weather";
+            battleContextText.text = contextDescription;
+
+            if (showDebugLogs)
+            {
+                Debug.Log($"🎨 Updated battle context UI: {contextDescription}");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Convert TerrainType to BFMTerrainType
+    /// </summary>
+    private BFMTerrainType ConvertToBFMTerrainType(TerrainType terrainType)
+    {
+        return terrainType switch
+        {
+            TerrainType.Plains => BFMTerrainType.Plain,
+            TerrainType.Forest => BFMTerrainType.Forest,
+            TerrainType.Mountain => BFMTerrainType.Mountain,
+            TerrainType.ForestRiver => BFMTerrainType.Forest,
+            _ => BFMTerrainType.Plain
+        };
+    }
+
+    /// <summary>
+    /// Convert time of day to readable description
+    /// </summary>
+    private string GetTimeDescription(float timeOfDay)
+    {
+        return timeOfDay switch
+        {
+            >= 6f and < 12f => "morning",
+            >= 12f and < 18f => "afternoon",
+            >= 18f and < 22f => "evening",
+            _ => "night"
+        };
+    }
+
+    /// <summary>
+    /// Get enhanced character stats for a team member
+    /// </summary>
+    public static void ApplyEnhancedStats(GameObject characterObject, CombatDataTransfer.TeamCharacterCombatData combatData)
+    {
+        if (characterObject == null || combatData == null) return;
+
+        var character = characterObject.GetComponent<Character>();
+        if (character != null)
+        {
+            // Apply enhanced stats from combat data
+            character.CharacterName = combatData.characterName;
+
+            // Apply combat stats if the Character component supports them
+            // character.MaxHealth = combatData.maxHealth; // Uncomment if property exists
+            // character.CurrentHealth = combatData.currentHealth;
+            // character.ArmorClass = combatData.armorClass;
+
+            Debug.Log($"📊 Applied enhanced stats to {combatData.characterName}: HP={combatData.currentHealth}/{combatData.maxHealth}, AC={combatData.armorClass}");
+        }
+    }
+
+    /// <summary>
+    /// Get enhanced enemy stats for an enemy character
+    /// </summary>
+    public static void ApplyEnhancedEnemyStats(GameObject enemyObject, CombatDataTransfer.EnemyCombatData enemyData)
+    {
+        if (enemyObject == null || enemyData == null) return;
+
+        var character = enemyObject.GetComponent<Character>();
+        if (character != null)
+        {
+            character.CharacterName = enemyData.enemyName;
+
+            // Apply enhanced enemy stats
+            // character.MaxHealth = enemyData.maxHealth; // Uncomment if property exists
+            // character.CurrentHealth = enemyData.currentHealth;
+            // character.ArmorClass = enemyData.armorClass;
+
+            Debug.Log($"👹 Applied enhanced enemy stats to {enemyData.enemyName}: HP={enemyData.currentHealth}/{enemyData.maxHealth}, AC={enemyData.armorClass}, Threat={enemyData.threatLevel}");
+        }
+    }
+
+    /// <summary>
+    /// Debug method to show current combat session info
+    /// </summary>
+    [ContextMenu("Debug Combat Session")]
+    public void DebugCombatSession()
+    {
+        if (CombatDataTransfer.HasValidSession())
+        {
+            CombatDataTransfer.DebugLogSession();
+        }
+        else
+        {
+            Debug.Log("🔍 No active combat session");
+        }
+    }
+
+    /// <summary>
+    /// Method to be called when battle ends to clean up
+    /// </summary>
+    public void EndBattleSession(bool playerVictory)
+    {
+        if (showDebugLogs)
+        {
+            Debug.Log($"🏆 Battle ended - Player victory: {playerVictory}");
+        }
+
+        // Find and use CombatSceneManager to handle the end
+        var combatSceneManager = FindFirstObjectByType<MonoBehaviour>();
+        if (combatSceneManager != null && combatSceneManager.GetType().Name == "CombatSceneManager")
+        {
+            var method = combatSceneManager.GetType().GetMethod("EndCombatSession");
+            if (method != null)
+            {
+                method.Invoke(combatSceneManager, new object[] { playerVictory });
+            }
+        }
+        else
+        {
+            // Fallback: just clear the session
+            CombatDataTransfer.ClearSession();
+            Debug.Log("🧹 Combat session cleared (no CombatSceneManager found)");
+        }
+    }
+}

Assets/Scripts/BattleSetup/CombatDataTransfer.cs

@@ -0,0 +1,448 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+/// <summary>
+/// Static data transfer class for passing combat-related data between scenes
+/// Handles team data, enemy data, terrain information, and battle context
+/// </summary>
+public static class CombatDataTransfer
+{
+    [System.Serializable]
+    public class CombatSessionData
+    {
+        [Header("Battle Context")]
+        public string battleDescription = "";
+        public Vector2Int battleLocation = Vector2Int.zero;
+        public TerrainType battleTerrain = TerrainType.Plains;
+        public FeatureType battleFeature = FeatureType.None;
+
+        [Header("Team Data")]
+        public List<TeamCharacterCombatData> playerTeam = new List<TeamCharacterCombatData>();
+
+        [Header("Enemy Data")]
+        public List<EnemyCombatData> enemies = new List<EnemyCombatData>();
+
+        [Header("Environmental Settings")]
+        public Weather weather = Weather.Clear;
+        public float timeOfDay = 12f; // 0-24 hours
+
+        public CombatSessionData()
+        {
+            playerTeam = new List<TeamCharacterCombatData>();
+            enemies = new List<EnemyCombatData>();
+        }
+    }
+
+    [System.Serializable]
+    public class TeamCharacterCombatData
+    {
+        public string characterName = "";
+        public bool isMale = true;
+
+        // Core stats
+        public int strength = 10;
+        public int dexterity = 10;
+        public int constitution = 10;
+        public int wisdom = 10;
+        public int perception = 10;
+
+        // Combat stats
+        public int maxHealth = 20;
+        public int currentHealth = 20;
+        public int armorClass = 10;
+
+        // Equipment
+        public string equippedWeapon = "Sword"; // Keep for backward compatibility
+        public WeaponItem equippedWeaponItem = null; // NEW: Actual weapon item reference
+        public string equippedArmor = "";
+        public List<string> availableWeapons = new List<string>();
+        public List<string> availableArmor = new List<string>();
+
+        // Resources
+        public int gold = 25;
+        public int silver = 0;
+        public int copper = 0;
+
+        public TeamCharacterCombatData()
+        {
+            availableWeapons = new List<string>();
+            availableArmor = new List<string>();
+        }
+
+        /// <summary>
+        /// Create combat data from a TeamCharacter
+        /// </summary>
+        public static TeamCharacterCombatData FromTeamCharacter(TeamCharacter teamChar)
+        {
+            var combatData = new TeamCharacterCombatData();
+
+            if (teamChar != null)
+            {
+                combatData.characterName = teamChar.name;
+                combatData.isMale = teamChar.isMale;
+                combatData.strength = teamChar.strength;
+                combatData.dexterity = teamChar.dexterity;
+                combatData.constitution = teamChar.constitution;
+                combatData.wisdom = teamChar.wisdom;
+                combatData.perception = teamChar.perception;
+                combatData.gold = teamChar.gold;
+                combatData.silver = teamChar.silver;
+                combatData.copper = teamChar.copper;
+
+                // Ensure equipped weapon is not empty, fallback to first available or "Fists"
+                combatData.equippedWeapon = !string.IsNullOrEmpty(teamChar.equippedWeapon)
+                    ? teamChar.equippedWeapon
+                    : (teamChar.weapons != null && teamChar.weapons.Count > 0)
+                        ? teamChar.weapons[0]
+                        : "Fists";
+
+                Debug.Log($"🔧 FromTeamCharacter: Character '{teamChar.name}' - equippedWeapon: '{teamChar.equippedWeapon}', weapons list: [{(teamChar.weapons != null ? string.Join(", ", teamChar.weapons) : "null")}], resolved to: '{combatData.equippedWeapon}'");
+
+                // Try to find the actual WeaponItem for the equipped weapon
+                combatData.equippedWeaponItem = FindWeaponItem(combatData.equippedWeapon);
+                if (combatData.equippedWeaponItem != null)
+                {
+                    Debug.Log($"🔧 Team character {teamChar.name}: Found WeaponItem '{combatData.equippedWeaponItem.itemName}' for weapon '{combatData.equippedWeapon}'");
+                }
+                else if (combatData.equippedWeapon != "Fists")
+                {
+                    Debug.LogWarning($"⚠️ Team character {teamChar.name}: Could not find WeaponItem for '{combatData.equippedWeapon}' - will use string fallback");
+                }
+
+                combatData.equippedArmor = teamChar.equippedArmor;
+
+                // Calculate derived stats
+                combatData.maxHealth = 10 + (teamChar.constitution * 2); // HP formula
+                combatData.currentHealth = combatData.maxHealth; // Start at full health
+                combatData.armorClass = 10 + (teamChar.dexterity / 2 - 5); // AC formula
+
+                // Copy equipment lists
+                if (teamChar.weapons != null)
+                    combatData.availableWeapons.AddRange(teamChar.weapons);
+                if (teamChar.armor != null)
+                    combatData.availableArmor.AddRange(teamChar.armor);
+            }
+
+            return combatData;
+        }
+    }
+
+    [System.Serializable]
+    public class EnemyCombatData
+    {
+        public string enemyName = "Bandit";
+        public string enemyType = "Humanoid";
+        public int maxHealth = 15;
+        public int currentHealth = 15;
+        public int armorClass = 12;
+        public int threatLevel = 2;
+        public string preferredWeapon = "Sword"; // Keep for backward compatibility
+        public WeaponItem preferredWeaponItem = null; // NEW: Actual weapon item reference
+        public EnemyCharacterData sourceData = null; // Reference to original data
+
+        /// <summary>
+        /// Create combat data from EnemyCharacterData
+        /// </summary>
+        public static EnemyCombatData FromEnemyData(EnemyCharacterData enemyData, int instanceNumber = 1)
+        {
+            var combatData = new EnemyCombatData();
+
+            if (enemyData != null)
+            {
+                combatData.enemyName = $"{enemyData.enemyName}_{instanceNumber}";
+                combatData.enemyType = enemyData.enemyName;
+                combatData.maxHealth = enemyData.maxHealth;
+                combatData.currentHealth = enemyData.maxHealth;
+                combatData.armorClass = enemyData.armorClass;
+                combatData.threatLevel = enemyData.threatLevel;
+
+                // Extract weapon type properly from WeaponItem
+                if (enemyData.preferredWeapon != null)
+                {
+                    combatData.preferredWeapon = enemyData.preferredWeapon.weaponType.ToString();
+                    combatData.preferredWeaponItem = enemyData.preferredWeapon; // Store actual WeaponItem
+                    Debug.Log($"🔧 Enemy {enemyData.enemyName}: WeaponItem.weaponType = {enemyData.preferredWeapon.weaponType} -> '{combatData.preferredWeapon}'");
+                }
+                else
+                {
+                    combatData.preferredWeapon = "Fists"; // Default fallback
+                    combatData.preferredWeaponItem = null;
+                    Debug.Log($"🔧 Enemy {enemyData.enemyName}: No preferredWeapon assigned -> defaulting to 'Fists'");
+                }
+
+                combatData.sourceData = enemyData;
+            }
+
+            return combatData;
+        }
+    }
+
+    // Current combat session data
+    private static CombatSessionData currentSession = null;
+
+    /// <summary>
+    /// Initialize a new combat session with the given data
+    /// </summary>
+    public static void InitializeCombatSession(BattleEventData battleData, TravelEventContext context, List<TeamCharacter> teamMembers)
+    {
+        currentSession = new CombatSessionData();
+
+        // Set battle context
+        if (context != null)
+        {
+            currentSession.battleLocation = context.currentPosition;
+            currentSession.battleTerrain = context.currentTile?.terrainType ?? TerrainType.Plains;
+            currentSession.battleFeature = context.currentTile?.featureType ?? FeatureType.None;
+            currentSession.weather = context.currentWeather;
+            currentSession.timeOfDay = context.timeOfDay;
+        }
+
+        // Set battle description
+        if (battleData != null)
+        {
+            currentSession.battleDescription = battleData.battleDescription;
+        }
+
+        // Convert team members to combat data
+        if (teamMembers != null)
+        {
+            foreach (var teamMember in teamMembers)
+            {
+                if (teamMember != null)
+                {
+                    currentSession.playerTeam.Add(TeamCharacterCombatData.FromTeamCharacter(teamMember));
+                }
+            }
+        }
+
+        // Create enemy combat data
+        if (battleData != null && battleData.enemyCharacterData != null)
+        {
+            for (int i = 0; i < battleData.enemyCount; i++)
+            {
+                currentSession.enemies.Add(EnemyCombatData.FromEnemyData(battleData.enemyCharacterData, i + 1));
+            }
+        }
+
+        Debug.Log($"🎯 Combat session initialized: {currentSession.playerTeam.Count} players vs {currentSession.enemies.Count} enemies on {currentSession.battleTerrain} terrain");
+    }
+
+    /// <summary>
+    /// Get the current combat session data
+    /// </summary>
+    public static CombatSessionData GetCurrentSession()
+    {
+        return currentSession;
+    }
+
+    /// <summary>
+    /// Check if there's a valid combat session
+    /// </summary>
+    public static bool HasValidSession()
+    {
+        return currentSession != null &&
+               currentSession.playerTeam.Count > 0 &&
+               currentSession.enemies.Count > 0;
+    }
+
+    /// <summary>
+    /// Clear the current combat session (call after battle ends)
+    /// </summary>
+    public static void ClearSession()
+    {
+        currentSession = null;
+        Debug.Log("🧹 Combat session cleared");
+    }
+
+    /// <summary>
+    /// Get terrain-appropriate description for battle setup
+    /// </summary>
+    public static string GetTerrainDescription(TerrainType terrain, FeatureType feature)
+    {
+        string baseDescription = terrain switch
+        {
+            TerrainType.Plains => "open grasslands",
+            TerrainType.Forest => "dense woodland",
+            TerrainType.Mountain => "rocky mountain terrain",
+            TerrainType.River => "along a flowing river",
+            TerrainType.Lake => "near a peaceful lake",
+            TerrainType.Ocean => "along the coastline",
+            TerrainType.Shore => "on sandy shores",
+            _ => "unknown terrain"
+        };
+
+        string featureDescription = feature switch
+        {
+            FeatureType.Road => "on a well-traveled road",
+            FeatureType.Bridge => "at a stone bridge",
+            FeatureType.Town => "within town limits",
+            FeatureType.Village => "near a small village",
+            FeatureType.Tunnel => "in a dark tunnel",
+            FeatureType.Ferry => "at a ferry crossing",
+            FeatureType.Harbour => "at a busy harbor",
+            _ => ""
+        };
+
+        if (!string.IsNullOrEmpty(featureDescription))
+        {
+            return $"{featureDescription} in {baseDescription}";
+        }
+
+        return $"in {baseDescription}";
+    }
+
+    /// <summary>
+    /// Create legacy BattleSetupData for compatibility with existing battle scene
+    /// </summary>
+    public static void PopulateLegacyBattleSetupData()
+    {
+        if (!HasValidSession())
+        {
+            Debug.LogError("❌ No valid combat session to populate legacy battle setup data");
+            return;
+        }
+
+        // Clear existing data
+        BattleSetupData.playerSelections.Clear();
+        BattleSetupData.enemySelections.Clear();
+
+        // Populate player selections
+        foreach (var player in currentSession.playerTeam)
+        {
+            string weaponType = !string.IsNullOrEmpty(player.equippedWeapon) ? player.equippedWeapon : "Fists";
+            Debug.Log($"🔧 Player {player.characterName}: equippedWeapon='{player.equippedWeapon}' -> weaponType='{weaponType}'");
+            BattleSetupData.playerSelections.Add(new CharacterSelection
+            {
+                characterName = player.characterName,
+                weaponType = weaponType
+            });
+        }
+
+        // Populate enemy selections
+        foreach (var enemy in currentSession.enemies)
+        {
+            string weaponType = !string.IsNullOrEmpty(enemy.preferredWeapon) ? enemy.preferredWeapon : "Fists";
+            Debug.Log($"🔧 Enemy {enemy.enemyName}: preferredWeapon='{enemy.preferredWeapon}' -> weaponType='{weaponType}'");
+            BattleSetupData.enemySelections.Add(new CharacterSelection
+            {
+                characterName = enemy.enemyName,
+                weaponType = weaponType
+            });
+        }
+
+        Debug.Log($"✅ Legacy battle setup data populated: {BattleSetupData.playerSelections.Count} players, {BattleSetupData.enemySelections.Count} enemies");
+    }
+
+    /// <summary>
+    /// Debug method to log current session information
+    /// </summary>
+    [System.Diagnostics.Conditional("UNITY_EDITOR")]
+    public static void DebugLogSession()
+    {
+        if (currentSession == null)
+        {
+            Debug.Log("🔍 No active combat session");
+            return;
+        }
+
+        Debug.Log("=== COMBAT SESSION DEBUG ===");
+        Debug.Log($"📍 Location: {currentSession.battleLocation}");
+        Debug.Log($"🌍 Terrain: {currentSession.battleTerrain} / {currentSession.battleFeature}");
+        Debug.Log($"🌤️ Weather: {currentSession.weather} at {currentSession.timeOfDay:F1}h");
+        Debug.Log($"👥 Players: {currentSession.playerTeam.Count}");
+        foreach (var player in currentSession.playerTeam)
+        {
+            Debug.Log($"  - {player.characterName} (HP: {player.currentHealth}/{player.maxHealth}, AC: {player.armorClass}, Weapon: {player.equippedWeapon})");
+        }
+        Debug.Log($"👹 Enemies: {currentSession.enemies.Count}");
+        foreach (var enemy in currentSession.enemies)
+        {
+            Debug.Log($"  - {enemy.enemyName} (HP: {enemy.currentHealth}/{enemy.maxHealth}, AC: {enemy.armorClass}, Threat: {enemy.threatLevel})");
+        }
+        Debug.Log("=== END COMBAT SESSION ===");
+    }
+
+    /// <summary>
+    /// Helper method to find a WeaponItem by name or type
+    /// </summary>
+    private static WeaponItem FindWeaponItem(string weaponIdentifier)
+    {
+        if (string.IsNullOrEmpty(weaponIdentifier) || weaponIdentifier == "Fists")
+        {
+            Debug.Log($"🔍 FindWeaponItem: Skipping '{weaponIdentifier}' (null/empty/Fists)");
+            return null;
+        }
+
+        Debug.Log($"🔍 FindWeaponItem: Looking for weapon '{weaponIdentifier}'");
+
+        // Load all WeaponItem assets from Resources folders
+        WeaponItem[] allWeapons = Resources.LoadAll<WeaponItem>("");
+        Debug.Log($"🔍 FindWeaponItem: Found {allWeapons.Length} WeaponItem assets in Resources");
+
+        // Debug: List all available weapons
+        foreach (var weapon in allWeapons)
+        {
+            if (weapon != null)
+            {
+                Debug.Log($"  📋 Available weapon: '{weapon.itemName}' (type: {weapon.weaponType})");
+            }
+        }
+
+        // First try exact name match
+        foreach (var weapon in allWeapons)
+        {
+            if (weapon != null && string.Equals(weapon.itemName, weaponIdentifier, System.StringComparison.OrdinalIgnoreCase))
+            {
+                Debug.Log($"✅ FindWeaponItem: Found exact match for '{weaponIdentifier}' -> '{weapon.itemName}'");
+                return weapon;
+            }
+        }
+
+        Debug.Log($"⚠️ FindWeaponItem: No exact name match for '{weaponIdentifier}', trying weapon type match...");
+
+        // Then try weapon type match
+        if (System.Enum.TryParse<WeaponType>(weaponIdentifier, true, out WeaponType weaponType))
+        {
+            Debug.Log($"🔍 FindWeaponItem: Parsed '{weaponIdentifier}' as WeaponType.{weaponType}");
+
+            // Look for a weapon of this type, prefer "Simple" variants
+            WeaponItem simpleWeapon = null;
+            WeaponItem anyWeapon = null;
+
+            foreach (var weapon in allWeapons)
+            {
+                if (weapon != null && weapon.weaponType == weaponType)
+                {
+                    anyWeapon = weapon; // Keep track of any weapon of this type
+                    Debug.Log($"  🎯 Found weapon of type {weaponType}: '{weapon.itemName}'");
+
+                    // Prefer simple/basic weapons
+                    if (weapon.itemName.ToLower().Contains("simple") || weapon.itemName.ToLower().Contains("basic"))
+                    {
+                        simpleWeapon = weapon;
+                        Debug.Log($"  ⭐ Preferred simple weapon: '{weapon.itemName}'");
+                        break; // Found preferred weapon, stop searching
+                    }
+                }
+            }
+
+            WeaponItem result = simpleWeapon ?? anyWeapon;
+            if (result != null)
+            {
+                Debug.Log($"✅ FindWeaponItem: Found weapon by type '{weaponIdentifier}' -> '{result.itemName}'");
+            }
+            else
+            {
+                Debug.LogWarning($"❌ FindWeaponItem: No weapon found for type '{weaponType}'");
+            }
+            return result;
+        }
+        else
+        {
+            Debug.LogWarning($"❌ FindWeaponItem: Could not parse '{weaponIdentifier}' as WeaponType enum");
+        }
+
+        Debug.LogError($"❌ FindWeaponItem: No weapon found for '{weaponIdentifier}'");
+        return null;
+    }
+}

Assets/Scripts/BattleSetup/CombatSceneManager.cs

@@ -0,0 +1,434 @@
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using System.Collections.Generic;
+using System.Collections;
+
+/// <summary>
+/// Manages the transition from travel events to battle scenes
+/// Handles terrain setup, team data transfer, and battle initialization
+/// </summary>
+public class CombatSceneManager : MonoBehaviour
+{
+    [Header("Scene Management")]
+    [Tooltip("Name of the battle scene to load")]
+    public string battleSceneName = "BattleScene";
+
+    [Header("Terrain Generation")]
+    [Tooltip("Reference to BFM Terrain Generator for battle field terrain")]
+    public BFMTerrainGenerator terrainGenerator;
+
+    [Header("Debug Settings")]
+    public bool showDebugLogs = true;
+
+    // Singleton instance
+    public static CombatSceneManager Instance { get; private set; }
+
+    // Events for other systems to hook into
+    public System.Action<CombatDataTransfer.CombatSessionData> OnCombatSessionStarted;
+    public System.Action OnBattleSceneLoaded;
+
+    private void Awake()
+    {
+        // Ensure singleton pattern
+        if (Instance == null)
+        {
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+        }
+        else
+        {
+            Destroy(gameObject);
+            return;
+        }
+    }
+
+    private void Start()
+    {
+        // Try to find terrain generator if not assigned
+        if (terrainGenerator == null)
+        {
+            terrainGenerator = FindFirstObjectByType<BFMTerrainGenerator>();
+        }
+    }
+
+    /// <summary>
+    /// Start a combat encounter by transitioning to the battle scene
+    /// </summary>
+    public void StartCombatEncounter(BattleEventData battleData, TravelEventContext context)
+    {
+        if (showDebugLogs)
+        {
+            Debug.Log("⚔️ CombatSceneManager: Starting combat encounter...");
+        }
+
+        // Get team members from the game state
+        List<TeamCharacter> teamMembers = GetCurrentTeamMembers();
+
+        if (teamMembers == null || teamMembers.Count == 0)
+        {
+            Debug.LogError("❌ No team members found! Cannot start combat.");
+            return;
+        }
+
+        // Initialize the combat session data
+        CombatDataTransfer.InitializeCombatSession(battleData, context, teamMembers);
+
+        if (showDebugLogs)
+        {
+            CombatDataTransfer.DebugLogSession();
+        }
+
+        // Populate legacy battle setup data for compatibility
+        CombatDataTransfer.PopulateLegacyBattleSetupData();
+
+        // Notify listeners
+        OnCombatSessionStarted?.Invoke(CombatDataTransfer.GetCurrentSession());
+
+        // Load the battle scene
+        StartCoroutine(LoadBattleSceneCoroutine());
+    }
+
+    /// <summary>
+    /// Get current team members from various sources
+    /// </summary>
+    private List<TeamCharacter> GetCurrentTeamMembers()
+    {
+        List<TeamCharacter> teamMembers = new List<TeamCharacter>();
+
+        // Method 1: Try MainTeamSelectScript first (if available)
+        var teamSelectScript = FindFirstObjectByType<MainTeamSelectScript>();
+        if (teamSelectScript != null)
+        {
+            var characters = teamSelectScript.GetConfiguredCharacters();
+            if (characters != null && characters.Count > 0)
+            {
+                teamMembers.AddRange(characters);
+                if (showDebugLogs)
+                {
+                    Debug.Log($"📋 Found {teamMembers.Count} team members from MainTeamSelectScript");
+                }
+                return teamMembers;
+            }
+        }
+
+        // Method 2: Try GameStateManager
+        if (GameStateManager.Instance != null && GameStateManager.Instance.savedTeam != null)
+        {
+            foreach (var character in GameStateManager.Instance.savedTeam)
+            {
+                if (character != null)
+                {
+                    teamMembers.Add(character);
+                }
+            }
+
+            if (teamMembers.Count > 0)
+            {
+                if (showDebugLogs)
+                {
+                    Debug.Log($"📋 Found {teamMembers.Count} team members from GameStateManager");
+                }
+                return teamMembers;
+            }
+        }
+
+        // Method 3: Try loading from PlayerPrefs as fallback
+        for (int i = 0; i < 4; i++)
+        {
+            string prefix = $"Character{i}_";
+            if (PlayerPrefs.HasKey(prefix + "Exists") && PlayerPrefs.GetInt(prefix + "Exists") == 1)
+            {
+                var character = new TeamCharacter();
+                character.name = PlayerPrefs.GetString(prefix + "Name", "");
+                character.isMale = PlayerPrefs.GetInt(prefix + "IsMale", 1) == 1;
+                character.strength = PlayerPrefs.GetInt(prefix + "Strength", 10);
+                character.dexterity = PlayerPrefs.GetInt(prefix + "Dexterity", 10);
+                character.constitution = PlayerPrefs.GetInt(prefix + "Constitution", 10);
+                character.wisdom = PlayerPrefs.GetInt(prefix + "Wisdom", 10);
+                character.perception = PlayerPrefs.GetInt(prefix + "Perception", 10);
+                character.gold = PlayerPrefs.GetInt(prefix + "Gold", 25);
+                character.silver = PlayerPrefs.GetInt(prefix + "Silver", 0);
+                character.copper = PlayerPrefs.GetInt(prefix + "Copper", 0);
+                character.equippedWeapon = PlayerPrefs.GetString(prefix + "EquippedWeapon", "");
+                character.equippedArmor = PlayerPrefs.GetString(prefix + "EquippedArmor", "");
+
+                // Load weapon list using the same format as MainTeamSelectScript
+                character.weapons = new List<string>();
+                int weaponCount = PlayerPrefs.GetInt(prefix + "WeaponCount", 0);
+                for (int j = 0; j < weaponCount; j++)
+                {
+                    string weapon = PlayerPrefs.GetString(prefix + $"Weapon{j}", "");
+                    if (!string.IsNullOrEmpty(weapon))
+                    {
+                        character.weapons.Add(weapon);
+                    }
+                }
+
+                // Load armor list using the same format as MainTeamSelectScript
+                character.armor = new List<string>();
+                int armorCount = PlayerPrefs.GetInt(prefix + "ArmorCount", 0);
+                for (int j = 0; j < armorCount; j++)
+                {
+                    string armor = PlayerPrefs.GetString(prefix + $"Armor{j}", "");
+                    if (!string.IsNullOrEmpty(armor))
+                    {
+                        character.armor.Add(armor);
+                    }
+                }
+
+                // Debug the loaded character data
+                if (showDebugLogs)
+                {
+                    Debug.Log($"🔧 Loaded character '{character.name}': equippedWeapon='{character.equippedWeapon}', weapons=[{string.Join(", ", character.weapons)}]");
+                }
+
+                teamMembers.Add(character);
+            }
+        }
+
+        if (teamMembers.Count > 0)
+        {
+            if (showDebugLogs)
+            {
+                Debug.Log($"📋 Found {teamMembers.Count} team members from PlayerPrefs");
+            }
+        }
+        else
+        {
+            Debug.LogWarning("⚠️ No team members found in any data source!");
+        }
+
+        return teamMembers;
+    }
+
+    /// <summary>
+    /// Coroutine to handle battle scene loading
+    /// </summary>
+    private IEnumerator LoadBattleSceneCoroutine()
+    {
+        if (showDebugLogs)
+        {
+            Debug.Log($"🎬 Loading battle scene: {battleSceneName}");
+        }
+
+        // Check if scene exists in build settings
+        if (!IsSceneInBuildSettings(battleSceneName))
+        {
+            Debug.LogError($"❌ Battle scene '{battleSceneName}' not found in Build Settings!");
+            yield break;
+        }
+
+        // Start loading the scene asynchronously
+        AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(battleSceneName);
+
+        // Wait for the scene to load
+        while (!asyncLoad.isDone)
+        {
+            // You could update a loading bar here
+            yield return null;
+        }
+
+        if (showDebugLogs)
+        {
+            Debug.Log("✅ Battle scene loaded successfully");
+        }
+
+        // Notify that the battle scene has loaded
+        OnBattleSceneLoaded?.Invoke();
+
+        // Set up the terrain in the battle scene
+        yield return StartCoroutine(SetupBattleTerrainCoroutine());
+    }
+
+    /// <summary>
+    /// Set up the battle terrain based on the combat session data
+    /// </summary>
+    private IEnumerator SetupBattleTerrainCoroutine()
+    {
+        // Wait a frame to ensure the scene is fully loaded
+        yield return null;
+
+        var session = CombatDataTransfer.GetCurrentSession();
+        if (session == null)
+        {
+            Debug.LogWarning("⚠️ No combat session data available for terrain setup");
+            yield break;
+        }
+
+        // Find or create terrain generator in the new scene
+        if (terrainGenerator == null)
+        {
+            terrainGenerator = FindFirstObjectByType<BFMTerrainGenerator>();
+        }
+
+        if (terrainGenerator != null)
+        {
+            // Convert TerrainType to BFMTerrainType
+            BFMTerrainType bfmTerrain = ConvertToBFMTerrainType(session.battleTerrain);
+
+            if (showDebugLogs)
+            {
+                Debug.Log($"🌍 Setting battle terrain to: {bfmTerrain} (from {session.battleTerrain})");
+            }
+
+            // Set the terrain type
+            terrainGenerator.SetTerrainType(bfmTerrain);
+
+            // Regenerate the terrain if there's a method for it
+            if (terrainGenerator.GetComponent<MonoBehaviour>() != null)
+            {
+                // You might need to call a regeneration method here
+                // terrainGenerator.RegenerateTerrain(); // If such method exists
+            }
+        }
+        else
+        {
+            if (showDebugLogs)
+            {
+                Debug.LogWarning("⚠️ No BFMTerrainGenerator found in battle scene - terrain setup skipped");
+            }
+        }
+
+        // Log the battle setup information
+        if (showDebugLogs)
+        {
+            string terrainDesc = CombatDataTransfer.GetTerrainDescription(session.battleTerrain, session.battleFeature);
+            Debug.Log($"🎯 Battle setup complete: Fighting {terrainDesc}");
+            Debug.Log($"⏰ Time: {session.timeOfDay:F1}h, Weather: {session.weather}");
+        }
+    }
+
+    /// <summary>
+    /// Convert TerrainType to BFMTerrainType for battle field generation
+    /// </summary>
+    private BFMTerrainType ConvertToBFMTerrainType(TerrainType terrainType)
+    {
+        return terrainType switch
+        {
+            TerrainType.Plains => BFMTerrainType.Plain,
+            TerrainType.Forest => BFMTerrainType.Forest,
+            TerrainType.Mountain => BFMTerrainType.Mountain,
+            TerrainType.ForestRiver => BFMTerrainType.Forest, // Forest with river features
+            _ => BFMTerrainType.Plain // Default to plains for other terrain types
+        };
+    }
+
+    /// <summary>
+    /// Check if a scene exists in build settings
+    /// </summary>
+    private bool IsSceneInBuildSettings(string sceneName)
+    {
+        for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
+        {
+            string scenePath = UnityEngine.SceneManagement.SceneUtility.GetScenePathByBuildIndex(i);
+            string sceneNameFromPath = System.IO.Path.GetFileNameWithoutExtension(scenePath);
+
+            if (sceneNameFromPath.Equals(sceneName, System.StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// End the current combat session and return to the map
+    /// </summary>
+    public void EndCombatSession(bool playerVictory)
+    {
+        if (showDebugLogs)
+        {
+            Debug.Log($"🏆 Combat session ended - Player victory: {playerVictory}");
+        }
+
+        // Clear the combat session data
+        CombatDataTransfer.ClearSession();
+
+        // Return to the map scene
+        // You might want to load "MapScene2" or whatever your main map scene is called
+        StartCoroutine(ReturnToMapCoroutine());
+    }
+
+    /// <summary>
+    /// Return to the map scene after combat
+    /// </summary>
+    private IEnumerator ReturnToMapCoroutine()
+    {
+        yield return new WaitForSeconds(2f); // Brief delay for any end-of-combat UI
+
+        string mapSceneName = "MapScene2"; // Adjust this to your actual map scene name
+
+        if (IsSceneInBuildSettings(mapSceneName))
+        {
+            if (showDebugLogs)
+            {
+                Debug.Log($"🗺️ Returning to map scene: {mapSceneName}");
+            }
+            SceneManager.LoadScene(mapSceneName);
+        }
+        else
+        {
+            Debug.LogError($"❌ Map scene '{mapSceneName}' not found in Build Settings!");
+        }
+    }
+
+    /// <summary>
+    /// Get current battle context for UI display
+    /// </summary>
+    public string GetBattleContextDescription()
+    {
+        var session = CombatDataTransfer.GetCurrentSession();
+        if (session == null) return "Unknown battle";
+
+        string terrainDesc = CombatDataTransfer.GetTerrainDescription(session.battleTerrain, session.battleFeature);
+        string timeDesc = GetTimeDescription(session.timeOfDay);
+        string weatherDesc = session.weather.ToString().ToLower();
+
+        return $"Battle {terrainDesc} during {timeDesc} ({weatherDesc} weather)";
+    }
+
+    /// <summary>
+    /// Convert time of day to readable description
+    /// </summary>
+    private string GetTimeDescription(float timeOfDay)
+    {
+        return timeOfDay switch
+        {
+            >= 6f and < 12f => "morning",
+            >= 12f and < 18f => "afternoon",
+            >= 18f and < 22f => "evening",
+            _ => "night"
+        };
+    }
+
+    /// <summary>
+    /// Debug method to manually start a test combat
+    /// </summary>
+    [ContextMenu("Start Test Combat")]
+    public void StartTestCombat()
+    {
+        // Create test battle data
+        var testBattleData = new BattleEventData
+        {
+            enemyCount = 2,
+            enemyType = "Test Bandit",
+            battleDescription = "A test combat encounter"
+        };
+
+        // Create test context
+        var testContext = new TravelEventContext(Vector2Int.zero, null, null)
+        {
+            currentWeather = Weather.Clear,
+            timeOfDay = 14f
+        };
+
+        // Use fake tile data
+        testContext.currentTile = new MapTile(0, 0)
+        {
+            terrainType = TerrainType.Plains,
+            featureType = FeatureType.Road
+        };
+
+        StartCombatEncounter(testBattleData, testContext);
+    }
+}

Assets/Scripts/Characters/Enemies/ForestTroll.asset

@@ -26,7 +26,7 @@ MonoBehaviour:
   spellModifier: 0
   movementSpeed: 8
   armorClass: 4
-  preferredWeapon: {fileID: 11400000, guid: ca900eb0c0ebd1c4f93304e12b7b5c82, type: 2}
+  preferredWeapon: {fileID: 11400000, guid: cc2b8adf1abf53e47a424b2a2dab8ad4, type: 2}
   aggressiveness: 0.5
   threatLevel: 5
   goldReward: 45

Assets/Scripts/Characters/Enemies/GoblinScout.asset

@@ -26,7 +26,7 @@ MonoBehaviour:
   spellModifier: -2
   movementSpeed: 15
   armorClass: 8
-  preferredWeapon: {fileID: 11400000, guid: 957092d704b5dae449a68fd38b0bb9da, type: 2}
+  preferredWeapon: {fileID: 11400000, guid: 28ae78245f61df040bda1181f2e9d35f, type: 2}
   aggressiveness: 0.9
   threatLevel: 1
   goldReward: 8

Assets/Scripts/Characters/Enemies/SkeletonWarrior.asset

@@ -26,7 +26,7 @@ MonoBehaviour:
   spellModifier: 0
   movementSpeed: 10
   armorClass: 6
-  preferredWeapon: {fileID: 11400000, guid: 25e42433d13b95f43b3cbb7849987b5c, type: 2}
+  preferredWeapon: {fileID: 11400000, guid: 45ec86ba4856b5946a198dfd809b68b9, type: 2}
   aggressiveness: 0.7
   threatLevel: 2
   goldReward: 15

Assets/Scripts/Events/CombatEventIntegration.cs

@@ -293,9 +293,31 @@ public class CombatEventIntegration : MonoBehaviour
         {
             Debug.Log($"⚔️ Starting battle: {result.battleData.enemyCount} {result.battleData.enemyType}(s)");
 
-            // TODO: Integrate with your battle system
-            // This is where you would transition to the battle scene
-            // or set up the battle data for your existing battle system
+            // Use the new CombatSceneManager to handle battle transition
+            MonoBehaviour combatSceneManager = FindCombatSceneManager();
+            if (combatSceneManager != null)
+            {
+                Debug.Log("🎬 Transitioning to battle scene with CombatSceneManager...");
+
+                // Use reflection to call StartCombatEncounter method
+                var method = combatSceneManager.GetType().GetMethod("StartCombatEncounter");
+                if (method != null)
+                {
+                    method.Invoke(combatSceneManager, new object[] { result.battleData, currentContext });
+                }
+                else
+                {
+                    Debug.LogError("❌ StartCombatEncounter method not found on CombatSceneManager");
+                    HandleLegacyBattleStart(result.battleData);
+                }
+            }
+            else
+            {
+                Debug.LogWarning("⚠️ CombatSceneManager not found! Looking for alternative battle systems...");
+
+                // Fallback to legacy battle system if available
+                HandleLegacyBattleStart(result.battleData);
+            }
 
             if (result.battleData.enemyCharacterData != null)
             {
@@ -327,4 +349,45 @@ public class CombatEventIntegration : MonoBehaviour
                 combatEventPopup.ForceClose();
         }
     }
+
+    /// <summary>
+    /// Handle legacy battle start when CombatSceneManager is not available
+    /// </summary>
+    private void HandleLegacyBattleStart(BattleEventData battleData)
+    {
+        Debug.Log("🔧 Using legacy battle system...");
+
+        // Try to find and use existing battle systems
+        var enhancedEventSystem = FindFirstObjectByType<EnhancedTravelEventSystem>();
+        if (enhancedEventSystem != null)
+        {
+            Debug.Log("📞 Delegating to EnhancedTravelEventSystem");
+            // This system should have methods to handle battle setup
+        }
+        else
+        {
+            Debug.Log("📝 Logging battle setup for manual handling");
+            Debug.Log($"⚔️ Battle Setup Required:");
+            Debug.Log($"  - Enemies: {battleData.enemyCount}x {battleData.enemyType}");
+            if (battleData.enemyCharacterData != null)
+            {
+                Debug.Log($"  - Enemy Data: {battleData.enemyCharacterData.enemyName}");
+                Debug.Log($"  - Enemy HP: {battleData.enemyCharacterData.maxHealth}");
+                Debug.Log($"  - Enemy AC: {battleData.enemyCharacterData.armorClass}");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Find CombatSceneManager using reflection to avoid compilation issues
+    /// </summary>
+    private MonoBehaviour FindCombatSceneManager()
+    {
+        // First try to find it by component type name
+        var allComponents = FindObjectsByType<MonoBehaviour>(FindObjectsSortMode.None);
+        var combatSceneManager = System.Array.Find(allComponents,
+            comp => comp.GetType().Name == "CombatSceneManager");
+
+        return combatSceneManager;
+    }
 }

Assets/Scripts/MainTeamSelect/MainTeamSelectScript.cs

@@ -481,6 +481,14 @@ public class MainTeamSelectScript : MonoBehaviour
         }
 
         currentCharacter.weapons.Add(weaponType);
+
+        // If this is the first weapon, equip it automatically
+        if (string.IsNullOrEmpty(currentCharacter.equippedWeapon))
+        {
+            currentCharacter.equippedWeapon = weaponType;
+            Debug.Log($"🔧 MainTeamSelect: Auto-equipped first weapon '{weaponType}' for {currentCharacter.name}");
+        }
+
         SaveCurrentCharacterToSlot();
     }
 
@@ -556,8 +564,8 @@ public class MainTeamSelectScript : MonoBehaviour
         if (silverField != null) silverField.value = currentCharacter.silver;
         if (copperField != null) copperField.value = currentCharacter.copper;
 
-        // Update weapon list
-        UpdateItemList(weaponsList, currentCharacter.weapons, "WeaponItemRow", OnRemoveWeapon);
+        // Update weapon list with equip status
+        UpdateWeaponListWithEquipStatus(weaponsList, currentCharacter.weapons, currentCharacter.equippedWeapon);
 
         // Update armor list  
         UpdateItemList(armorList, currentCharacter.armor, "ArmorItemRow", OnRemoveArmor);
@@ -566,6 +574,73 @@ public class MainTeamSelectScript : MonoBehaviour
         UpdateItemList(miscList, currentCharacter.miscItems, "MiscItemRow", OnRemoveMisc);
     }
 
+    private void UpdateWeaponListWithEquipStatus(VisualElement container, System.Collections.Generic.List<string> weapons, string equippedWeapon)
+    {
+        if (container == null || weapons == null) return;
+
+        // Clear existing items (except example rows)
+        var itemsToRemove = container.Query<VisualElement>(className: "inventory-item-row").ToList()
+            .Where(item => !item.name.Contains("Example")).ToList();
+
+        foreach (var item in itemsToRemove)
+        {
+            container.Remove(item);
+        }
+
+        // Add current weapons with equip status
+        foreach (var weaponName in weapons)
+        {
+            var itemRow = new VisualElement();
+            itemRow.AddToClassList("inventory-item-row");
+            itemRow.AddToClassList("WeaponItemRow");
+
+            bool isEquipped = weaponName == equippedWeapon;
+
+            var nameLabel = new Label(isEquipped ? $"[EQUIPPED] {weaponName}" : weaponName);
+            nameLabel.AddToClassList("item-name-label");
+            if (isEquipped)
+            {
+                nameLabel.style.color = UnityEngine.Color.green;
+                nameLabel.style.unityFontStyleAndWeight = UnityEngine.FontStyle.Bold;
+            }
+            itemRow.Add(nameLabel);
+
+            // Equip button (only show if not already equipped)
+            if (!isEquipped)
+            {
+                var equipButton = new Button(() => OnEquipWeapon(weaponName));
+                equipButton.text = "Equip";
+                equipButton.AddToClassList("equip-item-button");
+                itemRow.Add(equipButton);
+            }
+
+            var removeButton = new Button(() => OnRemoveWeapon(weaponName));
+            removeButton.text = "Remove (Refund)";
+            removeButton.AddToClassList("remove-item-button");
+
+            // Add tooltip for refund information
+            string refundInfo = GetRefundInfo(weaponName, "weapon");
+            if (!string.IsNullOrEmpty(refundInfo))
+            {
+                removeButton.tooltip = $"Remove and refund: {refundInfo}";
+            }
+
+            itemRow.Add(removeButton);
+            container.Add(itemRow);
+        }
+    }
+
+    private void OnEquipWeapon(string weaponName)
+    {
+        if (currentCharacter != null && currentCharacter.weapons.Contains(weaponName))
+        {
+            currentCharacter.equippedWeapon = weaponName;
+            Debug.Log($"🔧 MainTeamSelect: Equipped weapon '{weaponName}' for {currentCharacter.name}");
+            SaveCurrentCharacterToSlot();
+            UpdateInventoryUI();
+        }
+    }
+
     private void UpdateItemList(VisualElement container, System.Collections.Generic.List<string> items, string rowClassName, System.Action<string> removeAction)
     {
         if (container == null || items == null) return;
@@ -708,6 +783,21 @@ public class MainTeamSelectScript : MonoBehaviour
         {
             currentCharacter.weapons.Remove(weaponName);
 
+            // If this was the equipped weapon, unequip it and equip the first remaining weapon if any
+            if (currentCharacter.equippedWeapon == weaponName)
+            {
+                if (currentCharacter.weapons.Count > 0)
+                {
+                    currentCharacter.equippedWeapon = currentCharacter.weapons[0];
+                    Debug.Log($"🔧 MainTeamSelect: Equipped new weapon '{currentCharacter.equippedWeapon}' after removing '{weaponName}'");
+                }
+                else
+                {
+                    currentCharacter.equippedWeapon = "";
+                    Debug.Log($"🔧 MainTeamSelect: No weapons left, unequipped '{weaponName}'");
+                }
+            }
+
             // Refund the weapon price
             RefundItemPrice(weaponName, "weapon");
 
@@ -1493,6 +1583,55 @@ public class MainTeamSelectScript : MonoBehaviour
         character.silver = PlayerPrefs.GetInt(prefix + "Silver", 0);
         character.copper = PlayerPrefs.GetInt(prefix + "Copper", 0);
 
+        // Load equipped weapon
+        character.equippedWeapon = PlayerPrefs.GetString(prefix + "EquippedWeapon", "");
+
+        // Load weapon list
+        int weaponCount = PlayerPrefs.GetInt(prefix + "WeaponCount", 0);
+        character.weapons = new System.Collections.Generic.List<string>();
+        for (int i = 0; i < weaponCount; i++)
+        {
+            string weapon = PlayerPrefs.GetString(prefix + $"Weapon{i}", "");
+            if (!string.IsNullOrEmpty(weapon))
+            {
+                character.weapons.Add(weapon);
+            }
+        }
+
+        // Load armor list
+        int armorCount = PlayerPrefs.GetInt(prefix + "ArmorCount", 0);
+        character.armor = new System.Collections.Generic.List<string>();
+        for (int i = 0; i < armorCount; i++)
+        {
+            string armor = PlayerPrefs.GetString(prefix + $"Armor{i}", "");
+            if (!string.IsNullOrEmpty(armor))
+            {
+                character.armor.Add(armor);
+            }
+        }
+
+        // Load misc items
+        int miscCount = PlayerPrefs.GetInt(prefix + "MiscCount", 0);
+        character.miscItems = new System.Collections.Generic.List<string>();
+        for (int i = 0; i < miscCount; i++)
+        {
+            string misc = PlayerPrefs.GetString(prefix + $"Misc{i}", "");
+            if (!string.IsNullOrEmpty(misc))
+            {
+                character.miscItems.Add(misc);
+            }
+        }
+
+        // Load equipped armor
+        character.equippedArmor = PlayerPrefs.GetString(prefix + "EquippedArmor", "");
+
+        // If no equipped weapon but has weapons, equip the first one
+        if (string.IsNullOrEmpty(character.equippedWeapon) && character.weapons.Count > 0)
+        {
+            character.equippedWeapon = character.weapons[0];
+            Debug.Log($"🔧 LoadCharacter: Auto-equipped first weapon '{character.equippedWeapon}' for loaded character {character.name}");
+        }
+
         // Recalculate equipment bonuses from inventory after loading
         character.RecalculateEquipmentBonuses();
 
@@ -1516,9 +1655,60 @@ public class MainTeamSelectScript : MonoBehaviour
         PlayerPrefs.SetInt(prefix + "Silver", character.silver);
         PlayerPrefs.SetInt(prefix + "Copper", character.copper);
 
+        // Save equipped weapon
+        PlayerPrefs.SetString(prefix + "EquippedWeapon", character.equippedWeapon ?? "");
+
+        // Save weapon list
+        if (character.weapons != null)
+        {
+            PlayerPrefs.SetInt(prefix + "WeaponCount", character.weapons.Count);
+            for (int i = 0; i < character.weapons.Count; i++)
+            {
+                PlayerPrefs.SetString(prefix + $"Weapon{i}", character.weapons[i]);
+            }
+        }
+        else
+        {
+            PlayerPrefs.SetInt(prefix + "WeaponCount", 0);
+        }
+
+        // Save armor list
+        if (character.armor != null)
+        {
+            PlayerPrefs.SetInt(prefix + "ArmorCount", character.armor.Count);
+            for (int i = 0; i < character.armor.Count; i++)
+            {
+                PlayerPrefs.SetString(prefix + $"Armor{i}", character.armor[i]);
+            }
+        }
+        else
+        {
+            PlayerPrefs.SetInt(prefix + "ArmorCount", 0);
+        }
+
+        // Save misc items
+        if (character.miscItems != null)
+        {
+            PlayerPrefs.SetInt(prefix + "MiscCount", character.miscItems.Count);
+            for (int i = 0; i < character.miscItems.Count; i++)
+            {
+                PlayerPrefs.SetString(prefix + $"Misc{i}", character.miscItems[i]);
+            }
+        }
+        else
+        {
+            PlayerPrefs.SetInt(prefix + "MiscCount", 0);
+        }
+
+        // Save equipped armor
+        PlayerPrefs.SetString(prefix + "EquippedArmor", character.equippedArmor ?? "");
+
         // Immediately verify what was saved
         string savedName = PlayerPrefs.GetString(prefix + "Name", "FAILED_TO_SAVE");
         int savedStr = PlayerPrefs.GetInt(prefix + "Strength", -1);
+        string savedWeapon = PlayerPrefs.GetString(prefix + "EquippedWeapon", "FAILED_TO_SAVE");
+
+        Debug.Log($"💾 SaveCharacter: Saved {character.name} with equipped weapon '{character.equippedWeapon}' -> verified as '{savedWeapon}'");
 
 
         if (savedName != character.name)

Assets/Scripts/Objects/Armour/LeatherPants.asset

@@ -1,31 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: d37416b822a924a4ca8b3d4daafd98b5, type: 3}
-  m_Name: LeatherPants
-  m_EditorClassIdentifier: 
-  itemName: Leather pants
-  description: Simeple Leather pants
-  icon: {fileID: 0}
-  model3D: {fileID: 0}
-  itemType: 1
-  rarity: 0
-  goldCost: 0
-  silverCost: 0
-  copperCost: 0
-  searchTags: []
-  armorClass: 1
-  strengthModifier: 0
-  dexterityModifier: 0
-  constitutionModifier: 0
-  wisdomModifier: 0
-  armorType: 0
-  armorSlot: 2

Assets/Scripts/Objects/Armour/LetherChestPiece.asset

@@ -1,33 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: d37416b822a924a4ca8b3d4daafd98b5, type: 3}
-  m_Name: LetherChestPiece
-  m_EditorClassIdentifier: 
-  itemName: Chest Lether Armour
-  description: A simple leather armour for some protection
-  icon: {fileID: 0}
-  model3D: {fileID: 0}
-  itemType: 1
-  rarity: 0
-  goldCost: 5
-  silverCost: 0
-  copperCost: 0
-  searchTags:
-  - lether
-  - chest
-  armorClass: 1
-  strengthModifier: 0
-  dexterityModifier: 0
-  constitutionModifier: 0
-  wisdomModifier: 0
-  armorType: 0
-  armorSlot: 1

Assets/Scripts/Objects/Items/WeaponItem.cs

@@ -51,6 +51,10 @@ public class WeaponItem : Item
                 bowComponent.InitializeFromItem(this);
                 weaponComponent = bowComponent;
                 break;
+            case "Fists":
+                var fistsComponent = weaponObject.AddComponent<Fists>();
+                weaponComponent = fistsComponent;
+                break;
             // Add more weapon types here as you create them
             default:
                 Debug.LogError($"Unknown weapon class: {weaponClassName}");
@@ -85,6 +89,7 @@ public class WeaponItem : Item
 [System.Serializable]
 public enum WeaponType
 {
+    Fists,
     Sword,
     Bow,
     Crossbow,

Assets/Scripts/Objects/Items/WeaponRegistry.cs

@@ -0,0 +1,150 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+
+/// <summary>
+/// Registry system for looking up WeaponItem assets by name or weapon type
+/// Used to convert string-based weapon references to actual WeaponItem objects
+/// </summary>
+[CreateAssetMenu(fileName = "WeaponRegistry", menuName = "RPG/Systems/Weapon Registry")]
+public class WeaponRegistry : ScriptableObject
+{
+    [Header("Available Weapons")]
+    [SerializeField] private List<WeaponItem> availableWeapons = new List<WeaponItem>();
+
+    private static WeaponRegistry _instance;
+    public static WeaponRegistry Instance
+    {
+        get
+        {
+            if (_instance == null)
+            {
+                _instance = Resources.Load<WeaponRegistry>("WeaponRegistry");
+                if (_instance == null)
+                {
+                    Debug.LogWarning("WeaponRegistry not found in Resources folder. Creating default registry.");
+                    _instance = CreateInstance<WeaponRegistry>();
+                }
+            }
+            return _instance;
+        }
+    }
+
+    /// <summary>
+    /// Find a WeaponItem by exact name match
+    /// </summary>
+    public WeaponItem GetWeaponByName(string weaponName)
+    {
+        if (string.IsNullOrEmpty(weaponName)) return null;
+
+        return availableWeapons.FirstOrDefault(w =>
+            w != null && string.Equals(w.itemName, weaponName, System.StringComparison.OrdinalIgnoreCase));
+    }
+
+    /// <summary>
+    /// Find a WeaponItem by weapon type (finds first match of that type)
+    /// </summary>
+    public WeaponItem GetWeaponByType(WeaponType weaponType)
+    {
+        return availableWeapons.FirstOrDefault(w => w != null && w.weaponType == weaponType);
+    }
+
+    /// <summary>
+    /// Find a WeaponItem by weapon type string (e.g., "Sword", "Bow")
+    /// </summary>
+    public WeaponItem GetWeaponByTypeString(string weaponTypeString)
+    {
+        if (string.IsNullOrEmpty(weaponTypeString)) return null;
+
+        // Try to parse as WeaponType enum
+        if (System.Enum.TryParse<WeaponType>(weaponTypeString, true, out WeaponType weaponType))
+        {
+            return GetWeaponByType(weaponType);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Get all weapons of a specific type
+    /// </summary>
+    public List<WeaponItem> GetWeaponsByType(WeaponType weaponType)
+    {
+        return availableWeapons.Where(w => w != null && w.weaponType == weaponType).ToList();
+    }
+
+    /// <summary>
+    /// Get a random weapon of the specified type
+    /// </summary>
+    public WeaponItem GetRandomWeaponByType(WeaponType weaponType)
+    {
+        var weaponsOfType = GetWeaponsByType(weaponType);
+        if (weaponsOfType.Count == 0) return null;
+
+        int randomIndex = Random.Range(0, weaponsOfType.Count);
+        return weaponsOfType[randomIndex];
+    }
+
+    /// <summary>
+    /// Get the default/basic weapon for a weapon type
+    /// Prioritizes weapons with "Simple" or "Basic" in the name
+    /// </summary>
+    public WeaponItem GetDefaultWeaponByType(WeaponType weaponType)
+    {
+        var weaponsOfType = GetWeaponsByType(weaponType);
+        if (weaponsOfType.Count == 0) return null;
+
+        // Try to find a "simple" or "basic" weapon first
+        var simpleWeapon = weaponsOfType.FirstOrDefault(w =>
+            w.itemName.ToLower().Contains("simple") ||
+            w.itemName.ToLower().Contains("basic"));
+
+        return simpleWeapon ?? weaponsOfType[0]; // Return first if no simple weapon found
+    }
+
+    /// <summary>
+    /// Register a weapon in the registry (for runtime additions)
+    /// </summary>
+    public void RegisterWeapon(WeaponItem weapon)
+    {
+        if (weapon != null && !availableWeapons.Contains(weapon))
+        {
+            availableWeapons.Add(weapon);
+        }
+    }
+
+    /// <summary>
+    /// Get all available weapons
+    /// </summary>
+    public List<WeaponItem> GetAllWeapons()
+    {
+        return availableWeapons.Where(w => w != null).ToList();
+    }
+
+    /// <summary>
+    /// Debug method to list all available weapons
+    /// </summary>
+    [ContextMenu("Debug List All Weapons")]
+    public void DebugListAllWeapons()
+    {
+        Debug.Log($"=== WeaponRegistry: {availableWeapons.Count} weapons ===");
+        foreach (var weapon in availableWeapons)
+        {
+            if (weapon != null)
+            {
+                Debug.Log($"• {weapon.itemName} ({weapon.weaponType}) - Damage: {weapon.minDamage}-{weapon.maxDamage}");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Initialize the registry with common weapons if empty
+    /// </summary>
+    [ContextMenu("Initialize Default Weapons")]
+    public void InitializeDefaults()
+    {
+        // This would be called to auto-populate with default weapons
+        // In practice, you'd manually assign weapons in the inspector
+        Debug.Log("WeaponRegistry: Use the inspector to assign available weapons");
+    }
+}

Assets/Scripts/Objects/Weapons/Fists.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+
+public class Fists : Weapon
+{
+    public Fists() : base()
+    {
+        weaponName = "Fists";
+        description = "Bare fists - a basic unarmed attack.";
+        attackSpeed = 1.0f; // 1 second attack speed
+        weaponModel = null; // No 3D model needed for fists
+        weaponModifier = 0; // No modifier for bare fists
+        baseWeaponModifier = 0;
+    }
+
+    // Fists deal 1d4 damage (1-4)
+    public override int MinDamage => 1;
+    public override int MaxDamage => 4;
+
+    // Fists have very short range (melee)
+    public override int Range => 2;
+
+    public override int WeaponModifier { get => weaponModifier; set => weaponModifier = value; }
+}

Assets/Scripts/Objects/Weapons/SimpleBow.asset

@@ -1,32 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 3f3fc2d34ad47104ea60fdf8fa56b9e6, type: 3}
-  m_Name: SimpleBow
-  m_EditorClassIdentifier: 
-  itemName: Basic Bow
-  description: A Simple wooden bow
-  icon: {fileID: 0}
-  model3D: {fileID: 5410050047777400374, guid: e0447dc7b412ede4b9090f9a3cf4fdd4, type: 3}
-  itemType: 0
-  rarity: 0
-  goldCost: 15
-  silverCost: 0
-  copperCost: 0
-  searchTags: []
-  minDamage: 1
-  maxDamage: 6
-  range: 100
-  weaponModifier: 0
-  attackSpeed: 2
-  weaponType: 0
-  weaponClassName: 
-  arrowPrefab: {fileID: 6456274890147168025, guid: 74d688b6c70543e46a9b3ea3c4c8e787, type: 3}

Assets/Scripts/Objects/Weapons/SimpleSword.asset

@@ -1,33 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 3f3fc2d34ad47104ea60fdf8fa56b9e6, type: 3}
-  m_Name: SimpleSword
-  m_EditorClassIdentifier: 
-  itemName: Basic Sword
-  description: A common simple sword
-  icon: {fileID: 0}
-  model3D: {fileID: 5410050047777400374, guid: 2e07955f8c531dc4ea65c9d6a521f306, type: 3}
-  itemType: 0
-  rarity: 0
-  goldCost: 10
-  silverCost: 0
-  copperCost: 0
-  searchTags:
-  - sword
-  minDamage: 1
-  maxDamage: 6
-  range: 0
-  weaponModifier: 0
-  attackSpeed: 1
-  weaponType: 0
-  weaponClassName: 
-  arrowPrefab: {fileID: 0}

Assets/Scripts/UI/ItemShopManager.cs

@@ -100,7 +100,7 @@ public class ItemShopManager : MonoBehaviour
 
         // Note: This creates runtime instances, not asset files
         var simpleSword = ScriptableObject.CreateInstance<WeaponItem>();
-        simpleSword.itemName = "Simple Sword";
+        simpleSword.itemName = "Basic Sword"; // Match actual asset name
         simpleSword.description = "A basic sword for beginners.";
         simpleSword.itemType = ItemType.Weapon;
         simpleSword.goldCost = 10;
@@ -111,7 +111,7 @@ public class ItemShopManager : MonoBehaviour
         availableItems.Add(simpleSword);
 
         var simpleBow = ScriptableObject.CreateInstance<WeaponItem>();
-        simpleBow.itemName = "Simple Bow";
+        simpleBow.itemName = "Basic Bow"; // Match actual asset name
         simpleBow.description = "A basic bow for shooting arrows.";
         simpleBow.itemType = ItemType.Weapon;
         simpleBow.goldCost = 15;

Assets/Scripts/Utilities/CombatIntegrationSetup.cs

@@ -0,0 +1,404 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+/// <summary>
+/// Automatic setup script for the Combat Scene Integration system
+/// Run this in the Unity Editor to quickly set up the system in your scenes
+/// </summary>
+public class CombatIntegrationSetup : MonoBehaviour
+{
+    [Header("Setup Configuration")]
+    [Tooltip("The name of your battle scene")]
+    public string battleSceneName = "BattleScene";
+
+    [Tooltip("Enable debug logging for all components")]
+    public bool enableDebugLogs = true;
+
+    [Header("Setup Actions")]
+    [Tooltip("Set up the map scene with CombatSceneManager")]
+    public bool setupMapScene = true;
+
+    [Tooltip("Set up the battle scene with EnhancedBattleSetup")]
+    public bool setupBattleScene = true;
+
+    [Header("UI Setup")]
+    [Tooltip("Create a battle context UI text element")]
+    public bool createBattleContextUI = true;
+
+    [Tooltip("Font size for the battle context text")]
+    public int contextTextFontSize = 18;
+
+    /// <summary>
+    /// Set up the entire combat integration system
+    /// </summary>
+    [ContextMenu("Setup Combat Integration System")]
+    public void SetupSystem()
+    {
+        Debug.Log("🔧 Setting up Combat Integration System...");
+
+        string currentScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
+
+        if (setupMapScene && IsMapScene(currentScene))
+        {
+            SetupMapSceneComponents();
+        }
+
+        if (setupBattleScene && IsBattleScene(currentScene))
+        {
+            SetupBattleSceneComponents();
+        }
+
+        Debug.Log("✅ Combat Integration System setup complete!");
+        Debug.Log("📖 See COMBAT_SCENE_INTEGRATION_GUIDE.md for usage instructions");
+    }
+
+    /// <summary>
+    /// Set up components needed in the map scene
+    /// </summary>
+    [ContextMenu("Setup Map Scene")]
+    public void SetupMapSceneComponents()
+    {
+        Debug.Log("🗺️ Setting up map scene components...");
+
+        // 1. Find or create CombatSceneManager
+        var existingManager = FindFirstObjectByType<CombatSceneManager>();
+        if (existingManager == null)
+        {
+            GameObject managerObj = new GameObject("CombatSceneManager");
+            var manager = managerObj.AddComponent<CombatSceneManager>();
+
+            // Configure the manager
+            SetManagerProperties(manager);
+
+            Debug.Log("✅ Created CombatSceneManager");
+        }
+        else
+        {
+            SetManagerProperties(existingManager);
+            Debug.Log("✅ Found and configured existing CombatSceneManager");
+        }
+
+        // 2. Verify CombatEventIntegration exists
+        var combatIntegration = FindFirstObjectByType<CombatEventIntegration>();
+        if (combatIntegration == null)
+        {
+            Debug.LogWarning("⚠️ No CombatEventIntegration found in scene - please ensure it's set up for combat events to work");
+        }
+        else
+        {
+            Debug.Log("✅ Found CombatEventIntegration");
+        }
+
+        // 3. Check for terrain generator
+        var terrainGen = FindFirstObjectByType<BFMTerrainGenerator>();
+        if (terrainGen == null)
+        {
+            Debug.LogWarning("⚠️ No BFMTerrainGenerator found - terrain effects will be limited");
+        }
+        else
+        {
+            Debug.Log("✅ Found BFMTerrainGenerator");
+        }
+    }
+
+    /// <summary>
+    /// Set up components needed in the battle scene
+    /// </summary>
+    [ContextMenu("Setup Battle Scene")]
+    public void SetupBattleSceneComponents()
+    {
+        Debug.Log("⚔️ Setting up battle scene components...");
+
+        // 1. Find existing BattleSetup
+        var battleSetup = FindFirstObjectByType<BattleSetup>();
+        if (battleSetup == null)
+        {
+            Debug.LogError("❌ No BattleSetup component found in scene! Please ensure you're in the correct battle scene.");
+            return;
+        }
+
+        // 2. Add EnhancedBattleSetup if not present
+        var enhancedSetup = battleSetup.GetComponent<EnhancedBattleSetup>();
+        if (enhancedSetup == null)
+        {
+            enhancedSetup = battleSetup.gameObject.AddComponent<EnhancedBattleSetup>();
+            Debug.Log("✅ Added EnhancedBattleSetup component");
+        }
+        else
+        {
+            Debug.Log("✅ Found existing EnhancedBattleSetup component");
+        }
+
+        // Configure enhanced setup
+        SetEnhancedSetupProperties(enhancedSetup);
+
+        // 3. Set up terrain generator
+        var terrainGen = FindFirstObjectByType<BFMTerrainGenerator>();
+        if (terrainGen == null)
+        {
+            Debug.LogWarning("⚠️ No BFMTerrainGenerator found in battle scene - terrain setup will be skipped");
+        }
+        else
+        {
+            enhancedSetup.terrainGenerator = terrainGen;
+            Debug.Log("✅ Connected BFMTerrainGenerator to EnhancedBattleSetup");
+        }
+
+        // 4. Set up battle context UI if requested
+        if (createBattleContextUI)
+        {
+            SetupBattleContextUI(enhancedSetup);
+        }
+    }
+
+    /// <summary>
+    /// Configure CombatSceneManager properties
+    /// </summary>
+    private void SetManagerProperties(CombatSceneManager manager)
+    {
+        if (manager == null) return;
+
+        // Use reflection to set properties since we might have compilation issues
+        var type = manager.GetType();
+
+        // Set battle scene name
+        var battleSceneField = type.GetField("battleSceneName");
+        if (battleSceneField != null)
+        {
+            battleSceneField.SetValue(manager, battleSceneName);
+        }
+
+        // Set debug logs
+        var debugField = type.GetField("showDebugLogs");
+        if (debugField != null)
+        {
+            debugField.SetValue(manager, enableDebugLogs);
+        }
+
+        Debug.Log($"📝 Configured CombatSceneManager: scene='{battleSceneName}', debug={enableDebugLogs}");
+    }
+
+    /// <summary>
+    /// Configure EnhancedBattleSetup properties
+    /// </summary>
+    private void SetEnhancedSetupProperties(EnhancedBattleSetup enhancedSetup)
+    {
+        if (enhancedSetup == null) return;
+
+        var type = enhancedSetup.GetType();
+
+        // Enable enhanced setup
+        var useEnhancedField = type.GetField("useEnhancedSetup");
+        if (useEnhancedField != null)
+        {
+            useEnhancedField.SetValue(enhancedSetup, true);
+        }
+
+        // Set debug logs
+        var debugField = type.GetField("showDebugLogs");
+        if (debugField != null)
+        {
+            debugField.SetValue(enhancedSetup, enableDebugLogs);
+        }
+
+        Debug.Log($"📝 Configured EnhancedBattleSetup: enhanced=true, debug={enableDebugLogs}");
+    }
+
+    /// <summary>
+    /// Set up battle context UI
+    /// </summary>
+    private void SetupBattleContextUI(EnhancedBattleSetup enhancedSetup)
+    {
+        // Look for existing Canvas
+        Canvas canvas = FindFirstObjectByType<Canvas>();
+        if (canvas == null)
+        {
+            Debug.LogWarning("⚠️ No Canvas found - cannot create battle context UI");
+            return;
+        }
+
+        // Check if battle context text already exists
+        Transform existingText = canvas.transform.Find("BattleContextText");
+        if (existingText != null)
+        {
+            var existingTextComp = existingText.GetComponent<Text>();
+            if (existingTextComp != null)
+            {
+                AssignBattleContextText(enhancedSetup, existingTextComp);
+                Debug.Log("✅ Found and assigned existing BattleContextText");
+                return;
+            }
+        }
+
+        // Create new battle context UI
+        GameObject textObj = new GameObject("BattleContextText");
+        textObj.transform.SetParent(canvas.transform, false);
+
+        // Add Text component
+        Text textComponent = textObj.AddComponent<Text>();
+        textComponent.text = "Battle Context Will Appear Here";
+        textComponent.fontSize = contextTextFontSize;
+        textComponent.color = Color.white;
+        textComponent.alignment = TextAnchor.UpperCenter;
+
+        // Try to assign a font
+        textComponent.font = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
+
+        // Position at top of screen
+        RectTransform rectTransform = textComponent.GetComponent<RectTransform>();
+        rectTransform.anchorMin = new Vector2(0, 1);
+        rectTransform.anchorMax = new Vector2(1, 1);
+        rectTransform.pivot = new Vector2(0.5f, 1);
+        rectTransform.offsetMin = new Vector2(10, -100);
+        rectTransform.offsetMax = new Vector2(-10, -10);
+
+        // Assign to enhanced setup
+        AssignBattleContextText(enhancedSetup, textComponent);
+
+        Debug.Log("✅ Created BattleContextText UI element");
+    }
+
+    /// <summary>
+    /// Assign battle context text to enhanced setup using reflection
+    /// </summary>
+    private void AssignBattleContextText(EnhancedBattleSetup enhancedSetup, Text textComponent)
+    {
+        var type = enhancedSetup.GetType();
+        var textField = type.GetField("battleContextText");
+        if (textField != null)
+        {
+            textField.SetValue(enhancedSetup, textComponent);
+            Debug.Log("📝 Assigned battle context text to EnhancedBattleSetup");
+        }
+    }
+
+    /// <summary>
+    /// Check if current scene is a map scene
+    /// </summary>
+    private bool IsMapScene(string sceneName)
+    {
+        return sceneName.ToLower().Contains("map") ||
+               sceneName.ToLower().Contains("travel") ||
+               sceneName.ToLower().Contains("world");
+    }
+
+    /// <summary>
+    /// Check if current scene is a battle scene
+    /// </summary>
+    private bool IsBattleScene(string sceneName)
+    {
+        return sceneName.ToLower().Contains("battle") ||
+               sceneName.ToLower().Contains("combat") ||
+               sceneName.ToLower().Contains("fight");
+    }
+
+    /// <summary>
+    /// Validate the current setup
+    /// </summary>
+    [ContextMenu("Validate Setup")]
+    public void ValidateSetup()
+    {
+        Debug.Log("🔍 Validating Combat Integration Setup...");
+
+        string currentScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
+        bool isValid = true;
+
+        if (IsMapScene(currentScene))
+        {
+            isValid &= ValidateMapScene();
+        }
+        else if (IsBattleScene(currentScene))
+        {
+            isValid &= ValidateBattleScene();
+        }
+        else
+        {
+            Debug.LogWarning($"⚠️ Unknown scene type: {currentScene}");
+        }
+
+        if (isValid)
+        {
+            Debug.Log("✅ Setup validation passed!");
+        }
+        else
+        {
+            Debug.LogWarning("⚠️ Setup validation found issues - see messages above");
+        }
+    }
+
+    /// <summary>
+    /// Validate map scene setup
+    /// </summary>
+    private bool ValidateMapScene()
+    {
+        bool valid = true;
+
+        // Check CombatSceneManager
+        var manager = FindFirstObjectByType<CombatSceneManager>();
+        if (manager == null)
+        {
+            Debug.LogError("❌ CombatSceneManager not found in map scene");
+            valid = false;
+        }
+        else
+        {
+            Debug.Log("✅ CombatSceneManager found");
+        }
+
+        // Check CombatEventIntegration
+        var integration = FindFirstObjectByType<CombatEventIntegration>();
+        if (integration == null)
+        {
+            Debug.LogWarning("⚠️ CombatEventIntegration not found - combat events may not work");
+        }
+        else
+        {
+            Debug.Log("✅ CombatEventIntegration found");
+        }
+
+        return valid;
+    }
+
+    /// <summary>
+    /// Validate battle scene setup
+    /// </summary>
+    private bool ValidateBattleScene()
+    {
+        bool valid = true;
+
+        // Check BattleSetup
+        var battleSetup = FindFirstObjectByType<BattleSetup>();
+        if (battleSetup == null)
+        {
+            Debug.LogError("❌ BattleSetup not found in battle scene");
+            valid = false;
+        }
+        else
+        {
+            Debug.Log("✅ BattleSetup found");
+
+            // Check EnhancedBattleSetup
+            var enhancedSetup = battleSetup.GetComponent<EnhancedBattleSetup>();
+            if (enhancedSetup == null)
+            {
+                Debug.LogWarning("⚠️ EnhancedBattleSetup not found - enhanced features will not work");
+            }
+            else
+            {
+                Debug.Log("✅ EnhancedBattleSetup found");
+            }
+        }
+
+        return valid;
+    }
+
+    /// <summary>
+    /// Clean up this setup script (remove it after setup is complete)
+    /// </summary>
+    [ContextMenu("Remove Setup Script")]
+    public void RemoveSetupScript()
+    {
+        Debug.Log("🧹 Removing CombatIntegrationSetup script...");
+        DestroyImmediate(this);
+    }
+}

Assets/Scripts/Utilities/CombatIntegrationTest.cs

@@ -0,0 +1,304 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+/// <summary>
+/// Test script for the Combat Scene Integration system
+/// Use this to verify that the system works correctly
+/// </summary>
+public class CombatIntegrationTest : MonoBehaviour
+{
+    [Header("Test Configuration")]
+    [Tooltip("Test terrain type for combat")]
+    public TerrainType testTerrain = TerrainType.Forest;
+
+    [Tooltip("Test feature type")]
+    public FeatureType testFeature = FeatureType.Road;
+
+    [Tooltip("Number of test enemies")]
+    public int testEnemyCount = 2;
+
+    [Tooltip("Test enemy type name")]
+    public string testEnemyType = "Test Bandit";
+
+    [Header("Test Controls")]
+    [Tooltip("Enable this to run test combat on Start")]
+    public bool runTestOnStart = false;
+
+    void Start()
+    {
+        if (runTestOnStart)
+        {
+            // Delay the test slightly to ensure scene is fully loaded
+            Invoke(nameof(RunCombatTest), 1f);
+        }
+    }
+
+    /// <summary>
+    /// Run a test combat scenario
+    /// </summary>
+    [ContextMenu("Run Combat Test")]
+    public void RunCombatTest()
+    {
+        Debug.Log("🧪 Running combat integration test...");
+
+        // Create test team data
+        List<TeamCharacter> testTeam = CreateTestTeam();
+
+        // Create test battle data
+        BattleEventData testBattleData = CreateTestBattleData();
+
+        // Create test context
+        TravelEventContext testContext = CreateTestContext();
+
+        // Initialize combat session
+        CombatDataTransfer.InitializeCombatSession(testBattleData, testContext, testTeam);
+
+        // Debug the session
+        CombatDataTransfer.DebugLogSession();
+
+        // Test the CombatSceneManager
+        TestCombatSceneManager();
+
+        Debug.Log("✅ Combat integration test complete!");
+    }
+
+    /// <summary>
+    /// Create test team data
+    /// </summary>
+    private List<TeamCharacter> CreateTestTeam()
+    {
+        List<TeamCharacter> team = new List<TeamCharacter>();
+
+        // Create a test warrior
+        var warrior = new TeamCharacter
+        {
+            name = "Test Warrior",
+            isMale = true,
+            strength = 16,
+            dexterity = 12,
+            constitution = 14,
+            wisdom = 10,
+            perception = 11,
+            gold = 50,
+            silver = 25,
+            copper = 10,
+            equippedWeapon = "Sword",
+            equippedArmor = "Leather Armor",
+            weapons = new List<string> { "Sword", "Bow" },
+            armor = new List<string> { "Leather Armor" }
+        };
+        team.Add(warrior);
+
+        // Create a test archer
+        var archer = new TeamCharacter
+        {
+            name = "Test Archer",
+            isMale = false,
+            strength = 12,
+            dexterity = 16,
+            constitution = 12,
+            wisdom = 14,
+            perception = 15,
+            gold = 45,
+            silver = 30,
+            copper = 5,
+            equippedWeapon = "Bow",
+            equippedArmor = "",
+            weapons = new List<string> { "Bow", "Dagger" },
+            armor = new List<string>()
+        };
+        team.Add(archer);
+
+        Debug.Log($"🏷️ Created test team with {team.Count} members");
+        return team;
+    }
+
+    /// <summary>
+    /// Create test battle data
+    /// </summary>
+    private BattleEventData CreateTestBattleData()
+    {
+        var battleData = new BattleEventData
+        {
+            enemyCount = testEnemyCount,
+            enemyType = testEnemyType,
+            battleDescription = $"A test encounter with {testEnemyCount} {testEnemyType}s",
+            enemyCharacterData = null // Could be set to a real EnemyCharacterData asset
+        };
+
+        Debug.Log($"⚔️ Created test battle data: {battleData.enemyCount}x {battleData.enemyType}");
+        return battleData;
+    }
+
+    /// <summary>
+    /// Create test travel context
+    /// </summary>
+    private TravelEventContext CreateTestContext()
+    {
+        // Create a mock map tile
+        var mockTile = new MapTile(0, 0)
+        {
+            terrainType = testTerrain,
+            featureType = testFeature
+        };
+
+        var context = new TravelEventContext(Vector2Int.zero, mockTile, null)
+        {
+            dayOfJourney = 3,
+            timeOfDay = 14.5f, // 2:30 PM
+            currentWeather = Weather.Clear,
+            teamGold = 150,
+            teamFood = 75,
+            teamMorale = 0.8f,
+            isOnMainRoad = testFeature == FeatureType.Road,
+            distanceToDestination = 25.5f
+        };
+
+        Debug.Log($"🌍 Created test context: {testTerrain} terrain, {testFeature} feature");
+        return context;
+    }
+
+    /// <summary>
+    /// Test the CombatSceneManager functionality
+    /// </summary>
+    private void TestCombatSceneManager()
+    {
+        // Find CombatSceneManager
+        var manager = FindFirstObjectByType<MonoBehaviour>();
+        MonoBehaviour combatManager = null;
+
+        // Look for CombatSceneManager by name
+        var allComponents = FindObjectsByType<MonoBehaviour>(FindObjectsSortMode.None);
+        foreach (var comp in allComponents)
+        {
+            if (comp.GetType().Name == "CombatSceneManager")
+            {
+                combatManager = comp;
+                break;
+            }
+        }
+
+        if (combatManager != null)
+        {
+            Debug.Log("✅ Found CombatSceneManager");
+
+            // Test getting battle context description
+            var method = combatManager.GetType().GetMethod("GetBattleContextDescription");
+            if (method != null)
+            {
+                string description = (string)method.Invoke(combatManager, null);
+                Debug.Log($"📝 Battle context: {description}");
+            }
+        }
+        else
+        {
+            Debug.LogWarning("⚠️ CombatSceneManager not found - add it to test scene loading");
+        }
+    }
+
+    /// <summary>
+    /// Test data transfer without scene loading
+    /// </summary>
+    [ContextMenu("Test Data Transfer Only")]
+    public void TestDataTransferOnly()
+    {
+        Debug.Log("📊 Testing data transfer system...");
+
+        // Create test data
+        List<TeamCharacter> testTeam = CreateTestTeam();
+        BattleEventData testBattleData = CreateTestBattleData();
+        TravelEventContext testContext = CreateTestContext();
+
+        // Test initialization
+        CombatDataTransfer.InitializeCombatSession(testBattleData, testContext, testTeam);
+
+        // Test session validity
+        bool hasValidSession = CombatDataTransfer.HasValidSession();
+        Debug.Log($"🔍 Has valid session: {hasValidSession}");
+
+        // Test getting session data
+        var session = CombatDataTransfer.GetCurrentSession();
+        if (session != null)
+        {
+            Debug.Log($"👥 Player team: {session.playerTeam.Count} members");
+            Debug.Log($"👹 Enemies: {session.enemies.Count} enemies");
+            Debug.Log($"🌍 Terrain: {session.battleTerrain}");
+            Debug.Log($"🌤️ Weather: {session.weather}");
+
+            // Test terrain description
+            string terrainDesc = CombatDataTransfer.GetTerrainDescription(session.battleTerrain, session.battleFeature);
+            Debug.Log($"📝 Terrain description: {terrainDesc}");
+        }
+
+        // Test legacy compatibility
+        CombatDataTransfer.PopulateLegacyBattleSetupData();
+        Debug.Log($"🔧 Legacy data populated: {BattleSetupData.playerSelections.Count} players, {BattleSetupData.enemySelections.Count} enemies");
+
+        // Test cleanup
+        CombatDataTransfer.ClearSession();
+        Debug.Log($"🧹 Session cleared. Has valid session: {CombatDataTransfer.HasValidSession()}");
+
+        Debug.Log("✅ Data transfer test complete!");
+    }
+
+    /// <summary>
+    /// Test team data loading from various sources
+    /// </summary>
+    [ContextMenu("Test Team Data Loading")]
+    public void TestTeamDataLoading()
+    {
+        Debug.Log("👥 Testing team data loading...");
+
+        // Test MainTeamSelectScript
+        var teamSelect = FindFirstObjectByType<MainTeamSelectScript>();
+        if (teamSelect != null)
+        {
+            var characters = teamSelect.GetConfiguredCharacters();
+            Debug.Log($"📋 MainTeamSelectScript: {characters?.Count ?? 0} characters");
+        }
+        else
+        {
+            Debug.Log("📋 MainTeamSelectScript: Not found");
+        }
+
+        // Test GameStateManager
+        if (GameStateManager.Instance != null && GameStateManager.Instance.savedTeam != null)
+        {
+            int count = 0;
+            foreach (var char_ in GameStateManager.Instance.savedTeam)
+            {
+                if (char_ != null) count++;
+            }
+            Debug.Log($"💾 GameStateManager: {count} characters");
+        }
+        else
+        {
+            Debug.Log("💾 GameStateManager: Not available or no saved team");
+        }
+
+        // Test PlayerPrefs
+        int prefCount = 0;
+        for (int i = 0; i < 4; i++)
+        {
+            if (PlayerPrefs.GetInt($"Character{i}_Exists", 0) == 1)
+            {
+                prefCount++;
+            }
+        }
+        Debug.Log($"🗃️ PlayerPrefs: {prefCount} characters");
+
+        Debug.Log("✅ Team data loading test complete!");
+    }
+
+    /// <summary>
+    /// Clear test data
+    /// </summary>
+    [ContextMenu("Clear Test Data")]
+    public void ClearTestData()
+    {
+        CombatDataTransfer.ClearSession();
+        BattleSetupData.playerSelections.Clear();
+        BattleSetupData.enemySelections.Clear();
+        Debug.Log("🧹 Test data cleared");
+    }
+}

Assets/UI/MainSettings.asset

@@ -26,7 +26,7 @@ MonoBehaviour:
   m_ReferenceResolution: {x: 1200, y: 800}
   m_ScreenMatchMode: 0
   m_Match: 0
-  m_SortingOrder: 0
+  m_SortingOrder: 5
   m_TargetDisplay: 0
   m_BindingLogLevel: 0
   m_ClearDepthStencil: 1

COMBAT_SCENE_INTEGRATION_GUIDE.md

@@ -0,0 +1,315 @@
+# Combat Event to Battle Scene Integration Guide
+
+## Overview
+
+This guide explains how to implement the new combat event system that allows players to fight combat encounters and loads the BattleScene with team data (characters, weapons, etc.) and terrain information (plains, mountain, road, etc.).
+
+## 🎯 Features Implemented
+
+### 1. **Combat Data Transfer System**
+- **File**: `Assets/Scripts/BattleSetup/CombatDataTransfer.cs`
+- **Purpose**: Transfers team data, enemy data, and environmental information between scenes
+- **Features**:
+  - Team character combat data (stats, equipment, resources)
+  - Enemy combat data (health, armor class, threat level)
+  - Environmental context (terrain type, weather, time of day)
+  - Legacy compatibility with existing BattleSetupData
+
+### 2. **Combat Scene Manager**
+- **File**: `Assets/Scripts/BattleSetup/CombatSceneManager.cs`
+- **Purpose**: Manages the transition from travel events to battle scenes
+- **Features**:
+  - Loads battle scene with proper data transfer
+  - Sets up terrain based on combat location
+  - Manages team data collection from multiple sources
+  - Handles return to map after battle
+
+### 3. **Enhanced Battle Setup**
+- **File**: `Assets/Scripts/BattleScene/EnhancedBattleSetup.cs`
+- **Purpose**: Extends existing BattleSetup with rich combat data
+- **Features**:
+  - Terrain configuration in battle scene
+  - UI updates with battle context
+  - Enhanced character stat application
+  - Debug and monitoring tools
+
+### 4. **Updated Combat Event Integration**
+- **File**: `Assets/Scripts/Events/CombatEventIntegration.cs` (modified)
+- **Purpose**: Connects the new system with existing combat events
+- **Features**:
+  - Uses CombatSceneManager for battle transitions
+  - Fallback to legacy systems when needed
+  - Proper error handling and logging
+
+## 🚀 Setup Instructions
+
+### Step 1: Add CombatSceneManager to Your Map Scene
+
+1. **Create the Manager GameObject**:
+   ```
+   In your MapScene2 (or main travel scene):
+   1. Create an empty GameObject
+   2. Name it "CombatSceneManager"
+   3. Add the CombatSceneManager component
+   ```
+
+2. **Configure the Manager**:
+   ```
+   In the CombatSceneManager inspector:
+   - Battle Scene Name: "BattleScene" (or your battle scene name)
+   - Show Debug Logs: ✓ (recommended for testing)
+   - Terrain Generator: (will auto-find BFMTerrainGenerator)
+   ```
+
+### Step 2: Add EnhancedBattleSetup to Your Battle Scene
+
+1. **Enhance Battle Setup**:
+   ```
+   In your BattleScene:
+   1. Find the GameObject with BattleSetup component
+   2. Add the EnhancedBattleSetup component to the same GameObject
+   3. Configure the component settings
+   ```
+
+2. **Configure Enhanced Setup**:
+   ```
+   In the EnhancedBattleSetup inspector:
+   - Use Enhanced Setup: ✓
+   - Battle Context Text: (drag a UI Text element for battle info)
+   - Terrain Generator: (will auto-find BFMTerrainGenerator)
+   - Show Debug Logs: ✓ (recommended for testing)
+   ```
+
+### Step 3: Verify Combat Event Integration
+
+1. **Check CombatEventIntegration**:
+   ```
+   In your MapScene2:
+   1. Find the GameObject with CombatEventIntegration component
+   2. Ensure it's properly configured with popup references
+   3. The system will automatically use the new CombatSceneManager
+   ```
+
+## 🎮 How It Works
+
+### 1. **Combat Event Triggered**
+```
+Player travels on map → Travel Event System → Combat Event occurs → Combat popup appears
+```
+
+### 2. **Player Chooses to Fight**
+```
+Player clicks "ATTACK!" → CombatEventIntegration → CombatSceneManager → Battle scene loads
+```
+
+### 3. **Data Transfer Process**
+```
+1. CombatDataTransfer.InitializeCombatSession() is called
+2. Team data is collected from MainTeamSelectScript/GameStateManager/PlayerPrefs
+3. Enemy data is extracted from combat event
+4. Terrain and weather information is captured
+5. Legacy BattleSetupData is populated for compatibility
+6. Battle scene is loaded
+```
+
+### 4. **Battle Scene Setup**
+```
+1. EnhancedBattleSetup detects combat session data
+2. Terrain is configured based on travel location
+3. UI is updated with battle context
+4. Character placement proceeds using existing BattleSetup
+5. Enhanced stats are applied to characters
+```
+
+### 5. **Battle End**
+```
+Battle completes → EnhancedBattleSetup.EndBattleSession() → Return to map scene
+```
+
+## 🌍 Terrain System
+
+### Supported Terrain Types
+- **Plains**: Open grasslands (BFMTerrainType.Plain)
+- **Forest**: Dense woodland (BFMTerrainType.Forest)
+- **Mountain**: Rocky mountain terrain (BFMTerrainType.Mountain)
+- **River**: Along flowing water (defaults to Plain)
+- **Lake**: Near peaceful lake (defaults to Plain)
+- **Ocean**: Along coastline (defaults to Plain)
+
+### Environmental Features
+- **Roads**: Well-traveled paths
+- **Bridges**: Stone crossings
+- **Towns/Villages**: Settlement areas
+- **Tunnels**: Underground passages
+- **Harbors**: Coastal trading posts
+
+### Battle Context Examples
+```
+"Battle on a well-traveled road in open grasslands"
+"Battle in dense woodland during evening (clear weather)"
+"Battle at a stone bridge in rocky mountain terrain"
+```
+
+## 📊 Data Flow
+
+### Team Character Data
+```csharp
+TeamCharacter → TeamCharacterCombatData:
+- Name, gender, core stats (STR, DEX, CON, WIS, PER)
+- Combat stats (HP, AC) calculated from attributes
+- Equipment (weapons, armor)
+- Resources (gold, silver, copper)
+```
+
+### Enemy Data
+```csharp
+EnemyCharacterData → EnemyCombatData:
+- Enemy name and type
+- Health, armor class, threat level
+- Preferred weapons
+- Source data reference
+```
+
+### Environmental Data
+```csharp
+TravelEventContext → CombatSessionData:
+- Battle location coordinates
+- Terrain type and features
+- Weather conditions
+- Time of day
+```
+
+## 🔧 Integration Points
+
+### With Existing Systems
+
+1. **Travel Event System**: Automatically triggered during combat events
+2. **Team Selection**: Uses saved team data from character creation
+3. **Battle Setup**: Compatible with existing character placement system
+4. **Enemy System**: Works with EnemyCharacterData assets
+5. **UI System**: Integrates with existing combat popups
+
+### Data Sources Priority
+```
+1. MainTeamSelectScript.GetConfiguredCharacters() (if in scene)
+2. GameStateManager.Instance.savedTeam (persistent data)
+3. PlayerPrefs (fallback for individual character data)
+```
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **"No team members found" Error**:
+   ```
+   Solution: Ensure team data is saved properly:
+   - Create characters in Team Select scene
+   - Click "Save Game" or "Proceed to Battle"
+   - Check GameStateManager.Instance.savedTeam is populated
+   ```
+
+2. **"CombatSceneManager not found" Warning**:
+   ```
+   Solution: Add CombatSceneManager to your map scene:
+   - Create empty GameObject in MapScene2
+   - Add CombatSceneManager component
+   - Configure battle scene name
+   ```
+
+3. **Terrain not changing in battle**:
+   ```
+   Solution: Ensure BFMTerrainGenerator is properly set up:
+   - Add BFMTerrainGenerator to battle scene
+   - Assign to EnhancedBattleSetup.terrainGenerator field
+   - Check terrain type conversion in logs
+   ```
+
+4. **Battle scene not loading**:
+   ```
+   Solution: Check Build Settings:
+   - Ensure "BattleScene" is added to Build Settings
+   - Verify scene name matches CombatSceneManager.battleSceneName
+   - Check console for scene loading errors
+   ```
+
+### Debug Features
+
+1. **Enable Debug Logs**:
+   ```
+   - CombatSceneManager: showDebugLogs = true
+   - EnhancedBattleSetup: showDebugLogs = true
+   ```
+
+2. **Use Context Menu Commands**:
+   ```
+   - CombatSceneManager: "Start Test Combat"
+   - EnhancedBattleSetup: "Debug Combat Session"
+   ```
+
+3. **Check Combat Session Data**:
+   ```csharp
+   CombatDataTransfer.DebugLogSession(); // Call in console or script
+   ```
+
+## 🎯 Testing the System
+
+### 1. **Basic Test**
+```
+1. Start game → Create team → Travel on map
+2. Trigger combat event (wait for random or use debug)
+3. Choose "ATTACK!" in combat popup
+4. Verify battle scene loads with correct terrain
+5. Check console logs for data transfer info
+```
+
+### 2. **Terrain Test**
+```
+1. Travel to different terrain types (forest, mountain, plains)
+2. Trigger combat in each location
+3. Verify battle terrain matches travel terrain
+4. Check UI shows correct battle context
+```
+
+### 3. **Team Data Test**
+```
+1. Create characters with different equipment
+2. Start combat and check character stats in battle
+3. Verify weapons and armor are properly equipped
+4. Check combat stats (HP, AC) are calculated correctly
+```
+
+## 🔮 Future Enhancements
+
+### Planned Features
+- **Weather Effects**: Visual weather in battle scene
+- **Time of Day Lighting**: Dynamic lighting based on combat time
+- **Terrain Modifiers**: Stat bonuses/penalties based on terrain
+- **Equipment Integration**: Full equipment system in combat
+- **Experience Rewards**: Post-combat character progression
+
+### Extension Points
+- **Custom Terrain Types**: Add new BFMTerrainType values
+- **Environmental Hazards**: Weather-based combat effects
+- **Dynamic Enemy Scaling**: Terrain-based enemy modifications
+- **Post-Battle Events**: Consequences based on victory/defeat
+
+## 📝 Notes
+
+- The system maintains full backward compatibility with existing battle setup
+- All enhanced features are optional and can be disabled
+- Legacy BattleSetupData is still populated for existing systems
+- Debug logging provides detailed information for troubleshooting
+- The system gracefully degrades when components are missing
+
+---
+
+## Summary
+
+This combat integration system provides:
+✅ **Rich Data Transfer**: Team stats, equipment, and environmental context
+✅ **Terrain-Based Battles**: Dynamic battle environments based on travel location  
+✅ **Seamless Integration**: Works with existing combat and travel systems
+✅ **Robust Fallbacks**: Graceful degradation when components are missing
+✅ **Debug Support**: Comprehensive logging and testing tools
+
+The system transforms simple combat events into rich, contextual battle experiences that reflect where and when the fight takes place, while maintaining full compatibility with existing game systems.

COMBAT_SYSTEM_IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,176 @@
+# Combat Event to Battle Scene System - Implementation Summary
+
+## 🎯 What Was Implemented
+
+I've created a comprehensive system that allows combat events triggered during travel to seamlessly transition to the BattleScene with full team data (characters, weapons, equipment) and terrain information (plains, mountain, road, etc.).
+
+## 📁 Files Created
+
+### Core System Files
+1. **`CombatDataTransfer.cs`** - Handles data transfer between scenes
+2. **`CombatSceneManager.cs`** - Manages scene transitions and setup
+3. **`EnhancedBattleSetup.cs`** - Enhances battle scene with rich data
+4. **`CombatEventIntegration.cs`** - Modified to use new system
+
+### Utility Files
+5. **`CombatIntegrationSetup.cs`** - Automatic setup script
+6. **`CombatIntegrationTest.cs`** - Testing and validation script
+
+### Documentation
+7. **`COMBAT_SCENE_INTEGRATION_GUIDE.md`** - Complete usage guide
+
+## 🔧 How It Works
+
+### 1. **Combat Event Flow**
+```
+Travel on Map → Combat Event Triggered → Combat Popup Appears
+                                              ↓
+Player Chooses "FIGHT!" → CombatDataTransfer.InitializeCombatSession()
+                                              ↓
+                         CombatSceneManager.StartCombatEncounter()
+                                              ↓
+                         BattleScene Loads with Full Context
+```
+
+### 2. **Data Collection**
+The system automatically collects:
+- **Team Data**: From MainTeamSelectScript, GameStateManager, or PlayerPrefs
+- **Enemy Data**: From the combat event's EnemyCharacterData
+- **Terrain Data**: From the travel event context (current map position)
+- **Environmental Data**: Weather, time of day, location features
+
+### 3. **Battle Scene Setup**
+When the battle scene loads:
+- **Terrain**: Set based on travel location (Plains → BFMTerrainType.Plain, etc.)
+- **Team Stats**: Applied from saved character data (HP, AC calculated from attributes)
+- **Equipment**: Weapons and armor from character inventory
+- **Context UI**: Shows terrain, time, and weather information
+
+## 🌍 Terrain System
+
+### Supported Terrain Mapping
+- **Plains** → BFMTerrainType.Plain
+- **Forest** → BFMTerrainType.Forest  
+- **Mountain** → BFMTerrainType.Mountain
+- **River/Lake/Ocean** → BFMTerrainType.Plain (with contextual description)
+
+### Battle Context Examples
+- "Battle on a well-traveled road in open grasslands"
+- "Battle in dense woodland during evening (clear weather)"
+- "Battle at a stone bridge in rocky mountain terrain"
+
+## 🚀 Quick Setup Instructions
+
+### For Map Scene (MapScene2):
+1. Add `CombatIntegrationSetup` component to any GameObject
+2. Right-click component → "Setup Combat Integration System"
+3. This creates a `CombatSceneManager` GameObject with proper configuration
+
+### For Battle Scene:
+1. Add `CombatIntegrationSetup` component to any GameObject
+2. Right-click component → "Setup Combat Integration System"  
+3. This adds `EnhancedBattleSetup` to your existing `BattleSetup` GameObject
+
+### Manual Alternative:
+1. **Map Scene**: Create empty GameObject → Add `CombatSceneManager` component
+2. **Battle Scene**: Find `BattleSetup` GameObject → Add `EnhancedBattleSetup` component
+
+## 🧪 Testing the System
+
+### Method 1: Use Test Script
+1. Add `CombatIntegrationTest` to any GameObject
+2. Right-click component → "Run Combat Test"
+3. Check console logs for detailed test results
+
+### Method 2: Trigger Real Combat
+1. Start game → Create team → Travel on map
+2. Wait for combat event or use travel event debugging
+3. Choose "ATTACK!" in combat popup
+4. Verify battle scene loads with correct terrain
+
+## 📊 Data Flow Overview
+
+```
+TeamCharacter → TeamCharacterCombatData (HP, AC, equipment)
+     +
+EnemyCharacterData → EnemyCombatData (stats, threat level)
+     +
+TravelEventContext → Environmental Data (terrain, weather)
+     ↓
+CombatDataTransfer.CombatSessionData
+     ↓
+Battle Scene with Full Context
+```
+
+## 🔗 Integration Points
+
+### Existing Systems Compatibility
+- ✅ **Travel Event System**: Automatically triggered
+- ✅ **Team Selection**: Uses saved character data
+- ✅ **BattleSetup**: Maintains full compatibility
+- ✅ **Combat Popups**: Works with existing popup system
+- ✅ **Enemy System**: Uses EnemyCharacterData assets
+
+### Fallback Systems
+- **No CombatSceneManager**: Falls back to existing battle systems
+- **No Team Data**: Creates minimal viable battle setup
+- **No Terrain Generator**: Skips terrain setup gracefully
+- **Missing Components**: Detailed error logging for troubleshooting
+
+## 🐛 Common Issues & Solutions
+
+### "No team members found"
+- **Cause**: Team data not saved properly
+- **Solution**: Create characters in Team Select → Save Game
+
+### "CombatSceneManager not found"
+- **Cause**: Component not added to map scene
+- **Solution**: Run the setup script or manually add component
+
+### "Battle scene not loading"
+- **Cause**: Scene not in Build Settings
+- **Solution**: Add "BattleScene" to Build Settings
+
+### Terrain not changing
+- **Cause**: No BFMTerrainGenerator in battle scene
+- **Solution**: Ensure terrain generator is present and assigned
+
+## 🎯 Key Features
+
+### ✅ **Rich Data Transfer**
+- Full character stats, equipment, and resources
+- Enemy data with threat levels and preferred weapons
+- Environmental context (terrain, weather, time)
+
+### ✅ **Seamless Integration** 
+- Works with existing combat and travel systems
+- Maintains backward compatibility
+- Graceful fallbacks when components are missing
+
+### ✅ **Terrain-Based Battles**
+- Battle environment matches travel location
+- Visual and contextual terrain differences
+- Future-ready for terrain-based combat modifiers
+
+### ✅ **Debug & Testing Tools**
+- Comprehensive logging system
+- Test scripts for validation
+- Setup scripts for easy configuration
+
+## 🔮 Future Enhancement Ready
+
+The system is designed to easily support:
+- **Weather Effects**: Visual weather in battle scenes
+- **Time-based Lighting**: Dynamic lighting based on combat time  
+- **Terrain Modifiers**: Stat bonuses/penalties based on terrain
+- **Equipment Integration**: Full equipment system in combat
+- **Experience Rewards**: Post-combat character progression
+
+## 📝 Next Steps
+
+1. **Set up the system** using the provided setup scripts
+2. **Test with your existing combat events** to verify integration
+3. **Customize terrain mappings** if you have additional terrain types
+4. **Extend the system** with additional features as needed
+
+The system provides a solid foundation for rich, contextual combat experiences while maintaining full compatibility with your existing game systems!

UserSettings/EditorUserSettings.asset

@@ -18,16 +18,16 @@ EditorUserSettings:
       value: 510500025d560a0c095d092111730d44464f4b78757b72357a701c31b7b16368
       flags: 0
     RecentlyUsedSceneGuid-3:
-      value: 51020c5550545a0354575e7b47270744174e4b787e2b77687b7e1b37e7e4366d
+      value: 5309060006570d5f0c580e2715270c44144e1c722a7d20612c2d4b37b1b4643a
       flags: 0
     RecentlyUsedSceneGuid-4:
-      value: 5309060006570d5f0c580e2715270c44144e1c722a7d20612c2d4b37b1b4643a
+      value: 5a08575f5207595a0f5d59741173094444164f7d7d2a23317c7a4465bbe1646d
       flags: 0
     RecentlyUsedSceneGuid-5:
-      value: 5a08575f5207595a0f5d59741173094444164f7d7d2a23317c7a4465bbe1646d
+      value: 5a090503000558580f0d557342700844144f4d7c7b7d74692c281e63b0e2623c
       flags: 0
     RecentlyUsedSceneGuid-6:
-      value: 5a090503000558580f0d557342700844144f4d7c7b7d74692c281e63b0e2623c
+      value: 51020c5550545a0354575e7b47270744174e4b787e2b77687b7e1b37e7e4366d
       flags: 0
     vcSharedLogLevel:
       value: 0d5e400f0650

UserSettings/Layouts/default-6000.dwlt

@@ -19,7 +19,7 @@ MonoBehaviour:
     width: 3440
     height: 1349
   m_ShowMode: 4
-  m_Title: Inspector
+  m_Title: Scene
   m_RootView: {fileID: 5}
   m_MinSize: {x: 875, y: 332}
   m_MaxSize: {x: 10000, y: 10000}
@@ -39,9 +39,9 @@ MonoBehaviour:
   m_Children: []
   m_Position:
     serializedVersion: 2
-    x: 1686
+    x: 1680
     y: 0
-    width: 1110
+    width: 1105
     height: 439
   m_MinSize: {x: 102, y: 126}
   m_MaxSize: {x: 4002, y: 4026}
@@ -69,7 +69,7 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 854
-    width: 2796
+    width: 2785
     height: 439
   m_MinSize: {x: 200, y: 50}
   m_MaxSize: {x: 16192, y: 8096}
@@ -91,9 +91,9 @@ MonoBehaviour:
   m_Children: []
   m_Position:
     serializedVersion: 2
-    x: 1405
+    x: 1400
     y: 0
-    width: 1391
+    width: 1385
     height: 854
   m_MinSize: {x: 52, y: 76}
   m_MaxSize: {x: 4002, y: 4026}
@@ -198,7 +198,7 @@ MonoBehaviour:
   m_MinSize: {x: 400, y: 100}
   m_MaxSize: {x: 32384, y: 16192}
   vertical: 0
-  controlID: 47
+  controlID: 38
   draggingID: 0
 --- !u!114 &9
 MonoBehaviour:
@@ -219,12 +219,12 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 0
-    width: 2796
+    width: 2785
     height: 1293
   m_MinSize: {x: 300, y: 100}
   m_MaxSize: {x: 24288, y: 16192}
   vertical: 1
-  controlID: 48
+  controlID: 39
   draggingID: 0
 --- !u!114 &10
 MonoBehaviour:
@@ -246,12 +246,12 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 0
-    width: 2796
+    width: 2785
     height: 854
   m_MinSize: {x: 300, y: 50}
   m_MaxSize: {x: 24288, y: 8096}
   vertical: 0
-  controlID: 49
+  controlID: 40
   draggingID: 0
 --- !u!114 &11
 MonoBehaviour:
@@ -270,7 +270,7 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 0
-    width: 638
+    width: 637
     height: 854
   m_MinSize: {x: 201, y: 226}
   m_MaxSize: {x: 4001, y: 4026}
@@ -294,9 +294,9 @@ MonoBehaviour:
   m_Children: []
   m_Position:
     serializedVersion: 2
-    x: 638
+    x: 637
     y: 0
-    width: 767
+    width: 763
     height: 854
   m_MinSize: {x: 202, y: 226}
   m_MaxSize: {x: 4002, y: 4026}
@@ -324,7 +324,7 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 0
-    width: 1686
+    width: 1680
     height: 439
   m_MinSize: {x: 231, y: 276}
   m_MaxSize: {x: 10001, y: 10026}
@@ -348,9 +348,9 @@ MonoBehaviour:
   m_Children: []
   m_Position:
     serializedVersion: 2
-    x: 2796
+    x: 2785
     y: 0
-    width: 644
+    width: 655
     height: 1293
   m_MinSize: {x: 276, y: 76}
   m_MaxSize: {x: 4001, y: 4026}
@@ -380,9 +380,9 @@ MonoBehaviour:
     m_TextWithWhitespace: "UI Builder\u200B"
   m_Pos:
     serializedVersion: 2
-    x: 1405
+    x: 1400
     y: 79
-    width: 1389
+    width: 1383
     height: 828
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -416,9 +416,9 @@ MonoBehaviour:
     m_TextWithWhitespace: "Game\u200B"
   m_Pos:
     serializedVersion: 2
-    x: 1406
+    x: 1401
     y: 24
-    width: 1389
+    width: 1383
     height: 828
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -437,7 +437,7 @@ MonoBehaviour:
   m_ShowGizmos: 0
   m_TargetDisplay: 0
   m_ClearColor: {r: 0, g: 0, b: 0, a: 0}
-  m_TargetSize: {x: 1389, y: 807}
+  m_TargetSize: {x: 1383, y: 807}
   m_TextureFilterMode: 0
   m_TextureHideFlags: 61
   m_RenderIMGUI: 1
@@ -452,8 +452,8 @@ MonoBehaviour:
     m_VRangeLocked: 0
     hZoomLockedByDefault: 0
     vZoomLockedByDefault: 0
-    m_HBaseRangeMin: -694.5
-    m_HBaseRangeMax: 694.5
+    m_HBaseRangeMin: -691.5
+    m_HBaseRangeMax: 691.5
     m_VBaseRangeMin: -403.5
     m_VBaseRangeMax: 403.5
     m_HAllowExceedBaseRangeMin: 1
@@ -473,23 +473,23 @@ MonoBehaviour:
       serializedVersion: 2
       x: 0
       y: 21
-      width: 1389
+      width: 1383
       height: 807
     m_Scale: {x: 1, y: 1}
-    m_Translation: {x: 694.5, y: 403.5}
+    m_Translation: {x: 691.5, y: 403.5}
     m_MarginLeft: 0
     m_MarginRight: 0
     m_MarginTop: 0
     m_MarginBottom: 0
     m_LastShownAreaInsideMargins:
       serializedVersion: 2
-      x: -694.5
+      x: -691.5
       y: -403.5
-      width: 1389
+      width: 1383
       height: 807
     m_MinimalGUI: 1
   m_defaultScale: 1
-  m_LastWindowPixelSize: {x: 1389, y: 828}
+  m_LastWindowPixelSize: {x: 1383, y: 828}
   m_ClearInEditMode: 1
   m_NoCameraWarning: 1
   m_LowResolutionForAspectRatios: 01000000000000000000
@@ -534,7 +534,7 @@ MonoBehaviour:
     m_OverlaysVisible: 1
   m_LockTracker:
     m_IsLocked: 0
-  m_LastSelectedObjectID: 45276
+  m_LastSelectedObjectID: 52244
 --- !u!114 &18
 MonoBehaviour:
   m_ObjectHideFlags: 52
@@ -558,7 +558,7 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 24
-    width: 637
+    width: 636
     height: 828
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -576,7 +576,7 @@ MonoBehaviour:
       scrollPos: {x: 0, y: 0}
       m_SelectedIDs: 
       m_LastClickedID: 0
-      m_ExpandedIDs: b80aacff6e71b4ff009dcdffbc02d6ff1afbffff
+      m_ExpandedIDs: f2ff4cff56064dfffe064dff6ea755ffb4ba66ff90566fff32576fff56e980ffdaa889ffcaaa89ffc0ad89ff42d489ff52db89ff06e789ff82e889ff56e989ffe0f1ffff1afbffff1acc0000
       m_RenameOverlay:
         m_UserAcceptedRename: 0
         m_Name: 
@@ -622,9 +622,9 @@ MonoBehaviour:
     m_TextWithWhitespace: "Scene\u200B"
   m_Pos:
     serializedVersion: 2
-    x: 639
+    x: 638
     y: 24
-    width: 765
+    width: 761
     height: 828
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -1260,9 +1260,9 @@ MonoBehaviour:
     speed: 2
     m_Value: {x: -0.23769796, y: -0.0058279876, z: 0.0014266352, w: -0.9713199}
   m_Size:
-    m_Target: 10
+    m_Target: 30.05434
     speed: 2
-    m_Value: 10
+    m_Value: 30.05434
   m_Ortho:
     m_Target: 0
     speed: 2
@@ -1388,7 +1388,7 @@ MonoBehaviour:
     serializedVersion: 2
     x: 0
     y: 24
-    width: 1685
+    width: 1679
     height: 413
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -1412,7 +1412,7 @@ MonoBehaviour:
     m_SkipHidden: 0
     m_SearchArea: 1
     m_Folders:
-    - Assets/Scripts/Objects/Weapons
+    - Assets/Scenes
     m_Globs: []
     m_ProductIds: 
     m_AnyWithAssetOrigin: 0
@@ -1422,16 +1422,16 @@ MonoBehaviour:
   m_ViewMode: 1
   m_StartGridSize: 67
   m_LastFolders:
-  - Assets/Scripts/Objects/Weapons
+  - Assets/Scenes
   m_LastFoldersGridSize: 67
   m_LastProjectPath: C:\Users\Axel-PC\RPG-RougeLiteBatteler
   m_LockTracker:
     m_IsLocked: 0
   m_FolderTreeState:
-    scrollPos: {x: 0, y: 371}
-    m_SelectedIDs: 40be0000
-    m_LastClickedID: 48704
-    m_ExpandedIDs: 0000000036b3000038b300003ab300003cb300003eb3000040b3000042b3000044b3000046b30000
+    scrollPos: {x: 0, y: 219}
+    m_SelectedIDs: 2eb50000
+    m_LastClickedID: 46382
+    m_ExpandedIDs: 0000000090b3000092b3000094b3000096b3000098b300009ab300009cb300009eb30000a0b30000a2b30000a4b30000a6b30000a8b30000aab30000
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: 
@@ -1460,7 +1460,7 @@ MonoBehaviour:
     scrollPos: {x: 0, y: 0}
     m_SelectedIDs: 
     m_LastClickedID: 0
-    m_ExpandedIDs: 0000000036b3000038b300003ab300003cb300003eb3000040b3000042b3000044b3000046b30000
+    m_ExpandedIDs: 0000000090b3000092b3000094b3000096b3000098b300009ab300009cb300009eb30000a0b30000a2b30000a4b30000a6b30000a8b30000aab30000
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: 
@@ -1539,9 +1539,9 @@ MonoBehaviour:
     m_TextWithWhitespace: "Console\u200B"
   m_Pos:
     serializedVersion: 2
-    x: 1687
+    x: 1681
     y: 24
-    width: 1108
+    width: 1103
     height: 413
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -1575,9 +1575,9 @@ MonoBehaviour:
     m_TextWithWhitespace: "Inspector\u200B"
   m_Pos:
     serializedVersion: 2
-    x: 2797
+    x: 2786
     y: 24
-    width: 643
+    width: 654
     height: 1267
   m_SerializedDataModeController:
     m_DataMode: 0