public AMobileEntity( Vector3 location )
: base(location)
{
velocity = new Vector3();
impulses = new List<AImpulse>();
physics = PhysicsProperties.BasicBody;
}
public void OnPassThrough(
PhysicsProperties properties,
ref Vector2 position,
ref Vector2 velocity,
ref float angularVelocity,
ref BallPassThroughEvent collision)
{
switch (collision.Type)
{
case BallPassThroughType.Water:
velocity *= 0.91f;
angularVelocity *= 0.91f;
break;
case BallPassThroughType.Honey:
velocity *= 0.8f;
angularVelocity *= 0.8f;
break;
case BallPassThroughType.Tile:
TileMaterial byTileId = TileMaterials.GetByTileId(collision.Tile.type);
velocity *= byTileId.GolfPhysics.PassThroughDampening;
angularVelocity *= byTileId.GolfPhysics.PassThroughDampening;
break;
}
}
/// <summary>
/// Default constructor
/// </summary>
public Primitive()
{
Flexible = new FlexibleData();
Light = new LightData();
LightMap = new LightImage();
Sculpt = new SculptData();
PrimData = new ConstructionData();
PhysicsProps = new PhysicsProperties();
}
private void OnEnable()
{
objGravitate = GetComponent <Gravitate>();
objRigidbody = GetComponent <Rigidbody2D>();
objPhysicsProperties = GetComponent <PhysicsProperties>();
objOrbitTracker = GetComponent <OrbitTracker>();
Managers.ObjectTracker.Instance.RegisterObject(this);
}
public void OnCollision(
PhysicsProperties properties,
ref Vector2 position,
ref Vector2 velocity,
ref BallCollisionEvent collision)
{
TileMaterial byTileId = TileMaterials.GetByTileId(collision.Tile.type);
Vector2 vector2_1 = velocity * byTileId.GolfPhysics.SideImpactDampening;
Vector2 vector2_2 = collision.Normal * Vector2.Dot(velocity, collision.Normal) * (byTileId.GolfPhysics.DirectImpactDampening - byTileId.GolfPhysics.SideImpactDampening);
velocity = vector2_1 + vector2_2;
Projectile entity = collision.Entity as Projectile;
switch (collision.Tile.type)
{
case 421:
case 422:
float num1 = 2.5f * collision.TimeScale;
Vector2 vector2_3 = new Vector2(-collision.Normal.Y, collision.Normal.X);
if (collision.Tile.type == (ushort)422)
{
vector2_3 = -vector2_3;
}
float num2 = Vector2.Dot(velocity, vector2_3);
if ((double)num2 < (double)num1)
{
velocity += vector2_3 * MathHelper.Clamp(num1 - num2, 0.0f, num1 * 0.5f);
break;
}
break;
case 476:
float num3 = velocity.Length() / collision.TimeScale;
if ((double)collision.Normal.Y <= -0.00999999977648258 && (double)num3 <= 100.0)
{
velocity *= 0.0f;
if (entity != null && entity.active)
{
this.PutBallInCup(entity, collision);
break;
}
break;
}
break;
}
if (entity == null || (double)velocity.Y >= -0.300000011920929 || ((double)velocity.Y <= -2.0 || (double)velocity.Length() <= 1.0))
{
return;
}
Dust dust = Dust.NewDustPerfect(collision.Entity.Center, 31, new Vector2?(collision.Normal), (int)sbyte.MaxValue, new Color(), 1f);
dust.scale = 0.7f;
dust.fadeIn = 1f;
dust.velocity = dust.velocity * 0.5f + Main.rand.NextVector2CircularEdge(0.5f, 0.4f);
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("MSceneObjectUpdate(");
__sb.Append(", ID: ");
__sb.Append(ID);
if (Name != null && __isset.Name)
{
__sb.Append(", Name: ");
__sb.Append(Name);
}
if (Transform != null && __isset.Transform)
{
__sb.Append(", Transform: ");
__sb.Append(Transform == null ? "<null>" : Transform.ToString());
}
if (Collider != null && __isset.Collider)
{
__sb.Append(", Collider: ");
__sb.Append(Collider == null ? "<null>" : Collider.ToString());
}
if (Mesh != null && __isset.Mesh)
{
__sb.Append(", Mesh: ");
__sb.Append(Mesh == null ? "<null>" : Mesh.ToString());
}
if (PhysicsProperties != null && __isset.PhysicsProperties)
{
__sb.Append(", PhysicsProperties: ");
__sb.Append(PhysicsProperties == null ? "<null>" : PhysicsProperties.ToString());
}
if (HandPoses != null && __isset.HandPoses)
{
__sb.Append(", HandPoses: ");
__sb.Append(HandPoses);
}
if (Properties != null && __isset.Properties)
{
__sb.Append(", Properties: ");
__sb.Append(Properties);
}
if (Attachments != null && __isset.Attachments)
{
__sb.Append(", Attachments: ");
__sb.Append(Attachments);
}
if (Constraints != null && __isset.Constraints)
{
__sb.Append(", Constraints: ");
__sb.Append(Constraints);
}
__sb.Append(")");
return(__sb.ToString());
}
public void ApplyGravity(Gravitate objToGravitate)
{
Rigidbody2D rbToGravitate = objToGravitate.objSpaceObj.objRigidbody;
Vector2 direction = objSpaceObj.objRigidbody.position - rbToGravitate.position;
float distanceSquared = direction.sqrMagnitude;
float distanceFromCenter = (objPhysicsProperties.Radius + objToGravitate.objPhysicsProperties.Radius);
//Debug.Log("Dist from center: " + distanceFromCenter + " | Distance: " + direction.magnitude);
if (direction.magnitude > distanceFromCenter)
{
float gravitationMag = G * (objSpaceObj.objRigidbody.mass * rbToGravitate.mass) / distanceSquared;
Vector2 force = direction.normalized * gravitationMag;
rbToGravitate.AddRelativeForce(force, ForceMode2D.Force);
if (force.SqrMagnitude() > MIN_THRESHOLD)
{
if (!gravitatingObjects.Contains(objToGravitate))
{
gravitatingObjects.Add(objToGravitate);
if (objSpaceObj.objRigidbody.mass >= objToGravitate.objSpaceObj.objRigidbody.mass)
{
if (OnObjectEnteredGravitationalPull != null)
{
OnObjectEnteredGravitationalPull(objSpaceObj, objToGravitate.objSpaceObj);
}
}
}
}
else if (gravitatingObjects.Contains(objToGravitate))
{
gravitatingObjects.Remove(objToGravitate);
if (OnObjectExitedGravitationalPull != null)
{
if (objSpaceObj.objRigidbody.mass >= objToGravitate.objSpaceObj.objRigidbody.mass)
{
Debug.Log("OUT OF GRAVITATIONAL RANGE");
OnObjectExitedGravitationalPull(objSpaceObj, objToGravitate.objSpaceObj);
}
}
}
}
else
{
//Absorb!
PhysicsProperties.AbsorbObject(objSpaceObj, objToGravitate.objSpaceObj);
}
}
public void OnCollision(PhysicsProperties properties, Vector2 position, Vector2 velocity, BallCollisionEvent collision)
{
TileMaterial byTileId = TileMaterials.GetByTileId(collision.Tile.type);
Vector2 value = velocity * byTileId.GolfPhysics.SideImpactDampening;
Vector2 value2 = collision.Normal * Vector2.Dot(velocity, collision.Normal) * (byTileId.GolfPhysics.DirectImpactDampening - byTileId.GolfPhysics.SideImpactDampening);
velocity = value + value2;
Projectile projectile = collision.Entity as Projectile;
switch (collision.Tile.type)
{
case 421:
case 422:
{
float num2 = 2.5f * collision.TimeScale;
Vector2 vector = new Vector2(0f - collision.Normal.Y, collision.Normal.X);
if (collision.Tile.type == 422)
{
vector = -vector;
}
float num3 = Vector2.Dot(velocity, vector);
if (num3 < num2)
{
velocity += vector * MathHelper.Clamp(num2 - num3, 0f, num2 * 0.5f);
}
break;
}
case 476:
{
float num = velocity.Length() / collision.TimeScale;
if (!(collision.Normal.Y > -0.01f) && !(num > 100f))
{
velocity *= 0f;
if (projectile != null && projectile.active)
{
PutBallInCup(projectile, collision);
}
}
break;
}
}
if (projectile != null && velocity.Y < -0.3f && velocity.Y > -2f && velocity.Length() > 1f)
{
Dust dust = Dust.NewDustPerfect(collision.Entity.Center, 31, collision.Normal, 127);
dust.scale = 0.7f;
dust.fadeIn = 1f;
dust.velocity = dust.velocity * 0.5f + Main.rand.NextVector2CircularEdge(0.5f, 0.4f);
}
}
// Adjust physics components of lifted GameObject if confirmed liftable
void PrepForManipulation()
{
PhysicsProperties ppLifted = objectLifted.GetComponent <PhysicsProperties>();
if (!ppLifted || !ppLifted.liftable)
{
objectLifted = null;
return; // GameObject was not liftable
}
rbLifted = objectLifted.GetComponent <Rigidbody>();
rbLifted.velocity = Vector3.zero;
rbLifted.angularVelocity = Vector3.zero;
rbLifted.useGravity = false;
colliderLifted = objectLifted.GetComponent <Collider>();
colliderLifted.enabled = false;
currentLiftDist = startLiftDist;
objectLifted.transform.position = transform.position + (transform.forward * currentLiftDist);
objectLifted.transform.parent = this.transform; // Preserves relativity of rotation when Lifter looks around
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("MSceneObject");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (ID == null)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ID not set");
}
field.Name = "ID";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteString(ID);
oprot.WriteFieldEnd();
if (Name == null)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Name not set");
}
field.Name = "Name";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(Name);
oprot.WriteFieldEnd();
if (Transform == null)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Transform not set");
}
field.Name = "Transform";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Transform.Write(oprot);
oprot.WriteFieldEnd();
if (Collider != null && __isset.Collider)
{
field.Name = "Collider";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
Collider.Write(oprot);
oprot.WriteFieldEnd();
}
if (Mesh != null && __isset.Mesh)
{
field.Name = "Mesh";
field.Type = TType.Struct;
field.ID = 5;
oprot.WriteFieldBegin(field);
Mesh.Write(oprot);
oprot.WriteFieldEnd();
}
if (PhysicsProperties != null && __isset.PhysicsProperties)
{
field.Name = "PhysicsProperties";
field.Type = TType.Struct;
field.ID = 6;
oprot.WriteFieldBegin(field);
PhysicsProperties.Write(oprot);
oprot.WriteFieldEnd();
}
if (Properties != null && __isset.Properties)
{
field.Name = "Properties";
field.Type = TType.Map;
field.ID = 8;
oprot.WriteFieldBegin(field);
{
oprot.WriteMapBegin(new TMap(TType.String, TType.String, Properties.Count));
foreach (string _iter123 in Properties.Keys)
{
oprot.WriteString(_iter123);
oprot.WriteString(Properties[_iter123]);
}
oprot.WriteMapEnd();
}
oprot.WriteFieldEnd();
}
if (Attachments != null && __isset.Attachments)
{
field.Name = "Attachments";
field.Type = TType.List;
field.ID = 9;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Attachments.Count));
foreach (MAttachment _iter124 in Attachments)
{
_iter124.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Constraints != null && __isset.Constraints)
{
field.Name = "Constraints";
field.Type = TType.List;
field.ID = 10;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Constraints.Count));
foreach (MMIStandard.MConstraint _iter125 in Constraints)
{
_iter125.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Execute(PhysxScene scene)
{
bool isPhysical = (_flags & PhysicsScene.AddPrimShapeFlags.Physical) != 0;
if (_rootHasVdSet)
{
isPhysical = false;
}
if (_newPrimaryShape == null)
{
bool first = true;
foreach (BulkShapeData shape in _shapes)
{
BulkShapeData thisShape = shape;
SceneObjectPart thisPart = (SceneObjectPart)thisShape.Part;
String primName = String.Empty;
if (thisPart != null)
{
primName = thisPart.Name;
}
if (first)
{
_primaryShapeData = thisShape;
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, shape.Material, shape.PhysicsProperties);
_rootHasVdSet = properties.VolumeDetectActive;
if (_rootHasVdSet)
{
isPhysical = false;
}
scene.MeshingStageImpl.QueueForMeshing(primName, shape.Pbs, shape.Size, Meshing.MeshingStage.SCULPT_MESH_LOD,
isPhysical || _rootHasVdSet, shape.SerializedShapes,
(_flags& PhysxScene.AddPrimShapeFlags.FromCrossing) == PhysicsScene.AddPrimShapeFlags.FromCrossing,
delegate(PhysicsShape meshedShape)
{
_newPrimaryShape = meshedShape;
_meshedShapes.Add(thisShape, meshedShape);
if (++_meshedSoFar == _totalNumShapes)
{
scene.QueueCommand(this);
}
}
);
first = false;
}
else
{
scene.MeshingStageImpl.QueueForMeshing(primName, shape.Pbs, shape.Size, Meshing.MeshingStage.SCULPT_MESH_LOD,
isPhysical || _rootHasVdSet, shape.SerializedShapes,
(_flags& PhysxScene.AddPrimShapeFlags.FromCrossing) == PhysicsScene.AddPrimShapeFlags.FromCrossing,
delegate(PhysicsShape meshedShape)
{
_meshedShapes.Add(thisShape, meshedShape);
if (++_meshedSoFar == _totalNumShapes)
{
scene.QueueCommand(this);
}
}
);
}
}
}
else
{
OpenMetaverse.Vector3 rootVelocity = OpenMetaverse.Vector3.Zero;
OpenMetaverse.Vector3 rootAngularVelocity = OpenMetaverse.Vector3.Zero;
//we have all the shapes for the parent and all children, time to construct the group
bool first = true;
PhysxPrim rootPrim = null;
CollisionGroupFlag collisionGroup = (_flags & PhysicsScene.AddPrimShapeFlags.Phantom) == 0 ? CollisionGroupFlag.Normal : CollisionGroupFlag.PhysicalPhantom;
foreach (BulkShapeData shape in _shapes)
{
if (first)
{
bool kinematicStatic;
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, shape.Material, shape.PhysicsProperties);
PhysX.RigidActor actor = PhysxActorFactory.CreateProperInitialActor(_newPrimaryShape, scene, shape.Position, shape.Rotation, _flags, out kinematicStatic,
properties.PhysxMaterial);
rootPrim = new PhysxPrim(scene, shape.Pbs, shape.Position, shape.Rotation, _newPrimaryShape, actor,
isPhysical, properties, collisionGroup);
scene.AddPrimSync(rootPrim, isPhysical, kinematicStatic);
shape.OutActor = rootPrim;
rootVelocity = shape.Velocity;
rootAngularVelocity = shape.AngularVelocity;
first = false;
}
else
{
PhysicsShape phyShape = _meshedShapes[shape];
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, shape.Material, shape.PhysicsProperties);
PhysxPrim childPrim = new PhysxPrim(rootPrim, scene, shape.Pbs, shape.Position, shape.Rotation, phyShape,
null, isPhysical, properties, collisionGroup);
rootPrim.LinkPrimAsChildSync(phyShape, childPrim, shape.Position, shape.Rotation, true);
shape.OutActor = childPrim;
}
}
rootPrim.UpdateMassAndInertia();
if (_rootHasVdSet)
{
rootPrim.SetVolumeDetectSync(_rootHasVdSet);
}
if ((_flags & PhysicsScene.AddPrimShapeFlags.StartSuspended) != 0)
{
rootPrim.SuspendPhysicsSync(_primaryShapeData.ObjectReceivedOn);
}
rootPrim.DynamicsPostcheck();
rootPrim.SetInitialVelocities(rootVelocity, rootAngularVelocity);
if ((_flags & PhysicsScene.AddPrimShapeFlags.Interpolate) != 0)
{
rootPrim.SuspendPhysicsSync(_primaryShapeData.ObjectReceivedOn);
rootPrim.ResumePhysicsSync(true);
}
FinishedEvent.Set();
}
}
private void Start()
{
objSpaceObj = GetComponent <SpaceObject>();
objPhysicsProperties = GetComponent <PhysicsProperties>();
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("MSceneObjectUpdate");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (ID == null)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ID not set");
}
field.Name = "ID";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteString(ID);
oprot.WriteFieldEnd();
if (Name != null && __isset.Name)
{
field.Name = "Name";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(Name);
oprot.WriteFieldEnd();
}
if (Transform != null && __isset.Transform)
{
field.Name = "Transform";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Transform.Write(oprot);
oprot.WriteFieldEnd();
}
if (Collider != null && __isset.Collider)
{
field.Name = "Collider";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
Collider.Write(oprot);
oprot.WriteFieldEnd();
}
if (Mesh != null && __isset.Mesh)
{
field.Name = "Mesh";
field.Type = TType.Struct;
field.ID = 5;
oprot.WriteFieldBegin(field);
Mesh.Write(oprot);
oprot.WriteFieldEnd();
}
if (PhysicsProperties != null && __isset.PhysicsProperties)
{
field.Name = "PhysicsProperties";
field.Type = TType.Struct;
field.ID = 6;
oprot.WriteFieldBegin(field);
PhysicsProperties.Write(oprot);
oprot.WriteFieldEnd();
}
if (HandPoses != null && __isset.HandPoses)
{
field.Name = "HandPoses";
field.Type = TType.List;
field.ID = 7;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, HandPoses.Count));
foreach (MMIStandard.MHandPose _iter138 in HandPoses)
{
_iter138.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Properties != null && __isset.Properties)
{
field.Name = "Properties";
field.Type = TType.List;
field.ID = 8;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Properties.Count));
foreach (MPropertyUpdate _iter139 in Properties)
{
_iter139.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Attachments != null && __isset.Attachments)
{
field.Name = "Attachments";
field.Type = TType.List;
field.ID = 9;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Attachments.Count));
foreach (MAttachment _iter140 in Attachments)
{
_iter140.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Constraints != null && __isset.Constraints)
{
field.Name = "Constraints";
field.Type = TType.List;
field.ID = 10;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Constraints.Count));
foreach (MMIStandard.MConstraint _iter141 in Constraints)
{
_iter141.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Execute(PhysxScene scene)
{
if (Shape == null)
{
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, _material, _serializedPhysicsProperties);
_hasVdSet = properties.VolumeDetectActive;
scene.MeshingStageImpl.QueueForMeshing(_primName, _pbs, _size, _lod,
(_flags& PhysicsScene.AddPrimShapeFlags.Physical) != 0 || _hasVdSet,
_serializedPhysicsShapes,
(_flags& PhysxScene.AddPrimShapeFlags.FromCrossing) == PhysicsScene.AddPrimShapeFlags.FromCrossing,
delegate(PhysicsShape meshedShape)
{
Shape = meshedShape;
scene.QueueCommand(this);
}
);
}
else
{
bool isPhysical = (_flags & PhysicsScene.AddPrimShapeFlags.Physical) != 0;
if (_hasVdSet)
{
isPhysical = false;
}
CollisionGroupFlag collisionGroup = (_flags & PhysicsScene.AddPrimShapeFlags.Phantom) == 0 ? CollisionGroupFlag.Normal : CollisionGroupFlag.PhysicalPhantom;
if (_parent == null)
{
bool kinematicStatic;
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, _material, _serializedPhysicsProperties);
Actor = PhysxActorFactory.CreateProperInitialActor(Shape, scene, _position, _rotation, _flags, out kinematicStatic, properties.PhysxMaterial);
FinalPrim = new PhysxPrim(scene, _pbs, _position, _rotation, Shape, Actor, isPhysical, properties, collisionGroup);
scene.AddPrimSync(FinalPrim, isPhysical, kinematicStatic);
}
else
{
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, _material, _serializedPhysicsProperties);
FinalPrim = new PhysxPrim(_parent, scene, _pbs, _position, _rotation, Shape, null, isPhysical, properties, collisionGroup);
_parent.LinkPrimAsChildSync(Shape, FinalPrim, _position, _rotation, false);
}
if (_hasVdSet)
{
FinalPrim.SetVolumeDetectSync(true);
}
if ((_flags & PhysicsScene.AddPrimShapeFlags.StartSuspended) != 0)
{
FinalPrim.SuspendPhysicsSync(_interpolateTime);
}
FinalPrim.DynamicsPostcheck();
FinalPrim.SetInitialVelocities(_velocity, _angularVelocity);
if ((_flags & PhysicsScene.AddPrimShapeFlags.Interpolate) != 0)
{
FinalPrim.SuspendPhysicsSync(_interpolateTime);
FinalPrim.ResumePhysicsSync(true);
}
this.FinshedEvent.Set();
}
}
