
#### Initialization in Start Method

```csharp
private void Start()
{
    startPosition = transform.position;
}
```
**Purpose**: Stores the player's initial position when the game starts.

#### Restarting Player Position

```csharp
public void RestartPlayerPosition()
{
    transform.position = startPosition;
    rb.velocity = Vector2.zero;
}
```
**Purpose**: Resets the player's position to the start position and stops any movement by setting the velocity to zero.

#### Handling Player Input in Update Method

```csharp
private void Update()
{
    Vector2 oldVelocity = rb.velocity;
    if (Input.GetKeyDown(KeyCode.Space))
    {
        oldVelocity.y = 6;
    }
    oldVelocity.x = 4;
    rb.velocity = oldVelocity;
}
```
**Purpose**:
Captures the player's input (space key) to make the player "jump" by setting the y-velocity to 6, while constantly moving the player to the right by setting the x-velocity to 4.


**OnCollisionEnter2D**

```csharp
private void OnCollisionEnter2D(Collision2D collision)
{
    if (collision.collider.tag == "ground")
    {
        RestartPlayerPosition();
    }
}
```
**Purpose**: Resets the player's position when colliding with objects tagged as "ground".

**OnTriggerEnter2D**

```csharp
private void OnTriggerEnter2D(Collider2D collision)
{
    if (collision.tag == "win")
    {
        winPanel.SetActive(true);
        SoundManager.instance.PlayEffect(1);
    }
}
```
**Purpose**: Activates the win panel and plays a sound effect when the player collides with objects tagged as "win".


## Summary

- **Movement**: Player moves to the right continuously and jumps when the space key is pressed;
- **Restart**: Player position resets upon collision with the ground;
- **Winning**: Displays a win panel and plays a sound when reaching the win trigger.



#### Start Method

```csharp
private void Start()
{
    if (instance == null)
    {
        instance = this;
    }
    else
    {
        Destroy(gameObject);
        return;
    }
    DontDestroyOnLoad(gameObject);
}
```
**Purpose**:
Ensures there is only one instance of `SoundManager` in the game using the Singleton Pattern. Uses `DontDestroyOnLoad(gameObject)` to persist across different scenes.


#### PlayEffect Method

```csharp
public void PlayEffect(int index)
{
    if (index >= 0 && index < effects.Count)
    {
        source.PlayOneShot(effects[index]);
    }
}
```
**Purpose**:
Takes an integer `index` to identify which sound effect to play from the `effects` list. It checks if the `index` is within the valid range of the `effects` list and plays the specified sound effect using `source.PlayOneShot(effects[index])`.

## Summary

- **Singleton Pattern**: Ensures only one instance of `SoundManager` exists in the game, persisting across scenes;
- **Playing Sound Effects**: Uses the `PlayEffect` method to play sound effects by specifying their index in the `effects` list;
- **Audio Source**: Utilizes an `AudioSource` component to play the audio clips.

## WinPanel Class

The `WinPanel` class provides functionality for the UI panel that appears when the player wins. It includes methods to return to the main menu or restart the level, each playing a sound effect and loading the appropriate scene.



**ReturnToMainMenu Method**

```csharp
public void ReturnToMainMenu()
{
    SoundManager.instance.PlayEffect(0);
    SceneManager.LoadScene(0);
}
```
**Purpose**:
Plays a sound effect (index 0) using `SoundManager.instance.PlayEffect(0)`. Loads the main menu scene with build index 0 using `SceneManager.LoadScene(0)`.


**RestartLevel Method**

```csharp
public void RestartLevel()
{
    SoundManager.instance.PlayEffect(0);
    SceneManager.LoadScene("Game");
}
```
**Purpose**:
Plays a sound effect (index 0) using `SoundManager.instance.PlayEffect(0)`. Loads the game scene named "Game" using `SceneManager.LoadScene("Game")`.

Get ready to build an awesome fighting game featuring cool animations and a big boss battle! 
Learn Unity's animation system to create smooth player movements and powerful attacks.
Dive into enemy AI, shaping their behaviors from following to rage states. Improve your game with simple UI elements, cool effects, and sounds. Finally, share your game with others to play it.

In this chapter, we will learn all about animations, how to synchronize animations with movement, and how to smoothly transition between animations.


We will create a full behavior for the player and animate it. The player will be able to move, jump, and attack using different techniques, such as the Rigidbody2D for movement and triggers for attacks and interactions.

We will create the Boss AI and define its behavior based on the player's proximity. When the player is at a long distance, the Boss will either send a projectile or move toward the player. If the player is nearby, the Boss will attack with its weapon. Additionally, when the Boss's health drops below 40%, it will enter a rage state and unleash different, more aggressive attacks.

We will implement major improvements to the game, including adding particles and effects to enhance the overall feel. Additionally, we'll create UI elements such as the main menu and health bar, and ensure they are controllable. Finally, we'll export the game and test it.

We will revisit the game we created in the previous Unity course (Flappy Bird) and enhance it. We'll add random generation, synchronize the background movement with the player, and dynamically move obstacles, creating an endless gameplay experience.


Fighting Game in Unity

Explain the Code

Player Code

Initialization in Start Method

Restarting Player Position

Handling Player Input in Update Method

Collision Handling

Summary

SoundManager Class

Start Method

PlayEffect Method

Summary

WinPanel Class

Methods