public static RoadDirection Opposite(RoadDirection dir) { switch (dir) { case RoadDirection.Vertical: return(RoadDirection.Horizontal); case RoadDirection.Horizontal: return(RoadDirection.Vertical); case RoadDirection.North: return(RoadDirection.South); case RoadDirection.South: return(RoadDirection.North); case RoadDirection.West: return(RoadDirection.East); case RoadDirection.East: return(RoadDirection.West); case RoadDirection.NorthWest: return(RoadDirection.SouthEast); case RoadDirection.NorthEast: return(RoadDirection.SouthWest); case RoadDirection.SouthWest: return(RoadDirection.NorthEast); case RoadDirection.SouthEast: return(RoadDirection.NorthWest); default: return(RoadDirection.None); } }
/// <summary> /// Consulta si esta carretera tiene la salida indicada /// </summary> /// <param name="direction"></param> /// <returns></returns> public static bool HasDirection(this RoadDirection roadDirection, CardinalPoint direction) { bool r = false; switch (direction) { case CardinalPoint.N: r = roadDirection.HasN(); break; case CardinalPoint.E: r = roadDirection.HasE(); break; case CardinalPoint.W: r = roadDirection.HasW(); break; case CardinalPoint.S: r = roadDirection.HasS(); break; case CardinalPoint.None: r = true; break; default: r = false; break; } return(r); }
public static bool HasS(this RoadDirection roadDirection) { bool r = false; switch (roadDirection) { case RoadDirection.NEWS: r = true; break; case RoadDirection.NS: r = true; break; case RoadDirection.SE: r = true; break; case RoadDirection.SW: r = true; break; default: r = false; break; } return(r); }
public static List <RoadDirection> GetAll(this RoadDirection thisRD) { List <RoadDirection> rds = ((RoadDirection[])Enum.GetValues(typeof(RoadDirection))).ToList(); //rds.Remove(RoadDirection.NEWS); return(rds); }
public void UpdateMaterial(string LowIMGPath) { if (PermanentVisuals) { return; } RoadDirection dir = _direction; if (myRoad != null) { if (myRoad.gameObject.activeSelf == true) { myRoad.SetFrame((int)dir); } } if (myRoadLow != null) { if (myRoadLow.gameObject.activeSelf == true) { string s = (string)LowIMGPath + "sprite_" + (string)roadDirToString(dir); Sprite sp = Resources.Load <Sprite>(s); myRoadLow.sprite = sp; } } }
/// <summary> /// Compara dos "RoadDirection" Devuelve las similitudes en array de Truckdirection /// mediante el RETURN. /// Devuelve las diferencias en array de TruckDirection mediante out. /// Ambas arrays varian entre 0 y 2 elementos /// </summary> /// <param name="thisRoad">selfroad</param> /// <param name="otherRoad">La otra carretera a comparar</param> /// <param name="diferences">OUT de array de TruckDirection</param> /// <param name="focusDifferencesOnOtherRoad">Si es false, el out "differences" devuelve=> ¿Que tiene esta carretera que no tenga "otherRoad"?. Si es true => ¿Que tiene la otra carretera que no tenga esta?</param> /// <returns>array de TruckDirection</returns> public static CardinalPoint[] Compare(this RoadDirection thisRoad, RoadDirection otherRoad, out CardinalPoint[] diferences, bool focusDifferencesOnOtherRoad = false) { bool b = focusDifferencesOnOtherRoad; //alias //Arrays temporales a llenar CardinalPoint[] diff = new CardinalPoint[2]; CardinalPoint[] result = new CardinalPoint[2]; //contadores para las arrays int i = 0; //result int e = 0; //diff //MainLoop de 1 a 4. el ENUM TruckDirection puede ser casteado a INT (y viceversa) //Nota: Enum Truckdirection. None = 0, N = 1, E = 2, W = 3, S = 4. for (int index = 1; index <= 4; index++) { //Sacamos la dirección que vamos a comprobar en este loop: CardinalPoint dir = (CardinalPoint)index; //Cast de int a TruckDirection //La comprobamos! //Si ambos tienen la direción, guaramos la similitud y se acaba el loop if (thisRoad.HasDirection(dir) && otherRoad.HasDirection(dir)) { result[i] = dir; i++; } else //Si no comprobamos si alguno de los dos tiene esa dirección { //Nota: b es el focus. //Sobre Que carretera queremos devolver las diferencias // !b = esta carretera // b = la otra carretera if (thisRoad.HasDirection(dir) && !b) { diff[e] = dir; e++; } if (otherRoad.HasDirection(dir) && b) { diff[e] = dir; e++; } } } //End of Main Loop //reconstruimos ambas arrays y devolvemos. CardinalPoint[] resultd = new CardinalPoint[result.Length]; for (int x = 0; x < result.Length; x++) { resultd[x] = result[x]; } diferences = new CardinalPoint[diff.Length]; for (int y = 0; y < diff.Length; y++) { diferences[y] = diff[y]; } return(resultd); }
private RoadDirection CalculateRoadDirection(Feature feature, LineShape lineShape, Vertex startVertex) { int index = 0; // Given the vertex is the first of input line shape. if (!GeometryHelper.IsSamePoint(lineShape.Vertices[0], startVertex, Tolerance)) { index = lineShape.Vertices.Count - 1; } RoadDirection direction = RoadDirection.Noway; if (index == 0) { if (IsRoadDirectionAccessable(feature, RoadDirection.Forward)) { direction = RoadDirection.Forward; } } else { if (IsRoadDirectionAccessable(feature, RoadDirection.Backward)) { direction = RoadDirection.Backward; } } return(direction); }
void OnPress(bool isPressed) { if (NumberOfTruckOnTop > 0) { return; } if (numberOfComingTrucks > 0) { return; } if (freeze) { return; } if (!isPressed) { return; } if (!isClickable) { return; } switch (TypeOfRotation) { case RoadRotationType.Green: myAnimator.SetBool("Next", true); StartingGreenRotation = StartingGreenRotation.Next(); _direction = StartingGreenRotation.toRoadDirection(); break; case RoadRotationType.Blue: myAnimator.SetBool("Next", true); StartingGreenRotation = StartingGreenRotation.Next(); StartingBlueRotation = StartingGreenRotation.GreenToBlue(); _direction = StartingBlueRotation.toRoadDirection(); break; case RoadRotationType.Purple: roadStartingPurple = roadStartingPurple.NextPurpleCardinalPoint(roadAnchorPurple, ref purpleDirection); direction = RoadDirectionExtensions.ComposeRoadDirection(roadAnchorPurple, roadStartingPurple); TurnOffAllSprites(); if (direction == RoadDirection.EW || direction == RoadDirection.NS) { RecalculateSprites(RoadDirectionExtensions.ComposeRoadDirection(roadAnchorPurple, roadStartingPurple.NextPurpleCardinalPoint(roadAnchorPurple, ref purpleDirection))); } break; case RoadRotationType.Gold: direction = possibleGoldRotations[0]; possibleGoldRotations.RemoveAt(0); possibleGoldRotations.Add(direction); RecalculateSprites(); break; default: break; } }
public static RoadDirection ComposeRoadDirection(RoadPositionPurple A, RoadPositionPurple B) { List <RoadDirection> result = new List <RoadDirection>(); RoadDirection dummy = RoadDirection.NEWS; result = dummy.GetAll().FindAll(x => x.HasDirection(A.ToCardinalPoint()) && x.HasDirection(B.ToCardinalPoint())); result.Remove(RoadDirection.NEWS); return(result[0]); }
/// <summary> /// Initializes the starting position of the animator if the road is Clickable /// and other things /// </summary> void InitializeAnimator() { TurnOffAllSprites(); if (!isClickable || myAnimator == null) { return; } switch (TypeOfRotation) { case RoadRotationType.Green: _direction = StartingGreenRotation.toRoadDirection(); ChangeVisuals(RoadDirection.NE); if (myAnimator.GetCurrentAnimatorStateInfo(0).IsName("90_" + greenDirtoString(StartingGreenRotation) + "_state")) { break; } myAnimator.SetBool("NoAnim", true); myAnimator.SetBool("GoTo" + greenDirtoString(StartingGreenRotation), true); break; case RoadRotationType.Blue: _direction = StartingBlueRotation.toRoadDirection(); StartingGreenRotation = StartingBlueRotation.BlueToGreen(); ChangeVisuals(RoadDirection.EW); if (myAnimator.GetCurrentAnimatorStateInfo(0).IsName("90_" + greenDirtoString(StartingBlueRotation.BlueToGreen()) + "_State")) { break; } myAnimator.SetBool("NoAnim", true); myAnimator.SetBool("GoTo" + greenDirtoString(StartingBlueRotation.BlueToGreen()), true); break; case RoadRotationType.Purple: //This is "not" animator, but it's an initializatin needed for Purple type of clickable roads if (roadAnchorPurple == roadStartingPurple) { roadStartingPurple = roadStartingPurple.NextPurpleCardinalPoint(roadAnchorPurple, ref purpleDirection); } direction = RoadDirectionExtensions.ComposeRoadDirection(roadAnchorPurple, roadStartingPurple); RecalculateSprites(RoadDirectionExtensions.ComposeRoadDirection(roadAnchorPurple, roadStartingPurple.NextPurpleCardinalPoint(roadAnchorPurple, ref purpleDirection))); break; case RoadRotationType.Gold: direction = possibleGoldRotations[0]; possibleGoldRotations.RemoveAt(0); possibleGoldRotations.Add(direction); RecalculateSprites(); break; default: break; } }
public void SetTypeAndDirection(RoadType type, RoadDirection direction, bool link_wps = true) { SetType(type); SetDirection(direction); if (link_wps) { LinkWayPoints(); } }
public bool isActive; //Gets passed to false when hit //Contructor public Roads(bool act) { type = RoadType.m_null; direction = RoadDirection.m_null; rotation = Quaternion.Euler(0, 0, 0); pos = new Vector2(0, 0); m_GameObjectPrefabType = null; m_GameObjectInstance = null; m_renderer = null; isActive = act; }
public void setState(TownBuilder builder) { gameObject.transform.position = builder.Position; gameObject.transform.rotation = builder.Quaternion; this.direction = builder.Direction; layRoad(); this.id = builder.Id; this.level = builder.Level; this.size = builder.Size; this.priseMag = builder.PriseMag; this.clients = builder.Clients; this.merchants = builder.Merchants; this.citizens = builder.Citizens; this.attributeMag = builder.AttributeMag; this.grid = builder.Grid; this.buildingDatas = builder.BuildingDatas; this.attribute = TownAttributeMasterManager.getInstance().getTownAttributeFromId(builder.TownAttributeId); Debug.Log("attributeMag count " + attributeMag.Count); foreach (var buildingData in buildingDatas) { var building = buildingData.restore(); buildings.Add(building); building.transform.SetParent(transform); } characters.AddRange(citizens); foreach (Merchant merchant in merchants) { merchant.setTown(this); } characters.AddRange(merchants); characters.AddRange(clients); foreach (IFriendly friendlyCharacter in characters) { friendlyCharacter.getContainer().transform.SetParent(transform); } observer = new TownObserver(this); }
public virtual bool IsRoadDirectionAccessable(Feature feature, RoadDirection roadDirection) { // Todo: check one-way roads is right to the specific direction. bool isRoadDirectionAccessable = false; string onewayValue = feature.ColumnValues["oneway"]; if (String.Compare(onewayValue.Trim(), "1", true, CultureInfo.InvariantCulture) == 0) { isRoadDirectionAccessable = true; } else { isRoadDirectionAccessable = false; } return(isRoadDirectionAccessable); }
private RoadCreateResult CreateRoad(RoadDirection roadDirection, Vector3 startPosition, int length, int offset = 0) { var managerRoads = this.GetManager<ManagerRoads>(); Quaternion roadRotation = Quaternion.identity; Vector3 roadAddPositionDirection = Vector3.zero; switch (roadDirection) { case RoadDirection.Up: roadRotation = Quaternion.Euler(0, 90, 0); roadAddPositionDirection = new Vector3(0, 0, 1); break; case RoadDirection.Down: roadRotation = Quaternion.Euler(0, 90, 0); roadAddPositionDirection = new Vector3(0, 0, -1); break; case RoadDirection.Right: roadRotation = Quaternion.Euler(0, 0, 0); roadAddPositionDirection = new Vector3(1, 0, 0); break; case RoadDirection.Left: roadRotation = Quaternion.Euler(0, 0, 0); roadAddPositionDirection = new Vector3(-1, 0, 0); break; } for (int i = offset; i < length + offset; i++) { var controllerRoadStraight = managerRoads.CreateControllerRoadStraight( startPosition + new Vector3(0, 0.1f, 0) + roadAddPositionDirection * 7.62f * i ); controllerRoadStraight.transform.localRotation = roadRotation; } var controllerRoadCorner = managerRoads.CreateControllerRoadCorner( startPosition + new Vector3(0, 0.1f, 0) + roadAddPositionDirection * 7.62f * (length + offset) ); var cornerPosition = controllerRoadCorner.transform.position; return new RoadCreateResult { roadFinalPosition = new Vector3( cornerPosition.x, startPosition.y, cornerPosition.z ), }; }
private Node CreateNode(FeatureSource featureSource, RoadNetwork roadNetwork, Vertex vertex) { // Create node based on vertex. // Todo: check if it has been existed. Collection <Feature> adjacentTailNodeFeatures = GetAdjacentFeaturesOfVertex(featureSource, vertex); Node tailNode = InitializeNodeFromVeterx(vertex, adjacentTailNodeFeatures); roadNetwork.Nodes.Add(tailNode); // Loop and see if the queried shape is intersected with processing shape. foreach (Feature adjacentTailNodeFeature in adjacentTailNodeFeatures) { // Given the adjacent line is line shape, and create adjacent list without un-direction consideration. LineShape adjacentLineShape = GeometryHelper.GetLineShapes(adjacentTailNodeFeature)[0]; adjacentLineShape.Id = adjacentTailNodeFeature.Id; // Check if it's start vertext or end vertex of the adjacent line shape. int vertexIndex = 0; if (GeometryHelper.IsSamePoint(vertex, adjacentLineShape.Vertices[adjacentLineShape.Vertices.Count - 1], tolerance)) { vertexIndex = adjacentLineShape.Vertices.Count - 1; } // Todo: check if it has been existed. Collection <Feature> adjacentHeadNodeFeatures = GetAdjacentFeaturesOfVertex(featureSource, adjacentLineShape.Vertices[vertexIndex]); Node headNode = InitializeNodeFromVeterx(adjacentLineShape.Vertices[vertexIndex], adjacentHeadNodeFeatures); roadNetwork.Nodes.Add(headNode); Arc adjacentArc = new Arc(adjacentTailNodeFeature.Id, headNode, tailNode, CalculateRoadCost(adjacentLineShape)); // Check if the direction is the allowed of current segment? RoadDirection roadDirection = CalculateRoadDirection(adjacentTailNodeFeature, adjacentLineShape, vertex); if (roadDirection == RoadDirection.Forward) { tailNode.OutgoingArcs.Add(adjacentArc); } else if (roadDirection == RoadDirection.Backward) { tailNode.IncomingArcs.Add(adjacentArc); } } return(tailNode); }
public void Render(RectTransform parent, Vector2 position, Vector2 sizes) { var(unitsNumber, unitLength) = CalculateUnits(sizes); RoadDirection direction = sizes.x > sizes.y ? RoadDirection.ToRight : RoadDirection.ToUp; Vector2 unitSize = Vector2.one * unitLength; foreach (var i in Enumerable.Range(0, unitsNumber)) { var road = GameObject.Instantiate(RoadPrefab, parent); var rectTransform = road.GetComponent <RectTransform>(); rectTransform.anchorMin = Vector2.zero; rectTransform.anchorMax = Vector2.zero; rectTransform.pivot = Vector2.zero; rectTransform.anchoredPosition = position; rectTransform.sizeDelta = unitSize; position += unitLength * (direction == RoadDirection.ToRight ? Vector2.right : Vector2.up); } }
/// <summary> /// Devuelve un string que equivale a la dirección de una carretera /// </summary> /// <param name="road">Lacarretera</param> /// <returns>Un string</returns> public static string roadDirToString(RoadDirection road) { string s; switch (road) { case RoadDirection.EW: s = EW; break; case RoadDirection.NE: s = NE; break; case RoadDirection.NEWS: s = NEWS; break; case RoadDirection.NS: s = NS; break; case RoadDirection.NW: s = NW; break; case RoadDirection.SE: s = SE; break; case RoadDirection.SW: s = SW; break; default: s = ""; break; } return(s); }
private RoadDirection SimplifyDirection(RoadDirection dir) { switch (dir) { ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////From straights to straights////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case RoadDirection.up: return(RoadDirection.up); case RoadDirection.down: return(RoadDirection.down); case RoadDirection.left: return(RoadDirection.left); case RoadDirection.right: return(RoadDirection.right); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////From coners to straights///////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case RoadDirection.up_to_right: return(RoadDirection.right); case RoadDirection.down_to_right: return(RoadDirection.right); case RoadDirection.up_to_left: return(RoadDirection.left); case RoadDirection.down_to_left: return(RoadDirection.left); case RoadDirection.left_to_down: return(RoadDirection.down); case RoadDirection.left_to_up: return(RoadDirection.up); case RoadDirection.right_to_down: return(RoadDirection.down); case RoadDirection.right_to_up: return(RoadDirection.up); } return(RoadDirection.m_null); } //Takes in a RoadDirection and returns the absolute last direction. Eg Returns RoadDirection.up from input RoadDirection.right_to_up
public void CheckDirection(RoadDirection newroaddirection, Turn checkTurn) { CardinalPoint newtruckdirection = direction; switch (newroaddirection) { #region LineasRectas //LineaRecta E <-> W case RoadDirection.EW: if (direction == CardinalPoint.W) { newtruckdirection = CardinalPoint.W; } if (direction == CardinalPoint.E) { newtruckdirection = CardinalPoint.E; } break; //LineaRecta N <-> S case RoadDirection.NS: if (direction == CardinalPoint.S) { newtruckdirection = CardinalPoint.S; } if (direction == CardinalPoint.N) { newtruckdirection = CardinalPoint.N; } break; #endregion case RoadDirection.NEWS: //Todavia no hay! break; #region Curvas case RoadDirection.NE: if (direction == CardinalPoint.S) { if (checkTurn != Turn.Wide) { return; } newtruckdirection = CardinalPoint.E; } if (direction == CardinalPoint.W) { if (checkTurn != Turn.Close) { return; } newtruckdirection = CardinalPoint.N; } break; case RoadDirection.NW: if (direction == CardinalPoint.S) { if (checkTurn != Turn.Close) { return; } newtruckdirection = CardinalPoint.W; } if (direction == CardinalPoint.E) { if (checkTurn != Turn.Wide) { return; } newtruckdirection = CardinalPoint.N; } break; case RoadDirection.SE: if (direction == CardinalPoint.N) { if (checkTurn != Turn.Close) { return; } newtruckdirection = CardinalPoint.E; } if (direction == CardinalPoint.W) { if (checkTurn != Turn.Wide) { return; } newtruckdirection = CardinalPoint.S; } break; case RoadDirection.SW: if (direction == CardinalPoint.N) { if (checkTurn != Turn.Wide) { return; } newtruckdirection = CardinalPoint.W; } if (direction == CardinalPoint.E) { if (checkTurn != Turn.Close) { return; } newtruckdirection = CardinalPoint.S; } break; #endregion default: break; } if (direction != newtruckdirection) { ChangeDirection(newtruckdirection, checkTurn); } direction = newtruckdirection; }
public virtual bool IsRoadDirectionAccessable(Feature feature, RoadDirection roadDirection) { // Todo: check one-way roads is right to the specific direction. bool isRoadDirectionAccessable = false; string onewayValue = feature.ColumnValues["oneway"]; if (String.Compare(onewayValue.Trim(), "1", true, CultureInfo.InvariantCulture) == 0) { isRoadDirectionAccessable = true; } else { isRoadDirectionAccessable = false; } return isRoadDirectionAccessable; }
/// <summary> /// Selecciona que Sprites deben estar activados en función de si la carretera se puede mover. /// </summary> public void RecalculateSprites(RoadDirection RdPurple = RoadDirection.NEWS) { TurnOffAllSprites(); if (TypeOfRotation != RoadRotationType.Gold && TypeOfRotation != RoadRotationType.Purple) { return; } RoadDirection currentState = direction; RoadDirection nextState = RoadDirection.NEWS; if (TypeOfRotation == RoadRotationType.Gold) { nextState = possibleGoldRotations[0]; } if (TypeOfRotation == RoadRotationType.Purple) { if (RdPurple == RoadDirection.NEWS) { return; } nextState = RdPurple; } if (nextState == RoadDirection.NEWS) { return; } CardinalPoint[] differences; CardinalPoint[] equals = currentState.Compare(nextState, out differences, true); List <CardinalPoint> changed = new List <CardinalPoint>(); foreach (CardinalPoint dir in differences) { if (dir != CardinalPoint.None) { TurnOnArrow(dir); changed.Add(dir); } } if (TypeOfRotation == RoadRotationType.Purple) { return; } foreach (CardinalPoint dir1 in equals) { if (dir1 != CardinalPoint.None) { TurnOnEquals(dir1); changed.Add(dir1); } } if (possibleGoldRotations.Count <= 2 || TypeOfRotation != RoadRotationType.Gold) { return; } RoadDirection AfterState = possibleGoldRotations[1]; equals = nextState.Compare(AfterState, out differences, true); foreach (CardinalPoint dir in differences) { if (dir != CardinalPoint.None && (changed.Contains(dir) == false)) { //TurnOnArrowTrans(dir); changed.Add(dir); } } }
public override GameObject GetModel() { if (!_cachedPrefabs) { LoadRoadPrefabs(); } //We need to know if we have roads in 4 tile positions around this tile. //Example: We are #, tiles we want are N S E W. // 5 - - - - - // 4 - - N - - // 3 - W # E - // 2 - - S - - // y 1 - - - - - // x 0 1 2 3 4 //If a tile doesnt exist, wrong type or is out of bounds, it counts as a false reading. //Get if we have roads or not in the 4 tile positions; RoadDirection roadD = new RoadDirection(); roadD.N = CheckTileForRoad(new Vector2Int(0, 1)); roadD.E = CheckTileForRoad(new Vector2Int(1, 0)); roadD.S = CheckTileForRoad(new Vector2Int(0, -1)); roadD.W = CheckTileForRoad(new Vector2Int(-1, 0)); int numTrue = 0; if (roadD.N) { numTrue++; } if (roadD.E) { numTrue++; } if (roadD.S) { numTrue++; } if (roadD.W) { numTrue++; } //Check for road positions and decide what model to use and how to transform it (if at all). //We currently have to check for all 15 possible variations. Can be made more efficient but wont be very readable. if (numTrue == 1) { //One road piece if (roadD.N && !roadD.E && !roadD.S && !roadD.W) { _yRotationToApply = 90; return(RoadPrefabs[0]); } if (!roadD.N && roadD.E && !roadD.S && !roadD.W) { return(RoadPrefabs[0]); } if (!roadD.N && !roadD.E && roadD.S && !roadD.W) { _yRotationToApply = 90; return(RoadPrefabs[0]); } if (!roadD.N && !roadD.E && !roadD.S && roadD.W) { return(RoadPrefabs[0]); } } else if (numTrue == 2) { //Two road pieces if (roadD.N && !roadD.E && roadD.S && !roadD.W) { _yRotationToApply = 90; return(RoadPrefabs[0]); } if (!roadD.N && roadD.E && !roadD.S && roadD.W) { return(RoadPrefabs[0]); } if (roadD.N && roadD.E && !roadD.S && !roadD.W) { _yRotationToApply = 90; return(RoadPrefabs[3]); } if (!roadD.N && roadD.E && roadD.S && !roadD.W) { _yRotationToApply = 180; return(RoadPrefabs[3]); } if (!roadD.N && !roadD.E && roadD.S && roadD.W) { _yRotationToApply = -90; return(RoadPrefabs[3]); } if (roadD.N && !roadD.E && !roadD.S && roadD.W) { return(RoadPrefabs[3]); } } else if (numTrue == 3) { //Three road pieces if (!roadD.N && roadD.E && roadD.S && roadD.W) { _yRotationToApply = -90; return(RoadPrefabs[2]); } if (roadD.N && !roadD.E && roadD.S && roadD.W) { return(RoadPrefabs[2]); } if (roadD.N && roadD.E && !roadD.S && roadD.W) { _yRotationToApply = 90; return(RoadPrefabs[2]); } if (roadD.N && roadD.E && roadD.S && !roadD.W) { _yRotationToApply = 180; return(RoadPrefabs[2]); } } //If none are true, return the 4 way piece return(RoadPrefabs[1]); }
/// <summary> /// Cambia el material de la carretera /// </summary> /// <param name="dir"></param> public void ChangeVisuals(RoadDirection dir, GraphicQualitySettings GQS = GraphicQualitySettings.None, string LowIMGPath = "") { if (isClickable && TypeOfRotation == RoadRotationType.Green) { dir = RoadDirection.NE; } if (isClickable && TypeOfRotation == RoadRotationType.Blue) { dir = RoadDirection.EW; } if (LowIMGPath == "") { if (GameConfig.s == null) { LowIMGPath = "IMG\\LowIMGs\\"; } if (GameConfig.s != null) { LowIMGPath = GameConfig.s.LowIMGPath; } } if (GQS == GraphicQualitySettings.None) { if (sProfileManager.ProfileSingleton == null) {//we are probably at editor time, we change all roads ChangeVisuals(dir, GraphicQualitySettings.High, LowIMGPath); ChangeVisuals(dir, GraphicQualitySettings.Low, LowIMGPath); //Debug.Log("ChangingVisuals: EditorTime"); return; } else { //Debug.Log("ChangingVisuals: PlayTime"); GQS = sProfileManager.ProfileSingleton.GlobalGraphicQualitySettings; } } else { //Debug.Log("ChangingVisuals: PlayTime 2 "+ dir.ToString()); } if (PermanentVisuals) { return; } switch (GQS) { case GraphicQualitySettings.Low: //Low Quality using old Materials Sprite sprite = (Sprite)Resources.Load <Sprite>(LowIMGPath + "sprite_" + roadDirToString(dir)); if (myRoadLow != null) { myRoadLow.sprite = sprite; } break; case GraphicQualitySettings.Medium: Sprite sprite1 = (Sprite)Resources.Load <Sprite>(LowIMGPath + "sprite_" + roadDirToString(dir)); if (myRoadLow != null) { myRoadLow.sprite = sprite1; } break; case GraphicQualitySettings.High: //High Quality using PicaVoxel if (myRoad != null) { myRoad.SetFrame((int)dir); } break; default: break; } }
public Road(int row, int column, RoadDirection roadDirection) { Row = row; Column = column; RoadDirection = roadDirection; }
private bool CheckCollision(RoadDirection dir, Vector2 pos, Vector2[] roadsPos, ref Vector2 m_checked) { Vector2 CheckedPos; bool found; switch (dir) { case RoadDirection.up: CheckedPos = new Vector2(pos.x, pos.y + inGameUnitsSize); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.down: CheckedPos = new Vector2(pos.x, pos.y - inGameUnitsSize); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.right: CheckedPos = new Vector2(pos.x + inGameUnitsSize, pos.y); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.left: CheckedPos = new Vector2(pos.x - inGameUnitsSize, pos.y); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.left_to_up: CheckedPos = new Vector2(pos.x, pos.y + inGameUnitsSize); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.right_to_up: CheckedPos = new Vector2(pos.x, pos.y + inGameUnitsSize); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.left_to_down: CheckedPos = new Vector2(pos.x, pos.y - inGameUnitsSize); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.right_to_down: CheckedPos = new Vector2(pos.x, pos.y - inGameUnitsSize); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.down_to_right: CheckedPos = new Vector2(pos.x + inGameUnitsSize, pos.y); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.up_to_right: CheckedPos = new Vector2(pos.x + inGameUnitsSize, pos.y); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.down_to_left: CheckedPos = new Vector2(pos.x - inGameUnitsSize, pos.y); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); case RoadDirection.up_to_left: CheckedPos = new Vector2(pos.x - inGameUnitsSize, pos.y); m_checked = CheckedPos; found = CheckVecArray(CheckedPos, roadsPos); return(found); } return(false); }
public void SetDirection(RoadDirection direction) { ArgumentException AE = new ArgumentException("Direction \"" + direction.ToString() + "\" is not compatible with road type " + this.type.ToString() + "."); switch (this.type) { case RoadType.Straight: if (direction == RoadDirection.Vertical) { transform.localEulerAngles = new Vector3(90, 0, 0); } else if (direction == RoadDirection.Horizontal) { transform.localEulerAngles = new Vector3(90, 0, 270); } else { throw AE; } break; case RoadType.End: if (direction == RoadDirection.North) { transform.localEulerAngles = new Vector3(90, 0, 180); } else if (direction == RoadDirection.South) { transform.localEulerAngles = new Vector3(90, 0, 0); } else if (direction == RoadDirection.East) { transform.localEulerAngles = new Vector3(90, 0, 90); } else if (direction == RoadDirection.West) { transform.localEulerAngles = new Vector3(90, 0, 270); } else { throw AE; } break; case RoadType.Corner: if (direction == RoadDirection.NorthEast) { transform.localEulerAngles = new Vector3(90, 0, 90); } else if (direction == RoadDirection.NorthWest) { transform.localEulerAngles = new Vector3(90, 0, 180); } else if (direction == RoadDirection.SouthEast) { transform.localEulerAngles = new Vector3(90, 0, 0); } else if (direction == RoadDirection.SouthWest) { transform.localEulerAngles = new Vector3(90, 0, 270); } else { throw AE; } break; case RoadType.Cross_T: if (direction == RoadDirection.North) { transform.localEulerAngles = new Vector3(90, 0, 90); } else if (direction == RoadDirection.South) { transform.localEulerAngles = new Vector3(90, 0, 270); } else if (direction == RoadDirection.East) { transform.localEulerAngles = new Vector3(90, 0, 0); } else if (direction == RoadDirection.West) { transform.localEulerAngles = new Vector3(90, 0, 180); } else { throw AE; } break; case RoadType.Cross_X: if (direction != RoadDirection.None) { throw AE; } break; case RoadType.Single: if (direction == RoadDirection.None) { transform.localEulerAngles = new Vector3(90, 0, 0); } else { throw AE; } break; } this.direction = direction; //SetPoints(); }
public static string ToAddress(this RoadDirection direction) { return($"Assets/Tileset/{direction.ToString().ToLowerKebabCase()}.asset"); }
public static bool IsSouth(this RoadDirection value) { return(value == RoadDirection.SE || value == RoadDirection.SW); }
public RoadDirectionChangeCommand(Ground ground, RoadDirection oldDirection, RoadDirection newDirection) { this.ground = ground; this.oldDirection = oldDirection; this.newDirection = newDirection; }
public static bool IsNorth(this RoadDirection value) { return(value == RoadDirection.NE || value == RoadDirection.NW); }