예제 #1
0
    public static Wire newWire(HexagonPower hex, int sr, int ds, bool pow = false)
    {
        int src = sr;
        int dst = ds;

        if ((sr - ds + 6) % 6 > (ds - sr + 6) % 6)
        {
            src = ds;
            dst = sr;
        }
        if (!prefabsInitialized)
        {
            prefab0 = globalPrefabs.getPrefab("WirePrefab0");
            prefab1 = globalPrefabs.getPrefab("WirePrefab1");
            prefab2 = globalPrefabs.getPrefab("WirePrefab2");
        }
        GameObject go;

        switch ((src - dst + 6) % 6)
        {
        case 1:
            go = (GameObject)Instantiate(prefab0, hex.transform.position, Quaternion.identity);
            break;

        case 2:
            go = (GameObject)Instantiate(prefab1, hex.transform.position, Quaternion.identity);
            break;

        case 3:
            go = (GameObject)Instantiate(prefab2, hex.transform.position, Quaternion.identity);
            break;

        default:
            throw new UnityException("Invalid wire");
        }
        go.transform.RotateAround(hex.transform.position, Vector3.up, hex.currentRotation - 60.0f * (float)src);
        go.transform.parent = hex.transform;
        Wire res = go.GetComponent <Wire> ();

        res.src     = src;
        res.dst     = dst;
        res.hexagon = hex;
        if ((hex != null))
        {
            hex.wires [src] = res;
            hex.wires [dst] = res;
        }
        res.setPowered(pow);
        return(res);
    }
예제 #2
0
    void electrify()
    {
        GridPoint nearestGridPoint = hexHandler.closestGridPoint(new Vector2(gameObject.transform.position.x, gameObject.transform.position.z));

        List <Wire> hitWires = new List <Wire>();

        HexagonBase nexHexBase = hexHandler.getHexagon(nearestGridPoint);

        if (nexHexBase is HexagonPower)           //ha vmi megrázza, akkor a egközelebbi hatszög biztosan hatótávon belül van
        {
            foreach (Wire w in ((HexagonPower)nexHexBase).wires)
            {
                if (w != null)
                {
                    if (w.powered)
                    {
                        hitWires.Add(w);
                    }
                }
            }
        }

        foreach (GridPoint gPoint in nearestGridPoint.AdjacentPoints())
        {
            HexagonBase hexBase = hexHandler.getHexagon(gPoint);
            if (hexBase is HexagonPower)
            {
                HexagonPower hex = (HexagonPower)hexBase;
                if (inLethalRange(hexBase))
                {
                    foreach (Wire w in hex.wires)
                    {
                        if (w != null)
                        {
                            if (w.powered)
                            {
                                hitWires.Add(w);
                            }
                        }
                    }
                }
            }
        }

        int killerWireIndex = Random.Range(0, hitWires.Count);

        hitWires [killerWireIndex].Kill();
        gameObject.GetComponent <ZombieScript> ().Die();
    }
예제 #3
0
    void hoverWireRecursion(GridPoint currentGridPoint, int powerEntryPoint)
    {
        GridPoint nextGridPoint = currentGridPoint.AdjacentPointsCircular() [powerEntryPoint + 3];

        if (inRange(nextGridPoint))
        {
            HexagonBase hexBase = getHexagon(nextGridPoint);
            if (hexBase is HexagonPower)
            {
                HexagonPower nextHexPower = (HexagonPower)hexBase;
                Wire         activeWire   = nextHexPower.getWireAtEntryPoint(powerEntryPoint);
                if ((activeWire != null) && !nextHexPower.isRotating() && !activeWire.hover)
                {
                    activeWire.setHover(true);
                    int nextPowerEntryPoint = nextHexPower.otherEndpointOfWire(powerEntryPoint);
                    hoverWires.Add(activeWire);
                    hoverWireRecursion(nextGridPoint, (nextPowerEntryPoint + 3) % 6);
                }
            }
        }
    }
예제 #4
0
    void emitPowerRecursion(GridPoint currentGridPoint, int powerEntryPoint)
    {
        GridPoint nextGridPoint = currentGridPoint.AdjacentPointsCircular() [powerEntryPoint + 3];

        if (hexField.inRange(nextGridPoint))
        {
            HexagonBase hexBase = hexField.getHexagon(nextGridPoint);
            if (hexBase is HexagonPower)
            {
                HexagonPower nextHexPower = (HexagonPower)hexBase;
                Wire         activeWire   = nextHexPower.getWireAtEntryPoint(powerEntryPoint);
                if ((activeWire != null) && !nextHexPower.isRotating())
                {
                    activeWire.setPowered(true);
                    int nextPowerEntryPoint = nextHexPower.otherEndpointOfWire(powerEntryPoint);
                    poweredWires.Add(activeWire);
                    emitPowerRecursion(nextGridPoint, ((nextPowerEntryPoint + 9) % 6));
                }
            }
        }
    }
예제 #5
0
    // Update is called once per frame
    void Update()
    {
        Vector2    mousexy = Input.mousePosition;
        Ray        camRay  = GetComponentInChildren <Camera>().ScreenPointToRay(mousexy);
        RaycastHit floorHit;
        Vector2    mousepos = new Vector2();

        foreach (Wire w in hoverWires)
        {
            w.setHover(false);
        }
        hoverWires.Clear();
        if (Physics.Raycast(camRay, out floorHit, camRayLength, clickableMask))
        {
            mousepos.x = floorHit.point.x;
            mousepos.y = floorHit.point.z;
            if (inRange(closestGridPoint(mousepos)))
            {
                actDot = closestGridPoint(mousepos);
                HexagonBase actHexagon = getHexagon(actDot);

                float scrollWheel = Input.GetAxis("Mouse ScrollWheel");
                if (scrollWheel < 0)
                {
                    actHexagon.rotateClockwise();
                }
                else if (scrollWheel > 0)
                {
                    actHexagon.rotateCounterClockwise();
                }

                if (actHexagon is HexagonPower)
                {
                    HexagonPower hex      = (HexagonPower)actHexagon;
                    Vector3      deltaVec = floorHit.point - SpacePoint(actDot);
                    int          selectedWireEnd;
                    if (Vector3.Cross(deltaVec, Vector3.forward).y < 0)
                    {
                        //right half
                        if (Vector3.Cross(deltaVec, corner34).y < 0)
                        {
                            //2&3
                            if (Vector3.Cross(deltaVec, corner45).y < 0)
                            {
                                selectedWireEnd = 2;
                            }
                            else
                            {
                                selectedWireEnd = 3;
                            }
                        }
                        else
                        {
                            selectedWireEnd = 4;
                        }
                    }
                    else
                    {
                        if (Vector3.Cross(deltaVec, corner34).y < 0)
                        {
                            selectedWireEnd = 1;
                        }
                        else if (Vector3.Cross(deltaVec, corner45).y < 0)
                        {
                            selectedWireEnd = 0;
                        }
                        else
                        {
                            selectedWireEnd = 5;
                        }
                    }
                    //selectedWireEnd = Mathf.FloorToInt (
                    //	                     13.0f - Mathf.Atan2 (-0.5f * deltaVec.x + sqrt3p2 * deltaVec.z, -sqrt3p2 * deltaVec.x - 0.5f * deltaVec.z) * 3.0f / Mathf.PI) % 6;
                    Wire currentWire = hex.getWireAtEntryPoint(selectedWireEnd);
                    if (currentWire)
                    {
                        currentWire.setHover(true);
                        hoverWires.Add(currentWire);
                    }
                    hoverWireRecursion(actDot, (selectedWireEnd + 3) % 6);
                    int opposite = hex.otherEndpointOfWire(selectedWireEnd);
                    hoverWireRecursion(actDot, (opposite + 3) % 6);
                }

                if (Input.GetMouseButtonDown(0))
                {
                    leftClickHappened = true;
                }
                if (Input.GetMouseButtonDown(1))
                {
                    rightClickHappened = true;
                }

                if (leftClickHappened && (actHexagon is HexagonPower || actHexagon is HexCoreScript))
                {
                    actHexagon.rotateCounterClockwise();
                    leftClickHappened = false;
                }

                if (rightClickHappened && (actHexagon is HexagonPower || actHexagon is HexCoreScript))
                {
                    actHexagon.rotateClockwise();
                    rightClickHappened = false;
                }
            }
        }
    }