示例#1
0
    public void CreateLinks(LinkedListNode <GameObject> node)
    {
        scrNode nodeScript = node.Value.GetComponent <scrNode>();
        Bounds  nodeBounds = new Bounds(node.Value.transform.position, new Vector3(CELL_SIZE * 2, CELL_SIZE * 2, CELL_SIZE * 2));               // Instead, could look for nodes at the adjacent positions of positions array, derp.

        LinkedList <GameObject> .Enumerator activeNode = nodePool.GetEnumerator();
        for (int i = 0; i < inactiveNodeCount; ++i)
        {
            activeNode.MoveNext();
        }
        while (activeNode.MoveNext() && nodeScript.CurrentLinks != scrNode.LINKS_MAX)
        {
            // Don't link to fully infected nodes.
            if (nodeScript.FullyInfected ^ activeNode.Current.GetComponent <scrNode>().FullyInfected)
            {
                if (nodeBounds.Contains(activeNode.Current.transform.position))
                {
                    // Determine which order to link the nodes.
                    if (nodeScript.FullyInfected)
                    {
                        nodeScript.Link(activeNode.Current);
                    }
                    else
                    {
                        activeNode.Current.GetComponent <scrNode>().Link(node.Value);
                    }
                }
            }
        }
    }
示例#2
0
    public void Init(LinkedListNode <GameObject> cube, scrNode parent, Vector3 position, DataState state)
    {
        transform.position = position;
        transform.rotation = Quaternion.identity;
        Parent             = parent;
        Cube = cube;

        StatePrev = state;
        State     = state;
        if (State == DataState.INFECTED)
        {
            infectionTransitionCompleted = true;
            renderer.material            = scrNodeMaster.Instance.MatCubeInfected;
        }
        else
        {
            infectionTransitionCompleted = false;
            infectionTransitionTimer     = 0.0f;

            if (State == DataState.BLOCKED)
            {
                renderer.material = scrNodeMaster.Instance.MatCubeBlocked;
            }
            else
            {
                renderer.material = scrNodeMaster.Instance.MatCubeUninfected;
            }
        }

        damageTimer = 0;
        Uploading   = false;
        pathfinder.Pause();
    }
示例#3
0
    public IEnumerator Destroy(LinkedListNode <GameObject> node)
    {
        scrNode nodeScript = node.Value.GetComponent <scrNode>();

        CellStates[ToCellSpace(nodeScript.transform.position.x), ToCellSpace(nodeScript.transform.position.y)] = CellState.FREE;

        // Clear and reset the nodes cubes and make them available to future nodes.
        for (int i = 0, numLoops = 0; i < nodeScript.Cubes.Length; ++i)
        {
            LinkedListNode <GameObject> cube = nodeScript.Cubes[i];
            DeactivateCube(cube);
            if (++numLoops == LOOPS_PER_FRAME)
            {
                numLoops = 0;
                yield return(new WaitForEndOfFrame());
            }
        }

        DeactivateNode(node);
    }
示例#4
0
    public override void Init()
    {
        GetComponentInChildren <TextMesh>().text = Name;

        SiegeNode = null;

        pathfinder        = GetComponent <scrPathfinder>();
        pathfinder.Target = scrPlayer.Instance.gameObject;

        powerup.Colour      = NameToColour(Name);
        powerup.Size        = 0.5f + (Mathf.Max(Name.Length, 16)) / 10.0f;
        powerup.Speed       = 220.0f / powerup.Size;
        powerup.Wiggle      = Name[0] < 'M' ? Name[0] * 0.5f : 0;
        powerup.Erratic     = (Mathf.Abs(Name[Name.Length - 1] - Name[0]) % 10) / 7.0f;
        powerup.Homing      = Name[0].ToString().ToUpper()[0] < 'H';
        powerup.Penetrative = Name[Name.Length - 1] <= '9';

        Transform ship = transform.Find("Ship");

        ship.Find("Core_Core").renderer.material.color = powerup.Colour;
        ship.Find("Core_Glow").renderer.material.SetColor("_TintColor", new Color(powerup.Colour.r * 0.5f, powerup.Colour.g * 0.5f, powerup.Colour.b * 0.5f, 0.0625f));
        transform.GetComponentInChildren <TrailRenderer>().material.SetColor("_TintColor", powerup.Colour);
        ExplosionColour = powerup.Colour;
    }
示例#5
0
    // Update is called once per frame
    protected override void Update()
    {
        if (damageTimer >= DamageToDestroy)
        {
            scrPlayer.Instance.Powerups.Enqueue(powerup);
            scrGUI.Instance.EnqueuePowerup(Name, powerup.Colour);
        }

        pathfinder.Resume();

        // If sieging, shoot at the node.
        if (SiegeNode != null && SiegeNode.Cubes != null)
        {
            if (!SiegeNode.gameObject.activeSelf || SiegeNode.Infected)
            {
                SiegeNode         = null;
                pathfinder.Target = scrPlayer.Instance.gameObject;
                base.Update();
                return;
            }

            if (targetCubeIndex >= SiegeNode.Cubes.Length)
            {
                targetCubeIndex = 0;
            }

            // Change cube if target cube is destroyed.
            if (SiegeNode.Cubes[targetCubeIndex] == null)
            {
                ++targetCubeIndex;
            }
            else
            {
                Vector2 direction = SiegeNode.Cubes[targetCubeIndex].Value.transform.position - transform.position;
                transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.Euler(0, 0, Mathf.Rad2Deg * Mathf.Atan2(direction.y, direction.x)), 180 * Time.deltaTime);

                // Check the distance.
                if (direction.magnitude < scrNodeMaster.CELL_SIZE)
                {
                    fireTimer += Time.deltaTime * fireRate;
                    if (fireTimer >= 1)
                    {
                        fireTimer = 0;

                        StartCoroutine(Shoot(Random.Range(3, 8)));
                    }
                }
            }
        }
        // If not sieging, check for a node to siege.
        else
        {
            // Aim towards the player.
            Vector2 direction = scrPlayer.Instance.transform.position - transform.position;
            transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.Euler(0, 0, Mathf.Rad2Deg * Mathf.Atan2(direction.y, direction.x)), 180 * Time.deltaTime);

            if (direction.magnitude < scrNodeMaster.CELL_SIZE)
            {
                fireTimer += Time.deltaTime * fireRate;
                if (fireTimer >= 1)
                {
                    fireTimer = 0;

                    StartCoroutine(Shoot(Random.Range(3, 8)));
                }
            }

            // Get nodes that are close by.
            Collider2D[] nearNodes = Physics2D.OverlapCircleAll(transform.position, scrNodeMaster.CELL_SIZE, 1 << LayerMask.NameToLayer("Node"));

            // Get a near node that is clean.
            scrNode clean = null;
            foreach (Collider2D c in nearNodes)
            {
                scrNode n = c.GetComponent <scrNode>();
                if (!n.Infected && !n.Blocked)
                {
                    clean = n;
                    break;
                }
            }

            // If the clean node was set, start sieging.
            if (clean != null)
            {
                SiegeNode         = clean;
                pathfinder.Target = SiegeNode.gameObject;
            }
        }

        base.Update();
    }
示例#6
0
    public IEnumerator Create(Message message, bool infected)
    {
        creating = true;

        creatingMessage = message;

        yield return(StartCoroutine(Parse()));

        // Check if vandal tags detected.
        if (creating == false)
        {
            SpawnBoss(message);
            yield break;
        }

        if (scrMaster.Instance.Transitioning)
        {
            if (infected)
            {
                infectedBufferQueue.Enqueue(message);
            }
            else
            {
                scrGUI.Instance.AddToFeed(message.page_title, new Color(0.1f, 0.1f, 0.1f));
            }
            creating = false;
            yield break;
        }

        if (freePositionsCount == 0)
        {
            //	Debug.Log("There are no free positions left to create a node for \"" +  message.page_title + "\".");
            creating = false;
            if (!infected)
            {
                yield break;
            }
        }

        // Don't create a node if there are no nodes available.
        if (inactiveNodeCount == 0)
        {
            //	Debug.Log("There are no inactive nodes left to create a node for \"" +  message.page_title + "\".");
            creating = false;
            if (!infected)
            {
                yield break;
            }
        }

        // Don't create a node if there are no cubes available.
        if (inactiveCubeCount == 0)
        {
            //	Debug.Log("There are no inactive cubes left to create a node for \"" +  message.page_title + "\".");
            creating = false;
            if (!infected)
            {
                yield break;
            }
        }

        // Set the size of the core based on the change_size of the message.
        int coreSize = Mathf.Clamp(Mathf.CeilToInt(Mathf.Log10(Mathf.Abs(message.change_size) + 1)), scrNode.CORE_SIZE_MIN, scrNode.CORE_SIZE_MAX);

        // Get the number of cubes there would be around this core.
        int numCubes = scrNode.CubePositions[coreSize - 1].Length;

        // Don't create a node if there aren't enough cubes available.
        if (inactiveCubeCount < numCubes)
        {
            Debug.Log("There are not enough inactive cubes (" + inactiveCubeCount + "/" + numCubes + ") in the pool to create a node for \"" + message.page_title + "\".");
            creating = false;
            if (!infected)
            {
                yield break;
            }
        }

        // If not creating but got this far, node is infected and must replace an existing one,
        if (creating == false)
        {
            creating = true;

            // Loop through the active nodes until one is found that is completely out of the player's view.
            LinkedListNode <GameObject> n = nodePool.Last;
            for (int i = 0; i < TOTAL_NODES - inactiveNodeCount; ++i)
            {
                scrNode nScript = n.Value.GetComponent <scrNode>();

                // Don't replace nodes in view, fully infected nodes, the node being uploaded, or nodes that arent being infected.
                if (!(nScript.VisibleToPlayer || nScript.FullyInfected || !nScript.Infected || NodeBeingUploaded != null && n.Value == NodeBeingUploaded.gameObject))
                {
                    // Convert the node.
                    nScript.ConvertToInfected(message);
                    break;
                }

                // Move back one node.
                n = n.Previous;

                yield return(new WaitForEndOfFrame());
            }

            scrGUI.Instance.AddToFeed(message.page_title, ColCoreInfected);

            yield return(new WaitForSeconds(3.0f));             // 3 Second delay between node creation.

            creating = false;

            yield break;
        }

        // All checks have passed - a node can be made.  Get the first inactive node in the node pool.
        LinkedListNode <GameObject> node = nodePool.First;

        // Activate, position and initialise the node.
        ActivateNode(node);
        node.Value.transform.position = PopRandomFreePosition();
        scrNode nodeScript = node.Value.GetComponent <scrNode>();

        nodeScript.Init(node, message, coreSize, infected, creatingWords);
        // Set the cell's state to either infected or, if contribution is positive, clean else blocked.
        CellStates[ToCellSpace(nodeScript.transform.position.x), ToCellSpace(nodeScript.transform.position.y)] = infected ? CellState.INFECTED : nodeScript.Data.change_size > 0 ? CellState.CLEAN : CellState.BLOCKED;

        // Assign cubes to the node.
        LinkedListNode <GameObject> cube = cubePool.First;

        for (int i = 0, numLoops = 0; i < numCubes; ++i)
        {
            // Get the next cube before the cube is activated.
            LinkedListNode <GameObject> next = cube.Next;

            // Activate the cube and add it to the node.
            ActivateCube(cube);
            nodeScript.AddCube(cube);

            // Move to the next cube in the pool.
            cube = next;

            if (++numLoops == LOOPS_PER_FRAME)
            {
                numLoops = 0;
                yield return(new WaitForEndOfFrame());
            }
        }

        // Query surrounding nodes for links.
        CreateLinks(node);

        // Release the node! Go! Go free!!
        nodeScript.MakeReady();

        scrGUI.Instance.AddToFeed(message.page_title, infected ? ColCoreInfected : (message.change_size > 0 ? Color.cyan : Color.grey));

        creating = false;
    }
示例#7
0
 public void Upload()
 {
     Uploading = true;
     Parent    = null;
     pathfinder.Resume();
 }