protected override YAMLMappingNode ExportYAMLRoot(IAssetsExporter exporter)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(exporter);
node.AddSerializedVersion(GetSerializedVersion(exporter.Version));
node.Add("lengthInSec", LengthInSec);
node.Add("simulationSpeed", SimulationSpeed);
node.Add("stopAction", StopAction);
node.Add("looping", Looping);
node.Add("prewarm", Prewarm);
node.Add("playOnAwake", PlayOnAwake);
node.Add("useUnscaledTime", UseUnscaledTime);
node.Add("autoRandomSeed", AutoRandomSeed);
node.Add("useRigidbodyForVelocity", UseRigidbodyForVelocity);
node.Add("startDelay", StartDelay.ExportYAML(exporter));
node.Add("moveWithTransform", MoveWithTransform);
node.Add("moveWithCustomTransform", MoveWithCustomTransform.ExportYAML(exporter));
node.Add("scalingMode", ScalingMode);
node.Add("randomSeed", RandomSeed);
node.Add("InitialModule", InitialModule.ExportYAML(exporter));
node.Add("ShapeModule", ShapeModule.ExportYAML(exporter));
node.Add("EmissionModule", EmissionModule.ExportYAML(exporter));
node.Add("SizeModule", SizeModule.ExportYAML(exporter));
node.Add("RotationModule", RotationModule.ExportYAML(exporter));
node.Add("ColorModule", ColorModule.ExportYAML(exporter));
node.Add("UVModule", UVModule.ExportYAML(exporter));
node.Add("VelocityModule", VelocityModule.ExportYAML(exporter));
node.Add("InheritVelocityModule", InheritVelocityModule.ExportYAML(exporter));
node.Add("ForceModule", ForceModule.ExportYAML(exporter));
node.Add("ExternalForcesModule", ExternalForcesModule.ExportYAML(exporter));
node.Add("ClampVelocityModule", ClampVelocityModule.ExportYAML(exporter));
node.Add("NoiseModule", NoiseModule.ExportYAML(exporter));
node.Add("SizeBySpeedModule", SizeBySpeedModule.ExportYAML(exporter));
node.Add("RotationBySpeedModule", RotationBySpeedModule.ExportYAML(exporter));
node.Add("ColorBySpeedModule", ColorBySpeedModule.ExportYAML(exporter));
node.Add("CollisionModule", CollisionModule.ExportYAML(exporter));
node.Add("TriggerModule", TriggerModule.ExportYAML(exporter));
node.Add("SubModule", SubModule.ExportYAML(exporter));
node.Add("LightsModule", LightsModule.ExportYAML(exporter));
node.Add("TrailModule", TrailModule.ExportYAML(exporter));
node.Add("CustomDataModule", CustomDataModule.ExportYAML(exporter));
return(node);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LengthInSec = reader.ReadSingle();
if (IsStartDelayFirst(reader.Version))
{
if (HasStartDelaySingle(reader.Version))
{
StartDelaySingle = reader.ReadSingle();
}
else
{
StartDelay.Read(reader);
}
}
SimulationSpeed = reader.ReadSingle();
if (HasStopAction(reader.Version))
{
StopAction = (ParticleSystemStopAction)reader.ReadInt32();
}
if (IsRandomSeedFirst(reader.Version))
{
RandomSeed = unchecked ((int)reader.ReadUInt32());
}
if (HasCullingMode(reader.Version))
{
CullingMode = (ParticleSystemCullingMode)reader.ReadInt32();
RingBufferMode = (ParticleSystemRingBufferMode)reader.ReadInt32();
RingBufferLoopRange.Read(reader);
}
Looping = reader.ReadBoolean();
Prewarm = reader.ReadBoolean();
PlayOnAwake = reader.ReadBoolean();
if (HasUseUnscaledTime(reader.Version))
{
UseUnscaledTime = reader.ReadBoolean();
}
if (IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = reader.ReadBoolean() ? ParticleSystemSimulationSpace.Local : ParticleSystemSimulationSpace.World;
}
if (HasAutoRandomSeed(reader.Version))
{
AutoRandomSeed = reader.ReadBoolean();
}
if (HasUseRigidbodyForVelocity(reader.Version))
{
UseRigidbodyForVelocity = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream();
}
if (!IsStartDelayFirst(reader.Version))
{
StartDelay.Read(reader);
reader.AlignStream();
}
if (!IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = (ParticleSystemSimulationSpace)reader.ReadInt32();
reader.AlignStream();
}
if (HasMoveWithCustomTransform(reader.Version))
{
MoveWithCustomTransform.Read(reader);
}
if (HasScalingMode(reader.Version))
{
ScalingMode = (ParticleSystemScalingMode)reader.ReadInt32();
}
if (!IsRandomSeedFirst(reader.Version))
{
RandomSeed = reader.ReadInt32();
}
InitialModule.Read(reader);
ShapeModule.Read(reader);
EmissionModule.Read(reader);
SizeModule.Read(reader);
RotationModule.Read(reader);
ColorModule.Read(reader);
UVModule.Read(reader);
VelocityModule.Read(reader);
if (HasInheritVelocityModule(reader.Version))
{
InheritVelocityModule.Read(reader);
}
ForceModule.Read(reader);
if (HasExternalForcesModule(reader.Version))
{
ExternalForcesModule.Read(reader);
}
ClampVelocityModule.Read(reader);
if (HasNoiseModule(reader.Version))
{
NoiseModule.Read(reader);
}
SizeBySpeedModule.Read(reader);
RotationBySpeedModule.Read(reader);
ColorBySpeedModule.Read(reader);
CollisionModule.Read(reader);
if (HasTriggerModule(reader.Version))
{
TriggerModule.Read(reader);
}
SubModule.Read(reader);
if (HasLightsModule(reader.Version))
{
LightsModule.Read(reader);
TrailModule.Read(reader);
}
if (HasCustomDataModule(reader.Version))
{
CustomDataModule.Read(reader);
}
}
public string GetField(int field)
{
switch (field)
{
case 0: return(HostName);
case 1: return(GameName);
case 2: return(GameVersion);
case 3: return(MapName);
case 4: return(GameType);
case 5: return(GameVariant);
case 6: return(NumPlayers.ToString());
case 7: return(MaxPlayers.ToString());
case 8: return(GameMode);
case 9: return((Password ? 1 : 0).ToString());
case 10: return(TimeLimit.ToString());
case 11: return(RoundTime.ToString());
case 12: return(HostPort.ToString());
case 13: return((Dedicated ? 1 : 0).ToString());
case 14: return((Ranked ? 1 : 0).ToString());
case 15: return((AntiCheat ? 1 : 0).ToString());
case 16: return(OS);
case 17: return((BattleRecorder ? 1 : 0).ToString());
case 18: return(BRIndex);
case 19: return(BRDownload);
case 20: return((Voip ? 1 : 0).ToString());
case 21: return((AutoBalance ? 1 : 0).ToString());
case 22: return((FriendlyFire ? 1 : 0).ToString());
case 23: return(TKMode);
case 24: return(StartDelay.ToString());
case 25: return(SpawnTime.ToString("0.000000", CultureInfo.InvariantCulture));
case 26: return(ServerText);
case 27: return(ServerLogo);
case 28: return(CommunityWebsite);
case 29: return(ScoreLimit.ToString());
case 30: return(TicketRatio.ToString());
case 31: return(TeamRatio.ToString("0.000000", CultureInfo.InvariantCulture));
case 32: return(Team1Name);
case 33: return(Team2Name);
case 34: return((CoopEnabled ? 1 : 0).ToString());
case 35: return((Pure ? 1 : 0).ToString());
case 36: return(MapSize.ToString());
case 37: return((Unlocks ? 1 : 0).ToString());
case 38: return(Fps.ToString());
case 39: return((Plasma ? 1 : 0).ToString());
case 40: return(ReservedSlots.ToString());
case 41: return(CoopBotRatio.ToString());
case 42: return(CoopBotCount.ToString());
case 43: return(CoopBotDifficulty.ToString());
case 44: return((NoVehicles ? 1 : 0).ToString());
default:
return("");
}
}
private void Update()
{
if (InternalEnabled)
{
Action ApplyLoop = delegate
{
InternalLoop.Apply(
(Source, Retry) =>
{
var Music = Source.ToSound();
Music.PlaybackComplete += Retry;
Music.SetVolume(this.Volume);
Music.Start();
InternalLoopSetVolume = Music.SetVolume;
InternalLoopStop =
delegate
{
InternalLoopSetVolume = null;
Music.Stop();
};
}
);
};
if (LoopStarted != null)
{
LoopStarted();
}
Update_LoopStarted = true;
// start
if (!string.IsNullOrEmpty(this.Start))
{
var StartMusic = this.Start.ToSound();
StartMusic.SetVolume(this.Volume);
StartMusic.Start();
if (!string.IsNullOrEmpty(InternalLoop))
{
if (StartDelay > 0)
{
StartDelay.AtDelay(ApplyLoop);
}
else
{
ApplyLoop();
}
}
}
else
{
if (!string.IsNullOrEmpty(InternalLoop))
{
ApplyLoop();
}
}
}
else
{
if (Update_LoopStarted)
{
Action StopLoop = delegate
{
if (InternalLoopStop != null)
{
InternalLoopStop();
InternalLoopStop = null;
}
};
if (!string.IsNullOrEmpty(this.Stop))
{
var StopMusic = this.Stop.ToSound();
StopMusic.SetVolume(this.Volume);
StopMusic.Start();
if (!string.IsNullOrEmpty(InternalLoop))
{
if (StopDelay > 0)
{
StopDelay.AtDelay(StopLoop);
}
else
{
StopLoop();
}
}
StopMusic.PlaybackComplete +=
delegate
{
if (LoopStopped != null)
{
LoopStopped();
}
};
}
else
{
StopLoop();
if (LoopStopped != null)
{
LoopStopped();
}
}
}
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
LengthInSec = stream.ReadSingle();
if (IsStartDelayFirst(stream.Version))
{
if (IsReadStartDelaySingle(stream.Version))
{
StartDelaySingle = stream.ReadSingle();
}
else
{
StartDelay.Read(stream);
}
}
SimulationSpeed = stream.ReadSingle();
if (IsReadStopAction(stream.Version))
{
StopAction = stream.ReadInt32();
}
if (IsRandomSeedFirst(stream.Version))
{
RandomSeed = unchecked ((int)stream.ReadUInt32());
}
Looping = stream.ReadBoolean();
Prewarm = stream.ReadBoolean();
PlayOnAwake = stream.ReadBoolean();
if (IsReadUseUnscaledTime(stream.Version))
{
UseUnscaledTime = stream.ReadBoolean();
}
if (IsMoveWithTransformBool(stream.Version))
{
MoveWithTransform = stream.ReadBoolean() ? 1 : 0;
}
if (IsReadAutoRandomSeed(stream.Version))
{
AutoRandomSeed = stream.ReadBoolean();
}
if (IsReadUseRigidbodyForVelocity(stream.Version))
{
UseRigidbodyForVelocity = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (!IsStartDelayFirst(stream.Version))
{
StartDelay.Read(stream);
stream.AlignStream(AlignType.Align4);
}
if (!IsMoveWithTransformBool(stream.Version))
{
MoveWithTransform = stream.ReadInt32();
stream.AlignStream(AlignType.Align4);
}
if (IsReadMoveWithCustomTransform(stream.Version))
{
MoveWithCustomTransform.Read(stream);
}
if (IsReadScalingMode(stream.Version))
{
ScalingMode = stream.ReadInt32();
}
if (!IsRandomSeedFirst(stream.Version))
{
RandomSeed = stream.ReadInt32();
}
InitialModule.Read(stream);
ShapeModule.Read(stream);
EmissionModule.Read(stream);
SizeModule.Read(stream);
RotationModule.Read(stream);
ColorModule.Read(stream);
UVModule.Read(stream);
VelocityModule.Read(stream);
if (IsReadInheritVelocityModule(stream.Version))
{
InheritVelocityModule.Read(stream);
}
ForceModule.Read(stream);
if (IsReadExternalForcesModule(stream.Version))
{
ExternalForcesModule.Read(stream);
}
ClampVelocityModule.Read(stream);
if (IsReadNoiseModule(stream.Version))
{
NoiseModule.Read(stream);
}
SizeBySpeedModule.Read(stream);
RotationBySpeedModule.Read(stream);
ColorBySpeedModule.Read(stream);
CollisionModule.Read(stream);
if (IsReadTriggerModule(stream.Version))
{
TriggerModule.Read(stream);
}
SubModule.Read(stream);
if (IsReadLightsModule(stream.Version))
{
LightsModule.Read(stream);
TrailModule.Read(stream);
}
if (IsReadCustomDataModule(stream.Version))
{
CustomDataModule.Read(stream);
}
}
