public void FetchLevel(string levelName = "default")
{
HttpRequestOptions options = new HttpRequestOptions();
options.Method = HttpRequestMethod.GET;
var result = WaitFor(ScenePrivate.HttpClient.Request, $"{LevelUrl}/{levelName}", options) as HttpClient.RequestData;
if (!result.Success || result.Response.Status != 200)
{
Log.Write(LogLevel.Error, $"Bad request fetching level, {result.Response.Status}");
return;
}
string jsonResponse = result.Response.Body;
LevelResponse parsed = ((JsonSerializationData <LevelResponse>)(WaitFor(JsonSerializer.Deserialize <LevelResponse>, jsonResponse))).Object;
foreach (BitDefinition bitDefinition in parsed.data.bits)
{
FetchBit(bitDefinition.name);
}
foreach (ObjectiveEntity entity in parsed.data.objectives)
{
var match = ObjectivePositions.Find(entity.definition.p);
if (match == null)
{
ScenePrivate.CreateClusterData data = Spawner.SpawnGlobalObjective(entity);
Objectives.AddLast(data);
ObjectivePositions.AddLast(entity.definition.p);
}
}
}
public ScenePrivate.CreateClusterData SpawnGlobalObjective(ObjectiveEntity entity)
{
Vector location = new Vector(entity.definition.p.x, entity.definition.p.y, entity.definition.p.z);
Vector eulerRotation = new Vector(entity.definition.r.x, entity.definition.r.y, entity.definition.r.z);
Quaternion rotation = Quaternion.FromEulerAngles(eulerRotation);
ScenePrivate.CreateClusterData createData = null;
createData = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster, objectiveCluster, location, rotation, Vector.Zero);
ObjectPrivate.AddInteractionData addData = (ObjectPrivate.AddInteractionData)WaitFor(createData.ClusterReference.GetObjectPrivate(0).AddInteraction, entity.prompt, true);
addData.Interaction.Subscribe((InteractionData data) =>
{
AgentPrivate Quester = ScenePrivate.FindAgent(data.AgentId);
if (Quester == null || !Quester.IsValid)
{
return;
}
HttpRequestOptions options = new HttpRequestOptions();
options.Method = HttpRequestMethod.PATCH;
options.Headers = new Dictionary <string, string>()
{
{ "content-type", "application/json" }
};
options.Body = $"{{\"data\": {{\"state\":\"COMPLETED\"}} }}";
Guid PersonaId = Quester.AgentInfo.AvatarUuid;
string completeObjectiveUrl = $"{BaseUrl}/players/{PersonaId}/storylines/{entity.storylineId}/objectives/{entity.handle}";
Quester.SendChat(completeObjectiveUrl);
var result = WaitFor(ScenePrivate.HttpClient.Request, completeObjectiveUrl, options) as HttpClient.RequestData;
});
return(createData);
}
private void CreateClusterHandler(ScenePrivate.CreateClusterData obj)
{
try
{
StartCoroutine(DestroyCluster, obj.ClusterReference);
}
catch (Exception)
{
}
}
public ScenePrivate.CreateClusterData SpawnCube(ShapeDefinition definition)
{
Vector position = new Vector(definition.p.x, definition.p.y, definition.p.z);
ScenePrivate.CreateClusterData createData = null;
ClusterResource cube = cubes[definition.c][definition.s];
createData = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster, cube, position, Quaternion.Identity, Vector.Zero);
return(createData);
}
public override void Init()
{
if (QuestDefinition == null)
{
Log.Write(LogLevel.Error, "Quest Definition not found.");
initFail = true;
return;
}
ScenePrivate.User.Subscribe(User.AddUser, OnAddUser);
if (IndicatorResource == null)
{
ObjectPrivate.TryGetFirstComponent <MeshComponent>(out indicatorMeshComponent);
}
else
{
ScenePrivate.CreateClusterData indicatorClusterData = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster,
IndicatorResource,
ObjectPrivate.Position + IndicatorOffset,
ObjectPrivate.Rotation,
Vector.Zero);
if (indicatorClusterData.Success)
{
indicatorClusterData.ClusterReference.GetObjectPrivate(0).TryGetFirstComponent <MeshComponent>(out indicatorMeshComponent);
}
}
if (indicatorMeshComponent == null || !indicatorMeshComponent.IsScriptable)
{
Log.Write(LogLevel.Error, "Quest Indicator failed to obtain a scriptable MeshComponent.");
initFail = true;
return;
}
var update = WaitFor(QuestDefinition.Update);
if (update.Success)
{
Log.Write(LogLevel.Info, $"Got quest definition: {QuestDefinition.Title}");
}
else
{
Log.Write(LogLevel.Error, "Failed to update quest definition.");
initFail = true;
return;
}
initSuccess = true;
}
public ScenePrivate.CreateClusterData SpawnRamp(ShapeDefinition definition)
{
Vector location = new Vector(definition.p.x, definition.p.y, definition.p.z);
Vector eulerRotation = new Vector(definition.r.x, definition.r.y, definition.r.z);
Quaternion rotation = Quaternion.FromEulerAngles(eulerRotation);
ScenePrivate.CreateClusterData createData = null;
ClusterResource ramp = ramps[definition.c][definition.s];
createData = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster, ramp, location, rotation, Vector.Zero);
return(createData);
}
public void FetchBit(string bitName = "default")
{
HttpRequestOptions options = new HttpRequestOptions();
options.Method = HttpRequestMethod.GET;
var result = WaitFor(ScenePrivate.HttpClient.Request, $"{BitUrl}/{bitName}", options) as HttpClient.RequestData;
if (!result.Success || result.Response.Status != 200)
{
Log.Write(LogLevel.Error, $"Bad request fetching bit, {result.Response.Status}");
return;
}
string jsonResponse = result.Response.Body;
JsonSerializerOptions jsonOptions = new JsonSerializerOptions
{
SerializeReferences = false
};
BitResponse parsed = ((JsonSerializationData <BitResponse>)(WaitFor(JsonSerializer.Deserialize <BitResponse>, jsonResponse, jsonOptions))).Object;
foreach (ShapeDefinition definition in parsed.data.cubes)
{
var match = CubePositions.Find(definition.p);
if (match == null)
{
ScenePrivate.CreateClusterData data = Spawner.SpawnCube(definition);
Cubes.AddLast(data);
CubePositions.AddLast(definition.p);
}
}
foreach (ShapeDefinition definition in parsed.data.ramps)
{
var match = RampPositions.Find(definition.p);
if (match == null)
{
ScenePrivate.CreateClusterData data = Spawner.SpawnRamp(definition);
Ramps.AddLast(data);
RampPositions.AddLast(definition.p);
}
}
}
private void DispenseObject(ClusterResource clusterResource)
{
if ((MaxObjectCount > 0) && (dispensedObjects.Count >= MaxObjectCount))
{
DestroyOldestObject();
}
Vector rotWithVariance = RotationOffset;
if (hasRotationVariance)
{
rotWithVariance += new Vector(RotationVariance.X * RandomNegOneToOne(), RotationVariance.Y * RandomNegOneToOne(), RotationVariance.Z * RandomNegOneToOne());
}
Quaternion rotation = Quaternion.FromEulerAngles(Mathf.RadiansPerDegree * rotWithVariance);
Quaternion objectRotation = ObjectPrivate.Rotation;
Vector position = PositionOffset;
if (hasPositionVariance)
{
position += new Vector(PositionVariance.X * RandomNegOneToOne(), PositionVariance.Y * RandomNegOneToOne(), PositionVariance.Z * RandomNegOneToOne());
}
Vector velocity = InitialLinearVelocity;
if (hasLinearVelocityVariance)
{
velocity += new Vector(LinearVelocityVariance.X * RandomNegOneToOne(), LinearVelocityVariance.Y * RandomNegOneToOne(), LinearVelocityVariance.Z * RandomNegOneToOne());
}
if (InheritMotion && (dispenserRigidBody != null))
{
velocity += dispenserRigidBody.GetLinearVelocity();
}
try
{
ScenePrivate.CreateClusterData dispensedObject = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster,
clusterResource,
ObjectPrivate.Position + position.Rotate(objectRotation),
ObjectPrivate.Rotation * rotation,
velocity.Rotate(objectRotation));
if (hasInitialAngularVelocity)
{
RigidBodyComponent rb;
if (dispensedObject.ClusterReference.GetObjectPrivates().FirstOrDefault().TryGetFirstComponent(out rb))
{
if (rb.GetMotionType() != RigidBodyMotionType.MotionTypeStatic)
{
Vector angularVel = InitialAngularVelocity;
if (hasAngularVelocityVariance)
{
angularVel += new Vector(AngularVelocityVariance.X * RandomNegOneToOne(), AngularVelocityVariance.Y * RandomNegOneToOne(), AngularVelocityVariance.Z * RandomNegOneToOne());
}
if (InheritMotion && (dispenserRigidBody != null))
{
angularVel += dispenserRigidBody.GetAngularVelocity();
}
rb.SetAngularVelocity(angularVel);
}
}
}
dispensedObjects.AddLast(dispensedObject);
}
catch (ThrottleException)
{
// Throttled
Log.Write(LogLevel.Warning, "DispenseObject throttle hit. No object created.");
}
}
public void RezCannonball(Sansar.Vector initial_pos, Sansar.Quaternion rotation, Sansar.Vector vel)
{
ScenePrivate.CreateClusterData createData = null;
try
{
try
{
if (Projectile != null)
{
createData = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster, Projectile,
initial_pos,
rotation,
vel);
}
else
{ // No projectile override - just use cannon balls.
createData = (ScenePrivate.CreateClusterData)WaitFor(ScenePrivate.CreateCluster, "Export/CannonBall/",
initial_pos,
rotation,
vel);
}
}
catch (ThrottleException e)
{
Log.Write($"Too many rezzes! Throttle rate is {e.MaxEvents} per {e.Interval.TotalSeconds}.");
RezThrottled = true;
Wait(e.Interval - e.Elapsed); // Wait out the rest of the interval before trying again.
RezThrottled = false;
return;
}
if (createData.Success)
{
ObjectPrivate obj = createData.ClusterReference.GetObjectPrivate(0);
if (obj != null)
{
RigidBodyComponent RigidBody = null;
if (obj.TryGetFirstComponent(out RigidBody))
{
//exit after 3 hits or 1 character hit
for (int i = 0; i < 3; i++)
{
CollisionData data = (CollisionData)WaitFor(RigidBody.Subscribe, CollisionEventType.AllCollisions, ComponentId.Invalid);
if ((data.EventType & CollisionEventType.CharacterContact) != 0)
{
// Use the scene to find the full object API of the other object.
AgentPrivate hit = ScenePrivate.FindAgent(data.HitComponentId.ObjectId);
if (hit != null)
{
ObjectPrivate otherObject = ScenePrivate.FindObject(data.HitComponentId.ObjectId);
if (otherObject != null)
{
if (Hit_Sound != null)
{
ScenePrivate.PlaySoundAtPosition(Hit_Sound, otherObject.Position, SoundSettings);
}
if (Teleport_On_Hit)
{
AnimationComponent anim;
if (otherObject.TryGetFirstComponent(out anim))
{
anim.SetPosition(SpawnPoints[rng.Next(SpawnPoints.Count)]);
}
}
}
break;
}
}
}
}
}
}
}
catch (Exception e)
{
Log.Write(e.ToString());
}
finally
{
if (createData.ClusterReference != null)
{
try
{
createData.ClusterReference.Destroy();
}
catch (Exception) { }
}
}
}
