public void CanGetNextTrackPiece(string track, int x, int y, Direction startDirection, String desiredResult)
{
// Arrange
var grid = new Grid(track);
Coord pos = new Coord(x, y);
var direction = startDirection;
var resultTrack = new StringBuilder();
bool moreTrack = true;
int i = 0;
IGridNavigator nav = new GridNavigator();
// Act
do
{
char piece = grid[pos];
resultTrack.Append(piece);
var res = TrackBuilder.GetNextTrackPiece(nav, grid, pos, direction);
moreTrack = res.Found;
pos = res.NextPos;
direction = res.NextDir;
i++;
} while (moreTrack && i < 20);
// Assert
resultTrack.ToString().Should().Be(desiredResult);
}
public TestTrain()
{
IGrid grid = new Grid("/-------\\\n| |\n| |\n\\-------/\n");
Coord start = grid.GetStart();
track = TrackBuilder.GetTrack(start, grid);
}
void Awake()
{
TrackBuilder = this.gameObject.GetComponent <TrackBuilder>();
BindingFlags flags = BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic;
_trackerRiderField = TrackBuilder.GetType().GetField("trackedRide", flags);
}
private TrackSegment4 GetSelectedSegment()
{
int trackCursorPosition = (int)TrackBuilder.GetType().GetField("trackCursorPosition",
BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic).GetValue(TrackBuilder);
return(GetTrackRide().Track.trackSegments[trackCursorPosition]);
}
void Start()
{
GD = GridScript.gameObject.GetComponent <grid>();
TB = TBS.gameObject.GetComponent <TrackBuilder>();
Mat = GetComponent <Renderer>().material;
}
public static void reset()
{
for (int i = 0; i < objects.Count; i++)
{
if (objects[i].tag == "train")
{
TrackBuilder tb = objects[i].GetComponent <RollerCoaster>().tb; if (tb != null)
{
tb.reset();
}
}
else if (objects[i].tag == "wall")
{
WallBuilder wb = objects[i].GetComponent <Wall>().wb; if (wb != null)
{
wb.reset();
}
}
GameObject.Destroy(objects[i]);
}
objects.Clear();
animals.Clear();
rollerCoasters.Clear();
walls.Clear();
Data.activeObj = 0;
Data.startingPointIndex = -1;
GameObject.Destroy(landscape);
}
// =======================================
// Blaine is a pain, and that is the truth
// =======================================
public static int TrainCrash(string trackString, string aTrain, int aTrainPos, string bTrain, int bTrainPos, int limit, bool visualise = false)
{
Console.WriteLine($"aTrain: {aTrain}. aTrainPos: {aTrainPos}. bTrain: {bTrain}. bTrainPos: {bTrainPos}. Limit {limit}.");
var grid = new Grid(trackString);
grid.PrintGrid();
var start = grid.GetStart();
var track = TrackBuilder.GetTrack(start, grid);
var gridables = new IGridable[] { track, new Train(aTrain, aTrainPos, track), new Train(bTrain, bTrainPos, track) };
var moveables = gridables.OfType <IMoveable>();
grid.ClearGrid();
int timer = 0;
do
{
grid.Visualise(gridables, visualise, timer == 0);
if (moveables.IsCollision())
{
Console.WriteLine($"Collision at time {timer}.");
return(timer);
}
moveables.MoveAll();
timer++;
}while (timer <= limit);
Console.WriteLine($"No Collision before {timer}.");
return(-1);
}
internal static void OnBuildTracks(CustomDataDeserializer.DeserializeBeatmapEventArgs eventArgs)
{
TrackBuilder trackBuilder = eventArgs.TrackBuilder;
foreach (CustomEventData customEventData in eventArgs.CustomEventDatas)
{
try
{
switch (customEventData.type)
{
case ASSIGNPLAYERTOTRACK:
trackBuilder.AddTrack(customEventData.data.Get <string>(TRACK) ?? throw new InvalidOperationException("Track was not defined."));
break;
case ASSIGNTRACKPARENT:
trackBuilder.AddTrack(customEventData.data.Get <string>(PARENTTRACK) ?? throw new InvalidOperationException("Parent track was not defined."));
break;
default:
continue;
}
}
catch (Exception e)
{
CustomDataDeserializer.LogFailure(Plugin.Logger, e, customEventData);
}
}
}
public TestTrack()
{
IGrid grid = new Grid(trackStr);
Coord start = grid.GetStart();
track = TrackBuilder.GetTrack(start, grid);
}
private void ExtrudeRoad(TrackBuilder trackBuilder, Vector3 pPrev, Vector3 pCurr, Vector3 pNext)
{
Vector3 offset = Vector3.zero;
Vector3 targetOffset = Vector3.forward * lineWidth;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, 0);
offset += targetOffset;
targetOffset = Vector3.forward * roadWidth;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, 1);
int stripeSubmesh = 2;
if (stripeCheck)
{
stripeSubmesh = 3;
}
stripeCheck = !stripeCheck;
offset += targetOffset;
targetOffset = Vector3.up * edgeHeight;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, stripeSubmesh);
offset += targetOffset;
targetOffset = Vector3.forward * edgeWidth;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, stripeSubmesh);
offset += targetOffset;
targetOffset = -Vector3.up * edgeHeight;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, stripeSubmesh);
}
private void Start()
{
trackBuilder = this;
waitTime = 2.0f;
min = 0;
max = 3;
Track();
}
private void MakeRoadQuad(TrackBuilder trackBuilder, Vector3 pPrev, Vector3 pCurr, Vector3 pNext,
Vector3 offset, Vector3 targetOffset, int submesh)
{
Vector3 forward = (pNext - pCurr).normalized;
Vector3 forwardPrev = (pCurr - pPrev).normalized;
BuildHalfTrack(forward, forwardPrev, trackBuilder, pCurr, pNext, offset, targetOffset, submesh, false);
BuildHalfTrack(-forward, -forwardPrev, trackBuilder, pCurr, pNext, offset, targetOffset, submesh, true);
}
void train()
{
string code = "track 50 up 60 0 0;track 70 down 120 0 0;track 20 up 60 0 0;track 50 forward 0 0 0;";
GameObject startPoint = new GameObject("track start point");
startPoint.transform.position = new Vector3(0, 2, 0);
tb = new TrackBuilder(startPoint);
tb.generate(code);
_trainAnimFlag = true;
}
// Start is called before the first frame update
void Start()
{
TB = Tb.gameObject.GetComponent <TrackBuilder>();
// foreach (var Block in TB.TrackPeices)
// {
// GameObject Block1 = Block +1;
// Direction = (Block.transform.position - Block.transform.position);
// }
}
// Use this for initialization
void Start()
{
vr = new VR();
AStatus.sceneNumber = 3;
builder = new TrackBuilder();
builder.BuildTrack();
com = new Client();
//tclient = new TcpClient();
com.Connect();
}
public static Coord GetStart(this IGrid grid)
{
var res = new GridNavigator().FindFirst(grid, c => TrackBuilder.IsTrackPiece(c));
if (!res.IsInGrid)
{
throw new InvalidOperationException($"Grid Start could not be found.");
}
return(res.NewPosition);
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
TrackBuilder myScript = (TrackBuilder)target;
if (GUILayout.Button("Generate Track"))
{
myScript.BuildTrack();
}
}
void CreatePath(List <Vector3> points, TrackBuilder trackBuilder)
{
for (int i = 1; i < points.Count + 1; i++)
{
Vector3 pPrev = points[i - 1];
Vector3 pCurr = points[i % points.Count];
Vector3 pNext = points[(i + 1) % points.Count];
ExtrudeRoad(trackBuilder, pPrev, pCurr, pNext);
}
}
void CreatePath(List <Vector3> points, TrackBuilder trackBuilder)
{
//2. function to define the path - the path is defined by each segment
for (int i = 1; i < points.Count + 1; i++)
{
Vector3 pPrev = points[i - 1];
Vector3 pCurr = points[i % points.Count];
Vector3 pNext = points[(i + 1) % points.Count];
ExtrudeRoad(trackBuilder, pPrev, pCurr, pNext);
}
}
private TrackSegment4 GetGhostSegment()
{
GameObject go = (GameObject)TrackBuilder.GetType()
.GetField("ghost", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(TrackBuilder);
if (go == null)
{
return(null);
}
return(go.GetComponent <TrackSegment4>());
}
public void CanGetTrack(string trackStr, int x, int y, String desiredResult)
{
// Arrange
var grid = new Grid(trackStr);
Coord pos = new Coord(x, y);
// Act
var track = TrackBuilder.GetTrack(pos, grid);
// Assert
track.ToString().Should().Be(desiredResult);
}
public static void SaveTrack(TrackBuilder tiles, string fileName)
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "/" + fileName + ".fun";
Debug.Log("Created File: " + path);
FileStream stream = new FileStream(path, FileMode.Create);
Save SavedTracks = new Save(tiles);
formatter.Serialize(stream, SavedTracks);
stream.Close();
}
internal static void OnTrackManagerCreated(TrackBuilder trackManager, CustomBeatmapData customBeatmapData)
{
List <CustomEventData> customEventsData = customBeatmapData.customEventsData;
foreach (CustomEventData customEventData in customEventsData)
{
if (customEventData.type == ASSIGNPLAYERTOTRACK)
{
string?trackName = customEventData.data.Get <string>(TRACK);
if (trackName != null)
{
trackManager.AddTrack(trackName);
}
}
}
}
void Awake()
{
inputManager = GetComponent <InputManager> ();
trackPoints = new Transform[track.childCount];
for (int i = 0; i < trackPoints.Length; i++)
{
trackPoints [i] = track.GetChild(i);
}
car = GetComponent <carController> ();
carRigidbody = GetComponent <Rigidbody> ();
trackBuilder = track.GetComponent <TrackBuilder> ();
tdr = GetComponent <TrainingDataRecorder> ();
brain = GetComponent <NeuralBrain> ();
}
internal static void CreateEnvironmentTracks(TrackBuilder trackManager, CustomBeatmapData customBeatmapData)
{
IEnumerable <Dictionary <string, object?> >?environmentData = customBeatmapData.customData.Get <List <object> >(ENVIRONMENT)?.Cast <Dictionary <string, object?> >();
if (environmentData != null)
{
foreach (Dictionary <string, object?> gameObjectData in environmentData)
{
string?trackName = gameObjectData.Get <string>("_track");
if (trackName != null)
{
trackManager.AddTrack(trackName);
}
}
}
}
public RailGenerator(TrackBuilder tmp_gt)
{
gt = tmp_gt;
data = Data.data;
rollercoaster = new GameObject();
track_main = new GameObject("tracks");
hoarding_main = new GameObject("hoardings");
tunnels_main = new GameObject("tunnels");
railings = new GameObject("railings");
track_main.transform.parent = rollercoaster.transform;
hoarding_main.transform.parent = rollercoaster.transform;
tunnels_main.transform.parent = rollercoaster.transform;
railings.transform.parent = rollercoaster.transform;
}
public Save(TrackBuilder tiles)
{
isLoop = tiles.isLoop;
numOfLaps = 3;
SizeOfTheGrid = tiles.gridSize;
index = new int[tiles.count];
rotacaoEmZdeCadaTile = new float[tiles.count];
PosicoesDeEntradaX = new float[tiles.count];
PosicoesDeEntradaY = new float[tiles.count];
EscalaX = new float[tiles.count];
EscalaY = new float[tiles.count];
EscalaZ = new float[tiles.count];
numOfTiles = tiles.count;
for (int i = 0; i < index.Length;)
{
for (int x = 0; x < tiles.gridSize; x++)
{
for (int y = 0; y < tiles.gridSize; y++)
{
if (tiles.SlotGrid[x, y].CurrentState == TrackSlot.State.FULL)
{
if (tiles.SlotGrid[x, y].hasPiece == true)
{
Debug.Log("Tile Index: " + tiles.SlotGrid[x, y].Holder.index);
index[i] = tiles.SlotGrid[x, y].Holder.index;
rotacaoEmZdeCadaTile[i] = tiles.SlotGrid[x, y].Piece.transform.localEulerAngles.y;
Debug.Log("Save/ Piece rot: " + tiles.SlotGrid[x, y].Piece.transform.localEulerAngles.y);
Debug.Log("Save/ supposed rot: " + tiles.SlotGrid[x, y].Holder.pieceRotation);
Debug.Log("Save/ Each Z rot: " + rotacaoEmZdeCadaTile[i]);
PosicoesDeEntradaX[i] = tiles.SlotGrid[x, y].transform.position.x;
PosicoesDeEntradaY[i] = tiles.SlotGrid[x, y].transform.position.z;
EscalaX[i] = tiles.SlotGrid[x, y].transform.localScale.x;
EscalaY[i] = tiles.SlotGrid[x, y].transform.localScale.y;
EscalaZ[i] = tiles.SlotGrid[x, y].transform.localScale.z;
i++;
}
}
}
}
}
}
private void ExtrudeRoad(TrackBuilder trackBuilder, Vector3 pPrev, Vector3 pCurr, Vector3 pNext)
{
//3. This method will be usedto create the different segments for each segment we are going to draw the road marker
// (i.e white line in the middle), draw the road on each side of the line, draw the edges -
//all these are going to be placed in different positions
//Roadline
Vector3 offset = Vector3.zero;
Vector3 targetOffset = Vector3.forward * lineWidth;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, 0);
//Road
offset += targetOffset;
targetOffset = Vector3.forward * roadWidth;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, 1);
int stripeSubmesh = 2;
if (stripeCheck)
{
stripeSubmesh = 3;
}
stripeCheck = !stripeCheck;
//Edge
offset += targetOffset;
targetOffset = Vector3.up * edgeHeight;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, stripeSubmesh);
//Edge Top
offset += targetOffset;
targetOffset = Vector3.forward * edgeWidth;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, stripeSubmesh);
//Edge
offset += targetOffset;
targetOffset = -Vector3.up * edgeHeight;
MakeRoadQuad(trackBuilder, pPrev, pCurr, pNext, offset, targetOffset, stripeSubmesh);
}
void Start()
{
if (mode == usageMode.train)
{
c = startIndex;
track = GetComponent <CarAiController>().trackBuilder;
if (initOnStart)
{
writer = new StreamWriter(write_path + "/track_data_temp.csv");
}
cc = FindObjectOfType <carController>();
}
else
{
ThreadStart ts = new ThreadStart(GetInfo);
mThread = new Thread(ts);
mThread.Start();
}
}
public List <Segment> Build(IDbRecordset recordset)
{
var points = new List <Point>();
while (recordset.Read())
{
var dateTime = (DateTime)recordset["EndTime"];
var latitude = (double)Convert.ChangeType(recordset["Latitude"], typeof(double));
var longitude = (double)Convert.ChangeType(recordset["Longitude"], typeof(double));
var satellitesCount = (int)recordset["SatellitesCount"];
var point = new Point(dateTime, latitude, longitude, satellitesCount);
points.Add(point);
}
var builder = new TrackBuilder(Options);
return(builder.Build(points));
}
void OnEnable()
{
trackBuilder = target as TrackBuilder;
}
