Esempio n. 1
0
	public bool isAttracting(GameObject o)
	{
		if(!isStatic(o))
		{
			return false;
		}
		
		// and not surrounded
		bool innerTriangle = true;
		triangleNode thisNode = getNode(o);
		Vector2[] possibleoffsets = {new Vector2(-1,0), new Vector2(1,0), new Vector2(0,1)};
		if(isPointingUp(thisNode))
		{
			possibleoffsets[2] = new Vector2(0, -1);
		}
		
		for(int k=0; k< possibleoffsets.Length; k++)
		{
			if(getNode((int)possibleoffsets[k].x + thisNode.x, (int)possibleoffsets[k].y + thisNode.y) == null)
			{
				innerTriangle = false;
			}
		}
		
		return !innerTriangle;
	}
Esempio n. 2
0
	private void setCorrectPosition(triangleNode n)
	{
		Vector3 pos = getBasePosition(n.x, n.y);
	
		n.triangleObject.transform.rotation = Quaternion.Euler(getBaseRot(n.x, n.y));	
		n.triangleObject.transform.position = pos;
	}	
Esempio n. 3
0
	//input is a triangle on the outsde of a cluster. if a cluster exists, return the node that is the center of that cluster. else null
	private triangleNode getCenterOfNewCluster(triangleNode center)
	{
		triangleNode n;
		if(isPointingUp(center))
		{
			//check upper node
			n = getNode(center.x, center.y - 1);
			if(n != null && CompareTriangleColours(n) && !n.delayedDestroy)
			{
				return n;
			}
		}
		else
		{
			n = getNode(center.x, center.y + 1);
			if(n != null && CompareTriangleColours(n) && !n.delayedDestroy)
			{
				return n;
			}
		}
		
		n = getNode(center.x + 1, center.y);
		if(n != null && CompareTriangleColours(n) && !n.delayedDestroy )
		{
			return n;
		}
		
		n = getNode(center.x - 1, center.y);
		if(n != null && CompareTriangleColours(n) && !n.delayedDestroy)
		{
			return n;
		}
		
		return null;
	}
Esempio n. 4
0
	/// <summary>
	/// Sets the greater triangle colours to match the center colour
	/// Also increments score
	/// </summary>
	/// <param name="center">The Center Triangle</param>
	private void SetGreaterTriangleColours(triangleNode center)
	{
		GlobalFlags.setScore(GlobalFlags.getScore() + (GlobalFlags.getBaseScoreValue() * GlobalFlags.getMultiplier()));

		center.delayedDestroy = true;
		
		Color c = center.triangleObject.GetComponent<TriangleColour>().GetColour();
		triangleNode n;
		
		if( c != Color.black)
		{
			if(isPointingUp(center))
			{
				//check upper node
				n = getNode(center.x, center.y - 1);
				if(n !=null && 
				   n.triangleObject.GetComponent<TriangleColour>().GetColour() 
				   != Color.black)
				{
					n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
				}
			}
			else
			{
				//check lower node
				n = getNode(center.x, center.y + 1);
				if(n !=null && 
				   n.triangleObject.GetComponent<TriangleColour>().GetColour() 
				   != Color.black)
				{
					n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
				}
			}
		
			//check left node
			n = getNode(center.x - 1, center.y);
			if(n !=null && 
			   n.triangleObject.GetComponent<TriangleColour>().GetColour() 
			   != Color.black)
			{
				n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
			}
		
			//check right node
			n = getNode(center.x + 1, center.y);
			if(n !=null && 
			   n.triangleObject.GetComponent<TriangleColour>().GetColour() 
			   != Color.black)
			{
				n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
			}
		}
		
		CascadeAndClear(center);


	}
Esempio n. 5
0
	public void showGrid()
	{
		for(int i = -gridSize/2 + 1;i < gridSize/2; i++)
		{
			for(int j = -gridSize/2 + 1;j < gridSize/2; j++)
			{
				GameObject tempObj = (GameObject)Instantiate(triangleOutlinePrefab);
				//DestroyImmediate(temp.GetComponent<attraction>());
				//temp.GetComponent<Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
				
				triangleNode tempNode = new triangleNode(tempObj, i, j);
				gridOutline.Add(tempNode);

				setCorrectPosition(tempNode);
			}
		}
	}
Esempio n. 6
0
	/// <summary>
	/// Checks for greater triangle.
	/// </summary>
	/// <param name="justAdded">Triangle that was just added</param>
	private bool CheckForGreaterTriangle(triangleNode justAdded)
	{
		triangleNode n;

		if(isPointingUp(justAdded))
		{
			//check upper node
			n = getNode(justAdded.x, justAdded.y - 1);
			if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
			{
				SetGreaterTriangleColours(n);
				return true;
			}
		}
		else
		{
			//check lower node
			n = getNode(justAdded.x, justAdded.y + 1);
			if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
			{
				SetGreaterTriangleColours(n);
				return true;
			}
		}
		
		
		//check left node
		n = getNode(justAdded.x - 1, justAdded.y);
		if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
		{
			SetGreaterTriangleColours(n);
			return true;
		}
		
		//check right node
		n = getNode(justAdded.x + 1, justAdded.y);
		if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
		{
			SetGreaterTriangleColours(n);
			return true;
		}
		
		return false;
	}
Esempio n. 7
0
	void connectToNeighbours(triangleNode n)
	{
		Vector2[] possibleoffsets = {new Vector2(-1,0), new Vector2(1,0), new Vector2(0,1)};

		if(isPointingUp(n))
		{
			possibleoffsets[2] = new Vector2(0, -1);
		}
		
		for(int i=0; i < possibleoffsets.Length; i++)
		{
			if(getNode((int)(n.x + possibleoffsets[i].x), (int)(n.y + possibleoffsets[i].y)) != null)
			{
				triangleNode t = getNode((int)(n.x + possibleoffsets[i].x), (int)(n.y + possibleoffsets[i].y));
				FixedJoint f = n.triangleObject.AddComponent<FixedJoint>();
				f.connectedBody = t.triangleObject.GetComponent<Rigidbody>();
			}
		}
	}
Esempio n. 8
0
	Vector2 getBestPlaceOnGrid(GameObject oldTriangle, GameObject newTriangle)
	{
		triangleNode oldNode = getNode(oldTriangle);

		if(oldNode == null)
		{
			Debug.Log("could not find stationary triangle to attatch triange to");
			return new Vector2(0, 0);
		}

		//find the position closest to the new triangle around the possible locations for the new triangle to attatch
		//default to right
		int x = int.MaxValue,y = int.MaxValue;
		float minDist = float.MaxValue;

		Vector2[] possibleoffsets = {new Vector2(-1,0), new Vector2(1,0), new Vector2(0,1)};

		if(isPointingUp(oldNode))
		{
			possibleoffsets[2] = new Vector2(0, -1);
		}
		
		for(int i=0; i< possibleoffsets.Length; i++)
		{
			if(getNode(oldNode.x + (int)possibleoffsets[i].x, oldNode.y + (int)possibleoffsets[i].y) == null &&(
			   minDist > Vector3.Distance(newTriangle.transform.position, getBasePosition(oldNode.x + (int)possibleoffsets[i].x, oldNode.y + (int)possibleoffsets[i].y)) 
				|| (x == int.MaxValue || y == int.MaxValue)))
			{
				x = oldNode.x + (int)possibleoffsets[i].x;
				y = oldNode.y + (int)possibleoffsets[i].y;
				minDist = Vector3.Distance(newTriangle.transform.position, getBasePosition(x, y));
			}
		}

		if(x == int.MaxValue || y == int.MaxValue)
		{
			Debug.Log("all sides of the base triangle are taken. not able to attatch triangle");
			return new Vector2(0, 0);
		}
		
		
		return new Vector2(x, y);
	}
Esempio n. 9
0
	private bool skipNewCluster(triangleNode center)
	{
		Vector2[] possibleoffsets = {new Vector2(-1,0), new Vector2(1,0), new Vector2(0,1)};
		if(isPointingUp(center))
		{
			possibleoffsets[2] = new Vector2(0, -1);
		}
		
		for(int k=0; k< possibleoffsets.Length; k++)
		{
			triangleNode neighbour = getNode((int)possibleoffsets[k].x + center.x, (int)possibleoffsets[k].y + center.y);
			if(neighbour != null &&
				center.triangleObject.GetComponent<TriangleColour>().GetColour() != neighbour.triangleObject.GetComponent<TriangleColour>().GetColour())
			{
				return false;
			}
		}
		
		return true;
	}
Esempio n. 10
0
	public string[,] toStringArray()
	{
		string [,] array = new string[gridSize,gridSize];
		for(int i = 0; i < gridSize; i++)
		{
			for(int j = 0; j < gridSize; j++)
			{
				triangleNode n = grid[i,j];
				if(n == null)
				{
					array[i,j] = "";
				}
				else
				{
					array[i,j] = n.triangleObject.GetComponent<TriangleColour>()
						.GetCurrentColourAsString();
				}
			}
		}
		return array;
	}
Esempio n. 11
0
	/// <summary>
	/// Checks for any nodes not connected to the center and removes them
	/// </summary>
	private void dettatchStranded()
	{
		
		triangleNode center = getNode(0, 0);
		//remeber stranded triangles
		System.Collections.Generic.List<triangleNode> strandedTriangles = new System.Collections.Generic.List<triangleNode>();
		foreach( triangleNode n in grid)
		{	
			if(n != null)
			{
				if(!AStar(n,center))
				{
					strandedTriangles.Add(n);
				}
			}
		}
		
		foreach( triangleNode n in strandedTriangles)
		{
			if(n.triangleObject.GetComponent<attraction>() == null)
			{
				n.triangleObject.AddComponent<attraction>();
			}
			
			deleteNode(n.x, n.y);

			n.triangleObject.rigidbody.constraints = RigidbodyConstraints.FreezePositionZ | RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationY;
		}
		
		foreach( triangleNode n in strandedTriangles)
		{			
			n.triangleObject.GetComponent<attraction>().updateAttractionPoints();
			if(n.triangleObject.GetComponents<FixedJoint>().Length < 3)
			{
				n.triangleObject.GetComponent<attraction>().enabled = true;
			}
		}
	}
Esempio n. 12
0
	//for debugging purposes
	public string toString()
	{
		string s = "";

		for(int i= gridSize/2; i > -gridSize/2; i--)
		{
			for(int j= -gridSize/2; j < gridSize/2; j++)
			{
				triangleNode n = getNode(j, i);
				if(n != null)
				{
					s += "0";
				}
				else
				{
					s += "1";
				}
			}

			s += "\n";
		}

		return s;
	}
Esempio n. 13
0
    /// <summary>
    /// looks at the 3 surrounding triangles and ensures they have the 
    /// same colour
    /// </summary>
    /// <returns><c>true</c>, if triangle colours are the same
    /// <c>false</c> otherwise.</returns>
    /// <param name="center">The triangle in the center</param>
    private bool CompareTriangleColours(triangleNode center)
    {
        Color c = new Color();
        triangleNode n;

        if(isPointingUp(center))
        {
            //check upper node
            n = getNode(center.x, center.y - 1);
            if(n == null)
            {
                return false;
            }
            c = (n.triangleObject.GetComponent<TriangleColour>().GetColour());
        }
        else
        {
            //check lower node
            n = getNode(center.x, center.y + 1);
            if(n == null)
            {
                return false;
            }
            c = (n.triangleObject.GetComponent<TriangleColour>().GetColour());
        }

        //check left node
        n = getNode(center.x - 1, center.y);
        if(n != null)
        {
            if( c == Color.black)
            {
                c = (n.triangleObject.GetComponent<TriangleColour>().GetColour());
            }
            else
            {
                if(c != (n.triangleObject.GetComponent<TriangleColour>().GetColour())
                   && (n.triangleObject.GetComponent<TriangleColour>().GetColour()) != Color.black)
                {
                    return false;
                }
            }
        }
        else
        {
            return false;
        }

        //check right node
        n = getNode(center.x + 1, center.y);
        if(n != null)
        {
            if(c != (n.triangleObject.GetComponent<TriangleColour>().GetColour())
               && (n.triangleObject.GetComponent<TriangleColour>().GetColour()) != Color.black)
            {
                return false;
            }
        }
        else
        {
            return false;
        }

        return true;
    }
Esempio n. 14
0
	/// <summary>
	/// looks at the 3 surrounding triangles and ensures they have the 
	/// same colour
	/// </summary>
	/// <returns><c>true</c>, if triangle colours are the same
	/// <c>false</c> otherwise.</returns>
	/// <param name="center">The triangle in the center</param>
	private bool CompareTriangleColours(triangleNode center)
	{
		Color c = new Color();
		triangleNode n;

		if(isPointingUp(center))
		{
			//check upper node
			n = getNode(center.x, center.y - 1);
			if(n == null)
			{
				return false;
			}
			c = (n.triangleObject.GetComponent<TriangleColour>().GetColour());
		}
		else
		{
			//check lower node
			n = getNode(center.x, center.y + 1);
			if(n == null)
			{
				return false;
			}
			c = (n.triangleObject.GetComponent<TriangleColour>().GetColour());
		}
		
		//check left node
		n = getNode(center.x - 1, center.y);
		if(n != null)
		{
			if( c == Color.black)
			{
				c = (n.triangleObject.GetComponent<TriangleColour>().GetColour());
			}
			else
			{
				if(c != (n.triangleObject.GetComponent<TriangleColour>().GetColour())
				   && (n.triangleObject.GetComponent<TriangleColour>().GetColour()) != Color.black)
				{
					return false;
				}
			}
		}
		else
		{
			return false;
		}
		
		//check right node
		n = getNode(center.x + 1, center.y);
		if(n != null)
		{
			if(c != (n.triangleObject.GetComponent<TriangleColour>().GetColour())
			   && (n.triangleObject.GetComponent<TriangleColour>().GetColour()) != Color.black)
			{
				return false;
			}
		}
		else
		{
			return false;
		}

		return true;
	}
Esempio n. 15
0
    void connectToNeighbours(triangleNode n)
    {
        Vector2[] possibleoffsets = {new Vector2(-1,0), new Vector2(1,0), new Vector2(0,1)};

        if(isPointingUp(n))
        {
            possibleoffsets[2] = new Vector2(0, -1);
        }

        for(int i=0; i < possibleoffsets.Length; i++)
        {
            if(getNode((int)(n.x + possibleoffsets[i].x), (int)(n.y + possibleoffsets[i].y)) != null)
            {
                triangleNode t = getNode((int)(n.x + possibleoffsets[i].x), (int)(n.y + possibleoffsets[i].y));
                FixedJoint f = n.triangleObject.AddComponent<FixedJoint>();
                f.connectedBody = t.triangleObject.GetComponent<Rigidbody>();
            }
        }
    }
Esempio n. 16
0
    //input is a triangle on the outsde of a cluster. if a cluster exists, return the node that is the center of that cluster. else null
    private triangleNode getCenterOfNewCluster(triangleNode center)
    {
        triangleNode n;
        if(isPointingUp(center))
        {
            //check upper node
            n = getNode(center.x, center.y - 1);
            if(n != null && CompareTriangleColours(n) && !n.delayedDestroy)
            {
                return n;
            }
        }
        else
        {
            n = getNode(center.x, center.y + 1);
            if(n != null && CompareTriangleColours(n) && !n.delayedDestroy)
            {
                return n;
            }
        }

        n = getNode(center.x + 1, center.y);
        if(n != null && CompareTriangleColours(n) && !n.delayedDestroy )
        {
            return n;
        }

        n = getNode(center.x - 1, center.y);
        if(n != null && CompareTriangleColours(n) && !n.delayedDestroy)
        {
            return n;
        }

        return null;
    }
Esempio n. 17
0
    private void setCorrectPosition(triangleNode n)
    {
        Vector3 pos = getBasePosition(n.x, n.y);

        n.triangleObject.transform.rotation = Quaternion.Euler(getBaseRot(n.x, n.y));
        n.triangleObject.transform.position = pos;
    }
Esempio n. 18
0
	/// <summary>
	/// Searches for a path from start to goal
	/// </summary>
	/// <returns><c>true</c> if a path exists <c>false</c> otherwise.</returns>
	/// <param name="start">Starting node</param>
	/// <param name="goal">Goal node</param>
	private bool AStar(triangleNode start, triangleNode goal)
	{
		IList<triangleNode> closedSet = new List<triangleNode>();
		IList<triangleNode> openSet = new List<triangleNode>();
		openSet.Add(start);
		triangleNode current;
		triangleNode n;

		while (openSet.Count != 0)
		{
			current = openSet[0];

			if (current.Equals(goal))
			{
				return true;
			}
			
			closedSet.Add(current);
			openSet.Remove(current);

			if(isPointingUp(current))
			{
				if(current.y - 1 > -gridSize/2)
				{
					n = getNode(current.x, current.y - 1);
					if ( n != null && !closedSet.Contains(n))
					{
						openSet.Add(n);
					}
				}
			}
			else
			{
				if(current.y + 1 < gridSize/2)
				{
					n = getNode(current.x, current.y + 1);
					if ( n != null && !closedSet.Contains(n))
					{
						openSet.Add(n);
					}
				}
			}
			//check left
			if(current.x - 1 > -gridSize/2)
			{
				n = getNode(current.x - 1, current.y);
				if ( n != null && !closedSet.Contains(n))
				{
					openSet.Add(n);
				}
			}
			//check right
			if(current.x + 1 < gridSize/2)
			{
				n = getNode(current.x + 1, current.y);
				if ( n != null && !closedSet.Contains(n))
				{
					openSet.Add(n);
				}
			}
		}
		return false;
	}
Esempio n. 19
0
	private bool isPointingUp(triangleNode n)
	{
		return isPointingUp(n.x, n.y);
	}
Esempio n. 20
0
    private bool skipNewCluster(triangleNode center)
    {
        Vector2[] possibleoffsets = {new Vector2(-1,0), new Vector2(1,0), new Vector2(0,1)};
        if(isPointingUp(center))
        {
            possibleoffsets[2] = new Vector2(0, -1);
        }

        for(int k=0; k< possibleoffsets.Length; k++)
        {
            triangleNode neighbour = getNode((int)possibleoffsets[k].x + center.x, (int)possibleoffsets[k].y + center.y);
            if(neighbour != null &&
                center.triangleObject.GetComponent<TriangleColour>().GetColour() != neighbour.triangleObject.GetComponent<TriangleColour>().GetColour())
            {
                return false;
            }
        }

        return true;
    }
Esempio n. 21
0
    /// <summary>
    /// Sets the greater triangle colours to match the center colour
    /// Also increments score
    /// </summary>
    /// <param name="center">The Center Triangle</param>
    private void SetGreaterTriangleColours(triangleNode center)
    {
        GlobalFlags.setScore(GlobalFlags.getScore() + (GlobalFlags.getBaseScoreValue() * GlobalFlags.getMultiplier()));

        center.delayedDestroy = true;

        Color c = center.triangleObject.GetComponent<TriangleColour>().GetColour();
        triangleNode n;

        if( c != Color.black)
        {
            if(isPointingUp(center))
            {
                //check upper node
                n = getNode(center.x, center.y - 1);
                if(n !=null &&
                   n.triangleObject.GetComponent<TriangleColour>().GetColour()
                   != Color.black)
                {
                    n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
                }
            }
            else
            {
                //check lower node
                n = getNode(center.x, center.y + 1);
                if(n !=null &&
                   n.triangleObject.GetComponent<TriangleColour>().GetColour()
                   != Color.black)
                {
                    n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
                }
            }

            //check left node
            n = getNode(center.x - 1, center.y);
            if(n !=null &&
               n.triangleObject.GetComponent<TriangleColour>().GetColour()
               != Color.black)
            {
                n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
            }

            //check right node
            n = getNode(center.x + 1, center.y);
            if(n !=null &&
               n.triangleObject.GetComponent<TriangleColour>().GetColour()
               != Color.black)
            {
                n.triangleObject.GetComponent<TriangleColour>().SetColour(c);
            }
        }

        CascadeAndClear(center);
    }
Esempio n. 22
0
	private void CascadeAndClear(triangleNode center)
	{
		bool isUpwards = isPointingUp(center);
		int x = center.x;
		int y = center.y;
		Vector2 realCords = getRealCoords(x , y);
		triangleNode n;

		//destroy the center
		center.delayedDestroy = true;	

		if(isUpwards)
		{
			n = getNode(x, y - 1);
			if(n != null &&	
			   n.triangleObject.GetComponent<TriangleColour>().GetColour()
			   != Color.black)
			{
				n.delayedDestroy = true;
				triangleNode newCenter = getCenterOfNewCluster(n);
				if(newCenter != null)
				{
					if(skipNewCluster(newCenter))
					{
						//n.skipDelay = true;
					}
					chainedClusters.Push(n);
				}
			}
		}
		else
		{
			n = getNode(x, y + 1);
			if(n != null &&	
			   n.triangleObject.GetComponent<TriangleColour>().GetColour()
			   != Color.black)
			{
				n.delayedDestroy = true;
				triangleNode newCenter = getCenterOfNewCluster(n);
				if(newCenter != null)
				{
					if(skipNewCluster(newCenter))
					{
						//n.skipDelay = true;
					}
					chainedClusters.Push(n);
				}
			}
		}



		// Left Node
		n = getNode(x - 1, y);
		if(n != null &&	
		   n.triangleObject.GetComponent<TriangleColour>().GetColour()
		   != Color.black)
		{
			n.delayedDestroy = true;
			triangleNode newCenter = getCenterOfNewCluster(n);
			if(newCenter != null)
			{
				if(skipNewCluster(newCenter))
				{
					//n.skipDelay = true;
				}
				chainedClusters.Push(n);
			}
		}

		// Right Node
		n = getNode(x + 1, y);
		
		if(n != null &&	
		   n.triangleObject.GetComponent<TriangleColour>().GetColour()
		   != Color.black)
		{
			n.delayedDestroy = true;
			triangleNode newCenter = getCenterOfNewCluster(n);
			if(newCenter != null)
			{
				if(skipNewCluster(newCenter))
				{
					//n.skipDelay = true;
				}
				chainedClusters.Push(n);
			}
		}
		

		startChainDelay();
	}
Esempio n. 23
0
	// Update is called once per frame
	void Update ()
	{
		if(inEditMode && Input.GetMouseButtonUp(0))
		{
			Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
			RaycastHit hitInfo;
			if(Physics.Raycast(ray,out hitInfo))
			{
				if(hitInfo.collider.gameObject.tag == "gridPanel")
				{
					triangleNode node = findOutlineNode(hitInfo.collider.gameObject.transform.parent.gameObject);
					if(node != null && GetComponent<HandleUI>().IsAdding())
					{
						string c = GetComponent<HandleUI>().GetColourString();
						Vector2 realCoords = getRealCoords(node.x, node.y);
						if(grid[(int)realCoords.x,(int)realCoords.y] == null)
						{
							createTriangleOnGrid(node.x, node.y, c);
						}
					}
				}
				else if(hitInfo.collider.gameObject.tag == "Triangle")
				{
					triangleNode node = getNode(hitInfo.collider.gameObject);
					if(node != null && !GetComponent<HandleUI>().IsAdding()
					   && !(node.x == 0 && node.y == 0))
					{
						Vector2 realCoords = getRealCoords(node.x, node.y);
						grid[(int)realCoords.x,(int)realCoords.y] = null;
						Destroy(hitInfo.collider.gameObject);
					}
				}
			}
		}

		GameObject[] triangles = GameObject.FindGameObjectsWithTag("Triangle");
		GameObject gObject = GameObject.FindGameObjectWithTag("Queue");

		queue queueScript = gObject.GetComponent<queue>();

		if(GlobalFlags.updateControlPoints)			
		{
			updateAllAttractionPoints();
			GlobalFlags.updateControlPoints = false;

			//if all triangles are atatched to grid, let the player fire again
			if(allTrianglesStatic())
			{
				GlobalFlags.trianglesStatic = true;
				if (queueScript.trisLeftInQueue() == 0 && triangles.Length != 1) {
					if(GlobalFlags.getMusicVolume() > 0.1f)
					{
						music.audio.volume = 0.1f;
					}
					music.setSeStartTime(Time.time, 2);
					music.playSoundEffect("gameOver");
					Application.LoadLevel("EndGameMenu");
				}
			}
		}

		if(!inEditMode)
		{
			GameObject[] queueTriangles = GameObject.FindGameObjectsWithTag("QueueTriangle");
			GlobalFlags.setQueueBonusTotal(queueTriangles.Length * GlobalFlags.getQueueBounus());

			//decrement delay time
			if(((elapsedChainDelay > 0 && elapsedChainDelay != float.MaxValue)) && (chainedClusters.Count == 0 || (chainedClusters.Count > 0 && !chainedClusters.Peek().skipDelay)))
			{
				elapsedChainDelay -= Time.deltaTime;
			}
			else if (elapsedChainDelay != float.MaxValue)
			{
				elapsedChainDelay = float.MaxValue;
			
				//if clusters left to deal with, color them and chain more
				if(chainedClusters.Count > 0)
				{
					GlobalFlags.incrementMultiplier();
					CheckForGreaterTriangle(chainedClusters.Pop());
					startChainDelay();
				
				}
				else if(chainedClusters.Count == 0)
				{
		
					foreach (triangleNode n in grid)
					{
						if(n != null && n.delayedDestroy && n.triangleObject.GetComponent<TriangleColour>().GetColour() != Color.black)
						{
							Destroy(n.triangleObject);
							deleteNode(n.x, n.y);
						}
						else if(n != null) // if it is black, set to not deleted
						{
							n.delayedDestroy = false;
						}
					}
					
					//Remove any triangles stranded by this action
					dettatchStranded();
					
					GlobalFlags.updateControlPoints = true;
						
					GlobalFlags.resetMultiplier();	
				}		
			}
			else
			{
				if(triangles.Length == 1)
				{
					if(GlobalFlags.getMusicVolume() > 0.1f)
					{
						music.audio.volume = 0.1f;
					}
					music.setSeStartTime(Time.time, 6);
					music.playSoundEffect("machoMadness");
					if (!GlobalFlags.infiniteRandomMode){ 
						GlobalFlags.setScore(GlobalFlags.getScore() + GlobalFlags.getQueueBounusTotal());
					}
					else {
						GlobalFlags.setScore(GlobalFlags.getScore());
					}
					Application.LoadLevel("PostGameMenu");
				}
			}
		}
	}
Esempio n. 24
0
    /// <summary>
    /// Checks for greater triangle.
    /// </summary>
    /// <param name="justAdded">Triangle that was just added</param>
    private bool CheckForGreaterTriangle(triangleNode justAdded)
    {
        triangleNode n;

        if(isPointingUp(justAdded))
        {
            //check upper node
            n = getNode(justAdded.x, justAdded.y - 1);
            if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
            {
                SetGreaterTriangleColours(n);
                return true;
            }
        }
        else
        {
            //check lower node
            n = getNode(justAdded.x, justAdded.y + 1);
            if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
            {
                SetGreaterTriangleColours(n);
                return true;
            }
        }

        //check left node
        n = getNode(justAdded.x - 1, justAdded.y);
        if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
        {
            SetGreaterTriangleColours(n);
            return true;
        }

        //check right node
        n = getNode(justAdded.x + 1, justAdded.y);
        if(n !=null && CompareTriangleColours(n) && !n.delayedDestroy)
        {
            SetGreaterTriangleColours(n);
            return true;
        }

        return false;
    }
Esempio n. 25
0
    /// <summary>
    /// Searches for a path from start to goal
    /// </summary>
    /// <returns><c>true</c> if a path exists <c>false</c> otherwise.</returns>
    /// <param name="start">Starting node</param>
    /// <param name="goal">Goal node</param>
    private bool AStar(triangleNode start, triangleNode goal)
    {
        IList<triangleNode> closedSet = new List<triangleNode>();
        IList<triangleNode> openSet = new List<triangleNode>();
        openSet.Add(start);
        triangleNode current;
        triangleNode n;

        while (openSet.Count != 0)
        {
            current = openSet[0];

            if (current.Equals(goal))
            {
                return true;
            }

            closedSet.Add(current);
            openSet.Remove(current);

            if(isPointingUp(current))
            {
                if(current.y - 1 > -gridSize/2)
                {
                    n = getNode(current.x, current.y - 1);
                    if ( n != null && !closedSet.Contains(n))
                    {
                        openSet.Add(n);
                    }
                }
            }
            else
            {
                if(current.y + 1 < gridSize/2)
                {
                    n = getNode(current.x, current.y + 1);
                    if ( n != null && !closedSet.Contains(n))
                    {
                        openSet.Add(n);
                    }
                }
            }
            //check left
            if(current.x - 1 > -gridSize/2)
            {
                n = getNode(current.x - 1, current.y);
                if ( n != null && !closedSet.Contains(n))
                {
                    openSet.Add(n);
                }
            }
            //check right
            if(current.x + 1 < gridSize/2)
            {
                n = getNode(current.x + 1, current.y);
                if ( n != null && !closedSet.Contains(n))
                {
                    openSet.Add(n);
                }
            }
        }
        return false;
    }
Esempio n. 26
0
 private bool isPointingUp(triangleNode n)
 {
     return isPointingUp(n.x, n.y);
 }
Esempio n. 27
0
    public void showGrid()
    {
        for(int i = -gridSize/2 + 1;i < gridSize/2; i++)
        {
            for(int j = -gridSize/2 + 1;j < gridSize/2; j++)
            {
                GameObject tempObj = (GameObject)Instantiate(triangleOutlinePrefab);
                //DestroyImmediate(temp.GetComponent<attraction>());
                //temp.GetComponent<Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;

                triangleNode tempNode = new triangleNode(tempObj, i, j);
                gridOutline.Add(tempNode);

                setCorrectPosition(tempNode);
            }
        }
    }
Esempio n. 28
0
    private void CascadeAndClear(triangleNode center)
    {
        bool isUpwards = isPointingUp(center);
        int x = center.x;
        int y = center.y;
        Vector2 realCords = getRealCoords(x , y);
        triangleNode n;

        //destroy the center
        center.delayedDestroy = true;

        if(isUpwards)
        {
            n = getNode(x, y - 1);
            if(n != null &&
               n.triangleObject.GetComponent<TriangleColour>().GetColour()
               != Color.black)
            {
                n.delayedDestroy = true;
                triangleNode newCenter = getCenterOfNewCluster(n);
                if(newCenter != null)
                {
                    if(skipNewCluster(newCenter))
                    {
                        //n.skipDelay = true;
                    }
                    chainedClusters.Push(n);
                }
            }
        }
        else
        {
            n = getNode(x, y + 1);
            if(n != null &&
               n.triangleObject.GetComponent<TriangleColour>().GetColour()
               != Color.black)
            {
                n.delayedDestroy = true;
                triangleNode newCenter = getCenterOfNewCluster(n);
                if(newCenter != null)
                {
                    if(skipNewCluster(newCenter))
                    {
                        //n.skipDelay = true;
                    }
                    chainedClusters.Push(n);
                }
            }
        }

        // Left Node
        n = getNode(x - 1, y);
        if(n != null &&
           n.triangleObject.GetComponent<TriangleColour>().GetColour()
           != Color.black)
        {
            n.delayedDestroy = true;
            triangleNode newCenter = getCenterOfNewCluster(n);
            if(newCenter != null)
            {
                if(skipNewCluster(newCenter))
                {
                    //n.skipDelay = true;
                }
                chainedClusters.Push(n);
            }
        }

        // Right Node
        n = getNode(x + 1, y);

        if(n != null &&
           n.triangleObject.GetComponent<TriangleColour>().GetColour()
           != Color.black)
        {
            n.delayedDestroy = true;
            triangleNode newCenter = getCenterOfNewCluster(n);
            if(newCenter != null)
            {
                if(skipNewCluster(newCenter))
                {
                    //n.skipDelay = true;
                }
                chainedClusters.Push(n);
            }
        }

        startChainDelay();
    }