Haddock - Unity Library

"use imagefill example"

"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 script that makes a character move around"

"start Coroutines"

"Rotate the game object by pressing Key at runtime"

"create a button flicker class in unity"

"Does not destroy the game object when loading next scene"

"coin collect on trigger"

"sum two numbers"

"give me an example of a raycast hit and no hit in the same method"

"make a cube that will auto spawn"

"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."

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

public class HitscanWeapon : MonoBehaviour
{
    public Transform bulletSpawnPoint;
    public float bulletSpeed = 1000f;
    public float bulletDistance = 100f;
    public float rateOfFire = 0.1f;
    public AudioClip[] shootingSounds;
    public GameObject impactEffect;
    public GameObject muzzleFlashEffect;
    public float effectLifetime = 5f;

private AudioSource audioSource;
    private float lastFireTime;
    private RaycastHit hit;

void Start()
    {
        audioSource = GetComponent<AudioSource>();
        lastFireTime = Time.time;
    }

void Update()
    {
        if (Input.GetMouseButton(0) && Time.time > lastFireTime + rateOfFire)
        {
            Fire();
        }
    }

void Fire()
    {
        lastFireTime = Time.time;

// Play shooting sound
        int randomSoundIndex = Random.Range(0, shootingSounds.Length);
        audioSource.PlayOneShot(shootingSounds[randomSoundIndex]);

// Muzzle flash effect
        GameObject muzzleFlash = Instantiate(muzzleFlashEffect, bulletSpawnPoint.position, bulletSpawnPoint.rotation);
        Destroy(muzzleFlash, effectLifetime);

// Hitscan logic
        if (Physics.Raycast(bulletSpawnPoint.position, bulletSpawnPoint.forward, out hit, bulletDistance))
        {
            // Impact effect
            GameObject impact = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
            Destroy(impact, effectLifetime);

// Bullet trail
            GameObject bulletTrail = new GameObject();
            LineRenderer lineRenderer = bulletTrail.AddComponent<LineRenderer>();
            lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
            lineRenderer.startColor = Color.red;
            lineRenderer.endColor = Color.red;
            lineRenderer.startWidth = 0.05f;
            lineRenderer.endWidth = 0.05f;
            lineRenderer.SetPosition(0, bulletSpawnPoint.position);
            lineRenderer.SetPosition(1, hit.point);
            Destroy(bulletTrail, effectLifetime);
        }
    }
}

"When an object is activated, an animation plays and no input can be sent in that object when the animation is currently active"

using UnityEngine;
using UnityEngine.UI;

public class ObjectAnimation : MonoBehaviour
{
    public GameObject animatedObject;
    public Animator objectAnimator;
    private bool isAnimationPlaying;

// Start is called before the first frame update
    void Start()
    {
        objectAnimator = animatedObject.GetComponent<Animator>();
        isAnimationPlaying = false;
    }

// Update is called once per frame
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space) && !isAnimationPlaying)
        {
            ActivateObject();
        }
    }

void ActivateObject()
    {
        isAnimationPlaying = true;
        objectAnimator.SetTrigger("Activate");
        StartCoroutine(DisableInputDuringAnimation());
    }

System.Collections.IEnumerator DisableInputDuringAnimation()
    {
        // Get the animation clip length
        float animationLength = 0f;
        AnimationClip[] clips = objectAnimator.runtimeAnimatorController.animationClips;
        foreach (AnimationClip clip in clips)
        {
            if (clip.name == "YourAnimationName") // Replace with the name of your animation
            {
                animationLength = clip.length;
                break;
            }
        }

// Wait for the animation to finish
        yield return new WaitForSeconds(animationLength);

// Re-enable input
        isAnimationPlaying = false;
    }
}

"pause game when button is clicked"

"move UI element on an arc"

"implement fb login system"

// This Script is a community contribution and wasn't generated by ScripterAI
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using Facebook.Unity;

public class FacebookManager : MonoBehaviour {

public GameObject DialogLoggedIn;
        public GameObject DialogLoggedout;
        public GameObject DialogUserName;
        public GameObject DialogProfilePic,ProfilePic;

void Awake(){
        FB.Init(SetInit, OnHideUnity);
}
void SetInit(){
        if(FB.IsLoggedIn){
                Debug.Log("fb is loggin");
        }else
        {
                Debug.Log("fb is not loggin");
        }
        DealWithFBMenus (FB.IsLoggedIn);

}

void OnHideUnity(bool isGameShown){
        if(!isGameShown){
                Time.timeScale=0;
        
        }else
        {
                        Time.timeScale=0;
        }
}

public void FBLogin(){
            List<string> perms = new List<string>();
                perms.Add("public_profile");
FB.LogInWithReadPermissions(perms, AuthCallback);
}

private void AuthCallback (IResult result) {
    if (result.Error != null) {
                        Debug.Log(result.Error);
                } else
                {
                        if(FB.IsLoggedIn){
                        Debug.Log("fb is loggin");
                        }else
                        {
                        Debug.Log("fb is not loggin");
                        }
                                DealWithFBMenus (FB.IsLoggedIn);
                }
}

void DealWithFBMenus(bool IsLoggedIn)
{
        if(IsLoggedIn){
                DialogLoggedIn.SetActive(true);
                DialogLoggedout.SetActive(false);
                FB.API("/me?fields=first_name",HttpMethod.GET,DisplayUsername);
                FB.API("me/picture?type=square&height=600&width=600", HttpMethod.GET, GetPicture);
        
        }else
        {
                DialogLoggedIn.SetActive(false);
                DialogLoggedout.SetActive(true);
        }
}

void DisplayUsername(IResult result){
        Text UserName = DialogUserName.GetComponent<Text>();
        if(result.Error == null){
                UserName.text = ""+result.ResultDictionary["first_name"];
        }else
        {
                Debug.Log(result.Error);
        }
}
private void GetPicture(IGraphResult result)
{
    if (result.Texture != null)
    {          
        Image img = DialogProfilePic.GetComponent<Image>();
        img.sprite = Sprite.Create(result.Texture, new Rect(0, 0, 600, 600), new Vector2());    
                Image img1 = ProfilePic.GetComponent<Image>();
        img1.sprite = Sprite.Create(result.Texture, new Rect(0, 0, 600, 600), new Vector2());       
    }

}
}

"Destroy the Game and Remove the gameObejct"

"load scene trigger on game finish"

"third person action adventure character controller where you can add custom actions"

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

public class ThirdPersonCharacterController : MonoBehaviour
{
    public float speed;
    public float rotationSpeed;
    private Animator animator;
    private Rigidbody rb;

void Start()
    {
        animator = GetComponent<Animator>();
        rb = GetComponent<Rigidbody>();
    }

void Update()
    {
        float translation = Input.GetAxis("Vertical") * speed;
        float rotation = Input.GetAxis("Horizontal") * rotationSpeed;

translation *= Time.deltaTime;
        rotation *= Time.deltaTime;

transform.Translate(0, 0, translation);
        transform.Rotate(0, rotation, 0);

if(Input.GetKeyDown(KeyCode.Space))
        {
            animator.SetTrigger("isJumping");
        }

if(translation != 0)
        {
            animator.SetBool("isRunning", true);
            animator.SetBool("isIdle", false);
        }
        else
        {
            animator.SetBool("isRunning", false);
            animator.SetBool("isIdle", true);
        }
    }

// Custom action method
    public void PerformCustomAction(string actionName)
    {
        animator.SetTrigger(actionName);
    }
}
```
This script creates a basic third person character controller. You can add custom actions by calling the `PerformCustomAction` method and passing the name of the trigger in the animator controller.

"change skybox in game play by light intensity"

public class ChangingSkyboxByDayAndNight : MonoBehaviour, ISaveable
{
    public Material afternoonSkybox;
    public Material nightSkybox;
    Light light;
    public float lightMultiplier;

void Start()
    {
        light = gameObject.GetComponent<Light>();
        StartCoroutine(ChangeTimeOfDay());
    }

void UpdateSkybox()
    {
        if(light.intensity > 0.5)
        {
            RenderSettings.skybox = afternoonSkybox;
        }
        else
        {
            RenderSettings.skybox = nightSkybox;
        }
    }

IEnumerator ChangeTimeOfDay()
    {
        while(light.intensity > 0.2f)
        {
            light.intensity -= lightMultiplier;
            UpdateSkybox();

yield return new WaitForSeconds(10);
        }
    }

public object CaptureState()
    {
        return light.intensity;
    }

public void RestoreState(object state)
    {
        if(light == null)
        {
            light = gameObject.GetComponent<Light>();
        }
        light.intensity = (float)state;
    }
}

"Get nearest gameobject from the player with a tag called Hook, also it needs to be visible to the player. This on a 2D project"

"script that let's me play an animation and makes sure nothing else happens until the animation is finished"

"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.

"play animation on action"

"Functional Complex Character Controller with built in camera system that uses RigidBody. Footsteps system, headbobbing, Stamina system (With running), Jump, crouch, breathing system when sprinting, no stamina or stamina not in use and Grounding."

This is a complex character controller with many features. I'll provide you with a basic template, but you'll need to customize and expand it according to your needs.

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

public class ComplexCharacterController : MonoBehaviour
{
    public float walkSpeed = 2;
    public float runSpeed = 6;
    public float crouchSpeed = 1;
    public float acceleration = 5;
    public float jumpForce = 5;
    public float stamina = 100;
    public float staminaRecovery = 5;
    public float staminaConsumption = 10;
    public bool isGrounded;
    public Transform groundCheck;
    public LayerMask groundMask;
    public float groundDistance = 0.4f;

private Rigidbody rb;
    private Vector3 moveDirection;
    private float speed;
    private bool isRunning;
    private bool isCrouching;
    private float currentStamina;

void Start()
    {
        rb = GetComponent<Rigidbody>();
        currentStamina = stamina;
    }

void Update()
    {
        isGrounded = Physics.CheckSphere(groundCheck.position, groundDistance, groundMask);

float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

moveDirection = new Vector3(horizontal, 0, vertical).normalized;

if (Input.GetKey(KeyCode.LeftShift) && !isCrouching && currentStamina > 0)
        {
            isRunning = true;
            currentStamina -= staminaConsumption * Time.deltaTime;
        }
        else
        {
            isRunning = false;
            currentStamina += staminaRecovery * Time.deltaTime;
        }

currentStamina = Mathf.Clamp(currentStamina, 0, stamina);

if (Input.GetKeyDown(KeyCode.Space) && isGrounded)
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
        }

if (Input.GetKeyDown(KeyCode.C))
        {
            isCrouching = !isCrouching;
        }

if (isCrouching)
        {
            speed = Mathf.Lerp(speed, crouchSpeed, acceleration * Time.deltaTime);
        }
        else if (isRunning)
        {
            speed = Mathf.Lerp(speed, runSpeed, acceleration * Time.deltaTime);
        }
        else
        {
            speed = Mathf.Lerp(speed, walkSpeed, acceleration * Time.deltaTime);
        }
    }

void FixedUpdate()
    {
        rb.MovePosition(rb.position + transform.TransformDirection(moveDirection) * speed * Time.fixedDeltaTime);
    }
}
```

This script includes basic movement, running, crouching, and jumping. It also includes a stamina system for running. You'll need to add your own camera system, headbobbing, footsteps, and breathing system as needed.

"On trigger touch, start animation"

"third person action adventure character controller that can walk, run jump and roll. make it scalable so that custom input, actions and animations can be added in the inspector. add comments to code"

using UnityEngine;

public class ThirdPersonController : MonoBehaviour
{
    public float walkSpeed = 3f;
    public float runSpeed = 6f;
    public float jumpForce = 5f;
    public float rollForce = 10f;

private CharacterController controller;
    private Animator animator;
    private Vector3 moveDirection;
    private bool isRunning;
    private bool isJumping;
    private bool isRolling;

private void Start()
    {
        controller = GetComponent<CharacterController>();
        animator = GetComponent<Animator>();
    }

private void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

// Calculate movement direction based on input
        moveDirection = new Vector3(horizontalInput, 0f, verticalInput).normalized;

// Check if the player is running
        isRunning = Input.GetKey(KeyCode.LeftShift);

// Check if the player is jumping
        if (Input.GetButtonDown("Jump"))
        {
            isJumping = true;
            animator.SetTrigger("Jump");
        }

// Check if the player is rolling
        if (Input.GetButtonDown("Roll"))
        {
            isRolling = true;
            animator.SetTrigger("Roll");
        }

// Update animator parameters
        animator.SetBool("IsRunning", isRunning);
        animator.SetBool("IsJumping", isJumping);
        animator.SetBool("IsRolling", isRolling);
    }

private void FixedUpdate()
    {
        // Apply movement to the character controller
        if (isJumping)
        {
            controller.Move(moveDirection * jumpForce * Time.fixedDeltaTime);
            isJumping = false;
        }
        else if (isRolling)
        {
            controller.Move(moveDirection * rollForce * Time.fixedDeltaTime);
            isRolling = false;
        }
        else
        {
            float speed = isRunning ? runSpeed : walkSpeed;
            controller.Move(moveDirection * speed * Time.fixedDeltaTime);
        }
    }
}

"create an enemy spawner"

"Multiplayer network"

using UnityEngine;
using UnityEngine.Networking;

public class CustomNetworkManager : NetworkManager
{
    // Start is called before the first frame update
    void Start()
    {
        // Set the network address and port
        networkAddress = "localhost";
        networkPort = 7777;
    }

// Update is called once per frame
    void Update()
    {
        // Check if the server is active and if the client is not connected
        if (!NetworkServer.active && !NetworkClient.isConnected)
        {
            // Start the server if the "S" key is pressed
            if (Input.GetKeyDown(KeyCode.S))
            {
                StartServer();
            }

// Start the client if the "C" key is pressed
            if (Input.GetKeyDown(KeyCode.C))
            {
                StartClient();
            }

// Start the host if the "H" key is pressed
            if (Input.GetKeyDown(KeyCode.H))
            {
                StartHost();
            }
        }
    }

public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
    {
        // Instantiate the player prefab
        GameObject player = Instantiate(playerPrefab, Vector3.zero, Quaternion.identity);

// Spawn the player on the network
        NetworkServer.AddPlayerForConnection(conn, player, playerControllerId);
    }

public override void OnServerDisconnect(NetworkConnection conn)
    {
        // Destroy the player object associated with the disconnected client
        NetworkServer.DestroyPlayersForConnection(conn);

// Call the base functionality for handling server disconnects
        base.OnServerDisconnect(conn);
    }
}

"A timer that when it reaches 0, it deactivates the current object and activates another object instead"

"create an inventory system that is easy to customize from the Unity UI"

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

[System.Serializable]
public class InventoryItem
{
    public string itemName;
    public Sprite itemIcon;
}

public class InventorySystem : MonoBehaviour
{
    public List<InventoryItem> inventoryItems;
    public GameObject inventoryPanel;
    public GameObject inventorySlotPrefab;

private void Start()
    {
        PopulateInventory();
    }

void PopulateInventory()
    {
        foreach (InventoryItem item in inventoryItems)
        {
            GameObject newSlot = Instantiate(inventorySlotPrefab, inventoryPanel.transform);
            newSlot.GetComponentInChildren<Image>().sprite = item.itemIcon;
            newSlot.GetComponentInChildren<Text>().text = item.itemName;
        }
    }
}

/* To customize the inventory system, simply add or remove items from the "inventoryItems" list in the Unity UI. Each item should have a name and an icon. The inventory system will automatically create slots for each item in the list and display their names and icons. */

"left/right movement with finger swipe"

"create a movement script for a 2d cube"

"create a decreasing health bar"

"double jump of character"

public class DoubleJump : MonoBehaviour {

float dirX;
        [SerializeField]
        float jumpForce = 500f, moveSpeed = 5f;
        Rigidbody2D rb;
        bool doubleJumpAllowed = false;
        bool onTheGround = false;

void Start () {
                rb = GetComponent<Rigidbody2D> ();
        }
        
        void Update () {                
                if (rb.velocity.y == 0)
                        onTheGround = true;
                else
                        onTheGround = false;                
                if (onTheGround)
                        doubleJumpAllowed = true;
                if (onTheGround && Input.GetButtonDown ("Jump")) {
                        Jump ();
                } else if (doubleJumpAllowed && Input.GetButtonDown ("Jump")) {
                        Jump ();
                        doubleJumpAllowed = false;
                }                
                dirX = Input.GetAxis ("Horizontal") * moveSpeed;
        }

void FixedUpdate()
        {
                rb.velocity = new Vector2 (dirX, rb.velocity.y);
        }

void Jump()
        {
                rb.velocity = new Vector2 (rb.velocity.x, 0f);;
                rb.AddForce (Vector2.up * jumpForce);
        }
}

"self destruction of gameobject after a time"

"when 25 cubes with the tag Training get destroyed, object appears"

"create UI Button on runtime"

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

"follow the player"

"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 And Join Room By Using Photon SDK"

"Gun shooting with raycast, Fire rate, Multiple shooting sounds and animation with cooldown and doesn't play when reloading, Ammo management and Reloading with R key, Shooting effect and impact effect that destroys itself and Damage (target script)."

Here's a script that covers gun shooting with raycast, fire rate, multiple shooting sounds, animations with cooldown, ammo management, reloading with the R key, shooting effects, impact effects, and damage. You'll need to create a separate script for the target to handle damage.

```csharp
using UnityEngine;

public class Gun : MonoBehaviour
{
    public float damage = 10f;
    public float range = 100f;
    public float fireRate = 15f;
    public int maxAmmo = 10;
    public float reloadTime = 1f;
    public GameObject impactEffect;
    public GameObject muzzleFlash;

public Camera fpsCam;
    public AudioSource[] shootSounds;
    public Animator animator;

private int currentAmmo;
    private bool isReloading;
    private float nextTimeToFire = 0f;

void Start()
    {
        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 >= nextTimeToFire)
        {
            nextTimeToFire = Time.time + 1f / fireRate;
            Shoot();
        }
    }

IEnumerator Reload()
    {
        isReloading = true;
        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--;

int randomSoundIndex = Random.Range(0, shootSounds.Length);
        shootSounds[randomSoundIndex].Play();

RaycastHit hit;
        if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit, range))
        {
            Target target = hit.transform.GetComponent<Target>();
            if (target != null)
            {
                target.TakeDamage(damage);
            }

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

GameObject muzzleFlashGO = Instantiate(muzzleFlash, fpsCam.transform.position, fpsCam.transform.rotation);
        Destroy(muzzleFlashGO, 0.1f);
    }
}
```

For the target script, you can use the following:

```csharp
using UnityEngine;

public class Target : MonoBehaviour
{
    public float health = 50f;

public void TakeDamage(float amount)
    {
        health -= amount;
        if (health <= 0f)
        {
            Die();
        }
    }

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

"create a basic tower defense enemy movement script"

"Functional Complex Character Controller with built in camera system that uses RigidBody. Footsteps system, Stamina system (With running), Jump, crouch, breathing system when sprinting, no stamina or stamina not in use and Grounding."

Here's a script for a complex character controller with a built-in camera system, footstep system, stamina system (with running), jump, crouch, breathing system when sprinting, and grounding. This script uses a Rigidbody for the character controller.

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

[RequireComponent(typeof(Rigidbody))]
[RequireComponent(typeof(AudioSource))]
public class ComplexCharacterController : MonoBehaviour
{
    [Header("Movement")]
    public float walkSpeed = 2;
    public float runSpeed = 6;
    public float crouchSpeed = 1;
    public float jumpForce = 8;
    public float crouchHeight = 0.5f;
    public float standingHeight = 2f;
    public float stamina = 100f;
    public float staminaRecoveryRate = 10f;
    public float staminaDrainRate = 20f;

[Header("Camera")]
    public Camera playerCamera;
    public float lookSpeedX = 2;
    public float lookSpeedY = 2;
    public float minY = -60;
    public float maxY = 60;

[Header("Footsteps")]
    public AudioClip[] footstepSounds;
    public float footstepInterval = 0.5f;

private Rigidbody rb;
    private AudioSource audioSource;
    private Vector3 inputVector;
    private float currentSpeed;
    private float currentStamina;
    private bool isCrouching = false;
    private bool isGrounded = false;
    private bool isRunning = false;
    private bool isJumping = false;
    private float rotationX = 0;

void Start()
    {
        rb = GetComponent<Rigidbody>();
        audioSource = GetComponent<AudioSource>();
        currentStamina = stamina;
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
    }

void Update()
    {
        // Camera rotation
        float mouseX = Input.GetAxis("Mouse X") * lookSpeedX;
        float mouseY = Input.GetAxis("Mouse Y") * lookSpeedY;
        rotationX -= mouseY;
        rotationX = Mathf.Clamp(rotationX, minY, maxY);
        playerCamera.transform.localRotation = Quaternion.Euler(rotationX, 0, 0);
        transform.rotation *= Quaternion.Euler(0, mouseX, 0);

// Movement
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        inputVector = new Vector3(horizontal, 0, vertical).normalized;

// Crouching
        if (Input.GetKeyDown(KeyCode.LeftControl))
        {
            isCrouching = !isCrouching;
            float newHeight = isCrouching ? crouchHeight : standingHeight;
            GetComponent<CapsuleCollider>().height = newHeight;
        }

// Running
        if (Input.GetKey(KeyCode.LeftShift) && !isCrouching && vertical > 0)
        {
            isRunning = true;
            if (currentStamina > 0)
            {
                currentStamina -= staminaDrainRate * Time.deltaTime;
            }
        }
        else
        {
            isRunning = false;
            if (currentStamina < stamina)
            {
                currentStamina += staminaRecoveryRate * Time.deltaTime;
            }
        }
        currentStamina = Mathf.Clamp(currentStamina, 0, stamina);

// Jumping
        if (Input.GetButtonDown("Jump") && isGrounded && !isCrouching)
        {
            isJumping = true;
        }

// Footsteps
        if (inputVector != Vector3.zero && !audioSource.isPlaying && isGrounded)
        {
            StartCoroutine(PlayFootstepSound());
        }
    }

void FixedUpdate()
    {
        float speed = isCrouching ? crouchSpeed : (isRunning && currentStamina > 0) ? runSpeed : walkSpeed;
        Vector3 targetVelocity = transform.TransformDirection(inputVector) * speed;
        targetVelocity.y = rb.velocity.y;
        rb.velocity = targetVelocity;

if (isJumping)
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
            isJumping = false;
        }
    }

void OnCollisionStay(Collision collision)
    {
        isGrounded = true;
    }

void OnCollisionExit(Collision collision)
    {
        isGrounded = false;
    }

IEnumerator PlayFootstepSound()
    {
        audioSource.clip = footstepSounds[Random.Range(0, footstepSounds.Length)];
        audioSource.Play();
        yield return new WaitForSeconds(footstepInterval);
    }
}
```

This script covers the requested features, but you may need to adjust the values and settings to fit your specific game. Attach this script to your player character and assign the required components (camera, footstep sounds, etc.) in the Unity Inspector.

"Create a clicker game with instructions on how to make it work"

Creating a clicker game in Unity involves a few key components: a counter to track the number of clicks, a button to click on, and a way to display the number of clicks. Here's a step-by-step guide on how to create a simple clicker game in Unity:

1. Create a new Unity project and open the SampleScene.

2. Create a UI Canvas by right-clicking in the Hierarchy, selecting UI > Canvas. This will be the parent object for all UI elements in the game.

3. Create a UI Text element by right-clicking on the Canvas in the Hierarchy, and selecting UI > Text. This will be used to display the number of clicks. Rename it to "ClickCounterText" and set its text to "Clicks: 0".

4. Create a UI Button element by right-clicking on the Canvas in the Hierarchy, and selecting UI > Button. Rename it to "ClickButton". You can customize the button's appearance and text as desired.

5. Create a new C# script called "ClickerGameController" and attach it to the Canvas.

6. Open the "ClickerGameController" script and add the following code:

```csharp
using UnityEngine;
using UnityEngine.UI;

public class ClickerGameController : MonoBehaviour
{
    public Button clickButton;
    public Text clickCounterText;

private int clickCount;

void Start()
    {
        clickCount = 0;
        clickButton.onClick.AddListener(IncrementClickCount);
    }

void IncrementClickCount()
    {
        clickCount++;
        UpdateClickCounterText();
    }

void UpdateClickCounterText()
    {
        clickCounterText.text = "Clicks: " + clickCount;
    }
}
```

7. Save the script and return to the Unity editor.

8. In the Unity editor, select the Canvas object in the Hierarchy. In the Inspector, you should see the "Clicker Game Controller" script component. Assign the "ClickButton" and "ClickCounterText" objects to the corresponding fields in the script component.

9. Press the Play button in Unity to test your clicker game. You should be able to click the button and see the click counter increase.

You can expand on this basic clicker game by adding more features such as upgrades, achievements, and more.

"scroll over 2d background"

"gun change with mouse wheel"

"Gun shooting with hitscan, 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 and impact effect that destroys itself."

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

public class GunController : MonoBehaviour
{
    public float damage = 10f;
    public float range = 100f;
    public float fireRate = 15f;
    public float reloadTime = 1f;
    public int maxAmmo = 10;

public Camera fpsCam;
    public ParticleSystem muzzleFlash;
    public GameObject impactEffect;
    public AudioSource shootingSound;
    public AudioSource reloadSound;
    public Animator animator;

private float nextTimeToFire = 0f;
    private int currentAmmo;
    private bool isReloading = false;

void Start()
    {
        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 >= nextTimeToFire)
        {
            nextTimeToFire = Time.time + 1f / fireRate;
            Shoot();
        }
    }

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

reloadSound.Play();

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

currentAmmo = maxAmmo;
        isReloading = false;
    }

void Shoot()
    {
        muzzleFlash.Play();
        shootingSound.Play();
        currentAmmo--;

RaycastHit hit;
        if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit, range))
        {
            Debug.Log(hit.transform.name);

Target target = hit.transform.GetComponent<Target>();
            if (target != null)
            {
                target.TakeDamage(damage);
            }

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

"change audio on walking and running"

"shoot bullets randomly"

"A base class for a 2D platformer enemy"

using UnityEngine;

public class PlatformerEnemy2D : MonoBehaviour
{
    public float speed = 2.0f;
    public float detectionRange = 5.0f;
    public LayerMask playerLayer;
    private Rigidbody2D rb;
    private Transform player;

// Start is called before the first frame update
    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        player = GameObject.FindGameObjectWithTag("Player").transform;
    }

// Update is called once per frame
    void Update()
    {
        DetectPlayer();
    }

void DetectPlayer()
    {
        RaycastHit2D hit = Physics2D.Raycast(transform.position, player.position - transform.position, detectionRange, playerLayer);

if (hit.collider != null && hit.collider.CompareTag("Player"))
        {
            ChasePlayer();
        }
        else
        {
            Patrol();
        }
    }

void ChasePlayer()
    {
        float direction = Mathf.Sign(player.position.x - transform.position.x);
        rb.velocity = new Vector2(direction * speed, rb.velocity.y);
    }

void Patrol()
    {
        // Implement patrol behavior here
    }

private void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawLine(transform.position, transform.position + (Vector3)(player.position - transform.position).normalized * detectionRange);
    }
}

"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."

"change the cameras on mouse enter and exit"

"Changing the cameras on mouse enter and exit"

public class ChangingCameras : MonoBehaviour{
        public Camera mainCamera;
        public Camera sideCamera;
        
        private string textFromObject;

void Start(){
                mainCamera.enabled = true;
                sideCamera.enabled = false;        
    	}
        
        void OnMouseEnter(){
                gameObject.GetComponent<TextMesh>().color = Color.red;
        }
        
        void OnMouseExit(){
                gameObject.GetComponent<TextMesh>().color = Color.black;
        }
        
        void OnMouseUp(){
                textFromObject = gameObject.GetComponent<TextMesh>().text;
                
                if(textFromObject == "Start Game" || textFromObject == "Back"){
                        mainCamera.enabled = !mainCamera.enabled;
                        sideCamera.enabled = !sideCamera.enabled;
                }
                else if(textFromObject == "Quit"){
                        Application.Quit();
                }
        }
}

"follow object with mouse cursor"

"make a unity script that will auto spawn blocks"

"print hello"

"generate map data for level based on BlockElement"

public class MapGenerator : MonoBehaviour
{
    [SerializeField] private float blockSize;
    [SerializeField] private int levelId;

private MapData GenerateMapData()
    {
        List<BlockData> listBlockData = new List<BlockData>();

BlockElement[] blockElements = FindObjectsOfType<BlockElement>();

for (int index = 0; index < blockElements.Length; index   )
        {
            int blockIndex = blockElements[index].blockId;
            Vector2 position = blockElements[index].transform.position;
            BlockData.GridPosition gridPosition = new BlockData.GridPosition(
                Mathf.RoundToInt(position.x / blockSize), Mathf.RoundToInt(position.y / blockSize));

listBlockData.Add(new BlockData(blockIndex, gridPosition));
        }

return new MapData(blockSize, listBlockData.ToArray());
    }

[ContextMenu("Generate Level Data")]
    public void SaveLevelDataToPersistent()
    {
        string path = System.IO.Path.Combine(Application.persistentDataPath, $"{levelId.ToString()}.json");
        string content = JsonUtility.ToJson(GenerateMapData());

System.IO.File.WriteAllText(path, content);

Debug.Log($"Level {levelId.ToString()} saved to {path}");
    }
}

"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);
        }
    }
}

"set resolution"

"Write a compute shader function in hlsl that draw a line from point A to B in a texture. Add comments to code."

Here's a simple compute shader in HLSL that draws a line from point A to B in a texture using the Bresenham's line algorithm. I've added comments to explain each part of the code.

```hlsl
// Define the texture to draw on
RWTexture2D<float4> outputTexture;

// Define the points A and B as integer2 (x, y)
int2 pointA;
int2 pointB;

[numthreads(1, 1, 1)]
void main(uint3 id : SV_DispatchThreadID)
{
    // Bresenham's line algorithm
    int2 delta = abs(pointB - pointA);
    int2 step = int2(sign(pointB.x - pointA.x), sign(pointB.y - pointA.y));
    int2 current = pointA;

int err = (delta.x > delta.y ? delta.x : -delta.y) / 2;
    int err2;

while (true)
    {
        // Draw the pixel at the current position
        outputTexture[current] = float4(1, 1, 1, 1); // white color

// Check if the current position has reached point B
        if (current == pointB)
            break;

// Update the error and current position
        err2 = err;
        if (err2 > -delta.x)
        {
            err -= delta.y;
            current.x += step.x;
        }
        if (err2 < delta.y)
        {
            err += delta.x;
            current.y += step.y;
        }
    }
}
```

This compute shader function takes a texture and two points as input, and it modifies the texture by drawing a line between the two points using the Bresenham's line algorithm. The algorithm calculates the pixels that should be drawn to create a line with minimum error between the two points.

"quit game on button click"

"Spawn a prefab in parent position when Z key si pressed"

"make a unity script that will auto spawn blocks like its raining blocks"

"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;
                }
        }
}

"Control Player and set his Movement all about Player Body"

using UnityEngine;

public class PlayerBody : MonoBehaviour {

public Transform cam;
        public Rigidbody rigid;
        public Vector3 playerNormal;
        public bool onAir = true;
        private float speed = 10f;

private Vector3 _forceVector = Vector3.zero;
        private float _xSpeed = 0f;
        private float _ySpeed = 0f;
        private float _zSpeed = 0f;

void Start () {
                playerNormal = transform.up;
        }
        
        void Update () {
                transform.Rotate(Vector3.up, Input.GetAxisRaw("Mouse X")*1.75f);

Vector3 playerForward = Vector3.Cross(transform.right, playerNormal);
                transform.rotation = Quaternion.LookRotation(playerForward, playerNormal);

RaycastHit groundCast;
                if (Physics.Linecast (transform.position   transform.up * 0.5f, transform.position - transform.up*0.6f, out groundCast)) {
                        if (groundCast.distance <= 0.6f) {
                                
                                _ySpeed = 0f;

if (Input.GetButton ("Jump")) {
                                        transform.position  = transform.up * 0.1f;
                                        _ySpeed = 5f;
                                }

} else {
                                
                                if (_ySpeed > -25f) {
                                        _ySpeed -= 0.2f;
                                }
                        }
                } else {
                        if (_ySpeed > -25f) {
                                _ySpeed -= 0.2f;
                        }
                }

if (Input.GetAxisRaw ("Horizontal") == 1f) {
                        if (_xSpeed < speed) {
                                _xSpeed  = 1f;
                        } else {
                                _xSpeed -= 1f;
                        }
                                
                } else if (Input.GetAxisRaw ("Horizontal") == -1f) {
                        if (_xSpeed > -speed) {
                                _xSpeed -= 1f;
                        } else {
                                _xSpeed  = 1f;
                        }
                                
                } else {
                        _xSpeed *= 0.8f;
                }

if (Input.GetAxisRaw ("Vertical") == 1f) {
                        if (_zSpeed < speed) {
                                _zSpeed  = 1f;
                        } else {
                                _zSpeed -= 1f;
                        }
                                
                } else if (Input.GetAxisRaw ("Vertical") == -1f) {
                        if (_zSpeed > -speed) {
                                _zSpeed -= 1f;
                        } else {
                                _zSpeed  = 1f;
                        }
                                
                } else {
                        _zSpeed *= 0.8f;
                }

if (Mathf.Abs(_xSpeed)   Mathf.Abs(_zSpeed) > speed*1.4f) {
                        float divider = speed*1.4f / (Mathf.Abs(_xSpeed)   Mathf.Abs(_zSpeed));
                        _xSpeed *= divider;
                        _zSpeed *= divider;
                }

_forceVector.Set (_xSpeed, _ySpeed, _zSpeed);
                rigid.velocity = Quaternion.Euler (transform.eulerAngles) * _forceVector;

}
}

"dance animation"

"create an image aligner"

"create a third person orbit camera that orbits the player based on mouse input"

"Set money in UI"

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

"Get nearest gameobject from the player with a tag called Hook, also it needs to be visible to the player"

using UnityEngine;

public class NearestHook : MonoBehaviour
{
    public string targetTag = "Hook";
    public float maxDistance = Mathf.Infinity;
    public LayerMask layerMask;

private GameObject player;
    private GameObject nearestHook;

void Start()
    {
        player = GameObject.FindGameObjectWithTag("Player");
    }

void Update()
    {
        FindNearestHook();
    }

void FindNearestHook()
    {
        GameObject[] hooks = GameObject.FindGameObjectsWithTag(targetTag);
        float closestDistance = maxDistance;
        nearestHook = null;

foreach (GameObject hook in hooks)
        {
            float distance = Vector3.Distance(player.transform.position, hook.transform.position);

if (distance < closestDistance && IsVisibleToPlayer(hook))
            {
                closestDistance = distance;
                nearestHook = hook;
            }
        }

if (nearestHook != null)
        {
            Debug.Log("Nearest Hook: " + nearestHook.name);
        }
    }

bool IsVisibleToPlayer(GameObject hook)
    {
        RaycastHit hit;
        Vector3 direction = hook.transform.position - player.transform.position;

if (Physics.Raycast(player.transform.position, direction, out hit, maxDistance, layerMask))
        {
            if (hit.collider.gameObject == hook)
            {
                return true;
            }
        }

return false;
    }
}

"Interactable lever after pressing E add comments to code"

using UnityEngine;

public class InteractableLever : MonoBehaviour
{
    public GameObject lever;
    public float interactDistance = 3f;
    private bool isLeverActive = false;

// Update is called once per frame
    void Update()
    {
        // Check if the player presses the "E" key
        if (Input.GetKeyDown(KeyCode.E))
        {
            // Calculate the distance between the player and the lever
            float distance = Vector3.Distance(transform.position, lever.transform.position);

// If the player is within the interact distance, toggle the lever
            if (distance <= interactDistance)
            {
                ToggleLever();
            }
        }
    }

// Toggle the lever's active state and perform any necessary actions
    void ToggleLever()
    {
        // Toggle the lever's active state
        isLeverActive = !isLeverActive;

// Perform any actions needed when the lever is toggled
        // For example, opening a door or activating a mechanism
        // This will depend on your specific game implementation
        if (isLeverActive)
        {
            // Activate the mechanism
        }
        else
        {
            // Deactivate the mechanism
        }
    }
}

"a infinite runner"

using UnityEngine;

public class InfiniteRunner : MonoBehaviour
{
    public float speed = 5f;
    public float jumpForce = 10f;
    public LayerMask groundLayer;
    public Transform groundCheck;

private Rigidbody rb;
    private bool isGrounded;

// Start is called before the first frame update
    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

// Update is called once per frame
    void Update()
    {
        // Move the player forward
        transform.Translate(Vector3.forward * speed * Time.deltaTime);

// Check if the player is grounded
        isGrounded = Physics.CheckSphere(groundCheck.position, 0.1f, groundLayer);

// Jump if the player is grounded and the space key is pressed
        if (isGrounded && Input.GetKeyDown(KeyCode.Space))
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
        }
    }

// OnTriggerEnter is called when the player enters a trigger collider
    void OnTriggerEnter(Collider other)
    {
        // If the player enters a trigger with the tag "Obstacle", restart the level
        if (other.CompareTag("Obstacle"))
        {
            UnityEngine.SceneManagement.SceneManager.LoadScene(UnityEngine.SceneManagement.SceneManager.GetActiveScene().buildIndex);
        }
    }
}

"enemy movement on collide without pressing button"

"create a falling cube"

"Create a 7 by 7 square with an empty center with a game object called "desk" that has two empty slots in the center at the bottom, and 4 more desks in the center. Each square is 1 unity unit by 1 unity unit"

using UnityEngine;

public class DeskFormation : MonoBehaviour
{
    public GameObject deskPrefab;
    private int gridSize = 7;
    private int emptyCenterSize = 3;
    private int deskCount = 4;

void Start()
    {
        for (int x = 0; x < gridSize; x++)
        {
            for (int z = 0; z < gridSize; z++)
            {
                if (IsOuterSquare(x, z) || IsInnerDesks(x, z))
                {
                    Instantiate(deskPrefab, new Vector3(x, 0, z), Quaternion.identity);
                }
            }
        }
    }

bool IsOuterSquare(int x, int z)
    {
        return x == 0 || z == 0 || x == gridSize - 1 || z == gridSize - 1;
    }

bool IsInnerDesks(int x, int z)
    {
        int innerStart = (gridSize - emptyCenterSize) / 2;
        int innerEnd = innerStart + emptyCenterSize - 1;

if (x >= innerStart && x <= innerEnd && z >= innerStart && z <= innerEnd)
        {
            if ((x == innerStart || x == innerEnd) && (z == innerStart || z == innerEnd))
            {
                return true;
            }
        }

return false;
    }
}

"scale on mouse down"

"set debug developer console option to true"

"scale object at runtime"

"Find Game Object With Tag"

"advanced ai system"

using UnityEngine;
using UnityEngine.AI;

public class AdvancedAI : MonoBehaviour
{
    public Transform target;
    public float detectionRange = 10.0f;
    public float attackRange = 2.0f;

private NavMeshAgent agent;
    private Animator animator;
    private bool isAttacking = false;

// Start is called before the first frame update
    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        animator = GetComponent<Animator>();
    }

// Update is called once per frame
    void Update()
    {
        float distanceToTarget = Vector3.Distance(transform.position, target.position);

if (distanceToTarget <= detectionRange)
        {
            agent.SetDestination(target.position);
            animator.SetBool("isWalking", true);

if (distanceToTarget <= attackRange && !isAttacking)
            {
                StartCoroutine(Attack());
            }
        }
        else
        {
            animator.SetBool("isWalking", false);
        }
    }

private IEnumerator Attack()
    {
        isAttacking = true;
        animator.SetTrigger("attack");
        agent.isStopped = true;

yield return new WaitForSeconds(animator.GetCurrentAnimatorStateInfo(0).length);

agent.isStopped = false;
        isAttacking = false;
    }
}

"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);
                        }
                }
        }
}

"create an enemy state machine"

using UnityEngine;

public class EnemyStateMachine : MonoBehaviour
{
    public enum EnemyState
    {
        Idle,
        Patrol,
        Chase,
        Attack
    }

public EnemyState currentState;

// Use this for initialization
    void Start()
    {
        currentState = EnemyState.Idle;
    }

// Update is called once per frame
    void Update()
    {
        switch (currentState)
        {
            case EnemyState.Idle:
                Idle();
                break;
            case EnemyState.Patrol:
                Patrol();
                break;
            case EnemyState.Chase:
                Chase();
                break;
            case EnemyState.Attack:
                Attack();
                break;
        }
    }

void Idle()
    {
        // Implement idle behavior here
    }

void Patrol()
    {
        // Implement patrol behavior here
    }

void Chase()
    {
        // Implement chase behavior here
    }

void Attack()
    {
        // Implement attack behavior here
    }
}

"Restart button when the game is fail or completed"

"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.

"create a script where you can add characters to a list who will follow the player with their sprites changing to show their direction and with variable speeds and distances for a 2d game"

using System.Collections.Generic;
using UnityEngine;

public class FollowerManager : MonoBehaviour
{
    [System.Serializable]
    public class Follower
    {
        public GameObject character;
        public float followSpeed;
        public float followDistance;
        public Sprite leftSprite;
        public Sprite rightSprite;
        public Sprite upSprite;
        public Sprite downSprite;
    }

public List<Follower> followers;
    public Transform player;

private Vector3 lastPlayerPosition;

// Start is called before the first frame update
    void Start()
    {
        lastPlayerPosition = player.position;
    }

// Update is called once per frame
    void Update()
    {
        foreach (Follower follower in followers)
        {
            float distance = Vector3.Distance(follower.character.transform.position, player.position);

if (distance > follower.followDistance)
            {
                Vector3 direction = player.position - lastPlayerPosition;
                direction.Normalize();

follower.character.transform.position += direction * follower.followSpeed * Time.deltaTime;

// Update sprite based on direction
                SpriteRenderer sr = follower.character.GetComponent<SpriteRenderer>();
                if (Mathf.Abs(direction.x) > Mathf.Abs(direction.y))
                {
                    sr.sprite = direction.x > 0 ? follower.rightSprite : follower.leftSprite;
                }
                else
                {
                    sr.sprite = direction.y > 0 ? follower.upSprite : follower.downSprite;
                }
            }
        }

lastPlayerPosition = player.position;
    }
}

"Hitscan Weapon system"

using UnityEngine;

public class HitscanWeapon : MonoBehaviour
{
    public Camera fpsCamera;
    public float range = 100f;
    public float damage = 25f;
    public LayerMask layerMask;

// Update is called once per frame
    void Update()
    {
        if (Input.GetButtonDown("Fire1"))
        {
            Shoot();
        }
    }

void Shoot()
    {
        RaycastHit hit;
        if (Physics.Raycast(fpsCamera.transform.position, fpsCamera.transform.forward, out hit, range, layerMask))
        {
            Debug.Log(hit.transform.name);

// Apply damage to the target if it has a Health component
            Health targetHealth = hit.transform.GetComponent<Health>();
            if (targetHealth != null)
            {
                targetHealth.TakeDamage(damage);
            }
        }
    }
}

[System.Serializable]
public class Health : MonoBehaviour
{
    public float maxHealth = 100f;
    private float currentHealth;

void Start()
    {
        currentHealth = maxHealth;
    }

public void TakeDamage(float damageAmount)
    {
        currentHealth -= damageAmount;
        if (currentHealth <= 0)
        {
            Die();
        }
    }

void Die()
    {
        // Handle death logic, e.g. destroy the object or play an animation
        Destroy(gameObject);
    }
}

"Functional Working Character Controller with built in camera system that uses RigidBody. Footsteps system, Stamina system (With running), Jump, crouch, breathing system when sprinting, no stamina or stamina not in use and Grounding."

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

public class CharacterControllerWithCamera : MonoBehaviour
{
    public float speed = 5.0f;
    public float jumpForce = 8.0f;
    public float stamina = 100f;
    public float staminaDecreaseRate = 10f;
    public float staminaRecoveryRate = 5f;
    public float sprintMultiplier = 2.0f;
    public float crouchHeight = 0.5f;
    public float crouchSpeed = 2.0f;
    public float breathingThreshold = 30f;
    public AudioClip[] footsteps;
    public AudioSource audioSource;

private Rigidbody rb;
    private bool isGrounded;
    private bool isCrouching;
    private bool isSprinting;
    private float originalHeight;
    private float originalSpeed;
    private Vector3 movement;
    private Camera playerCamera;

void Start()
    {
        rb = GetComponent<Rigidbody>();
        playerCamera = Camera.main;
        originalHeight = transform.localScale.y;
        originalSpeed = speed;
    }

void Update()
    {
        // Movement
        float moveHorizontal = Input.GetAxis("Horizontal");
        float moveVertical = Input.GetAxis("Vertical");
        movement = new Vector3(moveHorizontal, 0.0f, moveVertical);
        movement.Normalize();

// Sprinting
        if (Input.GetKey(KeyCode.LeftShift) && stamina > 0 && !isCrouching)
        {
            speed = originalSpeed * sprintMultiplier;
            stamina -= staminaDecreaseRate * Time.deltaTime;
            isSprinting = true;
        }
        else
        {
            speed = originalSpeed;
            stamina += staminaRecoveryRate * Time.deltaTime;
            isSprinting = false;
        }
        stamina = Mathf.Clamp(stamina, 0, 100);

// Jumping
        if (Input.GetButtonDown("Jump") && isGrounded)
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
            isGrounded = false;
        }

// Crouching
        if (Input.GetKeyDown(KeyCode.C) && isGrounded)
        {
            isCrouching = !isCrouching;
            if (isCrouching)
            {
                transform.localScale = new Vector3(transform.localScale.x, crouchHeight, transform.localScale.z);
                speed = crouchSpeed;
            }
            else
            {
                transform.localScale = new Vector3(transform.localScale.x, originalHeight, transform.localScale.z);
            }
        }

// Breathing sound
        if (isSprinting && stamina < breathingThreshold && !audioSource.isPlaying)
        {
            audioSource.Play();
        }
        else if (!isSprinting || stamina >= breathingThreshold)
        {
            audioSource.Stop();
        }
    }

void FixedUpdate()
    {
        rb.MovePosition(rb.position + transform.TransformDirection(movement) * speed * Time.fixedDeltaTime);
    }

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

void OnCollisionExit(Collision collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            isGrounded = false;
        }
    }

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

"get name object"

"Functional Complex Character Controller with built in camera system that uses RigidBody. Footsteps system, Stamina system (With running), Jump, crouch, breathing system when sprinting, no stamina or stamina not in use and Grounding."

This is a comprehensive script for a complex character controller using Rigidbody, including camera control, footsteps, stamina, running, jumping, crouching, breathing, and grounding systems.

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

public class ComplexCharacterController : MonoBehaviour
{
    [Header("Movement Settings")]
    public float walkSpeed = 2;
    public float runSpeed = 6;
    public float crouchSpeed = 1;
    public float jumpForce = 8;
    public float crouchHeight = 0.5f;
    public float standingHeight = 2f;
    public float stamina = 100;
    public float staminaRecoveryRate = 1;
    public float staminaDrainRate = 1;

[Header("Camera Settings")]
    public Camera playerCamera;
    public float lookSpeedX = 2;
    public float lookSpeedY = 2;
    public float minY = -60;
    public float maxY = 60;

private Rigidbody rb;
    private CapsuleCollider col;
    private float xRotation;
    private bool isCrouching;
    private bool isGrounded;
    private bool isRunning;
    private float currentStamina;

void Start()
    {
        rb = GetComponent<Rigidbody>();
        col = GetComponent<CapsuleCollider>();
        currentStamina = stamina;
        Cursor.lockState = CursorLockMode.Locked;
    }

void Update()
    {
        GroundCheck();
        Movement();
        CameraControl();
        Footsteps();
        Breathing();
    }

void Movement()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        bool jump = Input.GetButtonDown("Jump");
        bool crouch = Input.GetButtonDown("Crouch");
        bool run = Input.GetKey(KeyCode.LeftShift);

Vector3 moveDirection = new Vector3(horizontal, 0, vertical).normalized;

if (isCrouching)
        {
            moveDirection *= crouchSpeed;
        }
        else if (run && isGrounded && currentStamina > 0)
        {
            moveDirection *= runSpeed;
            isRunning = true;
            currentStamina -= staminaDrainRate * Time.deltaTime;
        }
        else
        {
            moveDirection *= walkSpeed;
            isRunning = false;
        }

moveDirection = transform.TransformDirection(moveDirection);
        rb.velocity = new Vector3(moveDirection.x, rb.velocity.y, moveDirection.z);

if (jump && isGrounded)
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
        }

if (crouch && !isCrouching)
        {
            isCrouching = true;
            col.height = crouchHeight;
        }
        else if (!crouch && isCrouching)
        {
            isCrouching = false;
            col.height = standingHeight;
        }

if (!isRunning)
        {
            currentStamina += staminaRecoveryRate * Time.deltaTime;
            currentStamina = Mathf.Clamp(currentStamina, 0, stamina);
        }
    }

void CameraControl()
    {
        float mouseX = Input.GetAxis("Mouse X") * lookSpeedX;
        float mouseY = Input.GetAxis("Mouse Y") * lookSpeedY;

xRotation -= mouseY;
        xRotation = Mathf.Clamp(xRotation, minY, maxY);

playerCamera.transform.localRotation = Quaternion.Euler(xRotation, 0, 0);
        transform.rotation *= Quaternion.Euler(0, mouseX, 0);
    }

void GroundCheck()
    {
        RaycastHit hit;
        if (Physics.Raycast(transform.position, -Vector3.up, out hit, 1.1f))
        {
            isGrounded = true;
        }
        else
        {
            isGrounded = false;
        }
    }

void Footsteps()
    {
        // Implement footsteps system here
    }

void Breathing()
    {
        // Implement breathing system here
    }
}
```

This script covers the basic functionality you requested. You will need to implement the footsteps and breathing systems according to your specific needs. Attach this script to your player character and assign the appropriate values in the Inspector.

"Unity 2D. One script: draws and controls a player and creates the components it needs. Also draw a procedural endless platforming map with code and assign the correct components. Creates particle effects for death and jump. Creates hazards that kill."

using UnityEngine;
using System.Collections;

public class EndlessPlatformer : MonoBehaviour
{
    public GameObject playerPrefab;
    public GameObject platformPrefab;
    public GameObject hazardPrefab;
    public GameObject deathParticlesPrefab;
    public GameObject jumpParticlesPrefab;

private GameObject player;
    private Rigidbody2D playerRb;
    private BoxCollider2D playerCollider;
    private ParticleSystem deathParticles;
    private ParticleSystem jumpParticles;

private float platformWidth = 5f;
    private float platformHeight = 0.5f;
    private float platformSpawnDistance = 10f;
    private float hazardSpawnRate = 0.1f;
    private float jumpForce = 5f;
    private float deathHeight = -10f;

void Start()
    {
        CreatePlayer();
        StartCoroutine(SpawnPlatforms());
        StartCoroutine(SpawnHazards());
    }

void Update()
    {
        if (player.transform.position.y < deathHeight)
        {
            Instantiate(deathParticlesPrefab, player.transform.position, Quaternion.identity);
            Destroy(player);
            CreatePlayer();
        }

if (Input.GetButtonDown("Jump") && IsGrounded())
        {
            playerRb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
            Instantiate(jumpParticlesPrefab, player.transform.position, Quaternion.identity);
        }
    }

void CreatePlayer()
    {
        player = Instantiate(playerPrefab, Vector3.zero, Quaternion.identity);
        playerRb = player.AddComponent<Rigidbody2D>();
        playerCollider = player.AddComponent<BoxCollider2D>();
    }

IEnumerator SpawnPlatforms()
    {
        while (true)
        {
            Vector3 spawnPosition = new Vector3(player.transform.position.x + platformSpawnDistance, Random.Range(-2f, 2f), 0f);
            GameObject platform = Instantiate(platformPrefab, spawnPosition, Quaternion.identity);
            platform.transform.localScale = new Vector3(platformWidth, platformHeight, 1f);
            platform.AddComponent<BoxCollider2D>();
            platform.AddComponent<Rigidbody2D>().isKinematic = true;

yield return new WaitForSeconds(2f);
        }
    }

IEnumerator SpawnHazards()
    {
        while (true)
        {
            if (Random.value < hazardSpawnRate)
            {
                Vector3 spawnPosition = new Vector3(player.transform.position.x + platformSpawnDistance, Random.Range(-2f, 2f) + platformHeight, 0f);
                GameObject hazard = Instantiate(hazardPrefab, spawnPosition, Quaternion.identity);
                hazard.AddComponent<BoxCollider2D>();
                hazard.AddComponent<Rigidbody2D>().isKinematic = true;
                hazard.tag = "Hazard";
            }

yield return new WaitForSeconds(2f);
        }
    }

bool IsGrounded()
    {
        RaycastHit2D hit = Physics2D.Raycast(player.transform.position, Vector2.down, platformHeight + 0.1f);
        return hit.collider != null && hit.collider.tag != "Hazard";
    }

void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.tag == "Hazard")
        {
            Instantiate(deathParticlesPrefab, player.transform.position, Quaternion.identity);
            Destroy(player);
            CreatePlayer();
        }
    }
}

"Complex Character Controller that uses RigidBody"

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class ComplexCharacterController : MonoBehaviour
{
    public float moveSpeed = 5f;
    public float rotationSpeed = 100f;
    public float jumpForce = 5f;

private Rigidbody rb;
    private bool isGrounded;

void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

Vector3 movement = new Vector3(horizontal, 0, vertical);
        rb.MovePosition(transform.position + movement * moveSpeed * Time.deltaTime);

if (Input.GetKey(KeyCode.Q))
        {
            transform.Rotate(Vector3.down * rotationSpeed * Time.deltaTime);
        }
        if (Input.GetKey(KeyCode.E))
        {
            transform.Rotate(Vector3.up * rotationSpeed * Time.deltaTime);
        }

if (Input.GetButtonDown("Jump") && isGrounded)
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
            isGrounded = false;
        }
    }

private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            isGrounded = true;
        }
    }
}

"create coin object that has a looping 2d animation"

"make a rgb for my gorilla tag copy and tell me how to use it"

```csharp
using UnityEngine;

public class GorillaRGB : MonoBehaviour
{
    public Renderer gorillaRenderer; // Assign the renderer of your gorilla model here in the inspector

// Use this for initialization
    void Start()
    {
        SetGorillaColor(255, 0, 0); // Set gorilla color to red on start
    }

// Method to set the color of the gorilla
    public void SetGorillaColor(float r, float g, float b)
    {
        Color newColor = new Color(r / 255f, g / 255f, b / 255f);
        gorillaRenderer.material.color = newColor;
    }
}
```
To use this in Unity, follow these steps:
1. Attach this script to your Gorilla object in the scene.
2. In the inspector, you will see a field named 'Gorilla Renderer'. Drag and drop the Renderer component of your Gorilla model into this field.
3. Call the `SetGorillaColor` method from anywhere in your code and pass in the RGB values to change the color of your gorilla. The RGB values should be between 0 and 255. For example, calling `SetGorillaColor(0, 255, 0)` will change the gorilla color to green.

"clear the area in the game"

"Gun shooting with raycast, Fire rate, Shooting sound and animation with cooldown and doesn't play when reloading, Ammo management and Reloading with R key, Shooting effect and impact effect that destroys itself and Damage system."

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

public class Gun : MonoBehaviour
{
    public float damage = 10f;
    public float range = 100f;
    public float fireRate = 15f;
    public float reloadTime = 1f;
    public int maxAmmo = 10;
    public int currentAmmo;
    public AudioClip shootingSound;
    public AudioClip reloadSound;
    public ParticleSystem muzzleFlash;
    public GameObject impactEffect;
    public Animator animator;

private AudioSource audioSource;
    private float nextTimeToFire = 0f;
    private bool isReloading = false;

void Start()
    {
        currentAmmo = maxAmmo;
        audioSource = GetComponent<AudioSource>();
    }

void Update()
    {
        if (isReloading)
            return;

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

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

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

audioSource.clip = reloadSound;
        audioSource.Play();

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.clip = shootingSound;
        audioSource.Play();

muzzleFlash.Play();

RaycastHit hit;
        if (Physics.Raycast(transform.position, transform.forward, out hit, range))
        {
            Debug.Log(hit.transform.name);

Target target = hit.transform.GetComponent<Target>();
            if (target != null)
            {
                target.TakeDamage(damage);
            }

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

public class Target : MonoBehaviour
{
    public float health = 50f;

public void TakeDamage(float amount)
    {
        health -= amount;
        if (health <= 0f)
        {
            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);
            }
        }
    }
}

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

"display game time in seconds"

"For Unity 2D. Create one script that: draws and controls a player and creates the components it needs. Also draw the platforming map with code and assign the correct components. Creates particle effects for death and jump. Creates hazards that kill."

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour
{
    public float speed = 10f;
    public float jumpForce = 15f;
    public GameObject deathParticles;
    public GameObject jumpParticles;
    public GameObject hazard;
    public GameObject platformPrefab;
    public int numberOfPlatforms = 10;
    public Vector2 startPosition = new Vector2(0, 0);

private Rigidbody2D rb;
    private bool isGrounded = false;

void Start()
    {
        rb = GetComponent<Rigidbody2D>();

if (GetComponent<SpriteRenderer>() == null)
        {
            gameObject.AddComponent<SpriteRenderer>();
        }

if (GetComponent<BoxCollider2D>() == null)
        {
            gameObject.AddComponent<BoxCollider2D>();
        }

GeneratePlatformMap();
    }

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

if (Input.GetButtonDown("Jump") && isGrounded)
        {
            rb.AddForce(new Vector2(0, jumpForce), ForceMode2D.Impulse);
            Instantiate(jumpParticles, transform.position, Quaternion.identity);
        }
    }

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

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

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

void GeneratePlatformMap()
    {
        Vector2 spawnPosition = startPosition;

for (int i = 0; i < numberOfPlatforms; i++)
        {
            GameObject platform = Instantiate(platformPrefab, spawnPosition, Quaternion.identity);
            platform.tag = "Ground";
            platform.AddComponent<BoxCollider2D>();
            platform.AddComponent<SpriteRenderer>();

GameObject hazardInstance = Instantiate(hazard, new Vector2(spawnPosition.x, spawnPosition.y + 1), Quaternion.identity);
            hazardInstance.tag = "Hazard";
            hazardInstance.AddComponent<BoxCollider2D>();
            hazardInstance.AddComponent<SpriteRenderer>();

spawnPosition.x += 2;
        }
    }
}