RohanRathi/DeviantMobile-Rohan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chunk 1: core gameplay scripts scenes runtime assets

Browse Source
This commit is contained in:
folkward99
2026-04-06 11:02:34 +03:00
parent fa0388bc79
commit 0d11a097d8
703 changed files with 2292651 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

928
Assets/Scripts/Character Selection System/SelectionOptions.cs Normal file
View File

@@ -0,0 +1,928 @@
using UnityEngine;
using System.Collections.Generic;
using UnityEngine.InputSystem;
using static ModeSelection;
using UnityEngine.InputSystem.Users;
using Unity.VisualScripting;
using Cinemachine;
using System.Collections;
using System;
using TMPro;
using UnityEngine.InputSystem.UI;
using static UnityEngine.AudioSettings;
public class SelectionOptions : MonoBehaviour
{
private static SelectionOptions instance;
public static SelectionOptions Instance { get { return instance; } }
//public ModeSelection modeSelection;
public Dictionary<string, PlayerInfo> selectedPlayerDevice;
public Dictionary<string, string> selectedPlayersAI;
public InputActionAsset existingInputAsset;
public InputDevice activeDeviceforAI;
public string controlSchemeforAI;
private int count;
public GameObject eventSytem;
public bool is1v1Selected;
public bool isKillSelected;
public bool isTimeSelected;
public bool isPlayerSelected;
public bool isAISelected;
public bool isCashSystemSelected;
private bool isMobile;
// Cash System team data
public string[] playerTeam = new string[3]; // 3 characters for player team
public string[] enemyTeam = new string[3]; // 3 characters for enemy team
public int captainIndex = 0; // Index of player-controlled character
public int currentControlledIndex = 0; // Index of currently controlled character (for switching)
// Character portrait sprites — stored before scene transition so Game scene can use them
[System.NonSerialized] public Sprite[] playerTeamSprites;
[System.NonSerialized] public Sprite[] enemyTeamSprites;
private void Awake()
{
if (instance != null && instance != this)
{
Destroy(gameObject);
return;
}
instance = this;
DontDestroyOnLoad(gameObject);
is1v1Selected = false;
isKillSelected = false;
isTimeSelected = false;
isPlayerSelected = false;
isAISelected = false;
isCashSystemSelected = false;
}
public Dictionary<string, PlayerInfo> GetSelectedPlayerDevice()
{
return selectedPlayerDevice;
//return modeSelection.selectedPlayerDevice;
}
public Dictionary<string, string> GetSelectedPlayersAI()
{
return selectedPlayersAI;
//return modeSelection.selectedPlayerDevice;
}
public Transform FindGrandchildByName(Transform parent, string name)
{
foreach (Transform child in parent)
{
foreach (Transform grandchild in child)
{
if (grandchild.name == name)
{
return grandchild;
}
}
}
return null;
}
private void DeterminePlatform()
{
if (UnityEngine.Application.platform == RuntimePlatform.Android ||
UnityEngine.Application.platform == RuntimePlatform.IPhonePlayer)
{
isMobile = true;
}
}
private GameObject LoadPrefab(string playerName, string playerMode)
{
bool isAI = playerMode == "AI";
GameObject prefab = CharacterPrefabManager.Instance.GetCharacterPrefab(playerName, isAI);
if (prefab == null)
{
Debug.LogError($"Failed to load prefab for character {playerName} (AI: {isAI})");
}
else
{
// Ensure prefab has required components
if (prefab.GetComponent<PlayerInput>() == null)
{
Debug.LogWarning($"Adding missing PlayerInput component to prefab {playerName}");
prefab.AddComponent<PlayerInput>();
}
}
return prefab;
}
private GameObject LoadPlayerPrefab(string playerName)
{
return CharacterPrefabManager.Instance.GetCharacterPrefab(playerName, false);
}
private void SetUpPlayerInput(GameObject playerPrefab, string playerMode)
{
if (playerPrefab == null)
{
Debug.LogError("Player prefab is null in SetUpPlayerInput");
return;
}
// Check if the prefab has a PlayerInput component
if (playerPrefab.GetComponent<PlayerInput>() == null)
{
Debug.LogError($"Prefab {playerPrefab.name} does not have a PlayerInput component.");
// Add PlayerInput component if it doesn't exist
playerPrefab.AddComponent<PlayerInput>();
}
PlayerInput playerInput = null;
PlayerScript playerScript = null;
GameObject player = null;
if (playerMode == "AI")
{
try {
playerInput = PlayerInput.Instantiate(playerPrefab, controlScheme: controlSchemeforAI, pairWithDevices: activeDeviceforAI);
player = playerInput.gameObject;
player.tag = "Enemy";
// === NEW: Configure as EnemyAI using ControlType system ===
TeamMember teamMember = player.GetComponent<TeamMember>();
if (teamMember == null) teamMember = player.AddComponent<TeamMember>();
teamMember.CurrentTeam = TeamMember.Team.EnemyTeam;
teamMember.SetControlType(TeamMember.ControlType.EnemyAI);
if (CameraManager.Instance != null)
{
CameraManager.Instance.RegisterTeamMember(teamMember);
}
Debug.Log($"[SelectionOptions] SetUpPlayerInput: Spawned {player.name} as EnemyAI");
} catch (Exception e) {
Debug.LogError($"Error instantiating AI player: {e.Message}");
// Fallback to regular instantiation
player = Instantiate(playerPrefab);
player.tag = "Enemy";
}
}
else if (playerMode == "PLAYER")
{
try {
playerInput = PlayerInput.Instantiate(playerPrefab, controlScheme: controlSchemeforAI, pairWithDevices: activeDeviceforAI);
player = playerInput.gameObject;
player.tag = "Player";
playerScript = player.GetComponent<PlayerScript>();
// === NEW: Configure as HumanControlled using ControlType system ===
TeamMember teamMember = player.GetComponent<TeamMember>();
if (teamMember == null) teamMember = player.AddComponent<TeamMember>();
teamMember.CurrentTeam = TeamMember.Team.PlayerTeam;
teamMember.SetControlType(TeamMember.ControlType.HumanControlled);
if (CameraManager.Instance != null)
{
CameraManager.Instance.RegisterTeamMember(teamMember);
CameraManager.Instance.SetTarget(teamMember);
Debug.Log($"[SelectionOptions] SetUpPlayerInput: Set camera target to {player.name}");
}
Debug.Log($"[SelectionOptions] SetUpPlayerInput: Spawned {player.name} as HumanControlled");
if (playerInput != null && playerScript != null)
{
playerInput.neverAutoSwitchControlSchemes = true;
playerInput.defaultActionMap = "Player Controls";
// Use the TryBindAction method to safely bind to actions only if they exist
TryBindAction(playerInput, "Move", playerScript.OnMove);
// For actions that might be canceled
if (playerInput.currentActionMap != null && playerInput.currentActionMap.FindAction("Move") != null)
{
playerInput.currentActionMap["Move"].canceled += playerScript.OnMove;
}
// Punches
TryBindAction(playerInput, "Jab", playerScript.OnJab);
TryBindAction(playerInput, "Right", playerScript.OnRight);
TryBindAction(playerInput, "LeftHook", playerScript.OnLeftHook);
TryBindAction(playerInput, "RightHook", playerScript.OnRightHook);
TryBindAction(playerInput, "LeftElbow", playerScript.OnLeftElbow);
TryBindAction(playerInput, "RightElbow", playerScript.OnRightElbow);
TryBindAction(playerInput, "RightBody", playerScript.OnRightBody);
TryBindAction(playerInput, "PowerPunchLeft", playerScript.OnPowerPunchLeft);
TryBindAction(playerInput, "SupermanPunch", playerScript.OnSupermanPunch);
// Kicks
TryBindAction(playerInput, "LegKickRight", playerScript.OnLegKickRight);
TryBindAction(playerInput, "BodyKickRight", playerScript.OnBodyKickRight);
TryBindAction(playerInput, "KneeRight", playerScript.OnKneeRight);
TryBindAction(playerInput, "BackSideKick", playerScript.OnBackSideKick);
TryBindAction(playerInput, "FrontKickRight", playerScript.OnFrontKickRight);
TryBindAction(playerInput, "LegPowerKickRight", playerScript.OnLegPowerKickRight);
// Dodges
TryBindAction(playerInput, "JumpBack", playerScript.OnJumpBack);
TryBindAction(playerInput, "JumpLeft", playerScript.OnJumpLeft);
TryBindAction(playerInput, "JumpRight", playerScript.OnJumpRight);
// Blocks
TryBindAction(playerInput, "BlockStepBack", playerScript.OnBlockStepBack);
TryBindAction(playerInput, "BlockBodyLeft", playerScript.OnBlockBodyLeft);
TryBindAction(playerInput, "BlockLeg", playerScript.OnBlockLeg);
// Pause
TryBindAction(playerInput, "Pause", player.GetComponent<HealthNew>().OnPause);
}
else
{
Debug.LogError($"Player {player.name} is missing required components: PlayerInput={playerInput != null}, PlayerScript={playerScript != null}");
}
} catch (Exception e) {
Debug.LogError($"Error instantiating Player: {e.Message}");
// Fallback to regular instantiation
player = Instantiate(playerPrefab);
player.gameObject.tag = "Player";
}
}
}
private void SetUpPlayerInputAI(GameObject playerPrefab, string playerMode)
{
// Spawn the character
var character = Instantiate(playerPrefab);
// Add or get TeamMember component
TeamMember teamMember = character.GetComponent<TeamMember>();
if (teamMember == null)
{
teamMember = character.AddComponent<TeamMember>();
}
if (playerMode == "AI")
{
// Configure as enemy AI using the unified ControlType system
teamMember.CurrentTeam = TeamMember.Team.EnemyTeam;
teamMember.SetControlType(TeamMember.ControlType.EnemyAI);
character.gameObject.tag = "Enemy";
Debug.Log($"[SelectionOptions] Spawned {character.name} as EnemyAI");
}
else if (playerMode == "PLAYER")
{
// Configure as human-controlled player
teamMember.CurrentTeam = TeamMember.Team.PlayerTeam;
teamMember.SetControlType(TeamMember.ControlType.HumanControlled);
character.gameObject.tag = "Player";
Debug.Log($"[SelectionOptions] Spawned {character.name} as HumanControlled");
// DIRECTLY set camera target for the player character
if (CameraManager.Instance != null)
{
CameraManager.Instance.SetTarget(teamMember);
Debug.Log($"[SelectionOptions] Set CameraManager target to {character.name}");
}
}
// Register with CameraManager for automatic camera updates
if (CameraManager.Instance != null)
{
CameraManager.Instance.RegisterTeamMember(teamMember);
}
}
// private void SetUpCamera()
// {
// //print("user after pairing: " + inputUser);
// GameObject camera = GameObject.Find("CinemachineCamera");
// var vcam = camera.GetComponent<CinemachineFreeLook>();
// if (vcam != null)
// {
// var targets = GameObject.FindGameObjectsWithTag("Player");
// Transform headTransform = transform;
// if (targets[0].name == "Cheetah 2")
// {
// //Transform firstTarget = targets[0].transform;
// headTransform = targets[0].transform.GetChild(9).GetChild(6).GetChild(1);
// }
// else if (targets[0].name == "Rabbit 2")
// {
// headTransform = targets[0].transform.GetChild(7).GetChild(6).GetChild(1);
// }
// else if (targets[0].name == "Eagle")
// {
// headTransform = targets[0].transform.GetChild(7).GetChild(6).GetChild(1);
// }
// else if (targets[0].name == "Hyena")
// {
// headTransform = targets[0].transform.GetChild(7).GetChild(6).GetChild(1);
// }
// else if (targets[0].name == "HM")
// {
// headTransform = targets[0].transform.GetChild(7).GetChild(6).GetChild(1);
// }
// else if (targets[0].name == "Cat")
// {
// headTransform = targets[0].transform.GetChild(7).GetChild(6).GetChild(1);
// }
// if (headTransform != null)
// {
// vcam.LookAt = vcam.Follow = GameObject.Find("mixamorig:Head").transform;
// //vcam.LookAt = vcam.Follow = GameObject.Find("BUILD-WALL").transform;
// //vcam.m_Lens.FieldOfView = 43;
// }
// }
// }
private void SetUpCamera()
{
if (isPlayerSelected) // Local multiplayer mode
{
SetupSplitScreenCameras();
}
else // Single player or AI mode
{
SetupSingleCamera();
}
}
private void SetupSplitScreenCameras()
{
Camera mainCamera1 = GameObject.Find("MainCamera")?.GetComponent<Camera>();
Camera mainCamera2 = GameObject.Find("MainCamera2")?.GetComponent<Camera>();
if (mainCamera1 && mainCamera2)
{
// Set viewport rects
mainCamera1.rect = new Rect(0, 0, 0.5f, 1);
mainCamera2.rect = new Rect(0.5f, 0, 0.5f, 1);
// Configure comprehensive layer masks for both cameras
int commonLayers = LayerMask.GetMask("Default", "TransparentFX", "Water", "UI", "PostProcessing", "Ground");
// Camera 1: Everything + Player One specific layers
mainCamera1.cullingMask = commonLayers | LayerMask.GetMask("Player One");
// Camera 2: Everything + Player Two specific layers
mainCamera2.cullingMask = commonLayers | LayerMask.GetMask("Player Two");
SetupVirtualCameras();
}
}
private void SetupVirtualCameras()
{
var cinemachine1 = GameObject.Find("CinemachineCamera")?.GetComponent<CinemachineFreeLook>();
var cinemachine2 = GameObject.Find("CinemachineCamera2")?.GetComponent<CinemachineFreeLook>();
if (cinemachine1 && cinemachine2)
{
// Ensure both virtual cameras are active
cinemachine1.gameObject.SetActive(true);
cinemachine2.gameObject.SetActive(true);
// Configure input providers
var input1 = cinemachine1.GetComponent<CinemachineInputProvider>();
var input2 = cinemachine2.GetComponent<CinemachineInputProvider>();
if (input1) input1.PlayerIndex = 0;
if (input2) input2.PlayerIndex = 1;
// Assign players to cameras
var player = GameObject.FindGameObjectWithTag("Player");
var enemy = GameObject.FindGameObjectWithTag("Enemy");
if (player && enemy)
{
// Set camera targets with correct Follow/LookAt separation
// Follow = root (orbit center), LookAt = head (aim point)
cinemachine1.Follow = player.transform;
cinemachine1.LookAt = FindCharacterHead(player);
cinemachine2.Follow = enemy.transform;
cinemachine2.LookAt = FindCharacterHead(enemy);
// Set player layers
SetLayerRecursively(player, LayerMask.NameToLayer("Player One"));
SetLayerRecursively(enemy, LayerMask.NameToLayer("Player Two"));
}
}
}
private void SetLayerRecursively(GameObject obj, int layer)
{
if (obj == null) return;
obj.layer = layer;
foreach (Transform child in obj.transform)
{
SetLayerRecursively(child.gameObject, layer);
}
}
private void SetupSingleCamera()
{
GameObject camera = GameObject.Find("CinemachineCamera");
var vcam = camera?.GetComponent<CinemachineFreeLook>();
if (vcam != null)
{
var player = GameObject.FindGameObjectWithTag("Player");
Debug.Log($"[SelectionOptions] SetupSingleCamera - Found player: {(player != null ? player.name : "NULL")}");
if (player != null)
{
// Use root for Follow (stable orbit center)
Transform followTransform = player.transform;
// Use head for LookAt (camera points at upper body)
Transform lookAtTransform = FindCharacterHead(player);
vcam.Follow = followTransform;
vcam.LookAt = lookAtTransform;
Debug.Log($"[SelectionOptions] Camera - Follow: {followTransform.name}, LookAt: {lookAtTransform.name}");
}
else
{
Debug.LogWarning("[SelectionOptions] No player with tag 'Player' found for camera setup!");
}
}
else
{
Debug.LogWarning("[SelectionOptions] CinemachineCamera not found in scene!");
}
}
private Transform FindCharacterHead(GameObject character)
{
if (character == null) return null;
string characterName = character.name;
Transform headTransform = null;
// First, try to find head by common bone names (more reliable)
string[] headBoneNames = { "mixamorig:Head", "Head", "head", "Bip001 Head", "Bone_Head" };
foreach (string boneName in headBoneNames)
{
headTransform = FindChildRecursive(character.transform, boneName);
if (headTransform != null)
{
Debug.Log($"[SelectionOptions] Found head bone '{boneName}' for {characterName}");
return headTransform;
}
}
// Fallback to character-specific hardcoded paths
try
{
switch (characterName)
{
case var _ when characterName.Contains("Cheetah"):
headTransform = character.transform.GetChild(9)?.GetChild(6)?.GetChild(1);
break;
case var _ when characterName.Contains("Rabbit"):
case var _ when characterName.Contains("Eagle"):
case var _ when characterName.Contains("Hyena"):
case var _ when characterName.Contains("HM"):
case var _ when characterName.Contains("Cat"):
case var _ when characterName.Contains("CAT N"):
headTransform = character.transform.GetChild(7)?.GetChild(6)?.GetChild(1);
break;
}
if (headTransform != null)
{
Debug.Log($"[SelectionOptions] Found head via hardcoded path for {characterName}: {headTransform.name}");
return headTransform;
}
}
catch (Exception e)
{
Debug.LogWarning($"Error finding head for character {characterName}: {e.Message}");
}
// Final fallback: return root (will show legs like the user experienced)
Debug.LogWarning($"[SelectionOptions] Could not find head bone for {characterName}, using root transform");
return character.transform;
}
private Transform FindChildRecursive(Transform parent, string name)
{
if (parent.name == name) return parent;
foreach (Transform child in parent)
{
Transform result = FindChildRecursive(child, name);
if (result != null) return result;
}
return null;
}
public void SpawnPlayers()
{
// Skip spawning for Cash System mode - CashSystemManager handles its own team spawning
if (isCashSystemSelected)
{
Debug.Log("[SelectionOptions] SpawnPlayers skipped - Cash System mode uses CashSystemManager.SpawnTeams");
return;
}
try
{
isMobile = false;
DeterminePlatform();
// Initialize dictionaries if they're null
if (selectedPlayerDevice == null)
{
selectedPlayerDevice = new Dictionary<string, PlayerInfo>();
}
if (selectedPlayersAI == null)
{
selectedPlayersAI = new Dictionary<string, string>();
}
if (!isMobile)
{
if (isPlayerSelected)
{
if (selectedPlayerDevice == null)
{
selectedPlayerDevice = SelectionOptions.Instance.GetSelectedPlayerDevice();
}
// Setup split screen immediately after spawning players
SetupSplitScreenCameras();
// Setup split screen cameras
var camera1 = GameObject.Find("MainCamera");
var camera2 = GameObject.Find("MainCamera2");
if (camera1 != null && camera2 != null)
{
camera1.GetComponent<Camera>().rect = new Rect(0, 0, 0.5f, 1);
camera2.GetComponent<Camera>().rect = new Rect(0.5f, 0, 0.5f, 1);
}
foreach (var kvp in selectedPlayerDevice)
{
string playerName = kvp.Key;
PlayerInfo playerInfo = kvp.Value;
GameObject playerPrefab = LoadPlayerPrefab(playerName);
if (playerPrefab != null)
{
PlayerInput playerInput = PlayerInput.Instantiate(playerPrefab, controlScheme: playerInfo.ControlScheme, pairWithDevices: playerInfo.Device);
GameObject player = playerInput.gameObject;
player.tag = "Player";
if (count == 0)
{
player.layer = LayerMask.NameToLayer("Player One");
}
ConfigurePlayerInput(player);
foreach (var pair in selectedPlayerDevice)
{
if (pair.Key == playerName)
{
count++;
if (count == 2)
{
player.tag = "Enemy";
player.layer = LayerMask.NameToLayer("Player Two");
count = 0;
}
}
}
SetUpCamera();
}
}
}
else if (isAISelected)
{
// Disable split screen for AI mode
var camera2 = GameObject.Find("MainCamera2");
if (camera2 != null)
{
camera2.SetActive(false);
}
if (selectedPlayersAI == null)
{
selectedPlayersAI = SelectionOptions.Instance.GetSelectedPlayersAI();
}
foreach (var kvp in selectedPlayersAI)
{
string playerName = kvp.Key;
string playerMode = kvp.Value;
GameObject playerPrefab = LoadPrefab(playerName, playerMode);
if (playerPrefab != null)
{
SetUpPlayerInput(playerPrefab, playerMode);
SetUpCamera();
}
}
}
}
else
{
if (isAISelected)
{
var camera2 = GameObject.Find("MainCamera2");
if (camera2 != null)
{
camera2.SetActive(false);
}
if (selectedPlayersAI == null)
{
selectedPlayersAI = SelectionOptions.Instance.GetSelectedPlayersAI();
}
foreach (var kvp in selectedPlayersAI)
{
string playerName = kvp.Key;
string playerMode = kvp.Value;
GameObject playerPrefab = LoadPrefab(playerName, playerMode);
if (playerPrefab != null)
{
SetUpPlayerInputAI(playerPrefab, playerMode);
Debug.Log($"[SelectionOptions] Spawned {playerName} as {playerMode}");
}
}
// Set up camera AFTER all characters are spawned
// This ensures the Player tag is properly assigned before camera targets
SetUpCamera();
Debug.Log("[SelectionOptions] Camera setup complete after all spawns");
}
}
} // Close try block
catch (Exception ex)
{
Debug.LogError($"Error in SpawnPlayers: {ex.Message}\n{ex.StackTrace}");
}
}
private void ConfigurePlayerInput(GameObject player)
{
PlayerInput playerInput = player.GetComponent<PlayerInput>();
PlayerScript playerScript = player.GetComponent<PlayerScript>();
// === NEW: Configure ControlType for local multiplayer ===
TeamMember teamMember = player.GetComponent<TeamMember>();
if (teamMember == null) teamMember = player.AddComponent<TeamMember>();
teamMember.CurrentTeam = TeamMember.Team.PlayerTeam;
teamMember.SetControlType(TeamMember.ControlType.HumanControlled);
if (CameraManager.Instance != null)
{
CameraManager.Instance.RegisterTeamMember(teamMember);
// Note: In split screen, camera targets are handled differently via SetupVirtualCameras
}
Debug.Log($"[SelectionOptions] ConfigurePlayerInput: Configured {player.name} as HumanControlled");
playerInput.neverAutoSwitchControlSchemes = true;
playerInput.defaultActionMap = "Player Controls";
// Movement
playerInput.currentActionMap["Move"].performed += playerScript.OnMove;
playerInput.currentActionMap["Move"].canceled += playerScript.OnMove;
// Punches
playerInput.currentActionMap["Jab"].performed += playerScript.OnJab;
playerInput.currentActionMap["Right"].performed += playerScript.OnRight;
playerInput.currentActionMap["LeftHook"].performed += playerScript.OnLeftHook;
playerInput.currentActionMap["RightHook"].performed += playerScript.OnRightHook;
playerInput.currentActionMap["LeftElbow"].performed += playerScript.OnLeftElbow;
playerInput.currentActionMap["RightElbow"].performed += playerScript.OnRightElbow;
playerInput.currentActionMap["RightBody"].performed += playerScript.OnRightBody;
playerInput.currentActionMap["PowerPunchLeft"].performed += playerScript.OnPowerPunchLeft;
playerInput.currentActionMap["SupermanPunch"].performed += playerScript.OnSupermanPunch;
// Kicks
playerInput.currentActionMap["LegKickRight"].performed += playerScript.OnLegKickRight;
playerInput.currentActionMap["BodyKickRight"].performed += playerScript.OnBodyKickRight;
playerInput.currentActionMap["KneeRight"].performed += playerScript.OnKneeRight;
playerInput.currentActionMap["BackSideKick"].performed += playerScript.OnBackSideKick;
playerInput.currentActionMap["FrontKickRight"].performed += playerScript.OnFrontKickRight;
playerInput.currentActionMap["LegPowerKickRight"].performed += playerScript.OnLegPowerKickRight;
// Dodges
playerInput.currentActionMap["JumpBack"].performed += playerScript.OnJumpBack;
playerInput.currentActionMap["JumpLeft"].performed += playerScript.OnJumpLeft;
playerInput.currentActionMap["JumpRight"].performed += playerScript.OnJumpRight;
// Blocks
TryBindAction(playerInput, "BlockStepBack", playerScript.OnBlockStepBack);
TryBindAction(playerInput, "BlockBodyLeft", playerScript.OnBlockBodyLeft);
TryBindAction(playerInput, "BlockLeg", playerScript.OnBlockLeg);
// NEW: Vicious Attacks - Make sure to add these to your input action asset
TryBindAction(playerInput, "Chokeslam", playerScript.OnChokeslam);
TryBindAction(playerInput, "Suplex", playerScript.OnSuplex);
TryBindAction(playerInput, "GiantSwing", playerScript.OnGiantSwing);
TryBindAction(playerInput, "DiamondCrusher", playerScript.OnDiamondCrusher);
TryBindAction(playerInput, "SumoSlap", playerScript.OnSumoSlap);
TryBindAction(playerInput, "JavelinTackle", playerScript.OnJavelinTackle);
// NEW: Special Finishers - Make sure to add these to your input action asset
TryBindAction(playerInput, "RKO", playerScript.OnRKO);
TryBindAction(playerInput, "Spear", playerScript.OnSpear);
TryBindAction(playerInput, "RockBottom", playerScript.OnRockBottom);
TryBindAction(playerInput, "F5", playerScript.OnF5);
// SwantonBomb method doesn't exist in PlayerScript yet
// TODO: Implement OnSwantonBomb in PlayerScript
// TryBindAction(playerInput, "SwantonBomb", playerScript.OnSwantonBomb);
// Pause
TryBindAction(playerInput, "Pause", player.GetComponent<HealthNew>().OnPause);
}
// Helper method to safely bind an action if it exists in the action map
private void TryBindAction(PlayerInput playerInput, string actionName, System.Action<InputAction.CallbackContext> callback)
{
InputAction action = playerInput.currentActionMap.FindAction(actionName);
if (action != null)
{
action.performed += callback;
}
else
{
Debug.LogWarning($"Action '{actionName}' not found in current action map. Make sure to add it to your Input Actions asset.");
}
}
// public void SpawnPlayers()
// {
// //return this mobile to false
// isMobile = false;
// //determine platform
// DeterminePlatform();
// //isAISelected boolean is switched in the ModeSelectionManager.cs
// if (!isMobile)
// {
// if (isPlayerSelected)
// {
// if (selectedPlayerDevice == null)
// {
// selectedPlayerDevice = SelectionOptions.Instance.GetSelectedPlayerDevice();
// }
// // Now you can iterate through playerDeviceDict and spawn players using the data
// foreach (var kvp in selectedPlayerDevice)
// {
// string playerName = kvp.Key;
// PlayerInfo playerInfo = kvp.Value;
// GameObject playerPrefab = gameObject; // Assuming your player prefab names match the player object names
// if (playerName == "Windham")
// {
// playerPrefab = Resources.Load<GameObject>("Rabbit 2"); // Assuming your player prefab names match the player object names
// }
// else if (playerName == "Amira")
// {
// playerPrefab = Resources.Load<GameObject>("Cheetah 2"); // Assuming your player prefab names match the player object names
// }
// else if (playerName == "Bahman")
// {
// playerPrefab = Resources.Load<GameObject>("Eagle"); // Assuming your player prefab names match the player object names
// }
// else if (playerName == "Ziggy")
// {
// playerPrefab = Resources.Load<GameObject>("Cat"); // Assuming your player prefab names match the player object names
// }
// else if (playerName == "Imani")
// {
// playerPrefab = Resources.Load<GameObject>("Hyena"); // Assuming your player prefab names match the player object names
// }
// else if (playerName == "Amon")
// {
// playerPrefab = Resources.Load<GameObject>("Hammerhead"); // Assuming your player prefab names match the player object names
// }
// if (playerPrefab != null)
// {
// var player = PlayerInput.Instantiate(playerPrefab, controlScheme: playerInfo.ControlScheme, pairWithDevices: playerInfo.Device);
// player.tag = "Player";
// PlayerInput playerInput = player.GetComponent<PlayerInput>();
// PlayerScript playerScript = player.GetComponent<PlayerScript>();
// playerInput.neverAutoSwitchControlSchemes = true;
// playerInput.defaultActionMap = "Player Controls";
// playerInput.currentActionMap["Move"].performed += playerScript.OnMove;
// playerInput.currentActionMap["Move"].canceled += playerScript.OnMove;
// //punches
// playerInput.currentActionMap["Jab"].performed += playerScript.OnJab;
// playerInput.currentActionMap["Right"].performed += playerScript.OnRight;
// playerInput.currentActionMap["LeftHook"].performed += playerScript.OnLeftHook;
// playerInput.currentActionMap["RightHook"].performed += playerScript.OnRightHook;
// playerInput.currentActionMap["LeftElbow"].performed += playerScript.OnLeftElbow;
// playerInput.currentActionMap["RightElbow"].performed += playerScript.OnRightElbow;
// playerInput.currentActionMap["RightBody"].performed += playerScript.OnRightBody;
// playerInput.currentActionMap["PowerPunchLeft"].performed += playerScript.OnPowerPunchLeft;
// playerInput.currentActionMap["SupermanPunch"].performed += playerScript.OnSupermanPunch;
// //kicks
// playerInput.currentActionMap["LegKickRight"].performed += playerScript.OnLegKickRight;
// playerInput.currentActionMap["BodyKickRight"].performed += playerScript.OnBodyKickRight;
// playerInput.currentActionMap["KneeRight"].performed += playerScript.OnKneeRight;
// playerInput.currentActionMap["BackSideKick"].performed += playerScript.OnBackSideKick;
// playerInput.currentActionMap["FrontKickRight"].performed += playerScript.OnFrontKickRight;
// playerInput.currentActionMap["LegPowerKickRight"].performed += playerScript.OnLegPowerKickRight;
// //dodges
// playerInput.currentActionMap["JumpBack"].performed += playerScript.OnJumpBack;
// playerInput.currentActionMap["JumpLeft"].performed += playerScript.OnJumpLeft;
// playerInput.currentActionMap["JumpRight"].performed += playerScript.OnJumpRight;
// //blocks
// playerInput.currentActionMap["BlockStepBack"].performed += playerScript.OnBlockStepBack;
// playerInput.currentActionMap["BlockBodyLeft"].performed += playerScript.OnBlockBodyLeft;
// playerInput.currentActionMap["BlockLeg"].performed += playerScript.OnBlockLeg;
// playerInput.currentActionMap["Pause"].performed += player.GetComponent<HealthNew>().OnPause;
// foreach (var pair in selectedPlayerDevice)
// {
// if (pair.Key == playerName)
// {
// count++;
// if (count == 2)
// {
// player.gameObject.tag = "Enemy";
// count = 0;
// }
// }
// }
// SetUpCamera();
// }
// else
// {
// Debug.LogWarning($"Player prefab '{playerName}' not found in resources.");
// }
// }
// }
// else if (isAISelected)
// {
// if (selectedPlayersAI == null)
// {
// selectedPlayersAI = SelectionOptions.Instance.GetSelectedPlayersAI();
// }
// foreach (var kvp in selectedPlayersAI)
// {
// string playerName = kvp.Key;
// string playerMode = kvp.Value;
// GameObject playerPrefab = gameObject;
// playerPrefab = LoadPrefab(playerName, playerMode);
// if (playerPrefab != null)
// {
// SetUpPlayerInput(playerPrefab, playerMode);
// SetUpCamera();
// }
// else
// {
// Debug.LogWarning($"Player prefab '{playerName}' not found in resources.");
// }
// }
// }
// }
// else
// {
// if (isAISelected)
// {
// if (selectedPlayersAI == null)
// {
// selectedPlayersAI = SelectionOptions.Instance.GetSelectedPlayersAI();
// }
// foreach (var kvp in selectedPlayersAI)
// {
// string playerName = kvp.Key;
// string playerMode = kvp.Value;
// GameObject playerPrefab = gameObject;
// playerPrefab = LoadPrefab(playerName, playerMode);
// if (playerPrefab != null)
// {
// SetUpPlayerInputAI(playerPrefab, playerMode);
// SetUpCamera();
// }
// else
// {
// Debug.LogWarning($"Player prefab '{playerName}' not found in resources.");
// }
// }
// }
// }
// }
}