public override void OnEndDrag(PointerEventData eventData)
{
Vector2Int final_tilemap_position = GameManager.get_selected_tile(eventData.position);
Station_Track st = TrackManager.get_station_from_location(final_tilemap_position, CityManager.Activated_City_Component);
string vehicle_type = clicked_item.tag;
Destroy(clicked_item);
if (GameManager.is_tutorial_mode)
{
bool is_wrong_place;
if (vehicle_type == "train")
{
is_wrong_place = GameManager.tutorial_manager.is_click_in_wrong_place(final_tilemap_position, 4);
}
else
{
is_wrong_place = GameManager.tutorial_manager.is_click_in_wrong_place(final_tilemap_position);
}
if (is_wrong_place)
{
return;
}
}
if (st == null)
{
return; // not a valid station
}
if (vehicle_type == "home" || vehicle_type == "work" || vehicle_type == "vacation" || vehicle_type == "food")
{
if (st.train == null || !st.train.GetComponent <Train>().is_wait_for_turntable || !st.train.GetComponent <Train>().is_boxcar_within_max_limit())
{
return; // no train at this station
}
VehicleManager.instance.add_boxcar_to_train(st.train.GetComponent <Train>(), vehicle_type);
}
else if (vehicle_type.Contains("train"))
{
RouteManager.Orientation train_orientation = TrackManager.flip_straight_orientation(st.station.orientation);
VehicleManager.instance.create_vehicle_at_home_base(train_orientation, st);
}
else
{
throw new Exception("nto a valid vehicle type");
}
VehicleManager.update_vehicle_count(vehicle_type, -1); // "home", "food", "work", "vacation"
update_inventory();
if (VehicleManager.get_vehicle_count(vehicle_type) == 0)
{
RawImage raw_image = clicked_go.GetComponent <RawImage>();
raw_image.texture = empty_inventory_bubble;
}
}
public void Start()
{
board_desire_timeout = 120;
trip_desire_timeout = 300;
in_tile = true;
arrived_at_room = true;
is_egghead_thinking = true;
location = "station"; // person is spawned at station
enter_home_orientation = RouteManager.Orientation.None; // initialized on enter home sequence
final_dest_tile_pos = new Vector3Int(-1, -1, 0);
board_start_time = Time.time;
StartCoroutine(does_person_give_up());
}
public bool hide_exit_route(RouteManager.Orientation orientation, City city, Tilemap exit_tilemap)
{
Vector3Int city_loc = city.get_location();
Vector3Int loc;
if (orientation == RouteManager.Orientation.North)
{
loc = new Vector3Int(city_loc.x, city_loc.y + 1, city_loc.z);
}
else if (orientation == RouteManager.Orientation.East)
{
loc = new Vector3Int(city_loc.x + 1, city_loc.y, city_loc.z);
}
else if (orientation == RouteManager.Orientation.West)
{
loc = new Vector3Int(city_loc.x - 1, city_loc.y, city_loc.z);
}
else if (orientation == RouteManager.Orientation.South)
{
loc = new Vector3Int(city_loc.x, city_loc.y - 1, city_loc.z);
}
else
{
throw new Exception("not a valid orientation");
}
Tilemap track_tilemap = TrackManager.instance.top_tilemap;
Tile tile_type = (Tile)track_tilemap.GetTile(loc);
if (tile_type == null) // todo: an additional check that exit track orientation is correct
{
exit_tilemap.GetComponent <TilemapRenderer>().enabled = false;
return(true);
}
else
{
if ((orientation == RouteManager.Orientation.South && (tile_type.name == "vert" || tile_type.name == "WN" || tile_type.name == "NE")) ||
(orientation == RouteManager.Orientation.North && (tile_type.name == "vert" || tile_type.name == "WS" || tile_type.name == "ES")) ||
(orientation == RouteManager.Orientation.East && (tile_type.name == "hor" || tile_type.name == "WN" || tile_type.name == "WS")) ||
(orientation == RouteManager.Orientation.West && (tile_type.name == "hor" || tile_type.name == "NE" || tile_type.name == "ES")))
{
exit_tilemap.GetComponent <TilemapRenderer>().enabled = true;
return(false);
}
else
{
exit_tilemap.GetComponent <TilemapRenderer>().enabled = false;
return(true);
}
}
}
protected Vector2 transform_curve(Vector2 bezier_position, RouteManager.Orientation orientation, RouteManager.Orientation final_orientation)
{
// transform the coord of bezier curve so it matches shape of appropriate track
if (orientation == RouteManager.Orientation.North && final_orientation == RouteManager.Orientation.East)
{
return(bezier_position);
}
else if ((orientation == RouteManager.Orientation.South && final_orientation == RouteManager.Orientation.East) ||
final_orientation == RouteManager.Orientation.ne_SteepCurve || final_orientation == RouteManager.Orientation.ne_LessSteepCurve)
{
bezier_position[1] = -bezier_position[1];
}
else if ((orientation == RouteManager.Orientation.North && final_orientation == RouteManager.Orientation.West) ||
final_orientation == RouteManager.Orientation.sw_SteepCurve || final_orientation == RouteManager.Orientation.sw_LessSteepCurve)
{
bezier_position[0] = -bezier_position[0];
}
else if ((orientation == RouteManager.Orientation.South && final_orientation == RouteManager.Orientation.West) ||
final_orientation == RouteManager.Orientation.nw_SteepCurve || final_orientation == RouteManager.Orientation.nw_LessSteepCurve)
{
bezier_position[0] = -bezier_position[0];
bezier_position[1] = -bezier_position[1];
}
else if (orientation == RouteManager.Orientation.East && final_orientation == RouteManager.Orientation.South)
{ // rotate curve 90 degrees counter clockwise
float temp_x = bezier_position[0];
bezier_position[0] = bezier_position[1];
bezier_position[1] = -temp_x;
}
else if (orientation == RouteManager.Orientation.East && final_orientation == RouteManager.Orientation.North)
{
float temp_x = bezier_position[0];
bezier_position[0] = bezier_position[1];
bezier_position[1] = temp_x;
}
else if (orientation == RouteManager.Orientation.West && final_orientation == RouteManager.Orientation.South)
{
float temp_x = bezier_position[0];
bezier_position[0] = -bezier_position[1];
bezier_position[1] = -temp_x;
}
else if (orientation == RouteManager.Orientation.West && final_orientation == RouteManager.Orientation.North)
{
float temp_x = bezier_position[0];
bezier_position[0] = -bezier_position[1];
bezier_position[1] = temp_x;
}
return(bezier_position);
}
public static float get_exit_dist(RouteManager.Orientation orientation)
{
if (orientation == RouteManager.Orientation.West || orientation == RouteManager.Orientation.East)
{
return(exit_dest_west_east);
}
else if (orientation == RouteManager.Orientation.North || orientation == RouteManager.Orientation.South)
{
return(exit_dest_north_south);
}
else
{
throw new Exception(orientation + " is not a valid exit destination");
}
}
public IEnumerator one_time_bezier_move(Boxcar prev_boxcar)
{
prev_boxcar.train.is_boxcar_filling_void = true;
Vector3 prev_destination = prev_boxcar.train_destination;
Vector3Int prev_boxcar_position = prev_boxcar.tile_position;
RouteManager.Orientation prev_orientation = prev_boxcar.orientation;
yield return(StartCoroutine(bezier_move(transform, orientation, prev_boxcar.orientation)));
orientation = prev_orientation;
tile_position = prev_boxcar_position;
next_tilemap_position = (Vector2Int)prev_boxcar_position;
prev_tile_position = prev_boxcar_position;
train_destination = prev_destination;
prev_boxcar.train.is_boxcar_filling_void = false;
}
public static RouteManager.Orientation is_curve_steep(RouteManager.Orientation orientation)
{
if (orientation == RouteManager.Orientation.ne_SteepCurve || orientation == RouteManager.Orientation.nw_SteepCurve ||
orientation == RouteManager.Orientation.sw_SteepCurve || orientation == RouteManager.Orientation.se_SteepCurve)
{
return(RouteManager.Orientation.Steep_Angle);
}
else if (orientation == RouteManager.Orientation.ne_LessSteepCurve || orientation == RouteManager.Orientation.nw_LessSteepCurve ||
orientation == RouteManager.Orientation.sw_LessSteepCurve || orientation == RouteManager.Orientation.se_LessSteepCurve)
{
return(RouteManager.Orientation.Less_Steep_Angle);
}
else
{
return(RouteManager.Orientation.Right_Angle);
}
}
public Station get_station_by_orientation(RouteManager.Orientation orientation)
{
switch (orientation)
{
case RouteManager.Orientation.East:
return(East_Station);
case RouteManager.Orientation.West:
return(West_Station);
case RouteManager.Orientation.North:
return(North_Station);
case RouteManager.Orientation.South:
return(South_Station);
}
throw new Exception("not a valid orientation");
}
public Station(Vector3Int outer_start, Vector3Int inner_start, RouteManager.Orientation orientation, Tilemap outer_track_tilemap, Tilemap inner_track_tilemap)
{
this.orientation = orientation;
outer_track = new Station_Track();
outer_track.inner = 0;
outer_track.tilemap = outer_track_tilemap;
outer_track.start_location = outer_start;
outer_track.train = null;
outer_track.station = this;
inner_track = new Station_Track();
inner_track.inner = 1;
inner_track.tilemap = inner_track_tilemap;
inner_track.start_location = inner_start;
inner_track.train = null;
inner_track.station = this;
}
public void create_vehicle_at_home_base(RouteManager.Orientation orientation, Station_Track st)
{
// buying a new train in MenuManager
train_counter++;
GameObject new_train = Instantiate(Train);
Train_List.Add(new_train);
Train train_component = new_train.GetComponent <Train>();
train_component.initialize_orientation(orientation);
train_component.in_city = true;
train_component.set_id(train_counter);
train_component.set_city(CityManager.home_base); // new vehicles always created at home base
place_vehicle(new_train); // place the vehicle, which proceeds to depart
train_component.station_track = st;
train_component.init_arrive_at_city(st); // call immediately on instantiation. Otherwise, in_city = false and the wrong board is updated
//st.train = new_train; BUG! If a train collides with one which is first
}
public List <int[]> get_parking_list()
{
RouteManager.Orientation orientation = station_track.station.orientation;
int is_inner = station_track.inner; // 0 means no, 1 means yes
List <int> parking_coord = TrackManager.parking_coord_map[orientation];
int y = parking_coord[0];
int start_x = parking_coord[1];
int end_x = parking_coord[2];
List <int[]> valid_parking_coord_list = new List <int[]>();
for (int i = start_x; i < end_x; i++)
{
if (city.gameobject_board[i, y] == null) // parking spot is available
{
valid_parking_coord_list.Add(new int[] { i, y });
}
}
return(valid_parking_coord_list);
}
public void click_room(PointerEventData eventData)
{
// get station
// get adjacent boarding track
// if train is on track, then search for appropriate boxcars on track
all_eligible_boxcar = new List <Offset_Tile>();
List <string> train_hint_list = new List <string>();
Vector2Int selected_tile = GameManager.get_selected_tile(eventData.position);
// get room, and check if it is occupied before boarding
//get person
Room room = CityManager.Activated_City_Component.get_selected_room(selected_tile);
bool is_room_occupied = CityManager.Activated_City_Component.is_selected_room_occupied(room);
string building_type = CityManager.Activated_City_Component.city_type;
if (is_room_occupied)
{
Person person = room.person_go_instance.GetComponent <Person>();
person.is_selected = true;
Station cb_station = CityManager.Activated_City_Component.get_station_track(selected_tile).station;
RouteManager.Orientation orientation = cb_station.orientation;
bool is_outer_track_valid = is_track_contain_valid_boxcar(true, cb_station, building_type);
bool is_inner_track_valid = is_track_contain_valid_boxcar(false, cb_station, building_type);
if (is_outer_track_valid || is_inner_track_valid)
{
List <int[]> inner_outer_coord = new List <int[]>();
if (is_outer_track_valid)
{
List <int[]> available_outer_track_vehicle = filter_available_boxcar(TrackManager.add_to_train_coord_map[orientation][0], person);
inner_outer_coord.AddRange(available_outer_track_vehicle);
}
if (is_inner_track_valid)
{
List <int[]> available_inner_track_vehicle = filter_available_boxcar(TrackManager.add_to_train_coord_map[orientation][1], person);
inner_outer_coord.AddRange(available_inner_track_vehicle);
}
List <List <int[]> > city_action_coord = new List <List <int[]> > {
inner_outer_coord
};
train_hint_list.Add("board");
GameObject.Find("GameManager").GetComponent <GameManager>().mark_tile_as_eligible(city_action_coord, train_hint_list, gameObject, true);
}
}
}
public Station_Track add_train_to_station(GameObject train_object, RouteManager.Orientation orientation)
{
switch (orientation)
{
case RouteManager.Orientation.North:
return(South_Station.set_station_track(train_object));
case RouteManager.Orientation.East:
return(West_Station.set_station_track(train_object));
case RouteManager.Orientation.West:
return(East_Station.set_station_track(train_object));
case RouteManager.Orientation.South:
return(North_Station.set_station_track(train_object));
default:
return(null);
}
}
public static RouteManager.Orientation flip_straight_orientation(RouteManager.Orientation orientation)
{
switch (orientation)
{
case RouteManager.Orientation.East:
return(RouteManager.Orientation.West);
case RouteManager.Orientation.West:
return(RouteManager.Orientation.East);
case RouteManager.Orientation.North:
return(RouteManager.Orientation.South);
case RouteManager.Orientation.South:
return(RouteManager.Orientation.North);
default:
return(RouteManager.Orientation.None);
}
}
public IEnumerator turn_turntable(GameObject train_object, RouteManager.Orientation end_orientation, bool depart_for_turntable, City city = null)
{
////print("end orientation of turntable is " + end_orientation);
float turn_angle = get_turntable_rotation(end_orientation);
float t_param = 0;
float start_angle = transform.eulerAngles.z;
float end_angle = start_angle + turn_angle;
while (t_param < 1)
{
t_param += Time.deltaTime * turntable_speed_multiplier;
float angle = Mathf.LerpAngle(start_angle, end_angle, t_param);
transform.eulerAngles = new Vector3(0, 0, angle);
yield return(new WaitForEndOfFrame());
}
Train train = train_object.GetComponent <Train>();
train.GetComponent <CapsuleCollider2D>().size = new Vector2(.205f, .837f);
train.board_turntable(end_orientation, depart_for_turntable, city);
}
public static bool is_exit_route_shown(RouteManager.Orientation orientation)
{
//todo
switch (orientation)
{
case RouteManager.Orientation.North:
return(RouteManager.exit_north_tilemap.GetComponent <TilemapRenderer>().enabled);
case RouteManager.Orientation.East:
return(RouteManager.exit_east_tilemap.GetComponent <TilemapRenderer>().enabled);
case RouteManager.Orientation.West:
return(RouteManager.exit_west_tilemap.GetComponent <TilemapRenderer>().enabled);
case RouteManager.Orientation.South:
return(RouteManager.exit_south_tilemap.GetComponent <TilemapRenderer>().enabled);
default:
return(false);
}
}
public void unload_train(GameObject boxcar_go, Vector2Int room_position)
{
Boxcar boxcar = boxcar_go.GetComponent <Boxcar>();
Person person = boxcar.passenger_go.GetComponent <Person>();
person.offset_map = RouteManager.offset_route_map[boxcar.station_track.start_location];
person.is_enter_home = true;
Room room = city_room_matrix[room_position.x, room_position.y];
string track_name = RouteManager.shipyard_track_tilemap.GetTile(boxcar.tile_position).name;
try
{
//print("boxcar track loc " + boxcar.station_track.start_location + " track name is " + track_name);
RouteManager.Orientation exit_orientation = CityManager.station_track_unloading_map[boxcar.station_track.start_location][track_name];
StartCoroutine(GameObject.Find("PersonRouteManager").GetComponent <PersonRouteManager>().unload_train(boxcar, room, exit_orientation));
}
catch (KeyNotFoundException k)
{
print("exit orientation not found");
}
}
public IEnumerator one_time_straight_move(Boxcar prev_boxcar)
{
prev_boxcar.train.is_boxcar_filling_void = true;
Vector3Int prev_boxcar_position = prev_boxcar.tile_position;
//Vector3Int prev_boxcar_prev_tile_position = prev_boxcar.prev_tile_position;
//Vector2Int prevboxcar_next_tilemap_position = prev_boxcar.next_tilemap_position;
RouteManager.Orientation prev_orientation = prev_boxcar.orientation;
Vector3 prev_destination = prev_boxcar.train_destination;
//one_time_move_pass = true; // lets boxcar move even though train hasnt departed yet.
yield return(StartCoroutine(simple_straight_move(transform.position, prev_boxcar.transform.position))); // dont set new positions until movement is completed
//one_time_move_pass = false;
tile_position = prev_boxcar_position;
next_tilemap_position = (Vector2Int)prev_boxcar_position;
prev_tile_position = prev_boxcar_position;
orientation = prev_orientation;
train_destination = prev_destination;
prev_boxcar.train.is_boxcar_filling_void = false;
}
public virtual void set_initial_rotation(RouteManager.Orientation orientation)
{
switch (orientation)
{
case RouteManager.Orientation.North:
angle = 0;
break;
case RouteManager.Orientation.East:
angle = -90;
break;
case RouteManager.Orientation.West:
angle = 90;
break;
case RouteManager.Orientation.South:
angle = 180;
break;
}
}
public override void set_initial_rotation(RouteManager.Orientation orientation)
{
switch (orientation)
{
case RouteManager.Orientation.North:
transform.eulerAngles = new Vector3(0, 0, 0);
break;
case RouteManager.Orientation.East:
transform.eulerAngles = new Vector3(0, 0, -90);
break;
case RouteManager.Orientation.West:
transform.eulerAngles = new Vector3(0, 0, 90);
break;
case RouteManager.Orientation.South:
transform.eulerAngles = new Vector3(0, 0, 180);
break;
}
}
public IEnumerator move_checkpoints(List <Checkpoint> checkpoint_list)
{
Person person = gameObject.GetComponent <Person>();
////print("begin moving " + gameObject.name + " to checkpoints");
for (int i = 0; i < checkpoint_list.Count; i++)
{
Checkpoint cp = checkpoint_list[i];
if (cp.animation_clip != "none") // animation has changed
{
////print("set animation clip " + cp.animation_clip);
// flip here
if (cp.animation_clip == "player_idle_hor" || cp.animation_clip == "player_walk_hor")
{
if (cp.end_orientation == RouteManager.Orientation.West)
{
gameObject.GetComponent <SpriteRenderer>().flipX = true;
}
else if (cp.end_orientation == RouteManager.Orientation.East)
{
gameObject.GetComponent <SpriteRenderer>().flipX = false;
}
else
{
throw new Exception("cant have a up or down orientation for hor animation");
}
}
yield return(StartCoroutine(set_animation_clip(cp.animation_clip)));
}
Vector2 checkpoint_position = cp.dest_pos;
tile_position = (Vector3Int)cp.tile_position;
angle = cp.final_angle;
orientation = cp.end_orientation;
final_orientation = orientation;
yield return(StartCoroutine(straight_move(transform.position, checkpoint_position)));
person.tile_position = tile_position; // update tile position
}
person.next_tilemap_position = (Vector2Int)person.tile_position;
}
public bool is_train_on_track(RouteManager.Orientation orientation, bool get_outer)
{
Station_Track station_track;
Station station;
switch (orientation)
{
case RouteManager.Orientation.North:
station = North_Station;
break;
case RouteManager.Orientation.East:
station = East_Station;
break;
case RouteManager.Orientation.West:
station = West_Station;
break;
case RouteManager.Orientation.South:
station = South_Station;
break;
default:
throw new Exception("nota valid orientation for station");
}
if (get_outer)
{
station_track = station.outer_track;
}
else
{
station_track = station.inner_track;
}
if (station_track.train != null && station_track.train.GetComponent <Train>().is_boxcar_within_max_limit())
{
return(true);
}
return(false);
}
public void set_angle_using_orientation(RouteManager.Orientation orientation)
{
if (orientation == RouteManager.Orientation.North)
{
orient_angle = 0;
}
else if (orientation == RouteManager.Orientation.East)
{
orient_angle = -90f;
}
else if (orientation == RouteManager.Orientation.West)
{
orient_angle = 90f;
}
else if (orientation == RouteManager.Orientation.South)
{
orient_angle = 180f;
}
else
{
throw new Exception("unable to set angle because orientation not recognized");
}
}
public virtual IEnumerator bezier_move(Transform location, RouteManager.Orientation orientation, RouteManager.Orientation final_orientation)
{
Vector2 position = location.position;
float t_param;
t_param = 1;
bool final_step = false;
in_tile = true;
// change animation clip
string animation_name = PersonRouteManager.get_animation_from_orientation(final_orientation, "walk");
StartCoroutine(set_animation_clip(animation_name));
while (!final_step)
{
if (PauseManager.game_is_paused)
{
yield return(new WaitForEndOfFrame());
continue;
}
t_param -= Time.deltaTime * speed;
if (t_param < 0) // set t_param to 0 to get bezier coordinates closer to the destination (and be within tolerance)
{
t_param = 0;
final_step = true;
}
next_position = bezier_equation(t_param, TrackManager.offset_right_angle_inner_curve);
next_position = transform_curve(next_position, orientation, final_orientation) + position; //offset with current position
transform.position = next_position;
yield return(new WaitForEndOfFrame());
}
set_angle_using_orientation(final_orientation);
in_tile = false;
}
public void click_inventory(PointerEventData eventData)
{
// NOT GETTING CALLED
selected_tile_pos = GameManager.get_selected_tile(eventData.position);
selected_tile = (Tile)inventory_tilemap.GetTile((Vector3Int)selected_tile_pos);
if (selected_tile != null)
{
List <List <int[]> > boxcar_action_coord = new List <List <int[]> >();
List <int[]> valid_unloading_pos_list = new List <int[]>();
Station_Track station_track = CityManager.Activated_City_Component.get_station_track(selected_tile_pos); // inner, outer doesnt matter
RouteManager.Orientation[] orientation_list = new RouteManager.Orientation[] { RouteManager.Orientation.North, RouteManager.Orientation.East, RouteManager.Orientation.West, RouteManager.Orientation.South };
foreach (RouteManager.Orientation orientation in orientation_list)
{
List <List <int[]> > valid_boxcar_add_pos = TrackManager.add_to_train_coord_map[orientation];
bool train_in_outer_track = CityManager.Activated_City_Component.is_train_on_track(orientation, true);
bool train_in_inner_track = CityManager.Activated_City_Component.is_train_on_track(orientation, false);
//concatenate lists of outer track and inner track positions
if (train_in_outer_track)
{
valid_unloading_pos_list.AddRange(valid_boxcar_add_pos[0]);
}
if (train_in_inner_track)
{
valid_unloading_pos_list.AddRange(valid_boxcar_add_pos[1]);
}
boxcar_action_coord.Add(valid_unloading_pos_list);
}
List <string> hint_context_list = new List <string>()
{
"add"
};
GameObject.Find("GameManager").GetComponent <GameManager>().mark_tile_as_eligible(boxcar_action_coord, hint_context_list, gameObject, true);
}
}
public void board_turntable(RouteManager.Orientation orientation, bool depart_turntable, City city = null)
{
if (depart_turntable)
{
if (CityManager.Activated_City_Component == city)
{
GameManager.sound_manager.play_train_bell();
}
start_all_boxcar_at_turntable();
halt_train(true, false); //unhalt the boxcars
halt_train(is_halt = false, is_pause = false); // unpause the train
is_train_departed_for_turntable = true;
city.remove_train_from_station(gameObject);
}
else // leaving the turntable
{
leave_city = true;
foreach (GameObject boxcar_object in boxcar_squad)
{
Boxcar boxcar = boxcar_object.GetComponent <Boxcar>();
boxcar.leave_city = true;
}
}
}
public static float get_orientation_angle(RouteManager.Orientation orientation)
{
float final_angle = -1;
switch (orientation)
{
case RouteManager.Orientation.North:
final_angle = 90;
break;
case RouteManager.Orientation.East:
final_angle = 0; // random_algos.degree_to_radian(-90);
break;
case RouteManager.Orientation.West:
final_angle = 180; // random_algos.degree_to_radian(90);
break;
case RouteManager.Orientation.South:
final_angle = 270; // random_algos.degree_to_radian(180);
break;
}
return(final_angle);
}
public IEnumerator Make_All_Boxcars_Depart(GameObject[,] board, List <GameObject> boxcar_list, Train train)
{
// start coroutine when a train departs or arrives at a city
int boxcar_count = boxcar_list.Count;
int boxcar_depart_id = 0; // counter
// 1. train departs
// 2. train is placed in city tile
// 3. train calls Boxcar Depart Coroutine
// 4. train moves to city boundary
// 5. train updates tile position
// 6. train confirms end of track is next tile
// 7. train stops and tells boxcars to stop
Vector3Int last_location = train.tile_position;
////print("train last location is " + last_location);
RouteManager.Orientation depart_orientation = train.orientation;
MovingObject last_vehicle = train;
if (train.in_city)
{
board = train.get_city().city_board;
}
while (boxcar_depart_id < boxcar_count)
{
if (boxcar_depart_id >= boxcar_list.Count)
{
break;
}
GameObject boxcar = boxcar_list[boxcar_depart_id];
if (boxcar == null)
{
yield break; // the boxcar collidd with another train while entering city.
}
Boxcar moving_boxcar = boxcar.GetComponent <Boxcar>();
if (!is_vehicle_in_cell(last_location, board) && moving_boxcar.in_city == last_vehicle.in_city && !moving_boxcar.is_pause) // dont depart until boxcar has arrived at city
{
if (moving_boxcar.in_city && moving_boxcar.city != last_vehicle.city)
{
yield return(new WaitForEndOfFrame());
continue;
}
last_vehicle = moving_boxcar;
moving_boxcar.departing = false; // reset departing
//print("Make Boxcar depart. boxcar orientation is " + moving_boxcar.get_orientation() + " new tile position is " + last_location + "old tile position is " + moving_boxcar.tile_position);
moving_boxcar.set_depart_status(true);
if (train.in_city)
{
moving_boxcar.receive_train_order = true;
}
moving_boxcar.tile_position = last_location;
place_vehicle(boxcar);
moving_boxcar.is_halt = false;
spawn_moving_object(moving_boxcar);
moving_boxcar.set_depart_status(false);
boxcar_depart_id++;
game_manager.enable_vehicle_for_screen(boxcar); // switch on when boxcar is departing from the city. Dont show entire train cargo.
//board[last_location.x, last_location.y] = boxcar.gameObject;
}
yield return(new WaitForEndOfFrame());
}
}
public void set_signal_from_exit_route(Vector3Int city_tile_position, Traffic_Light_Loc traffic_light_loc)
{
bool exit_route_is_shown = CityManager.is_exit_route_shown(traffic_light_loc.orientation);
Tilemap toggled_tilemap = TrackManager.instance.top_tilemap;
tile_position = (Vector3Int)RouteManager.get_depart_tile_position(traffic_light_loc.orientation, city_tile_position);
if (!exit_route_is_shown) // no route exists, dont show signal
{
change_traffic_signal_tile(Traffic_Light.None, traffic_light_loc);
return;
}
HashSet <Vector3Int> seen_track_tile_set = new HashSet <Vector3Int>(); // keep track of tracks to discover loop routes
// used by traffic lights to warn of incoming trains etc.
final_orientation = traffic_light_loc.orientation;
Traffic_Light signal = Traffic_Light.Green;
int tile_count = 0;
while (true)
{
tile_count += 1;
this.orientation = final_orientation; // updating the orientation at every new tile
if (seen_track_tile_set.Contains(tile_position))
{
////print("yellow warning for orientation " + orientation + " this route contains loop");
signal = update_signal(signal, Traffic_Light.Yellow); // warning, this route contains a loop
break;
}
seen_track_tile_set.Add(tile_position);
GameObject vehicle_go = VehicleManager.vehicle_board[tile_position.x + 1, tile_position.y + 1]; // remove offset
if (!tile_position.Equals(city_tile_position) && vehicle_go != null)
{
////print("RED warning for orientation " + orientation + " vehicle " + vehicle_go.name + " found at " + tile_position);
signal = update_signal(signal, Traffic_Light.Red); // is train enroute? . If YES return RED todoed
}
PositionPair position_pair;
Vector2 no_offset = new Vector2(0, 0);
position_pair = RouteManager.get_destination(this, toggled_tilemap, no_offset); // set the final orientation and destination
next_tilemap_position = position_pair.tile_dest_pos; // discard abs pos information
tile_position = new Vector3Int(next_tilemap_position.x, next_tilemap_position.y, 0);
if (is_end_of_track())
{
GameObject city_object = CityManager.instance.get_city(next_tilemap_position);
if (city_object == null) // end of track
{
////print("yellow warning for orientation " + orientation + " this route does not end at a city");
signal = update_signal(signal, Traffic_Light.Yellow);
break;
}
else // is a city, find station
{
// return green or red depending on whether another train station is full todoed
// return city_object;
City city = city_object.GetComponent <City>();
RouteManager.Orientation flipped_final_orientation = TrackManager.flip_straight_orientation(final_orientation);
Station incoming_station = city.get_station_by_orientation(flipped_final_orientation);
bool station_available = incoming_station.is_station_track_available();
if (station_available)
{
////print("GREEN for orientation " + orientation + " stations available GOOD TO GO");
signal = update_signal(signal, Traffic_Light.Green);
}
else
{
////print("RED warning for orientation " + orientation + " the destination city has no available tracks");
signal = update_signal(signal, Traffic_Light.Red);
} // station track is not available
break;
}
}
}
change_traffic_signal_tile(signal, traffic_light_loc);
}
public Traffic_Light_Loc(Vector2Int tile_pos, Tilemap traffic_tilemap, RouteManager.Orientation orientation)
{
this.tile_pos = (Vector3Int)tile_pos;
this.traffic_tilemap = traffic_tilemap;
this.orientation = orientation;
}