//TODO: Maybe add EnvironmentState[][] states for aggregation of states in unity side buffer, when using skips?
/// <summary>
/// </summary>
/// <param name="states"></param>
void Reply(EnvironmentSnapshot[] states)
{
lock (this._send_lock) {
var configuration_message = new SimulatorConfigurationMessage(this.Configuration);
var describe = false;
if (this.CurrentReactions != null)
{
foreach (var reaction in this.CurrentReactions)
{
if (reaction.Parameters.Describe)
{
describe = true;
}
}
}
this._Message_Client.SendStates(states,
simulator_configuration_message: configuration_message,
do_serialise_unobservables:
describe || this.Configuration.AlwaysSerialiseUnobservables,
serialise_individual_observables:
describe || this.Configuration.AlwaysSerialiseIndividualObservables,
do_serialise_observables: describe ||
this._configuration
.AlwaysSerialiseAggregatedFloatArray);
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log("Replying");
}
#endif
}
}
/// <summary>
/// </summary>
/// <param name="states"></param>
/// <param name="simulator_configuration"></param>
/// <param name="serialise_individual_observables"></param>
/// <param name="do_serialise_unobservables"></param>
/// <param name="do_serialise_observables"></param>
/// <param name="api_version"></param>
/// <returns></returns>
public static byte[] Serialise(EnvironmentSnapshot[] states,
SimulatorConfigurationMessage simulator_configuration = null,
bool do_serialise_unobservables = false,
bool serialise_individual_observables = false,
bool do_serialise_observables = false,
string api_version = "N/A")
{
var b = new FlatBufferBuilder(1);
var state_offsets = new Offset <FState> [states.Length];
var i = 0;
foreach (var state in states)
{
state_offsets[i++] = SerialiseState(b,
state,
do_serialise_unobservables,
do_serialise_observables,
serialise_individual_observables:
serialise_individual_observables);
}
var states_vector_offset = FStates.CreateStatesVector(b, state_offsets);
var api_version_offset = b.CreateString(api_version);
FStates.StartFStates(b);
FStates.AddStates(b, states_vector_offset);
FStates.AddApiVersion(b, api_version_offset);
FStates.AddSimulatorConfiguration(b, Serialise(b, simulator_configuration));
var states_offset = FStates.EndFStates(b);
FStates.FinishFStatesBuffer(b, states_offset);
return(b.SizedByteArray());
}
/// <summary>
/// </summary>
/// <param name="reactions"></param>
/// <returns></returns>
public static Tuple <Reaction[], bool, string, SimulatorConfigurationMessage> deserialise_reactions(
FReactions?reactions)
{
_out_reactions.Clear();
var close = false;
var api_version = "";
var simulator_configuration = new SimulatorConfigurationMessage();
if (reactions.HasValue)
{
var rs = reactions.Value;
for (var i = 0; i < rs.ReactionsLength; i++)
{
_out_reactions.Add(deserialise_reaction(rs.Reactions(i)));
}
close = rs.Close;
api_version = rs.ApiVersion;
if (rs.SimulatorConfiguration.HasValue)
{
simulator_configuration.FbsParse(rs.SimulatorConfiguration.Value);
}
}
if (_out_reactions.Count == 0)
{
Debug.LogWarning("Empty reactions received");
}
return(new Tuple <Reaction[], bool, String, SimulatorConfigurationMessage>(_out_reactions.ToArray(),
close,
api_version,
simulator_configuration));
}
serialise_simulator_configuration(FlatBufferBuilder b, SimulatorConfigurationMessage configuration)
{
return(FSimulatorConfiguration.CreateFSimulatorConfiguration(
b,
configuration.Width,
configuration.Height,
configuration.FullScreen,
configuration.QualityLevel,
configuration.TimeScale,
configuration.TargetFrameRate,
configuration.SimulationType,
configuration.FrameSkips,
configuration.ResetIterations,
configuration.NumOfEnvironments,
configuration.DoSerialiseIndividualObservables,
configuration.DoSerialiseUnobservables));
}
//TODO: EnvironmentState[][] states for aggregation of states
/// <summary>
///
/// </summary>
/// <param name="states"></param>
void Reply(EnvironmentState[] states)
{
lock (this._send_lock) {
var configuration_message = new SimulatorConfigurationMessage(this.Configuration);
this._Message_Server.SendStates(
states,
simulator_configuration_message: configuration_message,
do_serialise_unobservables: this.Configuration.AlwaysSerialiseUnobservables,
serialise_indidual_observables: this.Configuration.AlwaysSerialiseIndividualObservables);
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log("Replying");
}
#endif
}
}
Serialise(FlatBufferBuilder b, SimulatorConfigurationMessage configuration)
{
return(FSimulatorConfiguration.CreateFSimulatorConfiguration(b,
configuration.Width,
configuration.Height,
configuration.FullScreen,
configuration.QualityLevel,
configuration.TimeScale,
configuration.TargetFrameRate,
(FSimulationType)configuration
.SimulationType,
configuration.FrameSkips,
0, //TODO: Remove
configuration.NumOfEnvironments,
configuration.DoSerialiseIndividualSensors,
configuration.DoSerialiseUnobservables
//TODO: ,configuration.DoSerialiseAggregatedFloatArray
));
}
/// <summary>
///
/// </summary>
/// <param name="environment_states"></param>
/// <param name="do_serialise_unobservables"></param>
/// <param name="serialise_indidual_observables"></param>
/// <param name="simulator_configuration_message"></param>
/// <param name="api_vesion"></param>
public void SendStates(
EnvironmentState[] environment_states,
bool do_serialise_unobservables = false,
bool serialise_indidual_observables = false,
SimulatorConfigurationMessage simulator_configuration_message = null,
string api_vesion = _api_version)
{
lock (this._thread_lock) {
#if NEODROID_DEBUG
if (this.Debugging)
{
var environment_state = environment_states.ToArray();
if (environment_state.Length > 0)
{
if (environment_state[0] != null)
{
var frame_number = environment_state[0].FrameNumber;
var time = environment_state[0].Time;
var frame_number_duplicate = this._last_send_frame_number == frame_number;
if (frame_number_duplicate && frame_number > 0)
{
Debug.LogWarning($"Sending duplicate frame! Frame number: {frame_number}");
}
if (frame_number <= this._last_send_frame_number)
{
Debug.LogWarning(
$"The current frame number {frame_number} is less or equal the last {this._last_send_frame_number}, SINCE AWAKE ({Time.frameCount})");
}
if (time <= this._last_send_time)
{
Debug.LogWarning($"The current time {time} is less or equal the last {this._last_send_time}");
}
if (environment_state[0].Description != null)
{
Debug.Log($"State has description: {environment_state[0].Description}");
}
this._last_send_frame_number = frame_number;
this._last_send_time = time;
}
}
else
{
Debug.LogWarning($"No environment states where send.");
}
}
#endif
this._byte_buffer = FbsStateUtilities.serialise_states(
environment_states,
do_serialise_unobservables: do_serialise_unobservables,
serialise_indidual_observables: serialise_indidual_observables,
simulator_configuration: simulator_configuration_message,
api_version: api_vesion);
this._socket.SendFrame(this._byte_buffer);
this._waiting_for_main_loop_to_send = false;
}
}
/// <summary>
/// </summary>
/// <param name="environment_states"></param>
/// <param name="do_serialise_unobservables"></param>
/// <param name="serialise_individual_observables"></param>
/// <param name="do_serialise_observables"></param>
/// <param name="simulator_configuration_message"></param>
/// <param name="api_version"></param>
public void SendStates(EnvironmentSnapshot[] environment_states,
bool do_serialise_unobservables = false,
bool serialise_individual_observables = false,
bool do_serialise_observables = false,
SimulatorConfigurationMessage simulator_configuration_message = null,
string api_version = NeodroidRuntimeInfo._Version)
{
lock (this._thread_lock) {
#if NEODROID_DEBUG
if (this.Debugging)
{
var environment_state = environment_states.ToArray();
if (environment_state.Length > 0)
{
if (environment_state[0] != null)
{
var frame_number = environment_state[0].FrameNumber;
var time = environment_state[0].Time;
var episode_count = this._last_received_reactions[0].Parameters.EpisodeCount;
var stepped = this._last_received_reactions[0].Parameters.StepResetObserveEnu == StepResetObserve
.Step_;
if (frame_number <= this._last_send_frame_number)
{
Debug.LogWarning($"The current frame number {frame_number} is less or equal the last {this._last_send_frame_number}, SINCE AWAKE ({Time.frameCount})");
if (this._last_send_frame_number == frame_number && frame_number > 0 && episode_count)
{
Debug.LogWarning($"Sending duplicate frame! Frame number: {frame_number}");
}
}
if (time <= this._last_send_time && stepped)
{
Debug.LogWarning($"The current time {time} is less or equal the last {this._last_send_time}");
}
if (environment_state[0].Description != null)
{
Debug.Log($"State has description: {environment_state[0].Description}");
}
this._last_send_frame_number = frame_number;
this._last_send_time = time;
}
}
else
{
Debug.LogWarning("No environment states where send.");
}
}
#endif
this._byte_buffer = FbsStateUtilities.Serialise(environment_states,
do_serialise_unobservables:
do_serialise_unobservables,
serialise_individual_observables:
serialise_individual_observables,
simulator_configuration:
simulator_configuration_message,
do_serialise_observables: do_serialise_observables,
api_version: api_version);
this._socket.SendFrame(this._byte_buffer);
this._waiting_for_main_loop_to_send = false;
}
}
