public static void Append(this StringBuilder builder, FixedString128 fixedString)
{
foreach (var c in fixedString)
{
builder.Append((char)c.value);
}
}
/// <summary>
/// Writes the string representation of a specified 64-bit floating-point number to the buffer.
/// </summary>
/// <param name="value">The value to write.</param>
public void Write(double value)
{
FixedString128 f = default;
f.Format((float)value);
Write(f);
}
/// <summary>
/// Writes the string representation of a specified 32-bit unsigned integer to the buffer.
/// </summary>
/// <param name="value">The value to write.</param>
public void Write(uint value)
{
FixedString128 f = default;
f.Append(value);
Write(f);
}
internal void AddOrUpdateString(FixedString128 key, TinyJsonObject value)
{
JsonKeyHandle jsonRefHandle;
if (m_RootObjMap.ContainsKey(key))
{
jsonRefHandle = m_RootObjMap[key];
if (JsonKeyType(jsonRefHandle) == JsonValueType.String)
{
UpdateStringBufferFromObjectBasedOnVariant(value, jsonRefHandle);
return;
}
// remove the old type completely and add a new one as normal
RemoveValueFromBuffer(jsonRefHandle);
}
jsonRefHandle = new JsonKeyHandle(ref this, JsonValueType.String, m_StringBuffer.Length);
if (!value.m_StringVal.IsEmpty)
{
m_StringBuffer.Add(value.m_StringVal[0]);
value.m_StringVal.Dispose();
}
else
{
m_StringBuffer.Add(value.m_Data.m_StringBuffer[value.m_Data.LocationInValueBuffer(value.m_StringRefHandle)]);
}
value.m_StringVal.Dispose();
m_RootObjMap[key] = jsonRefHandle;
}
public static unsafe bool WriteToDisk(FixedString128 gameSaveFilePath, MemoryBinaryWriter writer)
{
Baselib_ErrorState errorState = new Baselib_ErrorState();
Baselib_FileIO_SyncFile gameSaveFileHandle = Baselib_FileIO_SyncOpen(gameSaveFilePath.GetUnsafePtr(), Baselib_FileIO_OpenFlags.CreateAlways | Baselib_FileIO_OpenFlags.Write, &errorState);
if (errorState.code != Baselib_ErrorCode.Success)
{
return(false);
}
Baselib_FileIO_SyncWrite(gameSaveFileHandle, 0, (IntPtr)writer.Data, (uint)writer.Length, &errorState);
if (errorState.code != Baselib_ErrorCode.Success)
{
return(false);
}
Baselib_FileIO_SyncFlush(gameSaveFileHandle, &errorState);
if (errorState.code != Baselib_ErrorCode.Success)
{
return(false);
}
// If we get this far, we'll consider the write a success because it should have been completed.
Baselib_FileIO_SyncClose(gameSaveFileHandle, &errorState);
return(true);
}
/**
* Adds the object to the correct buffer associated with the provided key.
*/
internal void AddOrUpdateField(FixedString128 key, TinyJsonObject value)
{
switch (value.Type)
{
case JsonValueType.Bool:
AddOrUpdateBool(key, value);
break;
case JsonValueType.Int:
AddOrUpdateInt(key, value);
break;
case JsonValueType.Float:
AddOrUpdateFloat(key, value);
break;
case JsonValueType.String:
AddOrUpdateString(key, value);
break;
case JsonValueType.Array:
var tinyJsonArray = value.AsArray();
AddOrUpdateArray(key, ref tinyJsonArray);
break;
case JsonValueType.Object:
AddOrUpdateObject(key, ref value.m_Data);
break;
default:
InvalidJsonTypeException();
return;
}
}
/// <summary>
/// Writes the specified 64-bit signed integer value to the buffer with the correct formatting.
/// </summary>
/// <param name="value">The value to write.</param>
public void WriteValue(long value)
{
FixedString128 f = default;
f.Append(value);
WriteValue(f);
}
public static unsafe bool PullCompletedReadBuffer(FixedString128 gameSaveFilePath, byte *buffer, int bufferLength)
{
for (int i = 0; i < gameSaveReadFiles.Length; i++)
{
if (gameSaveReadFiles[i].filePath == gameSaveFilePath)
{
Baselib_ErrorState errorState = new Baselib_ErrorState();
bool result = false;
UInt64 fileSize = Baselib_FileIO_SyncGetFileSize(gameSaveReadFiles[i].fileHandle, &errorState);
if ((errorState.code == Baselib_ErrorCode.Success) && ((int)fileSize == bufferLength))
{
Baselib_FileIO_SyncRead(gameSaveReadFiles[i].fileHandle, 0, (IntPtr)buffer, fileSize, &errorState);
if (errorState.code == Baselib_ErrorCode.Success)
{
result = true;
}
}
Baselib_FileIO_SyncClose(gameSaveReadFiles[i].fileHandle, &errorState);
gameSaveReadFiles.RemoveAtSwapBack(i);
return(result);
}
}
return(false);
}
void Load(ref ClientMenuState state, ClientMenuState.Menu menu, FixedString128 name)
{
state.IsLoading = true;
state.LastLoadingMenu = menu;
state.LastLoadingMenuName = name;
SceneManager.LoadScene(name.ToString(), LoadSceneMode.Additive);
}
public unsafe bool WriteFixedString128(FixedString128 str)
{
int length = (int)*((ushort *)&str) + 2;
byte *data = ((byte *)&str);
return(WriteBytes(data, length));
}
public unsafe bool WritePackedFixedString128Delta(FixedString128 str, FixedString128 baseline, NetworkCompressionModel model)
{
ushort length = *((ushort *)&str);
byte * data = ((byte *)&str) + 2;
return(WritePackedFixedStringDelta(data, length, ((byte *)&baseline) + 2, *((ushort *)&baseline), model));
}
internal void AddOrUpdateArray(FixedString128 key, ref TinyJsonArray source)
{
var newArray = AddOrReplaceArrayField(key);
CheckNotSameDataAllocation(source.m_Data, this);
newArray.DeepCopyArrayValues(ref source);
}
/// <summary>
/// Writes the string representation of a specified 64-bit unsigned integer to the buffer.
/// </summary>
/// <param name="value">The value to write.</param>
public void Write(ulong value)
{
FixedString128 f = default;
f.Format(value);
Write(f);
}
public static void IsTrue(bool b, FixedString128 s)
{
if (!b)
{
Debug.Log(FixedString.Format("<color=red>##### ASSERT => {0}</color>", s));
throw new AssertException();
}
}
public unsafe void PushValueField(FixedString128 key, FixedString4096 value)
{
AddCommaIfRequired();
ValidateInObject();
FixedString128 str = $"\"{key}\": \"{value}\"";
m_Buffer.Append(str.GetUnsafePtr(), str.Length);
}
public unsafe FixedString128 ReadPackedFixedString128Delta(FixedString128 baseline, NetworkCompressionModel model)
{
FixedString128 str;
byte * data = ((byte *)&str) + 2;
*(ushort *)&str = ReadPackedFixedStringDelta(data, str.Capacity, ((byte *)&baseline) + 2, *((ushort *)&baseline), model);
return(str);
}
protected override void OnUpdate()
{
if (m_rlsQuery.CalculateChunkCount() > 0)
{
FixedString128 targetScene = new FixedString128();
bool isInvalid = false;
Entities.ForEach((ref RequestLoadScene rls) =>
{
if (rls.newScene.UTF8LengthInBytes == 0)
{
return;
}
if (targetScene.Length == 0)
{
targetScene = rls.newScene;
}
else if (rls.newScene != targetScene)
{
isInvalid = true;
}
}).Run();
if (targetScene.Length > 0)
{
if (isInvalid)
{
UnityEngine.Debug.LogError("Multiple scenes were requested to load during the previous frame.");
}
else
{
var curr = worldGlobalEntity.GetComponentData <CurrentScene>();
curr.previousScene = curr.currentScene;
UnityEngine.Debug.Log("Loading scene: " + targetScene);
SceneManager.LoadScene(targetScene.ToString());
latiosWorld.pauseForSceneLoad = true;
curr.currentScene = targetScene;
curr.isSceneFirstFrame = true;
worldGlobalEntity.SetComponentData(curr);
return;
}
}
}
//Handle case where initial scene loads or set firstFrame to false
var currentScene = worldGlobalEntity.GetComponentData <CurrentScene>();
if (currentScene.currentScene.UTF8LengthInBytes == 0)
{
currentScene.currentScene = SceneManager.GetActiveScene().name;
currentScene.isSceneFirstFrame = true;
}
else
{
currentScene.isSceneFirstFrame = false;
}
worldGlobalEntity.SetComponentData(currentScene);
}
public unsafe void PushValueField(FixedString128 key, bool value)
{
AddCommaIfRequired();
ValidateInObject();
var boolString = (value ? (FixedString128)"true" : (FixedString128)"false");
FixedString128 str = $"\"{key}\": {boolString}";
m_Buffer.Append(str.GetUnsafePtr(), str.Length);
}
public unsafe void PushArrayField(FixedString128 key)
{
AddCommaIfRequired();
ValidateInObject();
m_Stack.Push(k_EmptyArray);
FixedString128 str = $"\"{key}\": [";
m_Buffer.Append(str.GetUnsafePtr(), str.Length);
}
public void WordStorageFixedString128Works(String value)
{
NumberedWords w = new NumberedWords();
FixedString128 fixedString = default;
w.SetString(value);
w.ToFixedString(ref fixedString);
Assert.AreEqual(value, fixedString.ToString());
}
public void RemoveField(FixedString128 key)
{
CheckIsCorrectType(JsonValueType.Object, Type);
if (!m_Data.m_RootObjMap.ContainsKey(key))
{
ThrowKeyNotFoundException(key);
}
m_Data.RemoveValueFromBuffer(m_Data.m_RootObjMap[key]);
m_Data.m_RootObjMap.Remove(key);
}
/// <summary>
/// Writes the specified fixed string to the buffer as a literal.
/// </summary>
/// <param name="value">The string value to write.</param>
void WriteValue(FixedString128 value)
{
var value_ptr = UnsafeUtility.AddressOf(ref value);
var value_len = *(ushort *)value_ptr;
var value_bytes = (byte *)value_ptr + sizeof(ushort);
var utf16_buffer = stackalloc char[value_len];
// This is not actually correct -- We need Utf8ToUCS but that doesn't exist
Unicode.Utf8ToUtf16(value_bytes, value_len, utf16_buffer, out var utf16_length, value_len);
WriteValueLiteral(utf16_buffer, utf16_length);
}
public unsafe int PushValueToArray(bool value)
{
AddCommaIfRequired();
ValidateInArray();
int index = m_Stack.Peek();
FixedString128 str = value ? (FixedString128)"true" : (FixedString128)"false";
m_Buffer.Append(str.GetUnsafePtr(), str.Length);
m_Stack.IncrementTop();
return(index);
}
/// <summary>
/// Writes a copy of the specified <see cref="FixedString128"/> to the buffer.
/// </summary>
/// <param name="value">The value to write.</param>
void Write(FixedString128 value)
{
var capacity = value.UTF8LengthInBytes;
var utf16_buffer = stackalloc char[capacity];
fixed(FixedListByte128 *c = &value.AsFixedList)
{
Unicode.Utf8ToUtf16((byte *)c + sizeof(ushort), value.UTF8LengthInBytes, utf16_buffer, out var utf16_length, capacity);
Write(utf16_buffer, utf16_length);
}
}
public void ReadWriteFixedString128()
{
var dataStream = new DataStreamWriter(300 * 4, Allocator.Temp);
var src = new FixedString128("This is a string");
dataStream.WriteFixedString128(src);
//Assert.AreEqual(src.LengthInBytes+2, dataStream.Length);
var reader = new DataStreamReader(dataStream.AsNativeArray());
var dst = reader.ReadFixedString128();
Assert.AreEqual(src, dst);
}
/** Creates a new, empty object field or replaces an old one, deleting its data */
internal TinyJsonObject CreateObjectField(FixedString128 key)
{
// delete old object
if (m_RootObjMap.ContainsKey(key))
{
var objectHandle = m_RootObjMap[key];
RemoveValueFromBuffer(objectHandle);
}
// create new one
var jsonValRef = CreateNestedObject(out var value);
m_RootObjMap[key] = jsonValRef;
return(value);
}
/**
* Creates a new, empty array associated with the key. Replaces the key if it exists.
*/
internal TinyJsonArray AddOrReplaceArrayField(FixedString128 key)
{
// delete old key
if (m_RootObjMap.ContainsKey(key))
{
var handle = m_RootObjMap[key];
RemoveValueFromBuffer(handle);
}
// create new array
var jsonValRef = CreateNestedArray(out var array);
m_RootObjMap[key] = jsonValRef;
return(array);
}
protected override void OnUpdate()
{
var terminalEntity = _termQuery.GetSingletonEntity();
var jobData = new TerminalJobContext(this, terminalEntity, false);
Entities
.WithChangeFilter <UILogBuffer, HitPointsUI>()
//.WithoutBurst()
.ForEach((
ref DynamicBuffer <UILogBuffer> logBuffer,
in HitPointsUI hp) =>
{
var term = jobData.GetAccessor();
if (term.Length == 0)
{
return;
}
term.ClearScreen();
term.DrawBorder();
var emptyColor = new Color(0.05f, 0.05f, 0.05f);
FixedString128 hpString = $"HP: {hp.current} / {hp.max}";
int barWidth = term.Width - 20;
int barX = term.Width - barWidth - 1;
int hpX = barX - hpString.Length - 1;
term.PrintFGColor(hpX, term.Height - 1, hpString, Color.yellow);
term.DrawHorizontalBar(
term.Width - barWidth - 1,
term.Height - 1,
barWidth,
hp.current, hp.max,
Color.red, emptyColor);
int lineCount = 0;
for (int i = logBuffer.Length - 1;
i >= 0 && lineCount < term.Height - 2;
--i, ++lineCount)
{
term.Print(2, term.Height - 2 - lineCount, logBuffer[i].Value);
}
}).Schedule();
}
public static unsafe bool ReadFromDisk(FixedString128 gameSaveFilePath)
{
Baselib_ErrorState errorState = new Baselib_ErrorState();
Baselib_FileIO_SyncFile fileHandle = Baselib_FileIO_SyncOpen(gameSaveFilePath.GetUnsafePtr(), Baselib_FileIO_OpenFlags.Read, &errorState);
if (errorState.code != Baselib_ErrorCode.Success)
{
return(false);
}
GameSaveFile gameSaveFile;
gameSaveFile.filePath = gameSaveFilePath;
gameSaveFile.fileHandle = fileHandle;
gameSaveReadFiles.Add(gameSaveFile);
return(true);
}
public static unsafe bool GetLength(FixedString128 gameSaveFilePath, int *length)
{
for (int i = 0; i < gameSaveReadFiles.Length; i++)
{
if (gameSaveReadFiles[i].filePath == gameSaveFilePath)
{
Baselib_ErrorState errorState = new Baselib_ErrorState();
UInt64 fileSize = Baselib_FileIO_SyncGetFileSize(gameSaveReadFiles[i].fileHandle, &errorState);
if ((errorState.code == Baselib_ErrorCode.Success) && (fileSize <= Int32.MaxValue))
{
*length = (int)fileSize;
return(true);
}
}
}
return(false);
}
