// PUT api/<controller>/5
public HttpResponseMessage Put(int id, TrackDTO track)
{
HttpResponseMessage responseMessage;
using (var context = new ChinookEntities())
{
var oldTrack = context.Tracks.Find(id);
if (oldTrack != null)
{
int newGenreId = context.Genres.Where(g => g.Name == track.Genre).SingleOrDefault().GenreId;
oldTrack.Name = track.Name;
oldTrack.GenreId = newGenreId;
oldTrack.Milliseconds = track.Milliseconds;
oldTrack.UnitPrice = track.UnitPrice;
try
{
context.SaveChanges();
responseMessage = Request.CreateResponse <TrackDTO>(HttpStatusCode.OK, track);
}
catch (Exception ex)
{
responseMessage = Request.CreateErrorResponse(HttpStatusCode.BadRequest,
new HttpError("Track wasn't updated!"));
}
}
else
{
responseMessage = Request.CreateErrorResponse(HttpStatusCode.BadRequest,
new HttpError("Track wasn't found!"));
}
}
return(responseMessage);
}
public TrackDTO Read(int key)
{
TrackDTO track = new TrackDTO();
using (SqlConnection conn = new SqlConnection(DBConnection._connectionString))
{
using (SqlCommand cmd = new SqlCommand($"SELECT Track.Id, Track.TrackNumber, Track.PreferedTramType, Track.SectorId FROM [Track] INNER JOIN dbo.Sector ON dbo.Track.Id = dbo.Sector.TrackId WHERE [Id] = @key", conn))
{
cmd.Parameters.AddWithValue("@key", key);
conn.Open();
using (SqlDataReader datareader = cmd.ExecuteReader())
{
while (datareader.Read())
{
track.Id = datareader.GetInt32(0);
track.TrackNumber = datareader.GetInt32(1);
track.TramType = (TramType)datareader.GetInt32(2);
track.Sectors = new List <SectorDTO>();
}
}
conn.Close();
}
}
return(track);
}
public void Create(TrackDTO obj)
{
using (SqlConnection conn = new SqlConnection(DBConnection._connectionString))
{
throw new NotImplementedException();
}
}
public async Task <TrackResponse> Create([FromBody] TrackRequest newTrackRequest)
{
TrackDTO trackDTO = autoMapper.Map <TrackDTO>(newTrackRequest);
TrackDTO createdTrackDTO = await trackService.CreateAsync(trackDTO);
return(autoMapper.Map <TrackResponse>(createdTrackDTO));
}
public IEnumerable <TrackDTO> GetAllTracks(DepotDTO depot)
{
List <TrackDTO> tracks = new List <TrackDTO>();
using (SqlConnection conn = new SqlConnection(DBConnection._connectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand("SELECT dbo.Track.TrackNumber FROM dbo.Depot INNER JOIN dbo.Track ON dbo.Depot.Id = dbo.Track.DepotId;"))
{
using (SqlDataReader dataReader = cmd.ExecuteReader())
{
while (dataReader.Read())
{
int id = dataReader.GetInt32(0);
int trackNumber = dataReader.GetInt32(1);
TrackDTO track = new TrackDTO
{
Id = id,
TrackNumber = trackNumber
};
tracks.Add(track);
}
}
}
}
return(tracks);
}
public ICollection <TrackDTO> MapTracks(IEnumerable <Track> tracks)
{
ICollection <TrackDTO> trackDTOs = new LinkedList <TrackDTO>();
TrackDTO trackDTO = null;
foreach (var track in tracks)
{
trackDTO = new TrackDTO(track.Id, track.Title, track.Duration, track.ReleaseDate);
foreach (var album in track.Albums)
{
trackDTO.Albums.Add(new AlbumDetailDTO(album.Album.Title, album.Album.RecordLabel, album.Album.ReleaseDate));
}
foreach (var artist in track.Artists)
{
trackDTO.Artists.Add(new ArtistDetailDTO(artist.Artist.Name, artist.Artist.Description, artist.Artist.Country, artist.Artist.YearActive));
}
foreach (var genre in track.Genres)
{
trackDTO.Genres.Add(new GenreDetailDTO(genre.Genre.Type));
}
trackDTOs.Add(trackDTO);
}
return(trackDTOs);
}
public async Task Update(TrackDTO obj)
{
using (_context)
{
_context.Update(obj);
await _context.SaveChangesAsync();
}
}
public TrackDTO Read(int key)
{
using (_context)
{
TrackDTO track = new TrackDTO();
var readtrack = _context.Track.FirstOrDefault(i => i.Id == key);
return(track = _mapper.Map <TrackDTO>(readtrack));
}
}
public void StoreTram(TramDTO tram, TrackDTO track)
{
foreach (SectorDTO sector in track.Sectors)
{
if (_sectorLogic.CheckIfSectorIsEmpty(sector))
{
_sectorLogic.AddTram(sector, tram);
break;
}
}
}
private void InstantiateMapObjects(TrackDTO mapDTO)
{
track.TrackObjectsParent.transform.DestroyChildren();
foreach (var mapObjectDTO in mapDTO.MapObjects)
{
GameObject gameObj = ResourcesLoader.LoadTrackObject(mapObjectDTO.ID);
gameObj.transform.SetParent(track.TrackObjectsParent.transform);
Mapper.Map(mapObjectDTO, gameObj.GetComponent <TrackObject>());
}
}
/// <summary>
/// Registers the track name on the server and saves the name and Id to local settings.
/// </summary>
/// <param name="trackName"></param>
public async static Task <string> RegisterExistingTrackOnStartup(string secret)
{
TrackDTO trackDTO = new TrackDTO()
{
Secret = secret, Length = 0f
};
string returnName = string.Empty;
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpClient.Timeout = new TimeSpan(0, 0, 0, 20);
var uri = new Uri($@"{AppManager.ServerHostURL}/api/Tracks/{secret}");
try
{
var response = await Task.Run(async() => await httpClient.GetAsync(uri));
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
trackDTO = await Json.ToObjectAsync <TrackDTO>(content);
if (trackDTO != null)
{
AppManager.Track = new Track()
{
Name = trackDTO.Name,
Id = trackDTO.Id,
Secret = trackDTO.Secret
// Length = (float)trackCompositeValue["Length"],
// MacAddress = (string)trackCompositeValue["MacAddress"],
};
localSettings.Values["TrackName"] = trackDTO.Name;
localSettings.Values["TrackId"] = trackDTO.Id;
localSettings.Values["Secret"] = trackDTO.Secret;
// TODO: trackCompositeValue["Length"] = length;
// TODO: trackCompositeValue["MacAddress"] = macAddress; https://stackoverflow.com/questions/34097870/c-sharp-get-mac-address-in-universal-apps
returnName = trackDTO.Name;
}
}
}
catch (Exception e)
{
}
}
return(returnName);
}
public HttpResponseMessage ChangeTrack(int conferenceId, int id, [FromBody] TrackDTO data)
{
var session = SessionRepository.Instance.GetSession(conferenceId, id);
if (session == null)
{
return(ServiceError("Can't find session"));
}
session.TrackId = data.newTrack;
SessionRepository.Instance.UpdateSession(session.GetSessionBase(), UserInfo.UserID);
return(Request.CreateResponse(HttpStatusCode.OK, SessionRepository.Instance.GetSession(session.ConferenceId, session.SessionId)));
}
/// <summary>
/// Registers the track name on the server and saves the name and Id to local settings.
/// </summary>
/// <param name="trackName"></param>
public async static Task <string> RegisterTrackOnStartup(string trackName, string email)
{
TrackDTO trackDTO = new TrackDTO()
{
Name = trackName, OwnerEmail = email, Length = 0f
};
string returnSecret = string.Empty;
try
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(ServerHostURL);
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpClient.Timeout = new TimeSpan(0, 0, 0, 20);
string endpoint = @"/api/tracks";
HttpResponseMessage response = httpClient.PostAsJsonAsync(endpoint, trackDTO).Result;
if (response.IsSuccessStatusCode)
{
string jsonResponse = await response.Content.ReadAsStringAsync();
trackDTO = JsonConvert.DeserializeObject <TrackDTO>(jsonResponse);
if (trackDTO != null)
{
AppManager.Track = new Track()
{
Name = trackDTO.Name,
Id = trackDTO.Id,
Secret = trackDTO.Secret
// Length = (float)trackCompositeValue["Length"],
// MacAddress = (string)trackCompositeValue["MacAddress"],
};
localSettings.Values["TrackName"] = trackDTO.Name;
localSettings.Values["TrackId"] = trackDTO.Id;
localSettings.Values["Secret"] = trackDTO.Secret;
// TODO: trackCompositeValue["Length"] = length;
// TODO: trackCompositeValue["MacAddress"] = macAddress; https://stackoverflow.com/questions/34097870/c-sharp-get-mac-address-in-universal-apps
returnSecret = trackDTO.Secret;
}
}
}
}
catch (Exception)
{
}
return(returnSecret);
}
private bool CheckTramType(TramDTO tram, TrackDTO track)
{
return(true);
if (tram.Type == track.TramType || track.TramType == null)
{
return(true);
}
else
{
return(false);
}
}
public async Task <IHttpActionResult> PostTrack(TrackDTO trackDTO)
{
Track track = Mapper.Map <Track>(trackDTO);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
track = await repo.Insert(track);
return(CreatedAtRoute("DefaultApi", new { id = track.Id }, Mapper.Map <TrackDTO>(track)));
}
public void AddTrackToGenre(long id, TrackDTO trackDTO)
{
var genre = GenreRepository.Get(id);
if (genre == null)
{
throw new ArgumentException($"Genre {id} not found.");
}
var track = TrackRepository.Get(trackDTO.Id);
genre.AddTrack(track);
GenreRepository.UnitOfWork.SecondGenUnitOfWork.Commit();
}
private void InstantiateCheckpoints(TrackDTO mapDTO)
{
track.LapTracker.transform.DestroyChildren();
foreach (var checkpointDTO in mapDTO.Checkpoints)
{
GameObject gameObj = ResourcesLoader.LoadRoadObject("Checkpoint");
gameObj.transform.SetParent(track.LapTracker.transform);
Mapper.Map(checkpointDTO, gameObj.GetComponent <Checkpoint>());
gameObj.GetComponent <Checkpoint>().SetOrder(gameObj.GetComponent <Checkpoint>().CheckpointOrder);
}
}
private TrackData Convert(TrackDTO dto)
{
var track = new TrackData(
dto.ISRC,
dto.Artist,
dto.Title,
dto.Album,
dto.ReleaseYear,
dto.TrackLengthSec,
new SolrModelReference(dto.Id));
return(track);
}
public void TrackDTO_Test()
{
// Act
TrackDTO trackDTO = Mapper.Map <TrackDTO>(track);
Track testTrack = Mapper.Map <Track>(trackDTO);
// Assert
Assert.AreEqual(track.Length, trackDTO.Length);
Assert.AreEqual(track.Name, trackDTO.Name);
Assert.AreEqual(track.Length, testTrack.Length);
Assert.AreEqual(track.Name, testTrack.Name);
}
// Et enkelt track uploades til StreamingServeren
private async Task UploadTrack(TrackDTO track, string accessToken)
{
var trackFolder = _watchedFolder + "/work/tracks/" + track.Id;
var zipFilePath = trackFolder + ".zip";
try
{
// Zip track-mappen
ZipFile.CreateFromDirectory(trackFolder, zipFilePath);
}
catch (Exception ex)
{
Log(zipFilePath + " kunne ikke oprettes", true);
throw ex;
}
// Opret HTTP-klient
var uploadClient = new HttpClient();
// Access token sættes som authorization header
uploadClient.SetBearerToken(accessToken);
// Nyt HTTP-formular-dataindhold oprettes
var form = new MultipartFormDataContent();
// Zip-files indlæses som byte-array
var fileContent = new ByteArrayContent(await File.ReadAllBytesAsync(zipFilePath));
// Filheader sættes
fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
// Fil tilføjes til formular-data med navnet 'file'
form.Add(fileContent, "file", Path.GetFileName(zipFilePath));
// Streamingserver-url hentes fra environment-variabel
var streamingServerUrl = Environment.GetEnvironmentVariable("STREAMING_SERVER");
// Data sendes til StreamingServer med POST
var response = await uploadClient.PostAsync(streamingServerUrl, form);
// Tjek om det gik godt
if (!response.IsSuccessStatusCode)
{
Log(zipFilePath + " kunne ikke uploades til streamingserveren.", true);
throw new Exception();
}
else
{
Log(track.Number + ".wav blev uploadet");
}
}
public static void AllocateToRandomTrack(TramDTO tram, List <TrackDTO> tracks, Track _Tracklogic)
{
bool tramIsStored = false;
do
{
TrackDTO randomTrack = _Tracklogic.GetRandomTrack(tracks);
if (_Tracklogic.CheckTramCanBeStored(tram, randomTrack))
{
_Tracklogic.StoreTram(tram, randomTrack);
tramIsStored = true;
}
} while (tramIsStored == false);
}
public void TestThatThereIsAlways1()
{
TrackDTO dto = new TrackDTO()
{
Id = 42
};
var mock = new Mock <ITrackRepository>();
mock.Setup(a => a.Find(42)).ReturnsAsync(dto);
var view = new TrackPageViewModel(mock.Object);
view.EmptyAndAdd(42);
Assert.True(view.Track.Count() == 1);
}
public void TheElementGetsAdded()
{
TrackDTO dto = new TrackDTO()
{
Id = 42
};
var mock = new Mock <ITrackRepository>();
mock.Setup(a => a.Find(42)).ReturnsAsync(dto);
var view = new TrackPageViewModel(mock.Object);
view.EmptyAndAdd(42);
Assert.True(view.Track.First().Id == 42);
}
public async void getGivenExistingIDReturnsTrack()
{
var TrackDTO = new TrackDTO()
{
Id = 42
};
var mockRepository = new Mock <ITrackRepository>();
mockRepository.Setup(a => a.Find(42)).ReturnsAsync(TrackDTO);
var controller = new TracksController(mockRepository.Object);
var response = await controller.Get(42) as OkObjectResult;
Assert.Equal(TrackDTO, response.Value);
}
// Her transkodes et enkelt track
private void TranscodeTrack(string packageRoot, TrackDTO track)
{
var trackPath = packageRoot + "/data/" + track.Number + ".wav";
Log("Transkodning af " + track.Number + ".wav" + " påbegyndt ...");
try
{
// Vi opretter en specifik mappe til dette track
var singleTrackDirectory = Directory.CreateDirectory(_watchedFolder + "/work/tracks/" + track.Id);
// FFmpeg-kommando konstrueres
var cmdText = "-i \"" + trackPath +
"\" -c:a aac -b:a:0 128k -b:a:1 256k -map 0:a -map 0:a -f hls -hls_time 15 -hls_list_size 0 -var_stream_map \"a:0 a:1\"" +
" -master_pl_name " + track.Id + ".m3u8 -hls_segment_filename " + singleTrackDirectory.FullName + "/" + track.Id + "_v%v/%03d.ts " +
singleTrackDirectory.FullName + "/" + track.Id + "_v%v/output.m3u8";
// En ny FFmpeg-proces defineres
var process = new Process()
{
StartInfo = new ProcessStartInfo
{
FileName = "/Users/nikolajstrands/IT/Afgangsprojekt/IngestApp/ffmpeg",
Arguments = cmdText,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
}
};
// Processen startes
process.Start();
string errorOutput = process.StandardError.ReadToEnd();
string standardOutput = process.StandardOutput.ReadToEnd();
process.WaitForExit();
if (process.ExitCode != 0)
{
throw new Exception();
}
Log("Transkodning af " + track.Number + ".wav" + " afsluttet");
}
catch (Exception ex)
{
Log("Noget gik galt under transkodning af " + trackPath, true);
throw ex;
}
}
public TrackDTO GetTrackerReport()
{
TrackDTO trackDTO = null;
using (var unitOfWork = new UnitOfWork(new WorkoutTrackerContext()))
{
trackDTO = new TrackDTO();
var wtDs = unitOfWork.WorkoutActive.GetTotalWorkoutTimesReport();
if (wtDs != null && wtDs.Tables.Count > 0)
{
trackDTO.TotalWorkoutTimeOfDay = wtDs.Tables[0].Rows.Count > 0 ? Convert.ToInt32(wtDs.Tables[0].Rows[0]["TotalTimeInMinutes"]) : 0;
trackDTO.TotalWorkoutTimeOfWeek = wtDs.Tables[1] != null && wtDs.Tables[1].Rows.Count > 0 ? Convert.ToInt32(wtDs.Tables[1].Rows[0]["TotalTimeInMinutes"]) : 0;
trackDTO.TotalWorkoutTimeOfMonth = wtDs.Tables[2] != null && wtDs.Tables[2].Rows.Count > 0 ? Convert.ToInt32(wtDs.Tables[2].Rows[0]["TotalTimeInMinutes"]) : 0;
}
var dataSet = unitOfWork.WorkoutActive.GetTotalCaloriesReport();
if (dataSet != null && dataSet.Tables.Count > 0)
{
DataTable dt = dataSet.Tables[0];
trackDTO.TotalCaloriesBurntPerWeek = dt.AsEnumerable()
.Select(row => new TotalCalories()
{
Duration = Convert.ToString(row["Duration"]), TotalCaloriesBurnt = Convert.ToString(row["TotalCaloriesBurnt"])
});
if (dataSet.Tables.Count > 1)
{
dt = dataSet.Tables[1];
trackDTO.TotalCaloriesBurntPerMonth = dt.AsEnumerable()
.Select(row => new TotalCalories()
{
Duration = Convert.ToString(row["Duration"]), TotalCaloriesBurnt = Convert.ToString(row["TotalCaloriesBurnt"])
});
}
if (dataSet.Tables.Count > 2)
{
dt = dataSet.Tables[2];
trackDTO.TotalCaloriesBurntPerYear = dt.AsEnumerable()
.Select(row => new TotalCalories()
{
Duration = Convert.ToString(row["Duration"]), TotalCaloriesBurnt = Convert.ToString(row["TotalCaloriesBurnt"])
});
}
}
}
return(trackDTO);
}
public void lineUpThenCurveRight_producesCorrectSpline()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 3, 0)),
new TrackNodeDTO(null, new Vector3(3, 3, 0))
});
BezierSpline spline = GetSplineNoSplits(trackDto, 0, 0);
Assert.That(spline.pts.Length, Is.EqualTo(3));
AssertSplinePt(spline.pts[0], new Vector3(0.5f, 0, 0.5f), new Vector3(0.5f, 3, 0.5f));
AssertSplinePt(spline.pts[1], new Vector3(0.5f, 3, 0.5f), new Vector3(1, 3.5f, 0.5f));
AssertSplinePt(spline.pts[2], new Vector3(1, 3.5f, 0.5f), new Vector3(3, 3.5f, 0.5f));
}
public void Update(TrackDTO obj)
{
using (SqlConnection conn = new SqlConnection(DBConnection._connectionString))
{
using (SqlCommand cmd = new SqlCommand($"UPDATE Track SET [PreferedTramType] = @TramType WHERE [Id] = @Id", conn))
{
conn.Open();
cmd.Parameters.AddWithValue("@Id", obj.Id);
cmd.Parameters.AddWithValue("@TramType", obj.TramType);
cmd.ExecuteNonQuery();
conn.Close();
}
}
}
public IActionResult AddTrackToAlbum(long id, [FromBody] TrackDTO trackDTO)
{
try
{
AlbumService.AddTrackToAlbum(id, trackDTO);
}
catch (ArgumentException e)
{
log.LogError("The album with the id :" + id + " does not exist." + e.Message);
return(NotFound(StatusCodes.Status404NotFound));
}
return(Ok(StatusCodes.Status200OK));
}
public TrackDTO LoadWorld(string name)
{
var trackPath = directoryHelper.GetTrackPath(name);
XmlSerializer serializer = new XmlSerializer(typeof(TrackDTO));
TrackFileCompressor trackCompressor = new TrackFileCompressor();
TrackData decompressedTrackStreams = trackCompressor.DecompressPackage(trackPath);
TrackDTO mapObject = (TrackDTO)serializer.Deserialize(new MemoryStream(decompressedTrackStreams.ObjectsData));
track.Terrain.terrainData.SetHeights(0, 0, terrainSerializer.DeserializeHeightMap(decompressedTrackStreams.HeightMapData, track.HeightMapSize));
track.Terrain.terrainData.SetAlphamaps(0, 0, terrainSerializer.DeserializeTextureMap(decompressedTrackStreams.TextureMapData, track.TextureMapSize));
return(mapObject);
}
private byte[] SerializeMap(string name)
{
using (MemoryStream ms = new MemoryStream())
{
TrackDTO mapDTO = Mapper.Map <Track, TrackDTO>(track);
XmlSerializer serializer = new XmlSerializer(typeof(TrackDTO));
using (StreamWriter writer = new StreamWriter(name + Track_File_Extension, false, Encoding.GetEncoding("UTF-8")))
{
serializer.Serialize(writer, mapDTO);
}
return(ms.GetBytes());
}
}
public void oneTrackCurve_splitTwice_threeCorrectSubtracks()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 3, 0)),
new TrackNodeDTO(null, new Vector3(3, 3, 0))
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[] {
new Split("split_id", Vector3.up, new Vector3(), 2, new SubSplit[0]),
new Split("split_id", Vector3.right, new Vector3(), 2, new SubSplit[0]) }).SubTracks;
Assert.That(subTracks.Count, Is.EqualTo(3));
AssertSubtrackContainsNodes(subTracks[0], 0, new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 2, 0) });
AssertSubtrackContainsNodes(subTracks[1], 0, new Vector3[] { new Vector3(0, 2, 0), new Vector3(0, 3, 0), new Vector3(0, 3, 0), new Vector3(2, 3, 0) });
AssertSubtrackContainsNodes(subTracks[2], 0, new Vector3[] { new Vector3(2, 3, 0), new Vector3(3, 3, 0) });
}
public void ImmediateCurveToRight()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, Vector3.up, new[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(3, 0, 0)),
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[0]).SubTracks;
Assert.That(FirstPart(subTracks)[0].position, Is.EqualTo(new Vector3(0, 0, 0)));
Assert.That(FirstPart(subTracks)[0].forward, Is.EqualTo(Vector3.up));
Assert.That(FirstPart(subTracks)[1].position, Is.EqualTo(new Vector3(0, 0, 0)));
Assert.That(FirstPart(subTracks)[1].forward, Is.EqualTo(Vector3.right));
Assert.That(FirstPart(subTracks)[2].position, Is.EqualTo(new Vector3(3, 0, 0)));
Assert.That(FirstPart(subTracks)[2].forward, Is.EqualTo(Vector3.right));
}
public void curveAdjacentToSplit_doesNotAddCurveEndPosTwice()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.left, null, new[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 1, 0)),
new TrackNodeDTO(null, new Vector3(3, 1, 0))
});
BezierSpline[][] splines = GetSplinesWithSplits(trackDto, new[]{
new Split("split_id", Vector3.right, new Vector3(), 1, new SubSplit[0]),
});
Assert.That(splines.Length, Is.EqualTo(2));
Assert.That(splines[0][0].pts.Length, Is.EqualTo(2));
AssertSplinePt(splines[0][0].pts[0], new Vector3(0.5f, 0, 0.5f), new Vector3(0.5f, 1, 0.5f));
AssertSplinePt(splines[0][0].pts[1], new Vector3(0.5f, 1, 0.5f), new Vector3(1, 1.5f, 0.5f));
Assert.That(splines[1][0].pts.Length, Is.EqualTo(1));
AssertSplinePt(splines[1][0].pts[0], new Vector3(1, 1.5f, 0.5f), new Vector3(3, 1.5f, 0.5f));
}
public void splitBetweenBothNodes_addsOneIntersectNodeBetweenBoth()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.left, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 4, 0))
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[]{
new Split("", Vector3.up, new Vector3(), 2, new SubSplit[0])
}).SubTracks;
Assert.That(FirstPart(subTracks).NumTrackNodes, Is.EqualTo(2));
Assert.That(SecondPart(subTracks).NumTrackNodes, Is.EqualTo(2));
Assert.That(FirstPart(subTracks)[1], Is.EqualTo(SecondPart(subTracks)[0])); // assert that both intersecting NodesDto are the same
Assert.That(FirstPart(subTracks)[0].next, Is.EqualTo(FirstPart(subTracks)[1])); // assert that first node leads to intersecting node
Assert.That(FirstPart(subTracks)[1].next, Is.EqualTo(SecondPart(subTracks)[1])); // assert that intersecting node leads to last node
Assert.That(FirstPart(subTracks)[1].previous, Is.EqualTo(FirstPart(subTracks)[0])); // assert that intersecting node leads to previous node
Assert.That(SecondPart(subTracks)[1].previous, Is.EqualTo(SecondPart(subTracks)[0])); // assert that last node leads to intersecting node
}
public void withOffset_and_twoYAlignedNodesFacingForward_movesTrackForward()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 3, 0))
});
config.curveOffset = 0.25f;
BezierSpline spline = GetSplineNoSplits(trackDto, 0, 0);
AssertSplinePt(spline.pts[0], new Vector3(0.5f, 0, 0.75f), new Vector3(0.5f, 3, 0.75f));
}
public void withOffset_and_singleCurveRightFacingLeft_movesTrackCorrectly()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.left, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 2, 0)),
new TrackNodeDTO(null, new Vector3(2, 2, 0))
});
config.curveOffset = 0.25f;
BezierSpline spline = GetSplineNoSplits(trackDto, 0, 0);
Assert.That(spline.pts.Length, Is.EqualTo(3));
AssertSplinePt(spline.pts[0], new Vector3(0.25f, 0, 0.5f), new Vector3(0.25f, 2, 0.5f));
AssertSplinePt(spline.pts[1], new Vector3(0.25f, 2, 0.5f), new Vector3(1, 2.75f, 0.5f));
AssertSplinePt(spline.pts[2], new Vector3(1, 2.75f, 0.5f), new Vector3(2, 2.75f, 0.5f));
}
public void twoConsecutiveCurves_producesCorrectSpline()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 2, 0)),
new TrackNodeDTO(null, new Vector3(1, 2, 0)),
new TrackNodeDTO(null, new Vector3(1, 3, 0))
});
BezierSpline spline = GetSplineNoSplits(trackDto, 0, 0);
Assert.That(spline.pts.Length, Is.EqualTo(3));
AssertSplinePt(spline.pts[0], new Vector3(0.5f, 0, 0.5f), new Vector3(0.5f, 2, 0.5f));
AssertSplinePt(spline.pts[1], new Vector3(0.5f, 2, 0.5f), new Vector3(1, 2.5f, 0.5f));
AssertSplinePt(spline.pts[2], new Vector3(1, 2.5f, 0.5f), new Vector3(1.5f, 3f, 0.5f));
}
private BezierSpline[][] GetSplinesWithSplits(TrackDTO trackDto, Split[] splits)
{
SplitTrack splitTrack = splitter.SplitTrack(trackDto, splits);
return splitTrack.SubTracks.Select(subTrack => splineGenerator.GenerateSplines(splitTrack, subTrack)).ToArray();
}
public void twoZAlignedNodes_producesZLineBetween()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 0, 3))
});
BezierSpline spline = GetSplineNoSplits(trackDto, 0, 0);
Assert.That(spline.pts.Length, Is.EqualTo(1));
AssertSplinePt(spline.pts[0], new Vector3(0.5f, 0.5f, 0), new Vector3(0.5f, 0.5f, 3));
}
public void TrackCurvesRight_forwardAndBackValuesAreSetCorrectly()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.left, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 4, 0)),
new TrackNodeDTO(null, new Vector3(4, 4, 0))
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[]{ new Split("", Vector3.up, new Vector3(), 3, new SubSplit[0])}).SubTracks;
Assert.That(FirstPart(subTracks)[0].forward, Is.EqualTo(Vector3.up));
Assert.That(FirstPart(subTracks)[1].forward, Is.EqualTo(Vector3.up));
Assert.That(SecondPart(subTracks)[0].forward, Is.EqualTo(Vector3.up));
Assert.That(SecondPart(subTracks)[1].forward, Is.EqualTo(Vector3.up));
Assert.That(SecondPart(subTracks)[2].forward, Is.EqualTo(Vector3.right));
Assert.That(SecondPart(subTracks)[3].forward, Is.EqualTo(Vector3.right));
}
public void withOffset_and_twoXAlignedNodesFacingUpward_movesTrackUpward()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.up, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(3, 0, 0))
});
config.curveOffset = 0.25f;
BezierSpline spline = GetSplineNoSplits(trackDto, 0, 0);
Assert.That(spline.pts.Length, Is.EqualTo(1));
AssertSplinePt(spline.pts[0], new Vector3(0, 0.75f, 0.5f), new Vector3(3, 0.75f, 0.5f));
}
public void trackDoublesBack_createsTwoSubTracks()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(4, 0, 0)),
new TrackNodeDTO(null, new Vector3(4, 1, 0)),
new TrackNodeDTO(null, new Vector3(0, 1, 0))
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[]{
new Split("split_id", Vector3.right, new Vector3(), 2, new SubSplit[0])
}).SubTracks;
Assert.That(subTracks.Count, Is.EqualTo(2));
AssertSubtrackContainsNodes(subTracks[0], 0, new [] { new Vector3(0, 0, 0), new Vector3(2, 0, 0) });
AssertSubtrackContainsNodes(subTracks[1], 0, new [] { new Vector3(2, 0, 0), new Vector3(4, 0, 0), new Vector3(4, 0, 0), new Vector3(4, 1, 0), new Vector3(4, 1, 0), new Vector3(1, 1, 0) });
AssertSubtrackContainsNodes(subTracks[0], 1, new [] { new Vector3(1, 1, 0), new Vector3(0, 1, 0) });
}
public void trackCurvesRight_nextAndPreviousSetCorrectlyForCurveNodes()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.left, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 4, 0)),
new TrackNodeDTO(null, new Vector3(4, 4, 0))
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[0]).SubTracks;
Assert.That(FirstPart(subTracks)[0].next, Is.EqualTo(FirstPart(subTracks)[1]));
Assert.That(FirstPart(subTracks)[1].next, Is.EqualTo(FirstPart(subTracks)[2]));
Assert.That(FirstPart(subTracks)[2].next, Is.EqualTo(FirstPart(subTracks)[3]));
Assert.That(FirstPart(subTracks)[1].previous, Is.EqualTo(FirstPart(subTracks)[0]));
Assert.That(FirstPart(subTracks)[2].previous, Is.EqualTo(FirstPart(subTracks)[1]));
Assert.That(FirstPart(subTracks)[3].previous, Is.EqualTo(FirstPart(subTracks)[2]));
}
public void twoYAlignedNodes_splitXBetween_twoCorrectSubTracks()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(4, 0, 0))
});
Split[] splits = { new Split("split_1", Vector3.right, new Vector3(), 2, new SubSplit[0]) };
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, splits).SubTracks;
AssertSubtrackContainsNodes(subTracks[0], 0, new Vector3[] { new Vector3(0, 0, 0), new Vector3(2, 0, 0) });
AssertSubtrackContainsNodes(subTracks[1], 0, new Vector3[] { new Vector3(2, 0, 0), new Vector3(4, 0, 0) });
}
public void twoXAlignedNodes_splitYAboveBoth_oneSubtrackContainingBothNodes()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, null, new TrackNodeDTO[]{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 4, 0))
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new Split[] { new Split("split_id", Vector3.up, new Vector3(), 5, new SubSplit[0]) }).SubTracks;
Assert.That(subTracks.Count, Is.EqualTo(1));
AssertSubtrackContainsNodes(subTracks[0], 0, new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 4, 0) });
}
private BezierSpline GetSplineNoSplits(TrackDTO trackDto, int subTrackIdx, int groupIdx)
{
SplitTrack splitTrack = splitter.SplitTrack(trackDto, new Split[0]);
return splineGenerator.GenerateSplines(splitTrack, splitTrack.SubTracks[subTrackIdx])[groupIdx];
}
public void SplitsAtSamePointAsLastNode()
{
TrackDTO trackDto = new TrackDTO("id", Vector3.forward, Vector3.up, new []{
new TrackNodeDTO(null, new Vector3(0, 0, 0)),
new TrackNodeDTO(null, new Vector3(0, 3, 0)),
});
IList<SubTrack> subTracks = splitter.SplitTrack(trackDto, new []{
new Split("", Vector3.up, new Vector3(), 3, new SubSplit[0])
}).SubTracks;
Assert.That(subTracks.Count, Is.EqualTo(1));
}
