Haddock - Unity Library

"On trigger touch, switch to scene with name"

"buy menu in game"

"camera slow motion delay"

using System.Collections;
using UnityEngine;

public class CamSlowMotionDelay : MonoBehaviour {

public float slowMotionTimeScale = .2f;

public void StartSlowMotionDelay(float duration){
                StopAllCoroutines();
                StartCoroutine(SlowMotionRoutine(duration));
        }

//slow motion delay
        IEnumerator SlowMotionRoutine(float duration) {

//set timescale
                Time.timeScale = slowMotionTimeScale;

//wait a moment...
                float startTime = Time.realtimeSinceStartup;
                while (Time.realtimeSinceStartup < (startTime   duration)) {
                        yield return null;
                }
                
                //reset timescale
                GameSettings settings = Resources.Load("GameSettings", typeof(GameSettings)) as GameSettings;
                if (settings != null) { 
                        Time.timeScale = settings.timeScale;
                } else {
                        Time.timeScale = 1;
                }
        }
}

"Hitscan Gun with Fire rate, Shooting sound and animation with cooldown and doesn't play when reloading, Ammo management and Reloading with r key, sound plays when R is pressed, Shooting effect, bullet tracer and impact effect that destroys itself."

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

public class HitscanGun : MonoBehaviour
{
    public float fireRate = 0.1f;
    public float range = 100f;
    public int maxAmmo = 30;
    public int currentAmmo;
    public float reloadTime = 2f;
    public AudioClip shootSound;
    public AudioClip reloadSound;
    public GameObject muzzleFlashEffect;
    public GameObject bulletTracerPrefab;
    public GameObject impactEffect;

private float nextFireTime;
    private bool isReloading = false;
    private AudioSource audioSource;
    private Animator animator;
    private Camera playerCamera;

void Start()
    {
        audioSource = GetComponent<AudioSource>();
        animator = GetComponent<Animator>();
        playerCamera = Camera.main;
        currentAmmo = maxAmmo;
    }

void Update()
    {
        if (isReloading)
            return;

if (currentAmmo <= 0 || (Input.GetKeyDown(KeyCode.R) && currentAmmo < maxAmmo))
        {
            StartCoroutine(Reload());
            return;
        }

if (Input.GetButton("Fire1") && Time.time > nextFireTime)
        {
            nextFireTime = Time.time + fireRate;
            Shoot();
        }
    }

IEnumerator Reload()
    {
        isReloading = true;
        animator.SetBool("Reloading", true);
        audioSource.PlayOneShot(reloadSound);

yield return new WaitForSeconds(reloadTime - 0.25f);
        animator.SetBool("Reloading", false);
        yield return new WaitForSeconds(0.25f);

currentAmmo = maxAmmo;
        isReloading = false;
    }

void Shoot()
    {
        currentAmmo--;

audioSource.PlayOneShot(shootSound);
        animator.SetTrigger("Shoot");

GameObject muzzleFlash = Instantiate(muzzleFlashEffect, transform.position, transform.rotation);
        Destroy(muzzleFlash, 1f);

RaycastHit hit;
        if (Physics.Raycast(playerCamera.transform.position, playerCamera.transform.forward, out hit, range))
        {
            GameObject bulletTracer = Instantiate(bulletTracerPrefab, transform.position, Quaternion.LookRotation(hit.point - transform.position));
            Destroy(bulletTracer, 2f);

GameObject impact = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
            Destroy(impact, 2f);
        }
    }
}

"script for an extra life"

"Activating an object with an animation and nothing can be triggered in the object when the animation is currently active"

"rotate 3D object by touch, only horizontal rotation"

"create a timer with a main text that branched into three different floor lantai1,lantai5 and lantai10. this timer script has and different name because i want to make its specific"

public class FloorTimer : MonoBehaviour
{
    public float timeLimit;
    private float timeRemaining;
    public Text mainText;
    public Text floorText;

void Start()
    {
        timeRemaining = timeLimit;
    }

void Update()
    {
        timeRemaining -= Time.deltaTime;
        DisplayTime(timeRemaining);

if (timeRemaining <= 0)
        {
            mainText.text = "Time's up!";
            floorText.text = "";
            // Do something when time runs out
        }
        else if (timeRemaining <= 60)
        {
            mainText.text = "Hurry up!";
            floorText.text = "Floor: Lantai 1";
        }
        else if (timeRemaining <= 300)
        {
            mainText.text = "Keep going!";
            floorText.text = "Floor: Lantai 5";
        }
        else
        {
            mainText.text = "You've got time!";
            floorText.text = "Floor: Lantai 10";
        }
    }

void DisplayTime(float timeToDisplay)
    {
        float minutes = Mathf.FloorToInt(timeToDisplay / 60);
        float seconds = Mathf.FloorToInt(timeToDisplay % 60);
        mainText.text = string.Format("{0:00}:{1:00}", minutes, seconds);
    }
}

"Create code for a 3d fps shooter game where you fight zombies"

Creating a full 3D FPS shooter game with zombies would be too extensive to provide in a single response. However, I can provide you with a basic framework to get started. You can then build upon this foundation by adding more features, such as different weapons, enemy types, levels, and so on.

1. First, set up the player character with a first-person camera and basic movement controls:

```csharp
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float speed = 5.0f;
    public float mouseSensitivity = 2.0f;

private float verticalRotation = 0;
    private CharacterController characterController;

void Start()
    {
        characterController = GetComponent<CharacterController>();
        Cursor.lockState = CursorLockMode.Locked;
    }

void Update()
    {
        // Mouse look
        float horizontalRotation = Input.GetAxis("Mouse X") * mouseSensitivity;
        transform.Rotate(0, horizontalRotation, 0);

verticalRotation -= Input.GetAxis("Mouse Y") * mouseSensitivity;
        verticalRotation = Mathf.Clamp(verticalRotation, -90, 90);
        Camera.main.transform.localRotation = Quaternion.Euler(verticalRotation, 0, 0);

// Movement
        float forwardSpeed = Input.GetAxis("Vertical") * speed;
        float sideSpeed = Input.GetAxis("Horizontal") * speed;
        Vector3 velocity = new Vector3(sideSpeed, 0, forwardSpeed);
        velocity = transform.rotation * velocity;

characterController.SimpleMove(velocity);
    }
}
```

2. Create a simple shooting mechanic:

```csharp
using UnityEngine;

public class GunController : MonoBehaviour
{
    public GameObject bulletPrefab;
    public Transform bulletSpawn;
    public float fireRate = 0.5f;

private float nextFire = 0.0f;

void Update()
    {
        if (Input.GetButton("Fire1") && Time.time > nextFire)
        {
            nextFire = Time.time + fireRate;
            Shoot();
        }
    }

void Shoot()
    {
        GameObject bullet = Instantiate(bulletPrefab, bulletSpawn.position, bulletSpawn.rotation);
        bullet.GetComponent<Rigidbody>().velocity = bullet.transform.forward * 20;
        Destroy(bullet, 2.0f);
    }
}
```

3. Create a basic zombie AI:

```csharp
using UnityEngine;
using UnityEngine.AI;

public class ZombieAI : MonoBehaviour
{
    public Transform player;
    public float chaseDistance = 10.0f;

private NavMeshAgent navMeshAgent;

void Start()
    {
        navMeshAgent = GetComponent<NavMeshAgent>();
    }

void Update()
    {
        float distanceToPlayer = Vector3.Distance(transform.position, player.position);

if (distanceToPlayer < chaseDistance)
        {
            navMeshAgent.SetDestination(player.position);
        }
    }
}
```

4. Add health and damage mechanics:

```csharp
using UnityEngine;

public class Health : MonoBehaviour
{
    public float maxHealth = 100;
    public float currentHealth;

void Start()
    {
        currentHealth = maxHealth;
    }

public void TakeDamage(float damage)
    {
        currentHealth -= damage;

if (currentHealth <= 0)
        {
            Die();
        }
    }

void Die()
    {
        if (gameObject.CompareTag("Player"))
        {
            // Implement player death logic
        }
        else if (gameObject.CompareTag("Zombie"))
        {
            Destroy(gameObject);
        }
    }
}
```

5. Add a script to handle bullet collisions and apply damage:

```csharp
using UnityEngine;

public class Bullet : MonoBehaviour
{
    public float damage = 10f;

void OnCollisionEnter(Collision collision)
    {
        Health health = collision.collider.GetComponent<Health>();

if (health != null)
        {
            health.TakeDamage(damage);
        }

Destroy(gameObject);
    }
}
```

This is a basic framework for a 3D FPS shooter game with zombies. You can build upon this by adding more features, such as different weapons, enemy types, levels, and so on.

"Class which toggles the teleport on the right thumb stick input its use in VR unity games"

"count the game object cube with text"

"move and rotate object with arrow keys"

"Create a random map generation system with multiple layers of perlin noise for a 2d unity game"

To create a random map generation system with multiple layers of Perlin noise for a 2D Unity game, follow these steps:

1. Create a new 2D Unity project.
2. Create a new script called `MapGenerator` and paste the following code inside:

```csharp
using UnityEngine;

public class MapGenerator : MonoBehaviour
{
    public int width;
    public int height;
    public float scale;

public int octaves;
    public float persistence;
    public float lacunarity;

public int seed;
    public Vector2 offset;

private void Start()
    {
        GenerateMap();
    }

public void GenerateMap()
    {
        float[,] noiseMap = GenerateNoiseMap(width, height, scale, octaves, persistence, lacunarity, seed, offset);

// Here you can use the noiseMap to create your map using tiles, sprites or any other method you prefer.
    }

private float[,] GenerateNoiseMap(int mapWidth, int mapHeight, float scale, int octaves, float persistence, float lacunarity, int seed, Vector2 offset)
    {
        float[,] noiseMap = new float[mapWidth, mapHeight];

System.Random prng = new System.Random(seed);
        Vector2[] octaveOffsets = new Vector2[octaves];
        for (int i = 0; i < octaves; i++)
        {
            float offsetX = prng.Next(-100000, 100000) + offset.x;
            float offsetY = prng.Next(-100000, 100000) + offset.y;
            octaveOffsets[i] = new Vector2(offsetX, offsetY);
        }

if (scale <= 0)
        {
            scale = 0.0001f;
        }

float maxNoiseHeight = float.MinValue;
        float minNoiseHeight = float.MaxValue;

for (int y = 0; y < mapHeight; y++)
        {
            for (int x = 0; x < mapWidth; x++)
            {
                float amplitude = 1;
                float frequency = 1;
                float noiseHeight = 0;

for (int i = 0; i < octaves; i++)
                {
                    float sampleX = (x - mapWidth / 2f) / scale * frequency + octaveOffsets[i].x;
                    float sampleY = (y - mapHeight / 2f) / scale * frequency + octaveOffsets[i].y;

float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
                    noiseHeight += perlinValue * amplitude;

amplitude *= persistence;
                    frequency *= lacunarity;
                }

if (noiseHeight > maxNoiseHeight)
                {
                    maxNoiseHeight = noiseHeight;
                }
                else if (noiseHeight < minNoiseHeight)
                {
                    minNoiseHeight = noiseHeight;
                }

noiseMap[x, y] = noiseHeight;
            }
        }

for (int y = 0; y < mapHeight; y++)
        {
            for (int x = 0; x < mapWidth; x++)
            {
                noiseMap[x, y] = Mathf.InverseLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x, y]);
            }
        }

return noiseMap;
    }
}
```

3. Attach the `MapGenerator` script to an empty GameObject in your scene.
4. Set the values for `width`, `height`, `scale`, `octaves`, `persistence`, `lacunarity`, `seed`, and `offset` in the Inspector according to your preferences.
5. Implement your preferred method of creating the map using the generated `noiseMap` in the `GenerateMap()` function. You can use tilemaps, instantiate prefabs, or any other method to create your 2D map based on the Perlin noise values.

This script will generate a random map using multiple layers of Perlin noise. You can tweak the parameters to achieve the desired look for your map.

"Create code for a 3d fps shooter game where you fight zombies"

using UnityEngine;
using UnityEngine.AI;

public class FPSController : MonoBehaviour
{
    public GameObject bulletPrefab;
    public Transform bulletSpawn;
    public float bulletSpeed = 30;
    public float fireRate = 0.5f;
    private float nextFire = 0.0f;

private Camera playerCamera;
    private CharacterController characterController;
    private Vector3 moveDirection = Vector3.zero;
    public float speed = 6.0f;
    public float gravity = 20.0f;

void Start()
    {
        characterController = GetComponent<CharacterController>();
        playerCamera = Camera.main;
    }

void Update()
    {
        MovePlayer();

if (Input.GetButton("Fire1") && Time.time > nextFire)
        {
            nextFire = Time.time + fireRate;
            Shoot();
        }
    }

void MovePlayer()
    {
        if (characterController.isGrounded)
        {
            moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0.0f, Input.GetAxis("Vertical"));
            moveDirection = transform.TransformDirection(moveDirection);
            moveDirection *= speed;
        }

moveDirection.y -= gravity * Time.deltaTime;
        characterController.Move(moveDirection * Time.deltaTime);
    }

void Shoot()
    {
        var bullet = (GameObject)Instantiate(bulletPrefab, bulletSpawn.position, bulletSpawn.rotation);
        bullet.GetComponent<Rigidbody>().velocity = bullet.transform.forward * bulletSpeed;

Destroy(bullet, 2.0f);
    }
}

public class ZombieAI : MonoBehaviour
{
    public Transform target;
    private NavMeshAgent agent;

void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        target = GameObject.FindGameObjectWithTag("Player").transform;
    }

void Update()
    {
        agent.SetDestination(target.position);
    }
}

public class BulletCollision : MonoBehaviour
{
    public int damage = 10;

void OnCollisionEnter(Collision collision)
    {
        var hit = collision.gameObject;
        var health = hit.GetComponent<ZombieHealth>();

if (health != null)
        {
            health.TakeDamage(damage);
        }

Destroy(gameObject);
    }
}

public class ZombieHealth : MonoBehaviour
{
    public int startingHealth = 100;
    public int currentHealth;

void Start()
    {
        currentHealth = startingHealth;
    }

public void TakeDamage(int amount)
    {
        currentHealth -= amount;

if (currentHealth <= 0)
        {
            Die();
        }
    }

void Die()
    {
        Destroy(gameObject);
    }
}

"Unity2D. One script: draws and controls a player with WASD and creates the components it needs. Also draw a procedural endless platforming map. Creates particle effects for death and jump and plays them correctly. Creates hazards that kill. Color all"

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour
{
    public float moveSpeed = 5f;
    public float jumpForce = 10f;
    public GameObject deathParticles;
    public GameObject jumpParticles;
    public GameObject hazardPrefab;
    public Color[] colors;

private Rigidbody2D rb;
    private SpriteRenderer sr;
    private bool isGrounded = false;

void Start()
    {
        rb = gameObject.AddComponent<Rigidbody2D>();
        sr = gameObject.AddComponent<SpriteRenderer>();
        sr.color = colors[Random.Range(0, colors.Length)];

BoxCollider2D collider = gameObject.AddComponent<BoxCollider2D>();
        collider.size = new Vector2(1, 1);
    }

void Update()
    {
        float move = Input.GetAxis("Horizontal") * moveSpeed;
        rb.velocity = new Vector2(move, rb.velocity.y);

if (Input.GetKeyDown(KeyCode.W) && isGrounded)
        {
            rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
            Instantiate(jumpParticles, transform.position, Quaternion.identity);
            isGrounded = false;
        }

if (transform.position.y < -10)
        {
            Instantiate(deathParticles, transform.position, Quaternion.identity);
            transform.position = Vector3.zero;
        }
    }

void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            isGrounded = true;
        }

if (collision.gameObject.CompareTag("Hazard"))
        {
            Instantiate(deathParticles, transform.position, Quaternion.identity);
            transform.position = Vector3.zero;
        }
    }

void OnTriggerEnter2D(Collider2D collider)
    {
        if (collider.CompareTag("EndlessPlatform"))
        {
            // Generate new platform and hazards
            Vector3 newPosition = new Vector3(transform.position.x + 10, transform.position.y, transform.position.z);
            Instantiate(hazardPrefab, newPosition, Quaternion.identity);
        }
    }
}

public class EndlessPlatformGenerator : MonoBehaviour
{
    public GameObject platformPrefab;
    public GameObject hazardPrefab;

private void Start()
    {
        for (int i = 0; i < 10; i++)
        {
            Vector3 platformPosition = new Vector3(i * 10, Random.Range(-2f, 2f), 0);
            Instantiate(platformPrefab, platformPosition, Quaternion.identity);

if (Random.Range(0, 3) == 0)
            {
                Vector3 hazardPosition = new Vector3(platformPosition.x, platformPosition.y + 1, 0);
                Instantiate(hazardPrefab, hazardPosition, Quaternion.identity);
            }
        }
    }
}

"Write a compute shader function in HLSL that draw a line from point A to B in a texture using the DDA algorithm. Add comments to code."

Here's a compute shader function in HLSL that draws a line from point A to B in a texture using the DDA algorithm. I've added comments to explain the code.

```
// The shader is bound to a compute shader in Unity
#pragma kernel DrawLine

// Input texture
RWTexture2D<float4> Result;

// Function to draw a line from point A to B using the DDA algorithm
[numthreads(1, 1, 1)]
void DrawLine(uint3 id : SV_DispatchThreadID)
{
    // Input points A and B
    float2 A = float2(10, 20);
    float2 B = float2(100, 200);

// Calculate the differences in x and y coordinates
    float deltaX = B.x - A.x;
    float deltaY = B.y - A.y;

// Calculate the number of steps needed for the algorithm
    float steps = max(abs(deltaX), abs(deltaY));

// Calculate the increments for x and y
    float xIncrement = deltaX / steps;
    float yIncrement = deltaY / steps;

// Initialize the current position to point A
    float2 currentPosition = A;

// Loop through the steps and draw the line
    for (int i = 0; i <= steps; i++)
    {
        // Calculate the current pixel position
        int2 pixelPosition = int2(currentPosition.x, currentPosition.y);

// Set the color of the current pixel in the texture
        Result[pixelPosition] = float4(1, 1, 1, 1); // White color

// Update the current position with the increments
        currentPosition.x += xIncrement;
        currentPosition.y += yIncrement;
    }
}
```

This shader function can be used in a Unity compute shader to draw a line from point A to B in a texture. The DDA (Digital Differential Analyzer) algorithm is used to calculate the pixel positions along the line, and the texture is updated with the new color values.

"Script that get a json file with events list (title, type, date, location, interfering, description, price)"

To get a JSON file with an events list in Unity, you can use the `UnityWebRequest` class to download the JSON file from a URL and then parse it using the `JsonUtility` class. Here's an example script:

```csharp
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;

[Serializable]
public class Event
{
    public string title;
    public string type;
    public string date;
    public string location;
    public string interfering;
    public string description;
    public float price;
}

[Serializable]
public class EventsList
{
    public List<Event> events;
}

public class GetEventsFromJSON : MonoBehaviour
{
    public string jsonURL;

private void Start()
    {
        StartCoroutine(GetJSONData());
    }

private IEnumerator GetJSONData()
    {
        using (UnityWebRequest webRequest = UnityWebRequest.Get(jsonURL))
        {
            yield return webRequest.SendWebRequest();

if (webRequest.result == UnityWebRequest.Result.ConnectionError || webRequest.result == UnityWebRequest.Result.ProtocolError)
            {
                Debug.LogError("Error: "   webRequest.error);
            }
            else
            {
                string json = webRequest.downloadHandler.text;
                ParseJSONData(json);
            }
        }
    }

private void ParseJSONData(string json)
    {
        EventsList eventsList = JsonUtility.FromJson<EventsList>("{\"events\":"   json   "}");
        foreach (Event eventItem in eventsList.events)
        {
            Debug.Log("Title: "   eventItem.title);
            Debug.Log("Type: "   eventItem.type);
            Debug.Log("Date: "   eventItem.date);
            Debug.Log("Location: "   eventItem.location);
            Debug.Log("Interfering: "   eventItem.interfering);
            Debug.Log("Description: "   eventItem.description);
            Debug.Log("Price: "   eventItem.price);
            Debug.Log("-------------");
        }
    }
}
```

Replace `jsonURL` with the URL of your JSON file. This script will download the JSON file, parse it, and display the event information in the Unity console. Make sure to attach this script to a GameObject in your scene.

"give hint to user on click"

"Music Fade-In that makes volume go smoothly from 0 to 1 using coroutines and lerping"

"enemy wave"

"set the light emission in the game"

[Serializable]
public class LightEmission
{
        public MeshRenderer renderer;
        public Color emissionColor;

public void GetDefaultColor()
        {
                if (renderer != null)
                {
                        if (renderer.material.shader.name == "Standard")
                        {
                                emissionColor = renderer.material.GetColor("_EmissionColor");
                        }
                        if (renderer.material.shader.name == "ZeroGravity/Surface/MultiMaterial")
                        {
                                emissionColor = renderer.material.GetColor("_EmColor");
                        }
                }
        }

public void SetColor(Color color)
        {
                if (renderer != null)
                {
                        if (renderer.material.shader.name == "Standard")
                        {
                                renderer.material.SetColor("_EmissionColor", color);
                        }
                        if (renderer.material.shader.name == "ZeroGravity/Surface/MultiMaterial")
                        {
                                renderer.material.SetColor("_EmColor", color);
                        }
                }
        }

public void SetDefaultColor()
        {
                if (renderer != null)
                {
                        if (renderer.material.shader.name == "Standard")
                        {
                                renderer.material.SetColor("_EmissionColor", emissionColor);
                        }
                        if (renderer.material.shader.name == "ZeroGravity/Surface/MultiMaterial")
                        {
                                renderer.material.SetColor("_EmColor", emissionColor);
                        }
                }
        }
}

"Character controller with built in Camera system (controllable FOV), Walking and running with stamina system, Crouching, Jumping, Footstep system with multiple footsteps sounds, Headbobbing and all keys for each action can be changed."

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

public class CustomCharacterController : MonoBehaviour
{
    public float walkSpeed = 3f;
    public float runSpeed = 6f;
    public float crouchSpeed = 1.5f;
    public float jumpForce = 8f;
    public float crouchHeight = 0.5f;
    public float standingHeight = 2f;
    public float stamina = 100f;
    public float staminaRecoveryRate = 5f;
    public float staminaDrainRate = 10f;
    public float minStaminaToRun = 20f;
    public float headBobbingAmount = 0.1f;
    public float headBobbingSpeed = 10f;
    public KeyCode runKey = KeyCode.LeftShift;
    public KeyCode crouchKey = KeyCode.LeftControl;
    public KeyCode jumpKey = KeyCode.Space;
    public Camera playerCamera;
    public Slider staminaBar;
    public AudioClip[] footstepSounds;

private CharacterController characterController;
    private Vector3 moveDirection;
    private bool isCrouching = false;
    private bool isRunning = false;
    private float originalCameraY;
    private float currentStamina;
    private AudioSource audioSource;
    private float stepDistanceCounter;

void Start()
    {
        characterController = GetComponent<CharacterController>();
        originalCameraY = playerCamera.transform.localPosition.y;
        currentStamina = stamina;
        audioSource = GetComponent<AudioSource>();
    }

void Update()
    {
        MoveCharacter();
        HandleStamina();
        HandleHeadBobbing();
        HandleFootsteps();
    }

void MoveCharacter()
    {
        float moveHorizontal = Input.GetAxis("Horizontal");
        float moveVertical = Input.GetAxis("Vertical");

if (characterController.isGrounded)
        {
            moveDirection = new Vector3(moveHorizontal, 0, moveVertical);
            moveDirection = transform.TransformDirection(moveDirection);

if (Input.GetKey(runKey) && !isCrouching && currentStamina > minStaminaToRun)
            {
                moveDirection *= runSpeed;
                isRunning = true;
            }
            else if (isCrouching)
            {
                moveDirection *= crouchSpeed;
                isRunning = false;
            }
            else
            {
                moveDirection *= walkSpeed;
                isRunning = false;
            }

if (Input.GetKeyDown(jumpKey) && !isCrouching)
            {
                moveDirection.y = jumpForce;
            }

if (Input.GetKeyDown(crouchKey))
            {
                ToggleCrouch();
            }
        }

moveDirection.y -= 20f * Time.deltaTime; // Gravity
        characterController.Move(moveDirection * Time.deltaTime);
    }

void ToggleCrouch()
    {
        isCrouching = !isCrouching;
        characterController.height = isCrouching ? crouchHeight : standingHeight;
        Vector3 newCameraPos = playerCamera.transform.localPosition;
        newCameraPos.y = isCrouching ? originalCameraY / 2f : originalCameraY;
        playerCamera.transform.localPosition = newCameraPos;
    }

void HandleStamina()
    {
        if (isRunning)
        {
            currentStamina -= staminaDrainRate * Time.deltaTime;
            if (currentStamina < 0f)
            {
                currentStamina = 0f;
            }
        }
        else
        {
            currentStamina += staminaRecoveryRate * Time.deltaTime;
            if (currentStamina > stamina)
            {
                currentStamina = stamina;
            }
        }

staminaBar.value = currentStamina;
    }

void HandleHeadBobbing()
    {
        if (characterController.velocity.magnitude > 0.1f && characterController.isGrounded)
        {
            playerCamera.transform.localPosition = new Vector3(playerCamera.transform.localPosition.x, originalCameraY + Mathf.Sin(Time.time * headBobbingSpeed) * headBobbingAmount, playerCamera.transform.localPosition.z);
        }
        else
        {
            playerCamera.transform.localPosition = new Vector3(playerCamera.transform.localPosition.x, Mathf.Lerp(playerCamera.transform.localPosition.y, originalCameraY, Time.deltaTime * headBobbingSpeed), playerCamera.transform.localPosition.z);
        }
    }

void HandleFootsteps()
    {
        if (characterController.velocity.magnitude > 0.1f && characterController.isGrounded)
        {
            stepDistanceCounter += characterController.velocity.magnitude * Time.deltaTime;
            if (stepDistanceCounter > 1f)
            {
                PlayFootstepSound();
                stepDistanceCounter = 0f;
            }
        }
    }

void PlayFootstepSound()
    {
        int randomIndex = Random.Range(0, footstepSounds.Length);
        audioSource.clip = footstepSounds[randomIndex];
        audioSource.Play();
    }
}

"make a detailed achievement controller with pop ups to show and unlock achievements"

public class AchievementController : MonoBehaviour
{
    private static AchievementController _instance = null;
    public static AchievementController Instance
    {
        get{
            if(_instance == null)
            {
                _instance = FindObjectOfType<AchievementController>();
            }
            return _instance;
        }
    }

[SerializeField] private Transform _popUpTrans;
    [SerializeField] private Text _popUptext;
    [SerializeField] private float _popUpShowDuration = 3f;
    [SerializeField] private List<AchievementData> _achievementList;
    private float _popUpShowDurationCount;

private void Update()
    {
        if(_popUpShowDurationCount > 0)
        {
            _popUpShowDurationCount -= Time.unscaledDeltaTime;
            _popUpTrans.localScale = Vector3.LerpUnclamped(_popUpTrans.localScale,Vector3.one,0.5f);
        }
        else{
            _popUpTrans.localScale = Vector2.LerpUnclamped(_popUpTrans.localScale,Vector3.right,0.5f);
        }
    }

public void UnlockAchieve(Achievetype type, string val)
    {
        AchievementData achieve = _achievementList.Find(a=>a.Type == type

"create a cube and make it fall at position -1.92-0.4-0.3168189"

"Create a system with a public function where you can add party members to a list which follow the player in a line"

"start and update methods for fps"

using UnityEngine;
using System.Collections;
using UnityEngine.UI;

public class FPSTest : MonoBehaviour
{

float updateInterval = 0.5f;

private float accum = 0.0f; // FPS accumulated over the interval
private int frames = 0; // Frames drawn over the interval
private float fpsRate = 0.0f;
        float totalTime;

private float timeleft ; // Left time for current interval

void Start()
{
    Application.targetFrameRate = 60;
    timeleft = updateInterval; 
}

void Update()
{
    timeleft -= Time.deltaTime;
    accum  = Time.timeScale/Time.deltaTime;
      frames;
   
    // Interval ended - update GUI text and start new interval
    if( timeleft <= 0.0f )
    {
        // display two fractional digits (f2 format)
        fpsRate = (accum/frames);
                        GetComponent<Text>().text = "FPS = "   (fpsRate).ToString("f2"); // uncomment it to show FPS on device screen, don't disable this script from scene as it is making calculation of fps for everyplay replay videos at run time.

timeleft = updateInterval;
        accum = 0.0f;
        frames = 0;
    }
}

"Create a square at mouse position with a random colour from a gradient"

"HitscanGun with Fire rate, multiple shot sound and animation with cooldown and doesn't play when reloading, Ammo system and Reloading with R key, sound play when R is pressed, Muzzle effect, TrailRender bullet and impact effect that destroy itself."

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

public class HitscanGun : MonoBehaviour
{
    public float fireRate = 0.1f;
    public int maxAmmo = 30;
    public int currentAmmo;
    public float reloadTime = 2f;
    public bool isReloading = false;

public AudioClip[] shotSounds;
    public AudioClip reloadSound;
    public AudioSource audioSource;

public Animator animator;

public ParticleSystem muzzleFlash;
    public GameObject impactEffect;
    public GameObject bulletTrailPrefab;

public Camera fpsCam;

private float nextTimeToFire = 0f;

void Start()
    {
        currentAmmo = maxAmmo;
    }

void Update()
    {
        if (isReloading)
            return;

if (currentAmmo <= 0 || Input.GetKeyDown(KeyCode.R))
        {
            StartCoroutine(Reload());
            return;
        }

if (Input.GetButton("Fire1") && Time.time >= nextTimeToFire)
        {
            nextTimeToFire = Time.time + 1f / fireRate;
            Shoot();
        }
    }

IEnumerator Reload()
    {
        isReloading = true;
        audioSource.PlayOneShot(reloadSound);
        animator.SetBool("Reloading", true);

yield return new WaitForSeconds(reloadTime - 0.25f);
        animator.SetBool("Reloading", false);
        yield return new WaitForSeconds(0.25f);

currentAmmo = maxAmmo;
        isReloading = false;
    }

void Shoot()
    {
        currentAmmo--;

muzzleFlash.Play();

int randomIndex = Random.Range(0, shotSounds.Length);
        audioSource.PlayOneShot(shotSounds[randomIndex]);

RaycastHit hit;
        if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit))
        {
            GameObject bulletTrail = Instantiate(bulletTrailPrefab, muzzleFlash.transform.position, Quaternion.identity);
            LineRenderer lineRenderer = bulletTrail.GetComponent<LineRenderer>();
            lineRenderer.SetPosition(0, muzzleFlash.transform.position);
            lineRenderer.SetPosition(1, hit.point);

Destroy(bulletTrail, 0.05f);

GameObject impactGO = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
            Destroy(impactGO, 2f);
        }
    }
}

"create a cube"

"Jetpack system with spacebar and sound when first pressing space bar, mid air loop and when not pressing spacebar"

using UnityEngine;

public class Jetpack : MonoBehaviour
{
    public float jetpackForce = 75.0f;
    public AudioClip startJetpackSound;
    public AudioClip loopJetpackSound;
    public AudioClip stopJetpackSound;

private AudioSource audioSource;
    private Rigidbody rb;
    private bool isJetpacking;

void Start()
    {
        rb = GetComponent<Rigidbody>();
        audioSource = GetComponent<AudioSource>();
        isJetpacking = false;
    }

void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            StartJetpack();
        }
        else if (Input.GetKeyUp(KeyCode.Space))
        {
            StopJetpack();
        }
    }

void FixedUpdate()
    {
        if (isJetpacking)
        {
            rb.AddForce(Vector3.up * jetpackForce);
        }
    }

void StartJetpack()
    {
        isJetpacking = true;
        audioSource.Stop();
        audioSource.clip = startJetpackSound;
        audioSource.Play();
        Invoke("PlayLoopJetpackSound", startJetpackSound.length);
    }

void PlayLoopJetpackSound()
    {
        audioSource.Stop();
        audioSource.clip = loopJetpackSound;
        audioSource.loop = true;
        audioSource.Play();
    }

void StopJetpack()
    {
        isJetpacking = false;
        audioSource.Stop();
        audioSource.clip = stopJetpackSound;
        audioSource.loop = false;
        audioSource.Play();
    }
}

"Hitscan weapon with Trail render Bullet Trail, Bullet Spawn Point using a transform, Bullet speed, Bullet Distance, Rate of fire, Multiple custom shooting sounds, Impact and Muzzle flash Particle support. Delete effect after wall hit or time."

"create an enemy spawner"

"start Coroutines"