// Update is called once per frame
void Update()
{
if (started == true)
{
truck.MoveTruck(2);
truck.SteeringWheels(SeekPointFollow());
for (int i = 0; i < seekPoints.Length; i++)
{
seekPoints[i].pointPosition.z = truck._transform.position.z + 25f + truck.CurrentSpeed() * 0.05f;
}
for (int i = 0; i < seekPoints.Length; i++)
{
if (Physics.CheckSphere(seekPoints[i].pointPosition, 5, obstacleMsk))
{
seekPoints[i].isClosed = true;
}
else
{
seekPoints[i].isClosed = false;
}
}
for (int i = 0; i < seekPoints.Length; i++)
{
if (seekPoints[i].isClosed == false)
{
currentSeekPoint = seekPoints[i];
return;
}
}
}
}
/// ------------------------------------------------------------------------------------------------------------
/// <summary>
/// ■Seek (Sets the current position of this stream to the given value.)
/// </summary>
/// <param name="offset"> (I) The point relative to origin from which to begin seeking </param>
/// <param name="origin"> (I) Specifies the beginning, the end, or the current position as a reference point for origin </param>
/// <returns>
/// Return (O) the new position in the stream
/// </returns>
/// <exception>
/// Exception of System.IO.FileStream.Seek(long, SeekOrigin)
/// </exception>
/// <remarks>
/// Wrapper function System.IO.FileStream.Seek(long, SeekOrigin)
/// </remarks>
/// <history>
/// Ver.01.00.00.000 2013-06-05 (TSDV)hung.trinhhong Create
/// </history>
/// ------------------------------------------------------------------------------------------------------------
public long Seek(int offset, SeekPoint origin)
{
long position = 0;
if (m_BinaryRW != null)
{
// mapping Toshiba.BN.DataAccess.FileAccess.SeekPoint with Sytem.IO.SeekOrigin
SeekOrigin seekOrigin;
switch (origin)
{
case SeekPoint.Begin:
seekOrigin = SeekOrigin.Begin;
break;
case SeekPoint.End:
seekOrigin = SeekOrigin.End;
break;
default:
seekOrigin = SeekOrigin.Current;
break;
}
position = m_BinaryRW.Seek(offset, seekOrigin);
}
return(position);
}
public void CreateSeekTable()
{
ulong expectedNumberOfSamples; // Will be set while creating a new seekpoint
ulong expectedByteOffset; // Will be set while creating a new seekpoint
FileHelper.GetNewFile(origFile, newFile);
using (FlacFile flac = new FlacFile(newFile))
{
SeekTable seekTable = new SeekTable();
flac.Metadata.Add(seekTable);
// Create a new Seekpoint, a little further
SeekPoint newSeekpoint = new SeekPoint();
newSeekpoint.FirstSampleNumber = 1000;
newSeekpoint.NumberOfSamples = (ushort)1000;
expectedNumberOfSamples = newSeekpoint.NumberOfSamples;
newSeekpoint.ByteOffset = 0;
expectedByteOffset = newSeekpoint.ByteOffset;
seekTable.SeekPoints.Add(newSeekpoint);
// Create a placeholder seekpoint
SeekPoint placeHolder = new SeekPoint();
placeHolder.FirstSampleNumber = ulong.MaxValue;
// The other two values are "undefined"
Assert.IsTrue(placeHolder.IsPlaceHolder); // Already assert that the object itself handles this flac correctly.
seekTable.SeekPoints.Add(placeHolder);
// This should actually be allowed according to the FLAC format (multiple placeHolders are ok, but they must occur at the end of the seektable)
seekTable.SeekPoints.Add(placeHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual <int>(2, seekTable.SeekPoints.Placeholders);
flac.Save();
}
using (FlacFile flac = new FlacFile(newFile))
{
// Now we want to try and find our new SeekPoint
Assert.IsNotNull(flac.SeekTable);
Assert.IsTrue(flac.SeekTable.SeekPoints.ContainsKey(1000));
SeekPoint newSeekpoint = flac.SeekTable.SeekPoints[1000];
Assert.AreEqual <ulong>(expectedNumberOfSamples, newSeekpoint.NumberOfSamples);
Assert.AreEqual <ulong>(expectedByteOffset, newSeekpoint.ByteOffset);
Assert.IsFalse(newSeekpoint.IsPlaceHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual <int>(2, flac.SeekTable.SeekPoints.Placeholders);
}
}
/// <summary>
/// Creates a new SeekTable base on the provided binary data.
/// </summary>
/// <param name="data"></param>
public override void LoadBlockData(byte[] data)
{
UInt32 numberOfSeekpoints;
SeekPoint newSeekPoint;
numberOfSeekpoints = this.Header.MetaDataBlockLength / SEEKPOINT_SIZE;
for (int i = 0; i < numberOfSeekpoints; i++) {
newSeekPoint = new SeekPoint(BinaryDataHelper.GetDataSubset(data, i * (int)SEEKPOINT_SIZE, (int)SEEKPOINT_SIZE));
// We should keep in mind that the placeholder seekpoints aren't actually added to the list but are kept only as a
// count in this.SeekPoints.Placeholders
this.SeekPoints.Add(newSeekPoint);
}
}
/// <summary>
/// Execute the action.
/// </summary>
/// <param name='obj'>
/// Object doing the action
/// </param>
override public void Run(GameObject obj, ActionData data)
{
SeekPoint seek = obj.GetComponent <SeekPoint>();
if (seek == null)
{
seek = obj.AddComponent <SeekPoint>();
}
float hitT;
if (targetPos == Vector3.zero)
{
seek.targetPos = data.mousePos;
}
else
{
seek.targetPos = targetPos;
}
}
private IEnumerator latestart()
{
yield return(new WaitForSeconds(2f));
seekPoints = new SeekPoint[3];
for (int i = 0; i < seekPoints.Length; i++)
{
seekPoints[i] = new SeekPoint();
seekPoints[i].pointPosition = new Vector3();
}
currentSeekPoint = new SeekPoint();
currentSeekPoint.pointPosition = new Vector3();
for (int i = 0; i < seekPoints.Length; i++)
{
seekPoints[i].pointPosition.y = 0;
seekPoints[i].pointPosition.z = 15;
}
seekPoints[0].pointPosition.x = (truck._transform.right * 14).x;
seekPoints[2].pointPosition.x = -(truck._transform.right * 14).x;
started = true;
}
public override string ToString()
{
var filterParameters = new StringBuilder(100);
if (Resource != null)
{
FilterUtility.ConcatenateParameter(filterParameters, "filename", Resource.Path);
}
if (!string.IsNullOrWhiteSpace(FormatName))
{
FilterUtility.ConcatenateParameter(filterParameters, "f", FormatName);
}
if (SeekPoint.HasValue)
{
FilterUtility.ConcatenateParameter(filterParameters, "sp", SeekPoint.GetValueOrDefault());
}
if (!string.IsNullOrWhiteSpace(Streams))
{
FilterUtility.ConcatenateParameter(filterParameters, "s", Streams);
}
if (StreamIndex.HasValue)
{
FilterUtility.ConcatenateParameter(filterParameters, "si", StreamIndex.GetValueOrDefault());
}
if (Loop.HasValue)
{
FilterUtility.ConcatenateParameter(filterParameters, "loop", Loop.GetValueOrDefault());
}
return(FilterUtility.JoinTypeAndParameters(this, filterParameters));
}
public void CopyOpenEditAndSaveSeekTable()
{
ulong targetSampleNumber = 704512; // Will remove the seekpoint for this sample number ...
ulong expectedNumberOfSamples; // Will be set while creating a new seekpoint
ulong expectedByteOffset; // Will be set while creating a new seekpoint
string origFile = @"Data\testfile3.flac";
string newFile = @"Data\testfile3_temp.flac";
FileHelper.GetNewFile(origFile, newFile);
try
{
using (FlacFile flac = new FlacFile(newFile))
{
Assert.IsNotNull(flac.SeekTable);
// Will remove the at the given sample number ...
SeekPoint oldSeekpoint = flac.SeekTable.SeekPoints[targetSampleNumber];
flac.SeekTable.SeekPoints.Remove(targetSampleNumber);
// Create a new Seekpoint, a little further
SeekPoint newSeekpoint = new SeekPoint();
newSeekpoint.FirstSampleNumber = targetSampleNumber + 1000; // Put it a 1000 samples further ...
newSeekpoint.NumberOfSamples = (ushort)(oldSeekpoint.NumberOfSamples - (ushort)1000); // Since we are a 1000 further, we contain a 1000 less samples
expectedNumberOfSamples = newSeekpoint.NumberOfSamples;
newSeekpoint.ByteOffset = oldSeekpoint.ByteOffset;
expectedByteOffset = newSeekpoint.ByteOffset;
flac.SeekTable.SeekPoints.Add(newSeekpoint);
// Create a placeholder seekpoint
SeekPoint placeHolder = new SeekPoint();
placeHolder.FirstSampleNumber = ulong.MaxValue;
// The other two values are "undefined"
Assert.IsTrue(placeHolder.IsPlaceHolder); // Already assert that the object itself handles this flac correctly.
flac.SeekTable.SeekPoints.Add(placeHolder);
// This should actually be allowed according to the FLAC format (multiple placeHolders are ok, but they must occur at the end of the seektable)
flac.SeekTable.SeekPoints.Add(placeHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual <int>(2, flac.SeekTable.SeekPoints.Placeholders);
flac.Save();
}
using (FlacFile flac = new FlacFile(newFile))
{
// Now we want to try and find our new SeekPoint
Assert.IsNotNull(flac.SeekTable);
Assert.IsFalse(flac.SeekTable.SeekPoints.ContainsKey(targetSampleNumber));
Assert.IsTrue(flac.SeekTable.SeekPoints.ContainsKey(targetSampleNumber + 1000));
SeekPoint newSeekpoint = flac.SeekTable.SeekPoints[targetSampleNumber + 1000];
Assert.AreEqual <ulong>(expectedNumberOfSamples, newSeekpoint.NumberOfSamples);
Assert.AreEqual <ulong>(expectedByteOffset, newSeekpoint.ByteOffset);
Assert.IsFalse(newSeekpoint.IsPlaceHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual <int>(2, flac.SeekTable.SeekPoints.Placeholders);
}
}
finally
{
if (File.Exists(newFile))
{
File.Delete(newFile);
}
}
}
public void CopyOpenEditAndSaveSeekTable()
{
ulong targetSampleNumber = 704512; // Will remove the seekpoint for this sample number ...
ulong expectedNumberOfSamples; // Will be set while creating a new seekpoint
ulong expectedByteOffset; // Will be set while creating a new seekpoint
string origFile = @"Data\testfile3.flac";
string newFile = @"Data\testfile3_temp.flac";
FileHelper.GetNewFile(origFile, newFile);
try
{
using (FlacFile flac = new FlacFile(newFile))
{
Assert.IsNotNull(flac.SeekTable);
// Will remove the at the given sample number ...
SeekPoint oldSeekpoint = flac.SeekTable.SeekPoints[targetSampleNumber];
flac.SeekTable.SeekPoints.Remove(targetSampleNumber);
// Create a new Seekpoint, a little further
SeekPoint newSeekpoint = new SeekPoint();
newSeekpoint.FirstSampleNumber = targetSampleNumber + 1000; // Put it a 1000 samples further ...
newSeekpoint.NumberOfSamples = (ushort)(oldSeekpoint.NumberOfSamples - (ushort)1000); // Since we are a 1000 further, we contain a 1000 less samples
expectedNumberOfSamples = newSeekpoint.NumberOfSamples;
newSeekpoint.ByteOffset = oldSeekpoint.ByteOffset;
expectedByteOffset = newSeekpoint.ByteOffset;
flac.SeekTable.SeekPoints.Add(newSeekpoint);
// Create a placeholder seekpoint
SeekPoint placeHolder = new SeekPoint();
placeHolder.FirstSampleNumber = ulong.MaxValue;
// The other two values are "undefined"
Assert.IsTrue(placeHolder.IsPlaceHolder); // Already assert that the object itself handles this flac correctly.
flac.SeekTable.SeekPoints.Add(placeHolder);
// This should actually be allowed according to the FLAC format (multiple placeHolders are ok, but they must occur at the end of the seektable)
flac.SeekTable.SeekPoints.Add(placeHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual<int>(2, flac.SeekTable.SeekPoints.Placeholders);
flac.Save();
}
using (FlacFile flac = new FlacFile(newFile))
{
// Now we want to try and find our new SeekPoint
Assert.IsNotNull(flac.SeekTable);
Assert.IsFalse(flac.SeekTable.SeekPoints.ContainsKey(targetSampleNumber));
Assert.IsTrue(flac.SeekTable.SeekPoints.ContainsKey(targetSampleNumber + 1000));
SeekPoint newSeekpoint = flac.SeekTable.SeekPoints[targetSampleNumber + 1000];
Assert.AreEqual<ulong>(expectedNumberOfSamples, newSeekpoint.NumberOfSamples);
Assert.AreEqual<ulong>(expectedByteOffset, newSeekpoint.ByteOffset);
Assert.IsFalse(newSeekpoint.IsPlaceHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual<int>(2, flac.SeekTable.SeekPoints.Placeholders);
}
}
finally
{
if (File.Exists(newFile))
{
File.Delete(newFile);
}
}
}
/// <summary>
/// Will write the data describing this metadata block to the given stream.
/// </summary>
/// <param name="targetStream">Stream to write the data to.</param>
public override void WriteBlockData(Stream targetStream)
{
this.Header.MetaDataBlockLength = (uint)(SeekPoints.Count + SeekPoints.Placeholders) * SEEKPOINT_SIZE;
this.Header.WriteHeaderData(targetStream);
foreach (var seekPoint in this.SeekPoints)
{
seekPoint.Value.WriteData(targetStream);
}
SeekPoint placeholder = new SeekPoint();
placeholder.FirstSampleNumber = ulong.MaxValue;
for (int i = 0; i < SeekPoints.Placeholders; i++)
{
// Here, we shall actually physically write placeholders, even though they don't really exist in memory ...
// Again: this is a weird unnatural way to support multiple placeholders and it should be changed at some point!
placeholder.WriteData(targetStream);
}
}
public void CreateSeekTable()
{
ulong expectedNumberOfSamples; // Will be set while creating a new seekpoint
ulong expectedByteOffset; // Will be set while creating a new seekpoint
FileHelper.GetNewFile(origFile, newFile);
using (FlacFile flac = new FlacFile(newFile))
{
SeekTable seekTable = new SeekTable();
flac.Metadata.Add(seekTable);
// Create a new Seekpoint, a little further
SeekPoint newSeekpoint = new SeekPoint();
newSeekpoint.FirstSampleNumber = 1000;
newSeekpoint.NumberOfSamples = (ushort)1000;
expectedNumberOfSamples = newSeekpoint.NumberOfSamples;
newSeekpoint.ByteOffset = 0;
expectedByteOffset = newSeekpoint.ByteOffset;
seekTable.SeekPoints.Add(newSeekpoint);
// Create a placeholder seekpoint
SeekPoint placeHolder = new SeekPoint();
placeHolder.FirstSampleNumber = ulong.MaxValue;
// The other two values are "undefined"
Assert.IsTrue(placeHolder.IsPlaceHolder); // Already assert that the object itself handles this flac correctly.
seekTable.SeekPoints.Add(placeHolder);
// This should actually be allowed according to the FLAC format (multiple placeHolders are ok, but they must occur at the end of the seektable)
seekTable.SeekPoints.Add(placeHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual<int>(2, seekTable.SeekPoints.Placeholders);
flac.Save();
}
using (FlacFile flac = new FlacFile(newFile))
{
// Now we want to try and find our new SeekPoint
Assert.IsNotNull(flac.SeekTable);
Assert.IsTrue(flac.SeekTable.SeekPoints.ContainsKey(1000));
SeekPoint newSeekpoint = flac.SeekTable.SeekPoints[1000];
Assert.AreEqual<ulong>(expectedNumberOfSamples, newSeekpoint.NumberOfSamples);
Assert.AreEqual<ulong>(expectedByteOffset, newSeekpoint.ByteOffset);
Assert.IsFalse(newSeekpoint.IsPlaceHolder);
// Check if we actually get "2" placeholders ...
Assert.AreEqual<int>(2, flac.SeekTable.SeekPoints.Placeholders);
}
}
