public void changeEdgePieces(int edgeNum, BiomeTransistion transistion, Vector3 position, Vector3 secondPosition, EdgeOrientation orientate)
    {
        int     angle = 0;
        Vector3 z     = new Vector3(0, 0, 1);

        if (orientate == EdgeOrientation.NS)
        {
            angle = 0;
        }
        else if (orientate == EdgeOrientation.NWSE)
        {
            angle = 60;
        }
        else
        {
            angle = -60;
        }


        if (transistion.Equals(BiomeTransistion.Coast))
        {
            GameObject newEdgepiece = coastPiece;

            if (edgePieces[edgeNum] == null)
            {
                GameObject test = GameObject.Instantiate(newEdgepiece, position, Quaternion.AngleAxis(angle, z)) as GameObject;
                edgePieces[edgeNum]   = test;
                test.transform.parent = gameObject.transform;
                test.isStatic         = true;

                GameObject test1 = GameObject.Instantiate(newEdgepiece, secondPosition, Quaternion.AngleAxis(angle, z)) as GameObject;
                edgePieces[edgeNum + (edgePieces.Length / 2)] = test1;
                test1.transform.parent = gameObject.transform;
                test1.isStatic         = true;
            }
            else
            {
                Destroy(edgePieces[edgeNum]);
                GameObject test = GameObject.Instantiate(newEdgepiece, position, Quaternion.AngleAxis(angle, z)) as GameObject;
                edgePieces[edgeNum]   = test;
                test.transform.parent = gameObject.transform;
                test.isStatic         = true;

                Destroy(edgePieces[edgeNum + (edgePieces.Length / 2)]);
                GameObject test1 = GameObject.Instantiate(newEdgepiece, secondPosition, Quaternion.AngleAxis(angle, z)) as GameObject;
                edgePieces[edgeNum + (edgePieces.Length / 2)] = test1;
                test1.transform.parent = gameObject.transform;
                test1.isStatic         = true;
            }
        }

        if (transistion.Equals(BiomeTransistion.None))
        {
            if (edgePieces[edgeNum] != null)
            {
                Destroy(edgePieces[edgeNum]);
                Destroy(edgePieces[edgeNum + (edgePieces.Length / 2)]);
            }
        }
    }
Exemple #2
0
    public Edge(Vertex nNorthVertex, Vertex nSouthVertex, EdgeOrientation nOrientation, int num, BoardGraphics nGraphics, bool isInWestHalf, float mapX)
    {
        graphics = nGraphics;
        tileList = new List <Tile>();

        northVertex = nNorthVertex;
        southVertex = nSouthVertex;

        float northX = northVertex.getPosition().x;
        float northY = northVertex.getPosition().y;

        float southX = southVertex.getPosition().x;
        float southY = southVertex.getPosition().y;

        orientation = nOrientation;
        centre      = new Vector3((northX / 2f) + (southX / 2f), (northY / 2f) + (southY / 2f), 0f);
        if (isInWestHalf)
        {
            secondCentre = new Vector3(centre.x + mapX, centre.y, 0);
        }
        else
        {
            secondCentre = new Vector3(centre.x - mapX, centre.y, 0);
        }

        edgeNumber = num;

        biomeTransisition = BiomeTransistion.None;
    }
Exemple #3
0
    public void addRiver()
    {
        bool check = false;

        if (tileList.Count < 2)
        {
        }
        else
        {
            if (tileList[0].getBiome() == Biome.Ocean || tileList[1].getBiome() == Biome.Ocean)
            {
                check = true;
            }
        }


        if (this.biomeTransisition == BiomeTransistion.River || check)
        {
        }
        else
        {
            if (tileList.Count == 2)
            {
                graphics.buildRiverEdge(this.edgeNumber, this.getPosition(), this.secondCentre, this.orientation);
                this.biomeTransisition = BiomeTransistion.River;
                this.northVertex.setRiverJunction();
                this.southVertex.setRiverJunction();
            }
        }
    }
Exemple #4
0
 public void removeRiver()
 {
     if (this.biomeTransisition == BiomeTransistion.River)
     {
         graphics.deleteRiver(edgeNumber);
         this.biomeTransisition = BiomeTransistion.None;
         this.northVertex.setRiverJunction();
         this.southVertex.setRiverJunction();
     }
 }
Exemple #5
0
    public void changeEdgeType(float x, float y, BiomeTransistion bT)
    {
        Edge edge = this.getEdgefromPixel(x, y);

        if (edge != null && bT == BiomeTransistion.River)
        {
            edge.addRiver();
        }
        else if (edge != null && bT == BiomeTransistion.None)
        {
            edge.removeRiver();
        }
    }
	public void setOnClickActionRiver(){


		biomeSelected = Biome.None;
		biomeFeatureSelected = BiomeFeatures.None;
		if(biomeTransistionSelected == BiomeTransistion.None){
			biomeTransistionSelected = BiomeTransistion.River;
		}
		else{
			biomeTransistionSelected = BiomeTransistion.None;
		}

	}
Exemple #7
0
    public void changeTransistionType()
    {
        if (tileList.Count < 2)
        {
        }
        else
        {
            Tile tile1 = tileList[0];
            Tile tile2 = tileList[1];

            if (((tile1.getBiome() != Biome.Ocean) && (tile2.getBiome() == Biome.Ocean)) || ((tile1.getBiome() == Biome.Ocean) && (tile2.getBiome() != Biome.Ocean)))
            {
                graphics.changeEdgePieces(edgeNumber, BiomeTransistion.Coast, this.centre, this.secondCentre, this.orientation);
                this.biomeTransisition = BiomeTransistion.Coast;
            }
            else
            {
                graphics.changeEdgePieces(edgeNumber, BiomeTransistion.None, this.centre, this.secondCentre, this.orientation);
                this.biomeTransisition = BiomeTransistion.None;
            }
        }
    }
    public void setRiverJunction()
    {
        if (upOrDownEdge == null || eastWardEdge == null || westWardEdge == null)
        {
        }
        else
        {
            BiomeTransistion uBT = upOrDownEdge.getBiomeTransistion();
            BiomeTransistion eBT = eastWardEdge.getBiomeTransistion();
            BiomeTransistion wBT = westWardEdge.getBiomeTransistion();

            bool uCheck = (uBT == BiomeTransistion.River);
            bool eCheck = (eBT == BiomeTransistion.River);
            bool wCheck = (wBT == BiomeTransistion.River);

            bool uCoast = (uBT == BiomeTransistion.Coast);
            bool eCoast = (eBT == BiomeTransistion.Coast);
            bool wCoast = (wBT == BiomeTransistion.Coast);

            int coastType = 3;

            if (uCoast || eCoast || wCoast)
            {
                coastType = 2;
            }


            if (uCheck && eCheck && wCheck)
            {
                graphics.buildRiverVertex(0, this.orientation, true, true, true, this.vertNum, position, secondPosition);
            }
            else if (uCheck && eCheck && !wCheck)
            {
                graphics.buildRiverVertex(1, this.orientation, true, true, false, this.vertNum, position, secondPosition);
            }
            else if (uCheck && !eCheck && wCheck)
            {
                graphics.buildRiverVertex(1, this.orientation, true, false, true, this.vertNum, position, secondPosition);
            }
            else if (!uCheck && eCheck && wCheck)
            {
                graphics.buildRiverVertex(1, this.orientation, false, true, true, this.vertNum, position, secondPosition);
            }
            else if (uCheck)
            {
                graphics.buildRiverVertex(coastType, this.orientation, true, false, false, this.vertNum, position, secondPosition);
            }
            else if (eCheck)
            {
                graphics.buildRiverVertex(coastType, this.orientation, false, true, false, this.vertNum, position, secondPosition);
            }
            else if (wCheck)
            {
                graphics.buildRiverVertex(coastType, this.orientation, false, false, true, this.vertNum, position, secondPosition);
            }
            else
            {
                graphics.buildRiverVertex(4, this.orientation, false, false, false, vertNum, position, secondPosition);
            }
        }
    }
	// Use this for initialization
	void Start () {
	
		biomeSelected = Biome.None;
		biomeTransistionSelected = BiomeTransistion.None;

	}
	public void setOnClickActionTerrain(BiomeFeatures feature){

		biomeSelected = Biome.None;
		biomeTransistionSelected = BiomeTransistion.None;
		biomeFeatureSelected = feature;
	}
	public void setOnClickAction(Biome biome){
		biomeSelected = biome;
		biomeTransistionSelected = BiomeTransistion.None;
		biomeFeatureSelected = BiomeFeatures.None;
	}