public void LoadTrack(TrackSavable track)
{
CurrentTrackState = TrackState.TrackEmpty;
CurrentTrack = track;
//clear tiles left from the old loaded track
for (int i = 0; i < MapParentTransform.childCount; i++)
{
Destroy(MapParentTransform.GetChild(i).gameObject);
}
GetComponent <TerrainManager>().GenerateTerrain();
Tiles = new List <List <Transform> >(track.Height);
for (int y = 0; y < track.Height; y++)
{
Tiles.Add(new List <Transform>(track.Width));
for (int x = 0; x < track.Width; x++)
{
GameObject newTile = (GameObject)Instantiate(TilePrefab, Vector3.zero, Quaternion.identity);
newTile.name = x + ":" + y + " ";
newTile.transform.SetParent(MapParentTransform);
newTile.AddComponent <Tile>();
Tiles[y].Add(newTile.transform);
UpdateTileAt(x, y);
}
}
GetComponent <ToolManager>().OnMapSizeChange();
Camera.main.transform.position = new Vector3(CurrentTrack.Width * 10, 300, CurrentTrack.Height * -10);
CurrentTrackState = TrackState.TrackLoaded;
}
void OnGUI()
{
//GUI.skin = Skin;
if (GUI.Button(new Rect(5, 5, 160, 35), "Load map"))
{
string[] path = StandaloneFileBrowser.OpenFilePanel("Open trk file", CrashdayPath + "/user/", "trk", false);
if (path.Length != 0 && path[0].Length != 0)
{
PlayerPrefs.SetString("lastmappath", path[0]);
Track = MapParser.ReadMap(path[0]);
GetComponent <TrackManager>().LoadTrack(Track);
}
}
if (GUI.Button(new Rect(175, 5, 160, 35), "Save map"))
{
string path = StandaloneFileBrowser.SaveFilePanel("Save trk file", CrashdayPath + "/user/", "my_awesome_track", "trk");
if (path.Length != 0)
{
MapParser.SaveMap(GetComponent <TrackManager>().CurrentTrack, path);
}
}
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="old">Old track to copy parameters from</param>
public TrackSavable(TrackSavable old)
{
Author = old.Author;
Comment = old.Comment;
Style = old.Style;
Ambience = old.Ambience;
FieldFilesNumber = old.FieldFilesNumber;
FieldFiles = new List <string>(FieldFilesNumber);
foreach (var ff in old.FieldFiles)
{
FieldFiles.Add(ff);
}
Height = old.Height;
Width = old.Width;
TrackTiles = new List <List <TrackTileSavable> >(Height);
for (int y = 0; y < Height; y++)
{
TrackTiles.Add(new List <TrackTileSavable>(Width));
for (int x = 0; x < Width; x++)
{
TrackTiles[y].Add(new TrackTileSavable(old.TrackTiles[y][x]));
}
}
DynamicObjectFilesNumber = old.DynamicObjectFilesNumber;
DynamicObjectFiles = new List <string>(DynamicObjectFilesNumber);
foreach (var dof in old.DynamicObjectFiles)
{
DynamicObjectFiles.Add(dof);
}
DynamicObjectsNumber = old.DynamicObjectsNumber;
DynamicObjects = new List <DynamicObjectSavable>(DynamicObjectsNumber);
foreach (var d in old.DynamicObjects)
{
DynamicObjects.Add(d);
}
CheckpointsNumber = old.CheckpointsNumber;
Checkpoints = new List <ushort>(CheckpointsNumber);
foreach (var cp in old.Checkpoints)
{
Checkpoints.Add(cp);
}
Permission = old.Permission;
GroundBumpyness = old.GroundBumpyness;
Scenery = old.Scenery;
Heightmap = new List <List <float> >(Height * 4 + 1);
for (int y = 0; y < Height * 4 + 1; y++)
{
Heightmap.Add(new List <float>(Width * 4 + 1));
for (int x = 0; x < Width * 4 + 1; x++)
{
Heightmap[y].Add(old.Heightmap[y][x]);
}
}
}
/// <summary>
/// creates new resized track using tiles of old track as feed. Checkpoints are not loaded.
/// </summary>
/// <param name="old"></param>
/// <param name="newwidth"></param>
/// <param name="newheight"></param>
// info about checkpoints is ignored and is completely rebuilt depending on gameobjects in world, not on trk file
public TrackSavable(TrackSavable old, int plusR, int plusL, int plusUp, int plusDown)
{
CheckpointsNumber = 0;
Checkpoints = new List <ushort>();
Author = old.Author;
Comment = old.Comment;
Style = old.Style;
Ambience = old.Ambience;
Height = (ushort)(old.Height + plusUp + plusDown);
Width = (ushort)(old.Width + plusR + plusL);
FieldFilesNumber = 1;
FieldFiles = new List <string>()
{
"field.cfl"
};
TrackTiles = new List <List <TrackTileSavable> >(Height);
for (int y = 0; y < Height; y++)
{
TrackTiles.Add(new List <TrackTileSavable>(Width));
for (int x = 0; x < Width; x++)
{
// place trackpiece to translated location. If exceeding old dims, place grass
if (y - plusUp >= 0 && y - plusUp < old.Height && x - plusL >= 0 && x - plusL < old.Width)
{
TrackTiles[y].Add(new TrackTileSavable(old.TrackTiles[y - plusUp][x - plusL]));
// update fieldID (ignore quarters)
if (TrackTiles[y][x].FieldId < 65400)
{
string tilename = old.FieldFiles[TrackTiles[y][x].FieldId];
bool found = false;
for (ushort i = 0; i < FieldFiles.Count; i++)
{
if (tilename == FieldFiles[i])
{
TrackTiles[y][x].FieldId = i;
found = true;
break;
}
}
if (!found)
{
FieldFiles.Add(tilename);
TrackTiles[y][x].FieldId = FieldFilesNumber;
FieldFilesNumber++;
}
}
}
else
{
TrackTiles[y].Add(new TrackTileSavable(0, 0, 0, 0));
}
}
}
DynamicObjectsNumber = 0;
DynamicObjectFilesNumber = 0;
DynamicObjects = new List <DynamicObjectSavable>();
DynamicObjectFiles = new List <string>();
foreach (DynamicObjectSavable olddos in old.DynamicObjects)
{
if (olddos.Position.x >= -plusL * 20 && olddos.Position.z <= plusUp * 20 &&
olddos.Position.x <= 20 * (Width - plusL) && olddos.Position.z >= 20 * (plusUp - Height))
{
DynamicObjectSavable dos = new DynamicObjectSavable(olddos);
DynamicObjects.Add(dos);
dos.Position = new Vector3(olddos.Position.x + plusL * 20, olddos.Position.y, olddos.Position.z - plusUp * 20);
DynamicObjectsNumber++;
Debug.Log(olddos.Position == dos.Position);
string dof = old.DynamicObjectFiles[olddos.ObjectId];
if (!DynamicObjectFiles.Contains(dof))
{
DynamicObjectFiles.Add(dof);
dos.ObjectId = DynamicObjectFilesNumber;
DynamicObjectFilesNumber++;
}
else
{
dos.ObjectId = (ushort)DynamicObjectFiles.IndexOf(dof);
}
}
}
Permission = old.Permission;
GroundBumpyness = old.GroundBumpyness;
Scenery = old.Scenery;
Heightmap = new List <List <float> >(Height * 4 + 1);
for (int y = 0; y <= Height * 4; y++)
{
Heightmap.Add(new List <float>(Width * 4 + 1));
for (int x = 0; x <= Width * 4; x++)
{
if (x == 0 || x == 4 * Width || y == 0 || y == 4 * Height)
{
Heightmap[y].Add(old.Heightmap[0][0]);
}
else if (y - 4 * plusUp >= 0 && y - 4 * plusUp <= old.Height * 4 && x - 4 * plusL >= 0 && x - 4 * plusL <= old.Width * 4)
{
Heightmap[y].Add(old.Heightmap[y - 4 * plusUp][x - 4 * plusL]);
}
else
{
Heightmap[y].Add(0);
}
}
}
}
//reads map from file to Track object
public static TrackSavable ReadMap(string path)
{
TrackSavable Track = new TrackSavable();
List <byte> data = new List <byte>(File.ReadAllBytes(path));
ByteFileParser io = new ByteFileParser(data);
//ignore "CDTRK" string in the start of the file
io.SetReadingOffest(5);
//unused current time thing
Track.CurrentTime = io.ReadInt();
//author
Track.Author = io.ReadString();
//comment
Track.Comment = io.ReadString();
//skip unneeded block
for (int n = 0; n < 20; n++)
{
io.ReadInt();
io.ReadString();
}
//track style (race, derby, htf)
Track.Style = io.ReadByte();
//ambience
Track.Ambience = io.ReadString();
//amount of fileds used on map
Track.FieldFilesNumber = io.ReadUShort();
//name of fields
Track.FieldFiles = new List <string>(Track.FieldFilesNumber);
for (int n = 0; n < Track.FieldFilesNumber; n++)
{
Track.FieldFiles.Add(io.ReadString());
}
//width and height in tiles
Track.Width = io.ReadUShort();
Track.Height = io.ReadUShort();
Track.TrackTiles = new List <List <TrackTileSavable> >(Track.Height);
for (int y = 0; y < Track.Height; y++)
{
Track.TrackTiles.Add(new List <TrackTileSavable>(Track.Width));
for (int x = 0; x < Track.Width; x++)
{
TrackTileSavable newTile = new TrackTileSavable();
newTile.FieldId = io.ReadUShort();
newTile.Rotation = io.ReadByte();
newTile.IsMirrored = io.ReadByte();
newTile.Height = io.ReadByte();
Track.TrackTiles[y].Add(newTile);
}
}
Track.DynamicObjectFilesNumber = io.ReadUShort();
Track.DynamicObjectFiles = new List <string>(Track.DynamicObjectFilesNumber);
for (int i = 0; i < Track.DynamicObjectFilesNumber; i++)
{
Track.DynamicObjectFiles.Add(io.ReadString());
}
Track.DynamicObjectsNumber = io.ReadUShort();
Track.DynamicObjects = new List <DynamicObjectSavable>(Track.DynamicObjectsNumber);
for (int i = 0; i < Track.DynamicObjectsNumber; i++)
{
DynamicObjectSavable newDynamicObject = new DynamicObjectSavable();
newDynamicObject.ObjectId = io.ReadUShort();
newDynamicObject.Position = io.ReadVector3();
newDynamicObject.Rotation = io.ReadFloat();
Track.DynamicObjects.Add(newDynamicObject);
}
Track.CheckpointsNumber = io.ReadUShort();
Track.Checkpoints = new List <ushort>(Track.CheckpointsNumber);
for (int i = 0; i < Track.CheckpointsNumber; i++)
{
Track.Checkpoints.Add(io.ReadUShort());
}
Track.Permission = io.ReadByte();
Track.GroundBumpyness = io.ReadFloat();
Track.Scenery = io.ReadByte();
Track.Heightmap = new List <List <float> >();
for (int y = 0; y < Track.Height * 4 + 1; y++)
{
Track.Heightmap.Add(new List <float>());
for (int x = 0; x < Track.Width * 4 + 1; x++)
{
Track.Heightmap[y].Add(io.ReadFloat());
}
}
return(Track);
}
public static void SaveMap(TrackSavable track, string path)
{
List <byte> bytes = new List <byte>();
ByteFileParser io = new ByteFileParser(bytes);
//ignore "CDTRK" string in the start of the file
io.WriteFlag("CDTRK");
//unused current time thing
io.WriteInt(track.CurrentTime);
//author
io.WriteString(track.Author);
//comment
io.WriteString(track.Comment);
//skip unneeded block
for (int n = 0; n < 20; n++)
{
io.WriteInt(1);
io.WriteString("CDTrack editor by Wurunduk");
}
//track style (race, derby, htf)
io.WriteByte(track.Style);
//ambience
io.WriteString(track.Ambience);
//amount of fileds used on map
io.WriteUShort(track.FieldFilesNumber);
//name of fields
for (int n = 0; n < track.FieldFilesNumber; n++)
{
io.WriteString(track.FieldFiles[n]);
}
//width and height in tiles
io.WriteUShort(track.Width);
io.WriteUShort(track.Height);
for (int y = 0; y < track.Height; y++)
{
for (int x = 0; x < track.Width; x++)
{
io.WriteUShort(track.TrackTiles[y][x].FieldId);
io.WriteByte(track.TrackTiles[y][x].Rotation);
io.WriteByte(track.TrackTiles[y][x].IsMirrored);
io.WriteByte(track.TrackTiles[y][x].Height);
}
}
io.WriteUShort(track.DynamicObjectFilesNumber);
for (int i = 0; i < track.DynamicObjectFilesNumber; i++)
{
io.WriteString(track.DynamicObjectFiles[i]);
}
io.WriteUShort(track.DynamicObjectsNumber);
for (int i = 0; i < track.DynamicObjectsNumber; i++)
{
io.WriteUShort(track.DynamicObjects[i].ObjectId);
io.WriteVector3(track.DynamicObjects[i].Position);
io.WriteFloat(track.DynamicObjects[i].Rotation);
}
io.WriteUShort(track.CheckpointsNumber);
for (int i = 0; i < track.CheckpointsNumber; i++)
{
io.WriteUShort(track.Checkpoints[i]);
}
io.WriteByte(track.Permission);
io.WriteFloat(track.GroundBumpyness);
io.WriteByte(track.Scenery);
for (int y = 0; y < track.Height * 4 + 1; y++)
{
for (int x = 0; x < track.Width * 4 + 1; x++)
{
io.WriteFloat(track.Heightmap[y][x]);
}
}
File.WriteAllBytes(path, io.Data.ToArray());
}
public void UpdateTrackSize(int addLeft, int addRight, int addUp, int addDown)
{
//TODO:
//Move DynamicObjects
TrackSavable newTrack = new TrackSavable(CurrentTrack);
newTrack.Width += (ushort)(addLeft + addRight);
newTrack.Height += (ushort)(addUp + addDown);
List <ushort> newCPs = new List <ushort>();
for (int i = 0; i < CurrentTrack.CheckpointsNumber; i++)
{
int newPosX = CurrentTrack.Checkpoints[i] % CurrentTrack.Width;
int newPosY = CurrentTrack.Checkpoints[i] / CurrentTrack.Height;
newPosX += addLeft;
newPosY += addUp;
if (newPosX >= 0 && newPosX < newTrack.Width && newPosY >= 0 && newPosY < newTrack.Height)
{
newCPs.Add((ushort)(newPosY * newTrack.Width + newPosX));
}
}
newTrack.CheckpointsNumber = (ushort)newCPs.Count;
newTrack.Checkpoints = newCPs;
newTrack.TrackTiles = new List <List <TrackTileSavable> >(newTrack.Height);
for (int y = 0; y < newTrack.Height; y++)
{
newTrack.TrackTiles.Add(new List <TrackTileSavable>(newTrack.Width));
for (int x = 0; x < newTrack.Width; x++)
{
TrackTileSavable tile;
if (x - addLeft >= 0 && y - addUp >= 0 && x - addLeft < CurrentTrack.Width && y - addUp < CurrentTrack.Height)
{
tile = new TrackTileSavable(CurrentTrack.TrackTiles[y - addUp][x - addLeft]);
}
else
{
tile = new TrackTileSavable(0, 0, 0, 0);
}
newTrack.TrackTiles[y].Add(tile);
}
}
newTrack.Heightmap = new List <List <float> >(newTrack.Height * 4 + 1);
for (int y = 0; y < newTrack.Height * 4 + 1; y++)
{
newTrack.Heightmap.Add(new List <float>(newTrack.Width * 4 + 1));
for (int x = 0; x < newTrack.Width * 4 + 1; x++)
{
if (x + addLeft * 4 >= 0 && y + addUp * 4 >= 0 && x + addLeft * 4 < CurrentTrack.Width * 4 + 1 && y + addUp * 4 < CurrentTrack.Height * 4 + 1)
{
newTrack.Heightmap[y].Add(CurrentTrack.Heightmap[y + addUp * 4][x + addLeft * 4]);
}
else
{
newTrack.Heightmap[y].Add(0.0f);
}
}
}
LoadTrack(newTrack);
GetComponent <ToolManager>().OnMapSizeChange();
}
