// Release event may be accompained by a set animation event and set anchored position.
// It safely releases at the relative position to parent, taking physics in consideration
public static void ReleaseAnchoredEntity(GameEntityModel model, GameEntityModel anchoredEntityModel){
int anchorId = -1;
for (int i = 0; i < model.anchoredEntities.Count ; ++i){
if (model.anchoredEntities[i] == anchoredEntityModel.Index){
anchorId = i;
break;
}
}
if (anchorId == -1){
// entity is not grabbed, return
return;
}
anchoredEntityModel.parentEntity = new ModelReference();
PhysicPointModel pointModel = GameEntityController.GetPointModel(anchoredEntityModel);
if (pointModel != null){
pointModel.isActive = true;
PhysicPointModel parentPointModel = GameEntityController.GetPointModel(model);
PhysicPointController pointController = pointModel.Controller() as PhysicPointController;
if (pointController != null && parentPointModel != null){
// Set position directly
pointModel.position = parentPointModel.position;
if (!model.IsFacingRight()) anchoredEntityModel.positionRelativeToParent.X *= -1;
pointController.SetVelocityAffector(pointModel, PhysicPointController.setPositionffectorName, anchoredEntityModel.positionRelativeToParent);
anchoredEntityModel.positionRelativeToParent = FixedVector3.Zero;
}
}
model.anchoredEntities[anchorId] = new ModelReference();
}
// Anchor a model to it
public static void AnchorEntity(GameEntityModel model, GameEntityModel modelToBeAnchored, int anchorId){
if (IsAnchored(modelToBeAnchored)){
Debug.LogWarning("Trying to anchor an entity that is already anchored");
return;
}
if (model.parentEntity != null && model.parentEntity == modelToBeAnchored.Index){
Debug.LogWarning("Cyclic anchoring attempt");
return;
}
if (model.anchoredEntities == null) model.anchoredEntities = new List<ModelReference>(anchorId);
while (model.anchoredEntities.Count <= anchorId) {
model.anchoredEntities.Add(null);
}
if (model.anchoredEntities[anchorId] != null && model.anchoredEntities[anchorId] != ModelReference.InvalidModelIndex){
Debug.LogWarning("Trying to anchor an entity to a busy anchor");
return;
}
model.anchoredEntities[anchorId] = modelToBeAnchored.Index;
modelToBeAnchored.parentEntity = model.Index;
modelToBeAnchored.positionRelativeToParent = FixedVector3.Zero;
PhysicPointModel pointModel = GameEntityController.GetPointModel(modelToBeAnchored);
if (pointModel != null){
pointModel.isActive = false;
}
}
// Filter hit by hitter entity location
private static GameEntityModel getHitEntityIfConformingOrientationOptions(HitInformation hit, OrientationOptions orientationOptions, GameEntityModel model)
{
GameEntityModel hitterModel = StateManager.state.GetModel(hit.entityId) as GameEntityModel;
if (orientationOptions == OrientationOptions.any)
{
return(hitterModel);
}
PhysicPointModel modelPoint = GameEntityController.GetPointModel(model);
PhysicPointModel hitterPoint = GameEntityController.GetPointModel(hitterModel);
bool isFrontal;
if (model.IsFacingRight())
{
isFrontal = hitterPoint.position.X >= modelPoint.position.X;
}
else
{
isFrontal = hitterPoint.position.X <= modelPoint.position.X;
}
if (isFrontal == (orientationOptions == OrientationOptions.fromFront))
{
return(hitterModel);
}
return(null);
}
// ----------------------
// Ground and Wall checks
public static bool IsGrounded(GameEntityModel model)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return(false);
}
return(PhysicPointController.IsGrounded(pointModel));
}
// Apply a force on the physics velocity affector
public static FixedFloat GetVerticalImpulse(GameEntityModel model)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return(FixedFloat.Zero);
}
return(pointModel.velocityAffectors[PhysicPointModel.defaultVelocityAffectorName].Y);
}
public static FixedFloat CollisionZForce(GameEntityModel model)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return(FixedFloat.Zero);
}
return(FixedFloat.Abs(pointModel.collisionInpact.Z));
}
public static bool IsHittingFarWall(GameEntityModel model)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return(false);
}
return(pointModel.collisionInpact.Z > 0);
}
// Anchor a model to it, and optionally move the parent relative to the entity being anchored (e.g. move back a little when grabbing)
public static void AnchorEntity(GameEntityModel model, GameEntityModel modelToBeAnchored, int anchorId, FixedVector3 deltaPosRelativeToAnched){
AnchorEntity(model, modelToBeAnchored, anchorId);
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
PhysicPointModel anchoredPointModel = GameEntityController.GetPointModel(modelToBeAnchored);
if (pointModel != null && anchoredPointModel != null){
PhysicPointController pointController = pointModel.Controller() as PhysicPointController;
if (pointController != null){
if (!model.IsFacingRight()) deltaPosRelativeToAnched.X *= -1;
FixedVector3 deltaPos = (anchoredPointModel.position + deltaPosRelativeToAnched) - pointModel.position;
pointController.SetVelocityAffector(pointModel, PhysicPointController.setPositionffectorName, deltaPos);
}
}
}
// Safelly set position relative to self (e.g. vault), taking physics collisions in consideration
public static void MoveEntity(GameEntityModel model, FixedVector3 relativePosition)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel != null)
{
PhysicPointController pointController = pointModel.Controller() as PhysicPointController;
if (pointController != null)
{
pointController.SetVelocityAffector(pointModel, PhysicPointController.setPositionffectorName, relativePosition);
}
}
}
// Set the velocity affector bound to animation velocity control
public static void SetAnimationVelocity(GameEntityModel model, FixedVector3 velocity)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return;
}
if (!model.IsFacingRight())
{
velocity.X *= -1;
}
pointModel.velocityAffectors[GameEntityController.animVelocityAffector] = velocity;
}
// Reset X and Z force components on the physics velocity affector
public static void ResetPlanarImpulse(GameEntityModel model)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return;
}
FixedVector3 originalImpulse;
pointModel.velocityAffectors.TryGetValue(PhysicPointModel.defaultVelocityAffectorName, out originalImpulse);
pointModel.velocityAffectors[PhysicPointModel.defaultVelocityAffectorName] =
new FixedVector3(0, originalImpulse.Y, 0)
;
}
// Apply a force on the physics velocity affector
public static void AddImpulse(GameEntityModel model, FixedVector3 impulse)
{
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel == null)
{
return;
}
if (!model.IsFacingRight())
{
impulse.X *= -1;
}
pointModel.velocityAffectors[PhysicPointModel.defaultVelocityAffectorName] += impulse;
// pointModel.velocityAffectors[PhysicPointModel.defaultVelocityAffectorName] += new FixedVector3(0, impulse.Y, 0);
// pointModel.velocityAffectors[GameEntityController.animVelocityAffector] += new FixedVector3(impulse.X, 0, impulse.Z);
}
// Face to same direction as hitter is facing
public static void FaceToHitterDirection(GameEntityModel model, bool oppositeFacing)
{
GameEntityController controller = model.Controller() as GameEntityController;
PhysicPointModel pointModel = GameEntityController.GetPointModel(model);
if (pointModel != null && controller.lastHurts.Count > 0)
{
HitInformation info = controller.lastHurts[0];
GameEntityModel hitter = StateManager.state.GetModel(info.entityId) as GameEntityModel;
model.mIsFacingRight = hitter.IsFacingRight();
if (oppositeFacing)
{
model.mIsFacingRight = !model.IsFacingRight();
}
}
}
private static void SpawnAtIntersection(List <HitInformation> hits, GameEntityModel model, string prefabName, int lifetime, FixedVector3 offset, bool localSpace, ConvertGameToViewCoordinates gameToViewCoordinates)
{
GameObject selfObj = UnityObjectsPool.Instance.GetGameObject(model.Index);
// For each hit, spawn randomly within the intersection box
bool spawnAtLeft;
float randomValue;
Vector3 spawnLocation;
foreach (HitInformation info in hits)
{
GameEntityModel otherModel = StateManager.state.GetModel(info.entityId) as GameEntityModel;
if (otherModel != null)
{
spawnAtLeft = !otherModel.IsFacingRight();
randomValue = UnityEngine.Random.Range(0f, 1f);
randomValue = randomValue * randomValue * randomValue;
if (spawnAtLeft)
{
randomValue = 1 - randomValue;
}
// Get a suitable location to spawn
spawnLocation.x = (float)(info.intersection.pointOne.X + (info.intersection.pointTwo.X - info.intersection.pointOne.X) * randomValue);
randomValue = UnityEngine.Random.Range(0f, 1f);
randomValue = 1 - (randomValue * randomValue);
randomValue *= UnityEngine.Random.Range(0, 2) == 0 ? 0.5f : -0.5f;
spawnLocation.y = (float)(info.intersection.Center().Y + (info.intersection.pointTwo.Y - info.intersection.pointOne.Y) * randomValue);
float z1 = (float)GameEntityController.GetPointModel(model).position.Z;
float z2 = (float)GameEntityController.GetPointModel(otherModel).position.Z;
spawnLocation.z = Mathf.Min(z1, z2) - 0.1f;
// Spawn the object
GameObject obj = UnityObjectsPool.Instance.FireAndForget(model, prefabName, lifetime);
if (obj != null)
{
spawnLocation += offset.AsVector3();
obj.transform.position = gameToViewCoordinates(spawnLocation);
if (localSpace)
{
obj.transform.SetParent(selfObj.transform);
}
}
}
}
}
// Release event may be accompained by a set animation event and set anchored position.
// It safely releases at the relative position to parent, taking physics in consideration
public static void ReleaseAnchoredEntity(GameEntityModel model, int anchorId){
if (model.anchoredEntities == null || model.anchoredEntities.Count <= anchorId) return;
GameEntityModel anchoredEntityModel = StateManager.state.GetModel(model.anchoredEntities[anchorId]) as GameEntityModel;
if (anchoredEntityModel != null){
anchoredEntityModel.parentEntity = new ModelReference();
PhysicPointModel pointModel = GameEntityController.GetPointModel(anchoredEntityModel);
if (pointModel != null){
pointModel.isActive = true;
PhysicPointModel parentPointModel = GameEntityController.GetPointModel(model);
PhysicPointController pointController = pointModel.Controller() as PhysicPointController;
if (pointController != null && parentPointModel != null){
// Set position directly
pointModel.position = parentPointModel.position;
if (!model.IsFacingRight()) anchoredEntityModel.positionRelativeToParent.X *= -1;
pointController.SetVelocityAffector(pointModel, PhysicPointController.setPositionffectorName, anchoredEntityModel.positionRelativeToParent);
anchoredEntityModel.positionRelativeToParent = FixedVector3.Zero;
}
}
}
model.anchoredEntities[anchorId] = new ModelReference();
}
public static bool IsHurtFrontal(GameEntityModel model, bool frontal)
{
GameEntityController controller = model.Controller() as GameEntityController;
if (controller.lastHurts.Count == 0)
{
return(false);
}
GameEntityModel hitter = StateManager.state.GetModel(controller.lastHurts[0].entityId) as GameEntityModel;
PhysicPointModel modelPoint = GameEntityController.GetPointModel(model);
PhysicPointModel hitterPoint = GameEntityController.GetPointModel(hitter);
bool isFrontal;
if (model.IsFacingRight())
{
isFrontal = hitterPoint.position.X >= modelPoint.position.X;
}
else
{
isFrontal = hitterPoint.position.X <= modelPoint.position.X;
}
return(isFrontal == frontal);
}