/// <summary> /// Activate this lane /// </summary> /// <param name="rowNumber">Indacates how far into the map the lane is</param> /// <param name="prevPassableTileArray">Passable tile array of the previous lane</param> /// <param name="prevDir">Direction of previous lane</param> public override void Activate(int rowNumber, bool[] prevPassableTileArray, LaneDirection prevDir) { base.Activate(rowNumber, prevPassableTileArray, prevDir); DeactivateWarningLights(); CreateTrain(); SpawnCoin(); }
public RoadLane(Road road, LaneDirection lanedirection, LaneType lanetype, int laneindex, double width, double translation) { int colorindex; if (lanedirection == LaneDirection.Backward) colorindex = laneindex; else colorindex = -laneindex - 1; curvecolor = Colors.GetSaturatedColor(colorindex); ILaneContainer = road; LaneDirection = lanedirection; LaneIndex = laneindex; LaneType = lanetype; linecolor = road.LineColor; this.road = road; roadcolor = road.RoadColor; this.translation = translation; vehiclelist = new List<Vehicle>(); Width = width; setbeziers(); setgaplengths(); Length = beziers.Sum(bezier => bezier.Length); spawndistance = 2*road.GetMaximumSpeed("Vehicle")/beziers[0].Length; }
/// <summary> /// Activate this lane /// </summary> /// <param name="rowNumber">Indacates how far into the map the lane is</param> /// <param name="prevPassableTileArray">Passable tile array of the previous lane</param> /// <param name="prevDir">Direction of previous lane</param> public override void Activate(int rowNumber, bool[] prevPassableTileArray, LaneDirection prevDir) { base.Activate(rowNumber, prevPassableTileArray, prevDir); CreateEdgeItems(); CreateObstacles(rowNumber, prevPassableTileArray); if (rowNumber > 1) { SpawnCoin(); } }
/// <summary> /// Positions the new lane and activates it /// </summary> /// <param name="newLane"></param> protected void ActivateLane(Lane newLane) { float laneZPos = (m_startRowCoord + m_currentCount) * m_mapManager.TileSize; newLane.transform.SetPosZ(laneZPos); newLane.gameObject.SetActive(true); newLane.Activate(m_startRowCoord + m_currentCount, m_prevPassableTileArray, m_prevDir); m_prevPassableTileArray = newLane.PassableActiveTileArray; m_prevDir = newLane.Direction; m_currentCount++; }
/// <summary> /// Creates platforms /// </summary> private void CreatePlatforms(bool[] prevPassableTileArray, LaneDirection prevDir) { // Determine whether to spawn logs or lily pads if (Random.value <= m_lilyPadLaneProb) { SpawnLilyPads(prevPassableTileArray, prevDir); } else { StartLogSpawning(prevPassableTileArray, prevDir); } }
/* * Spawns a random enemy */ void SpawnEnemy() { if (normalVehicles.Count > 0 && emergencyVehicles.Count > 0) { GameObject vehicle = normalVehicles[0]; LaneDirection laneDirection = null; // diferentiate between avenue or normal road if (avenue) { Lane lane = (Lane)Random.Range(2, 6); laneDirection = GetVehicleStartPointOnLane(lane); } else { Lane lane = (Lane)Random.Range(0, 2); laneDirection = GetVehicleStartPointOnLane(lane); } // generates emergency vehicle if (Random.value < Constants.Probability.ProbabilityLow) { vehicle = emergencyVehicles[Random.Range(0, emergencyVehicles.Count)]; } else // generates normal vehicle { vehicle = normalVehicles[Random.Range(0, normalVehicles.Count)]; } // instantiates enemy at position GameObject enemy = InstantiateSceneObject(vehicle, laneDirection.startPosition); // saves new enemy on the list vehiclesOnLanes.Add(enemy); // sets the direction and orders to go VehicleController model = enemy.GetComponent <VehicleController>(); model.SetDirection(laneDirection.direction); model.Go(); } }
public static LaneDirection GetEndDirection(LaneDirection direction) { // Converts a turn lane direction into an end direction. ex. west_south turns into south_south string[] directions = direction.ToString().Split(new char[1] { '_' }); // index 0 is from direction, index 1 is to direction switch (directions[1]) { case "north": return(LaneDirection.north_north); case "south": return(LaneDirection.south_south); case "east": return(LaneDirection.east_east); case "west": return(LaneDirection.west_west); } return(direction); }
/// <summary> /// Creates vehicles /// </summary> private void CreateVehicles(LaneDirection prevDir) { // Determine a random "regular" vehicle type VehicleType vehType = (VehicleType)Random.Range(0, (int)VehicleType.Train); Vehicle vehSample = m_mapAssetPool.GetVehicleAssetPool(vehType).GetAsset(); // Determine speed and no. of vehicles float speed = vehSample.GetRandomSpeed(); float spaceBetweenVehicles = Random.Range(m_minSpace, m_maxSpace) * m_tileSize; float totalMoveSpace = (m_activeTileCount + (m_edgeTileCount * 2.0f)) * m_tileSize; float vehicleAndSpaceSize = spaceBetweenVehicles + vehSample.VehicleLength; totalMoveSpace += vehSample.VehicleLength; int vehicleCount = Mathf.FloorToInt(totalMoveSpace / vehicleAndSpaceSize); // Randomly determine lane direction // Determine log direction switch (prevDir) { case LaneDirection.NONE: // Random direction m_direction = (Random.Range(0, 2) == 1) ? LaneDirection.RIGHT : LaneDirection.LEFT; break; case LaneDirection.LEFT: case LaneDirection.RIGHT: if (Random.value <= m_oppositeDirProb) { m_direction = (prevDir == LaneDirection.LEFT) ? LaneDirection.RIGHT : LaneDirection.LEFT; } else { m_direction = prevDir; } break; } // Spawn the vehicles properly spaced apart Vector3 pos1 = new Vector3(totalMoveSpace * -0.5f, m_height, 0f) + transform.position; Vector3 pos2 = new Vector3(totalMoveSpace * 0.5f, m_height, 0f) + transform.position; if (m_direction == LaneDirection.LEFT) { Vector3 temp = pos1; pos1 = pos2; pos2 = temp; } // Create the array of vehicles m_vehicles = new Vehicle[vehicleCount]; m_vehicles[0] = vehSample; m_vehicles[0].gameObject.SetActive(true); m_vehicles[0].SetMapManagerInstance(m_mapManager); m_vehicles[0].StartMovement(speed, pos1, pos2, 0f); for (int i = 1; i < vehicleCount; ++i) { m_vehicles[i] = m_mapAssetPool.GetVehicleAssetPool(vehType).GetAsset(); m_vehicles[i].gameObject.SetActive(true); float timeFactor = i / (float)vehicleCount; m_vehicles[i].SetMapManagerInstance(m_mapManager); m_vehicles[i].StartMovement(speed, pos1, pos2, timeFactor); } }
/// <summary> /// Activate this lane /// </summary> /// <param name="rowNumber">Indacates how far into the map the lane is</param> /// <param name="prevPassableTileArray">Passable tile array of the previous lane</param> /// <param name="prevDir">Direction of previous lane</param> public virtual void Activate(int rowNumber, bool[] prevPassableTileArray, LaneDirection prevDir) { Reset(); m_isActivated = true; }
public Lane(LaneType type, LaneDirection direction, float width) { Type = type; Direction = direction; Width = width; }
/// <summary> /// Activate this lane /// </summary> /// <param name="rowNumber">Indacates how far into the map the lane is</param> /// <param name="prevPassableTileArray">Passable tile array of the previous lane</param> /// <param name="prevDir">Direction of previous lane</param> public override void Activate(int rowNumber, bool[] prevPassableTileArray, LaneDirection prevDir) { base.Activate(rowNumber, prevPassableTileArray, prevDir); PlayRiverSound(); CreatePlatforms(prevPassableTileArray, prevDir); }
public int GetLaneCount(LaneDirection lanedirection) { return lanelist.Count(lane => lane.LaneDirection == lanedirection); }
/// <summary> /// Sets the previous lane direction /// </summary> public void SetPrevLaneDirection(LaneDirection prevDir) { m_prevDir = prevDir; }
/// <summary> /// Start spawning logs /// </summary> private void StartLogSpawning(bool[] prevPassableTileArray, LaneDirection prevDir) { // Set a random spawn time m_spawnTime = Random.Range(m_minSpawnTime, m_maxSpawnTime); m_spawnTimer = Random.Range(0f, m_spawnTime); // Determine log direction switch (prevDir) { case LaneDirection.NONE: // Random direction m_direction = (Random.Range(0, 2) == 1) ? LaneDirection.RIGHT : LaneDirection.LEFT; break; case LaneDirection.LEFT: case LaneDirection.RIGHT: if (Random.value <= m_oppositeDirProb) { m_direction = (prevDir == LaneDirection.LEFT) ? LaneDirection.RIGHT : LaneDirection.LEFT; } else { m_direction = prevDir; } break; } // Update passable tiles if (m_direction == LaneDirection.RIGHT) { // Rightward m_isActiveTilePassable[0] = false; for (int i = 1; i < m_activeTileCount; ++i) { m_isActiveTilePassable[i] = m_isActiveTilePassable[i - 1] || prevPassableTileArray[i]; } } else { // Leftward m_isActiveTilePassable[m_activeTileCount - 1] = false; for (int i = m_activeTileCount - 2; i <= 0; --i) { m_isActiveTilePassable[i] = m_isActiveTilePassable[i + 1] || prevPassableTileArray[i]; } } // Determine log speed m_logSpeed = Random.Range(m_minSpeed, m_maxSpeed); // Ready the log list if (m_logs != null) { m_logs.Clear(); } else { m_logs = new List <Log>(); } // Determine log movement positions // Left int tileCountToEdge = Mathf.FloorToInt(m_activeTileCount * 0.5f) + 1; m_activeLeftPos = new Vector3(tileCountToEdge * -m_tileSize, m_height, transform.position.z); m_edgeLeftPos = new Vector3(m_activeLeftPos.x + (m_edgeTileCount * -m_tileSize), m_height, transform.position.z); // Right tileCountToEdge = Mathf.FloorToInt(m_activeTileCount * 0.5f); if (m_activeTileCount % 2 != 0) { tileCountToEdge++; } m_activeRightPos = new Vector3(tileCountToEdge * m_tileSize, m_height, transform.position.z); m_edgeRightPos = new Vector3(m_activeRightPos.x + (m_edgeTileCount * m_tileSize), m_height, transform.position.z); // Create logs to fill the initial space float randomXPos = Random.Range(m_activeLeftPos.x + m_tileSize * 3f, 0f); Vector3 startPos = new Vector3(randomXPos, m_height, transform.position.z); CreateLog(true, startPos); randomXPos = Random.Range(m_tileSize * 3f, m_activeRightPos.x); startPos = new Vector3(randomXPos, m_height, transform.position.z); CreateLog(true, startPos); }
/// <summary> /// Spawns lily pads /// </summary> private void SpawnLilyPads(bool[] prevPassableTileArray, LaneDirection prevDir) { m_direction = LaneDirection.NONE; // Check the list of passable tiles and choose a path where you can pass // Choose the center tile by default int mainPassableTile = Mathf.FloorToInt(m_activeTileCount * 0.5f); if (prevPassableTileArray != null) { List <int> passableTiles = new List <int>(prevPassableTileArray.Length); for (int i = 0; i < prevPassableTileArray.Length; ++i) { if (prevPassableTileArray[i]) { passableTiles.Add(i); } } for (int i = 6; i >= 0; --i) { if (passableTiles.Count > i) { // Avoid the edge columns if possible int j = i / 2; mainPassableTile = passableTiles[Random.Range(j, passableTiles.Count - j)]; break; } } } // Create the lily pad array m_lilyPads = new Platform[m_maxLilyPadCount]; // Spawn the lily pads int lilyPadCount = 0; float leftmostXPos = Mathf.FloorToInt(m_activeTileCount * 0.5f) * -m_tileSize; Vector3 leftmostPosition = new Vector3(leftmostXPos, m_height, 0f) + transform.position; // TODO: Make spawning logic better for (int i = 0; i < m_activeTileCount; ++i) { bool spawnFlag = false; // Determine whether to spawn if (i == mainPassableTile) { spawnFlag = true; } else { float prob = Random.value; if (prevPassableTileArray[i]) { if (prob <= m_lilyPadProbOpen && lilyPadCount < m_maxLilyPadCount - 1) { spawnFlag = true; } } else { if (prob <= m_lilyPadProbClosed && lilyPadCount < m_maxLilyPadCount - 1) { spawnFlag = true; } } } if (spawnFlag) { // Spawn a lily pad and position it correctly m_lilyPads[lilyPadCount] = m_mapAssetPool.GetPlatformAssetPool(MapItemType.LilyPad).GetAsset(); m_lilyPads[lilyPadCount].transform.position = leftmostPosition + (Vector3.right * i * m_tileSize); m_lilyPads[lilyPadCount].gameObject.SetActive(true); m_lilyPads[lilyPadCount].Activate(); // Temporarily indicate where lily pads are m_isActiveTilePassable[i] = true; // Spawn a coin SpawnCoin(m_lilyPads[lilyPadCount]); lilyPadCount++; } else { // If no lily pad spawned, tile is not passable m_isActiveTilePassable[i] = false; } } // Evaluate passable tiles branching from the main tile m_isActiveTilePassable[mainPassableTile] = true; // Leftward for (int i = mainPassableTile - 1; i >= 0; --i) { m_isActiveTilePassable[i] = m_isActiveTilePassable[i] && (m_isActiveTilePassable[i + 1] || prevPassableTileArray[i]); } // Rightward for (int i = mainPassableTile + 1; i < m_activeTileCount; ++i) { m_isActiveTilePassable[i] = m_isActiveTilePassable[i] && (m_isActiveTilePassable[i - 1] || prevPassableTileArray[i]); } }
/// <summary> /// Activate this lane /// </summary> /// <param name="rowNumber">Indacates how far into the map the lane is</param> /// <param name="prevPassableTileArray">Passable tile array of the previous lane</param> /// <param name="prevDir">Direction of previous lane</param> public override void Activate(int rowNumber, bool[] prevPassableTileArray, LaneDirection prevDir) { base.Activate(rowNumber, prevPassableTileArray, prevDir); CreateVehicles(prevDir); SpawnCoin(); }
public TrafficLane(SDL.SDL_Point origin, SDL.SDL_Point endPoint, LaneDirection direction) { Origin = origin; EndPoint = endPoint; Direction = direction; }
private void addlane(LaneDirection lanedirection, LaneType lanetype) { List<RoadLane> sublanelist = lanelist.Where(l => l.LaneDirection == lanedirection).ToList(); sublanelist.Sort((l1, l2) => l1.LaneIndex.CompareTo(l2.LaneIndex)); double translation = sublanelist.Sum(l => l.Width); translation += roaddata.LaneWidth/2; var lane = new RoadLane(this, lanedirection, lanetype, lanelist.Count(l => l.LaneDirection == lanedirection), roaddata.LaneWidth, translation); if (sublanelist.Count > 0 && lane.LaneType != LaneType.Shoulder) { lane.LeftLane = sublanelist[sublanelist.Count - 1]; sublanelist[sublanelist.Count - 1].RightLane = lane; } lanelist.Add(lane); }