بناء كود قابل لإعادة الاستخدام وقابل للتوسع في Unity: دليل كامل لعام 2025

using UnityEngine;

[CreateAssetMenu(fileName = "NewWeaponData", menuName = "Game/Weapon Data")]
public class WeaponData : ScriptableObject
{
    [Header("Basic Info")]
    public string weaponName;
    public Sprite icon;
    public GameObject prefab;
    
    [Header("Stats")]
    public float damage = 10f;
    public float fireRate = 1f;
    public int maxAmmo = 30;
    public float range = 50f;
    
    [Header("Visual Effects")]
    public ParticleSystem muzzleFlash;
    public AudioClip fireSound;
    public TrailRenderer bulletTrail;
}

using UnityEngine;
using UnityEngine.Events;

[CreateAssetMenu(fileName = "NewGameEvent", menuName = "Game/Game Event")]
public class GameEvent : ScriptableObject
{
    [TextArea(3, 10)]
    public string description;
    
    private UnityEvent onRaised = new UnityEvent();
    
    public void Raise()
    {
        onRaised.Invoke();
    }
    
    public void RegisterListener(UnityAction listener)
    {
        onRaised.AddListener(listener);
    }
    
    public void UnregisterListener(UnityAction listener)
    {
        onRaised.RemoveListener(listener);
    }
}

using UnityEngine;

public class GameManager : MonoBehaviour
{
    private static GameManager instance;
    public static GameManager Instance
    {
        get
        {
            if (instance == null)
            {
                instance = FindObjectOfType<GameManager>();
                if (instance == null)
                {
                    GameObject obj = new GameObject("GameManager");
                    instance = obj.AddComponent<GameManager>();
                }
            }
            return instance;
        }
    }
    
    private void Awake()
    {
        if (instance != null && instance != this)
        {
            Destroy(gameObject);
            return;
        }
        
        instance = this;
        DontDestroyOnLoad(gameObject);
    }
    
    // Game state management
    public int score = 0;
    public bool isPaused = false;
    
    public void AddScore(int points)
    {
        score += points;
        // Trigger score update events
    }
}

using System.Collections.Generic;
using UnityEngine;

public class ObjectPool<T> : MonoBehaviour where T : Component
{
    [SerializeField] private T prefab;
    [SerializeField] private int initialSize = 10;
    
    private Queue<T> pool = new Queue<T>();
    private List<T> activeObjects = new List<T>();
    
    private void Awake()
    {
        InitializePool();
    }
    
    private void InitializePool()
    {
        for (int i = 0; i < initialSize; i++)
        {
            CreateNewObject();
        }
    }
    
    private T CreateNewObject()
    {
        T newObj = Instantiate(prefab, transform);
        newObj.gameObject.SetActive(false);
        pool.Enqueue(newObj);
        return newObj;
    }
    
    public T GetObject()
    {
        if (pool.Count == 0)
        {
            CreateNewObject();
        }
        
        T obj = pool.Dequeue();
        obj.gameObject.SetActive(true);
        activeObjects.Add(obj);
        return obj;
    }
    
    public void ReturnObject(T obj)
    {
        obj.gameObject.SetActive(false);
        activeObjects.Remove(obj);
        pool.Enqueue(obj);
    }
    
    public void ReturnAllObjects()
    {
        foreach (T obj in activeObjects.ToArray())
        {
            ReturnObject(obj);
        }
    }
}

public class Player : MonoBehaviour
{
    // Movement
    public float speed = 5f;
    private Rigidbody rb;
    
    // Health
    public int maxHealth = 100;
    private int currentHealth;
    
    // Animation
    private Animator animator;
    
    // Input handling, collision detection, UI updates...
}

public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    private Rigidbody rb;
    
    private void FixedUpdate()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        
        Vector3 movement = new Vector3(horizontal, 0f, vertical) * speed;
        rb.AddForce(movement);
    }
}

public class PlayerHealth : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;
    private int currentHealth;
    
    public event Action<int> OnHealthChanged;
    public event Action OnDeath;
    
    private void Awake()
    {
        currentHealth = maxHealth;
    }
    
    public void TakeDamage(int damage)
    {
        currentHealth -= damage;
        OnHealthChanged?.Invoke(currentHealth);
        
        if (currentHealth <= 0)
        {
            OnDeath?.Invoke();
        }
    }
}

public interface IDamageable
{
    void TakeDamage(int damage);
    bool IsAlive { get; }
}

public interface IInteractable
{
    void Interact(GameObject interactor);
    string InteractionPrompt { get; }
}

public class Enemy : MonoBehaviour, IDamageable
{
    [SerializeField] private int maxHealth = 50;
    private int currentHealth;
    
    public bool IsAlive => currentHealth > 0;
    
    private void Awake()
    {
        currentHealth = maxHealth;
    }
    
    public void TakeDamage(int damage)
    {
        currentHealth -= damage;
        if (currentHealth <= 0)
        {
            Die();
        }
    }
    
    private void Die()
    {
        // Death logic
        Destroy(gameObject);
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;

public class ServiceLocator : MonoBehaviour
{
    private static ServiceLocator instance;
    public static ServiceLocator Instance => instance;
    
    private readonly Dictionary<Type, object> services = new Dictionary<Type, object>();
    
    private void Awake()
    {
        if (instance != null && instance != this)
        {
            Destroy(gameObject);
            return;
        }
        
        instance = this;
        DontDestroyOnLoad(gameObject);
    }
    
    public void RegisterService<T>(T service)
    {
        services[typeof(T)] = service;
    }
    
    public void UnregisterService<T>()
    {
        services.Remove(typeof(T));
    }
    
    public T GetService<T>()
    {
        if (services.TryGetValue(typeof(T), out object service))
        {
            return (T)service;
        }
        
        throw new Exception($"Service {typeof(T)} not registered!");
    }
    
    public bool TryGetService<T>(out T service)
    {
        if (services.TryGetValue(typeof(T), out object obj))
        {
            service = (T)obj;
            return true;
        }
        
        service = default;
        return false;
    }
}

// Usage
public class AudioManager : MonoBehaviour
{
    private void Awake()
    {
        ServiceLocator.Instance.RegisterService<AudioManager>(this);
    }
    
    public void PlaySound(AudioClip clip)
    {
        // Play sound logic
    }
}

public class PlayerController : MonoBehaviour
{
    private AudioManager audioManager;
    
    private void Start()
    {
        audioManager = ServiceLocator.Instance.GetService<AudioManager>();
    }
    
    private void OnJump()
    {
        audioManager.PlaySound(jumpSound);
    }
}

using UnityEngine;

public abstract class State
{
    protected Enemy enemy;
    
    public State(Enemy enemy)
    {
        this.enemy = enemy;
    }
    
    public abstract void Enter();
    public abstract void Update();
    public abstract void Exit();
}

public class Enemy : MonoBehaviour
{
    [SerializeField] private float patrolSpeed = 2f;
    [SerializeField] private float chaseSpeed = 4f;
    [SerializeField] private float detectionRange = 10f;
    
    private State currentState;
    
    public Transform Player { get; set; }
    public float Speed { get; set; } = 2f;
    
    private void Start()
    {
        Player = GameObject.FindGameObjectWithTag("Player").transform;
        ChangeState(new PatrolState(this));
    }
    
    private void Update()
    {
        currentState?.Update();
    }
    
    public void ChangeState(State newState)
    {
        currentState?.Exit();
        currentState = newState;
        currentState.Enter();
    }
    
    public bool CanSeePlayer()
    {
        return Vector3.Distance(transform.position, Player.position) <= detectionRange;
    }
}

public class PatrolState : State
{
    private Vector3 patrolPoint;
    private float patrolTimer;
    
    public PatrolState(Enemy enemy) : base(enemy) { }
    
    public override void Enter()
    {
        enemy.Speed = enemy.patrolSpeed;
        SetNewPatrolPoint();
    }
    
    public override void Update()
    {
        patrolTimer -= Time.deltaTime;
        
        if (patrolTimer <= 0)
        {
            SetNewPatrolPoint();
        }
        
        // Move towards patrol point
        enemy.transform.position = Vector3.MoveTowards(
            enemy.transform.position, 
            patrolPoint, 
            enemy.Speed * Time.deltaTime
        );
        
        if (enemy.CanSeePlayer())
        {
            enemy.ChangeState(new ChaseState(enemy));
        }
    }
    
    public override void Exit() { }
    
    private void SetNewPatrolPoint()
    {
        patrolTimer = Random.Range(3f, 8f);
        patrolPoint = enemy.transform.position + 
            new Vector3(Random.Range(-5f, 5f), 0f, Random.Range(-5f, 5f));
    }
}

public class ChaseState : State
{
    public ChaseState(Enemy enemy) : base(enemy) { }
    
    public override void Enter()
    {
        enemy.Speed = enemy.chaseSpeed;
    }
    
    public override void Update()
    {
        // Move towards player
        enemy.transform.position = Vector3.MoveTowards(
            enemy.transform.position,
            enemy.Player.position,
            enemy.Speed * Time.deltaTime
        );
        
        if (!enemy.CanSeePlayer())
        {
            enemy.ChangeState(new PatrolState(enemy));
        }
    }
    
    public override void Exit() { }
}

using System.IO;
using UnityEngine;

[System.Serializable]
public class GameSaveData
{
    public int level;
    public int score;
    public Vector3 playerPosition;
    public string[] inventory;
    public bool[] completedLevels;
}

public static class SaveLoadSystem
{
    private static readonly string saveFileName = "gameSave.json";
    
    public static void SaveGame(GameSaveData data)
    {
        string json = JsonUtility.ToJson(data, true);
        string path = Path.Combine(Application.persistentDataPath, saveFileName);
        File.WriteAllText(path, json);
    }
    
    public static GameSaveData LoadGame()
    {
        string path = Path.Combine(Application.persistentDataPath, saveFileName);
        
        if (File.Exists(path))
        {
            string json = File.ReadAllText(path);
            return JsonUtility.FromJson<GameSaveData>(json);
        }
        
        return new GameSaveData(); // Return default save
    }
    
    public static bool HasSaveFile()
    {
        string path = Path.Combine(Application.persistentDataPath, saveFileName);
        return File.Exists(path);
    }
    
    public static void DeleteSaveFile()
    {
        string path = Path.Combine(Application.persistentDataPath, saveFileName);
        if (File.Exists(path))
        {
            File.Delete(path);
        }
    }
}

// Usage
public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }
    
    public int currentLevel = 1;
    public int score = 0;
    public Vector3 playerPosition;
    
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            LoadGame();
        }
    }
    
    private void OnApplicationQuit()
    {
        SaveGame();
    }
    
    public void SaveGame()
    {
        GameSaveData saveData = new GameSaveData
        {
            level = currentLevel,
            score = score,
            playerPosition = playerPosition,
            // Add other save data
        };
        
        SaveLoadSystem.SaveGame(saveData);
    }
    
    public void LoadGame()
    {
        if (SaveLoadSystem.HasSaveFile())
        {
            GameSaveData saveData = SaveLoadSystem.LoadGame();
            currentLevel = saveData.level;
            score = saveData.score;
            playerPosition = saveData.playerPosition;
        }
    }
}

using System;
using UnityEngine;

[Serializable]
public class InputBinding
{
    public string actionName;
    public KeyCode primaryKey;
    public KeyCode secondaryKey;
    
    public bool IsPressed()
    {
        return Input.GetKey(primaryKey) || Input.GetKey(secondaryKey);
    }
    
    public bool IsDown()
    {
        return Input.GetKeyDown(primaryKey) || Input.GetKeyDown(secondaryKey);
    }
    
    public bool IsUp()
    {
        return Input.GetKeyUp(primaryKey) || Input.GetKeyUp(secondaryKey);
    }
}

public class InputManager : MonoBehaviour
{
    public static InputManager Instance { get; private set; }
    
    [Header("Movement")]
    public InputBinding moveUp = new InputBinding { actionName = "Move Up", primaryKey = KeyCode.W };
    public InputBinding moveDown = new InputBinding { actionName = "Move Down", primaryKey = KeyCode.S };
    public InputBinding moveLeft = new InputBinding { actionName = "Move Left", primaryKey = KeyCode.A };
    public InputBinding moveRight = new InputBinding { actionName = "Move Right", primaryKey = KeyCode.D };
    
    [Header("Actions")]
    public InputBinding jump = new InputBinding { actionName = "Jump", primaryKey = KeyCode.Space };
    public InputBinding interact = new InputBinding { actionName = "Interact", primaryKey = KeyCode.E };
    
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            LoadInputBindings();
        }
        else
        {
            Destroy(gameObject);
        }
    }
    
    // Public methods for checking input
    public bool IsMovingUp() => moveUp.IsPressed();
    public bool IsMovingDown() => moveDown.IsPressed();
    public bool IsMovingLeft() => moveLeft.IsPressed();
    public bool IsMovingRight() => moveRight.IsPressed();
    
    public bool JumpPressed() => jump.IsDown();
    public bool InteractPressed() => interact.IsDown();
    
    // Save/Load input bindings
    private void LoadInputBindings()
    {
        // Load from PlayerPrefs or file
        // Implementation depends on your save system
    }
    
    public void ResetToDefaults()
    {
        // Reset all bindings to default values
    }
}

using UnityEngine;
using UnityEngine.UI;
using TMPro;

public abstract class UIManager : MonoBehaviour
{
    protected Canvas canvas;
    protected GraphicRaycaster raycaster;
    
    protected virtual void Awake()
    {
        canvas = GetComponent<Canvas>();
        raycaster = GetComponent<GraphicRaycaster>();
    }
    
    public virtual void Show()
    {
        canvas.enabled = true;
    }
    
    public virtual void Hide()
    {
        canvas.enabled = false;
    }
    
    public virtual void Toggle()
    {
        canvas.enabled = !canvas.enabled;
    }
}

public class HUDManager : UIManager
{
    [SerializeField] private TextMeshProUGUI scoreText;
    [SerializeField] private TextMeshProUGUI healthText;
    [SerializeField] private Slider healthBar;
    
    private void Start()
    {
        UpdateScore(0);
        UpdateHealth(100, 100);
    }
    
    public void UpdateScore(int score)
    {
        scoreText.text = $"Score: {score}";
    }
    
    public void UpdateHealth(int current, int max)
    {
        healthText.text = $"{current}/{max}";
        healthBar.value = (float)current / max;
    }
}

public class PauseMenuManager : UIManager
{
    [SerializeField] private Button resumeButton;
    [SerializeField] private Button settingsButton;
    [SerializeField] private Button quitButton;
    
    protected override void Awake()
    {
        base.Awake();
        
        resumeButton.onClick.AddListener(ResumeGame);
        settingsButton.onClick.AddListener(OpenSettings);
        quitButton.onClick.AddListener(QuitGame);
    }
    
    private void ResumeGame()
    {
        Time.timeScale = 1f;
        Hide();
    }
    
    private void OpenSettings()
    {
        // Open settings menu
    }
    
    private void QuitGame()
    {
        Application.Quit();
    }
}

using System.Collections.Generic;
using UnityEngine;

[System.Serializable]
public class Sound
{
    public string name;
    public AudioClip clip;
    
    [Range(0f, 1f)]
    public float volume = 1f;
    
    [Range(0.1f, 3f)]
    public float pitch = 1f;
    
    public bool loop = false;
    
    [HideInInspector]
    public AudioSource source;
}

public class AudioManager : MonoBehaviour
{
    public static AudioManager Instance { get; private set; }
    
    [SerializeField] private Sound[] sounds;
    [SerializeField] private AudioSource musicSource;
    [SerializeField] private AudioSource sfxSource;
    
    private Dictionary<string, Sound> soundDictionary;
    
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            InitializeAudio();
        }
        else
        {
            Destroy(gameObject);
        }
    }
    
    private void InitializeAudio()
    {
        soundDictionary = new Dictionary<string, Sound>();
        
        foreach (Sound sound in sounds)
        {
            sound.source = gameObject.AddComponent<AudioSource>();
            sound.source.clip = sound.clip;
            sound.source.volume = sound.volume;
            sound.source.pitch = sound.pitch;
            sound.source.loop = sound.loop;
            
            soundDictionary[sound.name] = sound;
        }
    }
    
    public void Play(string soundName)
    {
        if (soundDictionary.TryGetValue(soundName, out Sound sound))
        {
            sound.source.Play();
        }
        else
        {
            Debug.LogWarning($"Sound {soundName} not found!");
        }
    }
    
    public void Stop(string soundName)
    {
        if (soundDictionary.TryGetValue(soundName, out Sound sound))
        {
            sound.source.Stop();
        }
    }
    
    public void SetVolume(string soundName, float volume)
    {
        if (soundDictionary.TryGetValue(soundName, out Sound sound))
        {
            sound.source.volume = volume;
        }
    }
    
    public void PlayMusic(AudioClip musicClip)
    {
        musicSource.clip = musicClip;
        musicSource.Play();
    }
    
    public void StopMusic()
    {
        musicSource.Stop();
    }
    
    public void SetMusicVolume(float volume)
    {
        musicSource.volume = volume;
    }
}

using UnityEngine;

public class OptimizedPhysics : MonoBehaviour
{
    [Header("Physics Settings")]
    [SerializeField] private float fixedTimeStep = 0.02f;
    [SerializeField] private int maximumAllowedTimestep = 1;
    [SerializeField] private int solverIterations = 6;
    [SerializeField] private int solverVelocityIterations = 1;
    
    [Header("Layer Collision Matrix")]
    [SerializeField] private LayerMask playerLayer;
    [SerializeField] private LayerMask enemyLayer;
    [SerializeField] private LayerMask projectileLayer;
    [SerializeField] private LayerMask environmentLayer;
    
    private void Awake()
    {
        ConfigurePhysics();
        SetupCollisionMatrix();
    }
    
    private void ConfigurePhysics()
    {
        Time.fixedDeltaTime = fixedTimeStep;
        Physics.defaultMaxAngularSpeed = maximumAllowedTimestep;
        
        // Configure solver iterations for better performance
        Physics.defaultSolverIterations = solverIterations;
        Physics.defaultSolverVelocityIterations = solverVelocityIterations;
        
        // Enable auto-simulation if needed
        Physics.autoSimulation = true;
        
        // Configure physics gravity if needed
        Physics.gravity = new Vector3(0, -9.81f, 0);
    }
    
    private void SetupCollisionMatrix()
    {
        // Disable unnecessary collisions for performance
        // Players don't collide with other players
        Physics.IgnoreLayerCollision(playerLayer, playerLayer, true);
        
        // Projectiles don't collide with other projectiles
        Physics.IgnoreLayerCollision(projectileLayer, projectileLayer, true);
        
        // Enemies don't collide with other enemies (use custom collision detection)
        Physics.IgnoreLayerCollision(enemyLayer, enemyLayer, true);
    }
    
    // Performance monitoring
    private void Update()
    {
        // Monitor physics performance
        if (Time.frameCount % 60 == 0) // Every second at 60 FPS
        {
            MonitorPhysicsPerformance();
        }
    }
    
    private void MonitorPhysicsPerformance()
    {
        int activeBodies = Physics.Bodies.Count;
        int activeColliders = FindObjectsOfType<Collider>().Length;
        
        // Log or send to analytics if performance is degrading
        if (activeBodies > 1000 || activeColliders > 5000)
        {
            Debug.LogWarning($"High physics load: {activeBodies} bodies, {activeColliders} colliders");
        }
    }
    
    // Public methods for runtime physics control
    public void PausePhysics()
    {
        Physics.autoSimulation = false;
    }
    
    public void ResumePhysics()
    {
        Physics.autoSimulation = true;
        Physics.Simulate(Time.fixedDeltaTime);
    }
    
    public void SetTimeScale(float timeScale)
    {
        Time.timeScale = timeScale;
        Time.fixedDeltaTime = fixedTimeStep * timeScale;
    }
}