pastemyst | Canon issue

Canon issue

Gridcell

EQcopy raw

using UnityEngine;

public class GridCell : MonoBehaviour
{
    private GameObject canon;
    public GameObject canonPrefab;
    private bool isOccupied = false;
    [SerializeField] private Material originalMat, occupiedMat;
    int price = 10;

public void Highlight()
    {
        GetComponent<Renderer>().material = occupiedMat;
    }

public void Occupy()
    {
        GetComponent<Renderer>().material = occupiedMat;
        isOccupied = true;
    }

public GameObject GetCanonOnCell()
    {
        return canon;
    }
    public void UnOccupy()
    {
        UnHighlight();
        isOccupied = false;
        Debug.Log(gameObject.name);
        Debug.Log(isOccupied);
    }

public void UnHighlight()
    {
        GetComponent<Renderer>().material = originalMat;
    }

public void SpawnMachineGun()
    {
        if (isOccupied || canonPrefab == null || CoinSystem.instance.availableCoins < price)
            return;

// Force correct z position for rendering
        Vector3 spawnPos = transform.position + new Vector3(0, 0f, 0f);
        spawnPos.z = 1f; // Match your intended prefab depth

// Create the canon only once
        GameObject newCanon = Instantiate(canonPrefab, spawnPos, Quaternion.identity);
        canon = newCanon;
        canon.GetComponent<CanonController>().SetCurrentCell(gameObject);
        canon.GetComponent<CanonController>().SetCurrentCellPosition();

// Tell the placement manager
        CanonPlacementManager.instance.CanonPlaced(newCanon);

isOccupied = true;

Highlight();

Debug.Log("Canons: " + CanonPlacementManager.instance.GetCanonCount());

SFXController.instance?.PlaySFX(5);

CoinSystem.instance.SpendCoins(price);
    }

public void RelocateMachineGun(GameObject newCanon)
    {
        if (isOccupied || canonPrefab == null || CoinSystem.instance.availableCoins < price)
            return;

// Force correct z position for rendering
        Vector3 spawnPos = transform.position + new Vector3(0, 0f, 0f);
        spawnPos.z = 1f; // Match your intended prefab depth

newCanon.GetComponent<Transform>().position = spawnPos;
        newCanon.GetComponent<CanonController>().SetCurrentCell(gameObject);
        newCanon.GetComponent<CanonController>().SetCurrentCellPosition();
        canon = newCanon;

isOccupied = true;

Highlight();

Debug.Log("Canons: " + CanonPlacementManager.instance.GetCanonCount());

SFXController.instance?.PlaySFX(5);
    }

public bool IsOccupied()
    {
        return isOccupied;
    }
}

canon placement manager

EQcopy raw

using System.Xml.Serialization;
using UnityEngine;

public class CanonPlacementManager : MonoBehaviour
{
    public static CanonPlacementManager instance;

[Tooltip("How many canons are allowed per level")]
    public int allowedCanonCount = 2; // Now editable via Inspector

private int currentCanonCount = 0;

[Header("Assign the blinking arrows manually")]
    public GameObject[] blinkingArrows;

void Awake()
    {
        instance = this;
    }

public void DecrementCanonCount()
    {
        currentCanonCount--;
    }

//public bool CanPlaceCanon()
    //{
    //    return currentCanonCount < allowedCanonCount && !gameManager.gameStarted;
    //}

public int GetCanonCount()
    {
        return currentCanonCount;
    }

public void CanonPlaced(GameObject canonInstance)
    {
        currentCanonCount++;
        // Enable firing if CanonController is attached
        CanonController controller = canonInstance.GetComponent<CanonController>();
        if (controller != null)
        {
            controller.canFire = true;
        }
        else
        {
            Debug.LogWarning("CanonPlaced: Missing CanonController on canonInstance");
        }
        // Start enemy spawn only once
        if (currentCanonCount == 2)
        {
            Debug.Log("Spawning Enemies");
            //EnemySpawner.instance?.StartSpawningEnemies();
        }

if (currentCanonCount >= allowedCanonCount)
        {
            foreach (GameObject arrow in blinkingArrows)
            {
                arrow.SetActive(false);
            }
        }

Debug.Log("Placed Cannon " + currentCanonCount);
    }

public void ResetCanonCount()
    {
        currentCanonCount = 0;
        foreach (GameObject arrow in blinkingArrows)
        {
            ArrowBlinker blinker = arrow.GetComponent<ArrowBlinker>();
            if (blinker != null)
                blinker.StopBlinking();
        }
    }

public void StartCanonFire()
    {
        CanonController[] canons = FindObjectsByType<CanonController>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);

foreach (CanonController canon in canons)
        {
            canon.canFire = true;
        }
    }

public void StopCanonFire()
    {
        CanonController[] canons = FindObjectsByType<CanonController>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);

foreach (CanonController canon in canons)
        {
            canon.canFire = false;
        }
    }
}

drag canon

EQcopy raw

using JetBrains.Annotations;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.UIElements;

public class DragCanon : MonoBehaviour
{
    private Vector2 initialOffset;
    private bool dragging;
    private GameObject oldCell;

[SerializeField] private float planeHeight = 0; // Set to canon Y pos
    [SerializeField] private float mergeThreshold;

GridCell[] allCells;

private Vector3 offset;

private GameManager gameManager;

private void Start()
    {
        allCells = FindObjectsByType<GridCell>(FindObjectsSortMode.None);
        oldCell = gameObject.GetComponent<CanonController>().GetCurrentCell();
        initialOffset = transform.position - GetClosestCell().transform.position;
        dragging = false;
        planeHeight = transform.position.y;
        gameManager = GameObject.FindGameObjectWithTag("GameManager").GetComponent<GameManager>();
    }

void OnMouseDown()
    {
        if (Camera.main == null) return;

offset = (Vector2)Camera.main.ScreenToWorldPoint(Input.mousePosition) - (Vector2)transform.position;
            //Debug.Log(offset);
            dragging = true;
    }

private void OnMouseDrag()
    {

Drag_Canon();

}

void Drag_Canon()
    {
        transform.position = (Vector2)Camera.main.ScreenToWorldPoint(Input.mousePosition) - (Vector2)offset;
    }

void SnapToNewCell()
    {
        GameObject closestCell = GetClosestCell();

//if (closestCell.GetComponent<GridCell>().IsOccupied())
        //{
        //    Debug.Log(closestCell.transform.position);
        //    Debug.Log("Canons: " + CanonPlacementManager.instance.GetCanonCount());
        //    Debug.Log("Is Occupied");

if (closestCell != oldCell)
        {
            if (closestCell.GetComponent<GridCell>().IsOccupied())
            {                
                GameObject canonOnClosestCell = closestCell.GetComponent<GridCell>().GetCanonOnCell();
                if (canonOnClosestCell == null)
                {
                    Debug.Log("no canon found");
                    return;
                }

if (canonOnClosestCell.GetComponent<CanonController>().GetCanonStage() == gameObject.GetComponent<CanonController>().GetCanonStage())
                {
                    Destroy(canonOnClosestCell);
                    MergeCanon(closestCell);
                }
                else
                {
                    GoToUnoccupiedCell();
                }
            }
            else
            {
                GoToUnoccupiedCell();
            }
        }
        else
        {
            gameObject.GetComponent<Transform>().position = gameObject.GetComponent<CanonController>().GetCurrrentCellPosition();
        }

}

void GoToUnoccupiedCell()
    {
        GameObject cell = GetClosestUnOccupiedCell();
        if (cell == null) 
        {
            Debug.Log("no cell unoccupied");
        }
        oldCell.GetComponent<GridCell>().UnOccupy();
        oldCell = cell;
        cell.GetComponent<GridCell>().RelocateMachineGun(gameObject);
    }

void MergeCanon(GameObject cell)
    {
        oldCell.GetComponent<GridCell>().UnOccupy();
        oldCell = cell;
        oldCell.GetComponent<GridCell>().RelocateMachineGun(gameObject);
        gameObject.GetComponent<CanonController>().IncrementCanonStage();
        CanonPlacementManager.instance.DecrementCanonCount();
    }

void OnMouseUp()
    {
            //Debug.Log("dragging: " + dragging);
            if (dragging)
            {
                dragging = false;
                //Debug.Log(dragging);
                SnapToNewCell();
            }
    }

GameObject GetClosestCell()
    {
        if (allCells == null)
        {
            return null;
        }

if (allCells.Length == 0)
        {
            return null;
        }

GameObject closestCell = allCells[0].GameObject();
        foreach (GridCell cell in allCells)
        {
            if (IsCloser(cell.GameObject(), closestCell))
            {
                closestCell = cell.GameObject();
            }
        }
        return closestCell;
    }

GameObject GetClosestUnOccupiedCell()
    {
        if (allCells.Length == 0)
            return null;

GameObject closestCell = allCells[0].GameObject();
        foreach (GridCell cell in allCells)
        {
            if (!cell.GetComponent<GridCell>().IsOccupied())
                closestCell = cell.GameObject();
        }

foreach (GridCell cell in allCells)
        {
            if (IsCloser(cell.GameObject(), closestCell) && !cell.GetComponent<GridCell>().IsOccupied())
            {
                closestCell = cell.GameObject();
            }
        }
        return closestCell;
    }

//CanonController GetCanonWithinThreshold(float threshold)
    //{
    //    return null;
    //}

bool IsCloser(GameObject cell, GameObject currentClosest)
    {
        bool closer = Mathf.Abs(Vector3.Distance(cell.GetComponent<Transform>().position, transform.position)) < Mathf.Abs(Vector3.Distance(currentClosest.GetComponent<Transform>().position, transform.position));
        //Debug.Log(closer);
        return closer;
    }

}

created at:

stats: 381 lines, 760 words, 10.39kb