private Response parseAsync()
{
Response asyncSensorDatum;
Byte item = _rawData[2];
Byte num = _rawData[3];
Byte item1 = _rawData[4];
Int32 num1 = Value.IntForBytes(item1, num) - 1;
Int32 num2 = num1 + 6;
if (_rawData.Count >= num2)
{
Byte[] numArray = new Byte[num1];
_rawData.CopyTo(5, numArray, 0, num1);
_rawData.RemoveRange(0, num2);
if (item == 3)
{
asyncSensorDatum = new AsyncSensorData(_robot, ResponseCode.OK, 0, numArray, AsynchronousId.SENSOR_DATA_STREAMING, num1, _robot.SensorControl.Mask);
}
else if (item != 7)
{
asyncSensorDatum = null;
}
else
{
asyncSensorDatum = new CollisionData(_robot, ResponseCode.OK, 0, numArray, AsynchronousId.COLLISION_DETECTED, num1);
}
}
else
{
asyncSensorDatum = null;
}
return asyncSensorDatum;
}
public EnemyEnemyCollisionHandler(CollisionData collision)
{
this.collision = collision;
enemyA = (IEnemy)collision.GameObjectA;
enemyB = (IEnemy)collision.GameObjectB;
side = (ICollisionSide)collision.CollisionSide;
}
public override void OnMovementCollision(CollisionData xCollisionData)
{
foreach (DeligateEntity.OnMovementCollisionDelegate x in this.lxOnMovementCollisionDelegates)
{
x(xCollisionData);
}
}
public override void OnCollide(CollisionData collision)
{
bool isEnemy = EnemyManager.Instance.IsEnemy(collision.sender);
if (isEnemy) {
TakeDamage(25);
}
}
public ColEvent(EventType type, Fixture fxA, Fixture fxB, CollisionData data)
{
this.Type = type;
this.FixtureA = fxA;
this.FixtureB = fxB;
this.Data = data;
}
public void OnCollide(CollisionData collision)
{
var health = collision.sender.GetComponent<Health>();
if (health) {
health.Kill();
}
}
private void NotifyOnCollision(Collision collision, Type type, State state)
{
if(OnCollision != null)
{
CollisionData data = new CollisionData(collision, state);
OnCollision(data);
}
}
public void MakeBonus(int score, CollisionData d)
{
ms.UpdateScore(score);
convertObject.RemoveCollidingObjects(d);
clickObject.MakeBonus(this);
}
public override void OnMovementCollision(CollisionData xCollisionData)
{
IEntity xOtherEntity = xCollisionData.xOtherEntity;
if (xOtherEntity == null || xOtherEntity.enEntityType == IEntity.EntityType.EntityShell)
{
this.bToBeDestroyed = true;
}
}
private void NotifyOnCollision(Collider collider, Type type, State state)
{
//Debug.Log("NotifyOnCollision collider = '" + collider.name + "' Notifier = '" + transform.name + "' type = '" + type + "' state = '" + state + "'");
if (OnCollision != null)
{
CollisionData data = new CollisionData(collider, state);
OnCollision(data);
}
}
public override void RespondToCollision(CollisionData collisionData)
{
//the unstoppable ball should respond (change direction) only
//if it collides with an indestructible block or a racket
if (collisionData.hitObjectsCollisionGroupStrings.Contains(IndestructibleBlock.CollisionGroupString) ||
collisionData.hitObjectsCollisionGroupStrings.Contains(Racket.CollisionGroupString))
{
base.RespondToCollision(collisionData);
}
}
// Change direction after collision
public override void RespondToCollision(CollisionData collisionData)
{
if (
collisionData.hitObjectsCollisionGroupStrings.Contains("racket") ||
collisionData.hitObjectsCollisionGroupStrings.Contains("unpassableBlock") ||
collisionData.hitObjectsCollisionGroupStrings.Contains("indestructibleBlock"))
{
if (collisionData.CollisionForceDirection.Row * this.Speed.Row < 0) this.Speed.Row *= -1;
if (collisionData.CollisionForceDirection.Col * this.Speed.Col < 0) this.Speed.Col *= -1;
}
}
public override void RespondToCollision(CollisionData collisionData)
{
foreach (var item in collisionData.hitObjectsCollisionGroupStrings)
{
if (item == "unpassableBlock" || item == "racket")
{
base.RespondToCollision(collisionData);
}
}
}
public void OnCollide(CollisionData collision)
{
Health health = collision.sender.GetComponent<Health>();
bool shouldDestroy = (health == null || !health.IsInvincible());
if (shouldDestroy) {
Destroy();
}
if (health != null) {
health.TakeDamage(Damage);
}
}
public override void RespondToCollision(CollisionData collisionData)
{
if (collisionData.CollisionForceDirection.Row * this.Speed.Row < 0)
{
this.Speed.Row *= -1;
}
if (collisionData.CollisionForceDirection.Col * this.Speed.Col < 0)
{
this.Speed.Col *= -1;
}
}
public override void manageCollision(CollisionData data)
{
PipeController other = data.other.GetComponent<PipeController>();
if (other != null) {
if (GetComponent<EndNode>() != null && GetComponent<EndNode>().Ending != null) {
other.kill(GetComponent<EndNode>().Ending.edgeId);
}
else {
other.kill("");
}
}
}
public override void OnMovementCollision(CollisionData xCollisionData)
{
if (this.iInTravel != 0)
{
return;
}
PlayerEntity xPlayer = xCollisionData.xOtherEntity as PlayerEntity;
if (xPlayer != null && Utility.ConvertV2DirectionToClosestByteDirection(xCollisionData.v2CollisionNormal) == xPlayer.byAnimationDirection)
{
this.v2PushDir += Utility.AnimationDirectionToVector2((int)xPlayer.byAnimationDirection) * 2f;
this.CheckPushDir();
}
}
public void GetData(CollisionData d)
{
if (d.isEnter)
{
DataCollection.Add(d);
CheckConversion(d);
}
else if(d.almostBonus)
{
CheckReverseConversion(d);
}
}
public void TakeDamage(CollisionData cd)
{
if (canTakeDamage)
{
hitPoints -= cd.damageToDeal; //apply damage
attackerPos = cd.sender.transform.position; //set the position of the attacker so we can perform knockback
takingDamage = true; //sets taking damage flag to true
canTakeDamage = false;
Invoke("UnlockControls", .08f); //resets taking damage flag
Invoke("EnableDamage", .35f); //Allows us to take damage again
Camera.main.GetComponent<CameraFollow>().ShakeCamera(.08f, .1f);
}
}
public EnemyFireballCollisionHandler(CollisionData collision)
{
if (collision.GameObjectA is IEnemy)
{
enemy = (IEnemy)collision.GameObjectA;
fireball = (IProjectile)collision.GameObjectB;
}
else
{
enemy = (IEnemy)collision.GameObjectB;
fireball = (IProjectile)collision.GameObjectA;
}
}
public void Update()
{
GameStep++;
Input.UpdateState();
List<CollisionData> collided = new List<CollisionData>();
foreach(GameObject toUpdate in GameObject.AllObjects)
{
toUpdate.UpdateObject();
}
List<GameObject> collisionCheck = GameObject.AllObjects.FindAll(o => !o.IgnoreCollisions && o.Active);
foreach(GameObject toUpdate in collisionCheck)
{
foreach (GameObject potentialCollision in collisionCheck)
{
if (potentialCollision != toUpdate)
{
if (collided.Find(o => ((o.objOne == toUpdate && o.objTwo == potentialCollision) || (o.objOne == potentialCollision && o.objTwo == toUpdate))) == null)
{
if (toUpdate.Bounds.Intersects(potentialCollision.Bounds))
{
CollisionData newCollision = new CollisionData();
newCollision.objOne = toUpdate;
newCollision.objTwo = potentialCollision;
collided.Add(newCollision);
}
}
}
}
}
foreach (CollisionData collision in collided)
collision.SendCollisionMessage();
if (GameObject.NewObjects != null)
{
GameObject.AllObjects.AddRange(GameObject.NewObjects);
GameObject.NewObjects.RemoveAll(o => true);
GameObject.AllObjects.RemoveAll(o => o.destroyed);
}
GameObject.SortObjects();
game.Update();
}
public EnemyPipeCollisionHandler(CollisionData collision)
{
this.collision = collision;
side = collision.CollisionSide;
if (collision.GameObjectA is IEnemy)
{
enemy = (IEnemy)collision.GameObjectA;
}
else
{
enemy = (IEnemy)collision.GameObjectB;
side = side.FlipSide();
}
}
// если был клик на пересекающиеся объекты
// выпиливает данные о коллизии кликнутого объекта
// а так же данные объекта с которым была коллизия
// второй объект уничтожается
public void RemoveCollidingObjects(CollisionData d)
{
foreach(CollisionData arrayData in AlmostBonusColliding)
{
if(d.targetCollider == arrayData.otherCollider && d.otherCollider == arrayData.targetCollider)
{
AlmostBonusColliding.Remove(arrayData);
break;
}
}
AlmostBonusColliding.Remove(d);
d.otherCollider.gameObject.SendMessage("DestroyClickObject");
}
public void OnCollisionEnter(CollisionData data)
{
if (smc.GetCurrentState() == flyingTowardsWall &&
data.collidedObj.GetID() != player.GetID())
{
CPhysics phyComp = data.collidedObj.GetComponent<CPhysics>();
if (phyComp != null && !phyComp.mIsTriggered)
{
Logger.Log("Collided with: " + data.collidedObj.GetName());
OnCollidingAgainstWall(data.collidedObj);
hasHitWall = true;
}
}
}
public PipeFireballCollisionHandler(CollisionData collision)
{
this.collision = collision;
this.side = collision.CollisionSide;
if (collision.GameObjectA is IProjectile)
{
fireball = (IProjectile)collision.GameObjectA;
}
else
{
fireball = (IProjectile)collision.GameObjectB;
this.side.FlipSide();
}
}
public ItemPipeCollisionHandler(CollisionData collision)
{
this.collision = collision;
side = collision.CollisionSide;
if (collision.GameObjectA is IItem)
{
collidingItem = (IItem)collision.GameObjectA;
}
else
{
collidingItem = (IItem)collision.GameObjectB;
side = side.FlipSide();
}
}
public MarioItemCollisionHandler(CollisionData collision, IGameState gameState)
{
this.gameState = gameState;
if (collision.GameObjectA is IMario)
{
collidingMario = (IMario)collision.GameObjectA;
collidingItem = (IItem)collision.GameObjectB;
}
else
{
collidingMario = (IMario)collision.GameObjectB;
collidingItem = (IItem)collision.GameObjectA;
}
}
public MarioBlockCollisionHandler(CollisionData collision)
{
this.collision = collision;
collisionSide = (ICollisionSide)collision.CollisionSide;
if (collision.GameObjectA is IMario)
{
collidingMario = (IMario)collision.GameObjectA;
collidingBlock = (Block)collision.GameObjectB;
}
else
{
collidingMario = (IMario)collision.GameObjectB;
collidingBlock = (Block)collision.GameObjectA;
collisionSide = collisionSide.FlipSide();
}
}
public MarioFlagPoleCollisionHandler(CollisionData collision, IGameState gameState)
{
this.collision = collision;
this.gameState = gameState;
if (collision.GameObjectA is IFlagPole)
{
collidingFlagPole = (IFlagPole)collision.GameObjectA;
collidingMario = (IMario)collision.GameObjectB;
}
else
{
collidingFlagPole = (IFlagPole)collision.GameObjectB;
collidingMario = (IMario)collision.GameObjectA;
}
}
public override void OnMovementCollision(CollisionData xCollisionData)
{
IEntity xOtherEntity = xCollisionData.xOtherEntity;
if (this.v2MoveDir == Vector2.Zero)
{
return;
}
Vector2 v2LolDir = xOtherEntity.xTransform.v2Pos - this.xOwner.xTransform.v2Pos;
v2LolDir.Normalize();
byte byDir = Utility.ConvertV2DirectionToClosestByteDirection(v2LolDir);
if (byDir == (byte)this.iMoveDir)
{
this.xOwner.xRenderComponent.SwitchAnimation((ushort)((byte)this.iMoveDir), Animation.CancelOptions.UseAnimationDefault);
this.v2MoveDir = Vector2.Zero;
}
}
public void OnCollisionEnter(CollisionData data)
{
// Logger.Log(data.collidedObj.GetName());
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasLODData(reader.Version))
{
LODData = reader.ReadAssetArray <LOD>();
}
else
{
if (HasUse16bitIndices(reader.Version))
{
Use16BitIndices = reader.ReadUInt32();
}
if (IsIndexBufferFirst(reader.Version))
{
IndexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
SubMeshes = reader.ReadAssetArray <SubMesh>();
}
if (HasBlendShapes(reader.Version))
{
if (HasBlendChannels(reader.Version))
{
Shapes.Read(reader);
}
else
{
BlendShapes = reader.ReadAssetArray <BlendShape>();
reader.AlignStream(AlignType.Align4);
ShapeVertices = reader.ReadAssetArray <BlendShapeVertex>();
}
}
if (HasBindPose(reader.Version))
{
if (IsBindPoseFirst(reader.Version))
{
BindPose = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (HasBoneNameHashes(reader.Version))
{
BoneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
if (HasBonesAABB(reader.Version))
{
BonesAABB = reader.ReadAssetArray <MinMaxAABB>();
VariableBoneCountWeights.Read(reader);
}
if (HasMeshCompression(reader.Version))
{
MeshCompression = (MeshCompression)reader.ReadByte();
}
if (HasStreamCompression(reader.Version))
{
StreamCompression = reader.ReadByte();
}
if (HasIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
KeepVertices = reader.ReadBoolean();
KeepIndices = reader.ReadBoolean();
}
if (IsAlignFlags(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (HasIndexFormat(reader.Version))
{
if (IsIndexFormatCondition(reader.Version))
{
if (MeshCompression == MeshCompression.Off)
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
else
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
if (!HasLODData(reader.Version))
{
if (!IsIndexBufferFirst(reader.Version))
{
IndexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (HasVertexData(reader.Version))
{
if (!IsOnlyVertexData(reader.Version))
{
if (MeshCompression != MeshCompression.Off)
{
Vertices = reader.ReadAssetArray <Vector3f>();
}
}
}
else
{
Vertices = reader.ReadAssetArray <Vector3f>();
}
if (HasSkin(reader.Version))
{
Skin = reader.ReadAssetArray <BoneWeights4>();
}
if (HasBindPose(reader.Version))
{
if (!IsBindPoseFirst(reader.Version))
{
BindPose = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (HasVertexData(reader.Version))
{
if (IsOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == MeshCompression.Off)
{
VertexData.Read(reader);
}
else
{
UV = reader.ReadAssetArray <Vector2f>();
UV1 = reader.ReadAssetArray <Vector2f>();
Tangents = reader.ReadAssetArray <Vector4f>();
Normals = reader.ReadAssetArray <Vector3f>();
Colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
}
else
{
UV = reader.ReadAssetArray <Vector2f>();
if (HasUV1(reader.Version))
{
UV1 = reader.ReadAssetArray <Vector2f>();
}
if (HasTangentSpace(reader.Version))
{
TangentSpace = reader.ReadAssetArray <Tangent>();
}
else
{
Tangents = reader.ReadAssetArray <Vector4f>();
Normals = reader.ReadAssetArray <Vector3f>();
}
}
if (IsAlignVertex(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (HasCompressedMesh(reader.Version))
{
CompressedMesh.Read(reader);
}
LocalAABB.Read(reader);
if (!HasVertexData(reader.Version))
{
Colors = reader.ReadAssetArray <ColorRGBA32>();
}
if (HasCollisionTriangles(reader.Version))
{
CollisionTriangles = reader.ReadUInt32Array();
CollisionVertexCount = reader.ReadInt32();
}
if (HasMeshUsageFlags(reader.Version))
{
MeshUsageFlags = reader.ReadInt32();
}
if (HasCollision(reader.Version))
{
CollisionData.Read(reader);
}
if (HasMeshMetrics(reader.Version))
{
MeshMetrics = new float[2];
MeshMetrics[0] = reader.ReadSingle();
MeshMetrics[1] = reader.ReadSingle();
}
#if UNIVERSAL
if (HasMeshOptimization(reader.Version, reader.Flags))
{
if (IsMeshOptimizationFlags(reader.Version))
{
MeshOptimizationFlags = (MeshOptimizationFlags)reader.ReadInt32();
}
else
{
MeshOptimized = reader.ReadBoolean();
}
}
#endif
if (HasStreamData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
StreamData.Read(reader);
}
}
private void HandleTriggerCollision(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if (m_justWarped | !IsOpenForTeleport)
{
return;
}
PlayerController player = specRigidbody.GetComponent <PlayerController>();
if (player)
{
switch (warpType)
{
case WarpType.Normal:
m_justWarped = true;
player.SetInputOverride("arbitrary warp");
StartCoroutine(HandleWarp(player));
return;
case WarpType.FloorWarp:
StartCoroutine(HandleExitFloor());
m_justWarped = true;
return;
case WarpType.OldWestFloorWarp:
StartCoroutine(HandleOldWestExitFloor(player));
m_justWarped = true;
break;
default:
break;
}
}
}
public void HandleTriggerCollision(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if (m_Triggered)
{
return;
}
PlayerController player = specRigidbody.GetComponent <PlayerController>();
if (player && MonsterController)
{
m_Triggered = true;
MonsterController.Awakened = true;
GameObject BellySoundFXObject = new GameObject("BellySoundFXObject")
{
layer = 0
};
BellySoundFXObject.transform.position = (transform.position - new Vector3(15, 0) + new Vector3(0, 8));
BellySoundFXObject.transform.parent = ParentRoom.hierarchyParent;
AkSoundEngine.PostEvent("Play_OBJ_moondoor_close_01", BellySoundFXObject);
Destroy(gameObject);
return;
}
}
private void HandleTriggerEntered(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
PlayerController component = specRigidbody.GetComponent <PlayerController>();
if (component)
{
if (IsSecretGlitchFloorPit)
{
GameManager.Instance.InjectedFlowPath = "secretglitchfloor_flow";
ExpandUtility.RatDungeon = DungeonDatabase.GetOrLoadByName("Base_ResourcefulRat");
ExpandUtility.RatDungeon.LevelOverrideType = GameManager.LevelOverrideState.NONE;
ExpandPrefabs.InitCanyonTileSet(ExpandUtility.RatDungeon, GlobalDungeonData.ValidTilesets.PHOBOSGEON);
}
component.LevelToLoadOnPitfall = targetLevelName;
}
}
void Awake()
{
collisionData = GetComponent <CollisionData>();
}
public static void ExplosiveHook(Action <ExplosiveModifier, Vector2, bool, CollisionData> orig, ExplosiveModifier self, Vector2 sourceNormal, bool ignoreDamageCaps = false, CollisionData cd = null)
{
if (self.projectile && self.projectile.Owner)
{
if (self.projectile.Owner is PlayerController)
{
for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++)
{
PlayerController playerController = GameManager.Instance.AllPlayers[i];
if (playerController && playerController.specRigidbody)
{
if (playerController.HasPickupID(ETGMod.Databases.Items["Nuclear Talisman"].PickupObjectId))
{
self.explosionData.ignoreList.Remove(playerController.specRigidbody);
self.explosionData.damageToPlayer = 4;
if (playerController.HasPickupID(ETGMod.Databases.Items["Boiling Veins"].PickupObjectId) & playerController.healthHaver.GetCurrentHealth() <= 2)
{
self.explosionData.ignoreList.Add(playerController.specRigidbody);
}
}
else
{
self.explosionData.ignoreList.Add(playerController.specRigidbody);
}
}
}
}
else
{
self.explosionData.ignoreList.Add(self.projectile.Owner.specRigidbody);
}
}
Vector3 vector = (cd == null) ? self.specRigidbody.UnitCenter.ToVector3ZUp(0f) : cd.Contact.ToVector3ZUp(0f);
if (self.doExplosion)
{
CoreDamageTypes coreDamageTypes = CoreDamageTypes.None;
if (self.explosionData.doDamage && self.explosionData.damageRadius < 10f && self.projectile)
{
if (self.projectile.AppliesFreeze)
{
coreDamageTypes |= CoreDamageTypes.Ice;
}
if (self.projectile.AppliesFire)
{
coreDamageTypes |= CoreDamageTypes.Fire;
}
if (self.projectile.AppliesPoison)
{
coreDamageTypes |= CoreDamageTypes.Poison;
}
if (self.projectile.statusEffectsToApply != null)
{
for (int j = 0; j < self.projectile.statusEffectsToApply.Count; j++)
{
GameActorEffect gameActorEffect = self.projectile.statusEffectsToApply[j];
if (gameActorEffect is GameActorFreezeEffect)
{
coreDamageTypes |= CoreDamageTypes.Ice;
}
else if (gameActorEffect is GameActorFireEffect)
{
coreDamageTypes |= CoreDamageTypes.Fire;
}
else if (gameActorEffect is GameActorHealthEffect)
{
coreDamageTypes |= CoreDamageTypes.Poison;
}
}
}
}
Exploder.Explode(vector, self.explosionData, sourceNormal, null, self.IgnoreQueues, coreDamageTypes, ignoreDamageCaps);
}
if (self.doDistortionWave)
{
Exploder.DoDistortionWave(vector, self.distortionIntensity, self.distortionRadius, self.maxDistortionRadius, self.distortionDuration);
}
}
public void Add(int i, CollisionData data)
{
collisions[i] = data;
}
public CollideLeft(ICollidable collidable, CollisionData collisionData)
{
this.collidable = collidable;
this.collisionData = collisionData;
}
public RigidBodyCollisionEventArgs(GameObject obj, CollisionData data, ShapeInfo shapeA, ShapeInfo shapeB) : base(obj, data)
{
this.colShapeA = shapeA;
this.colShapeB = shapeB;
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadLODData(stream.Version))
{
m_LODData = stream.ReadArray <LOD>();
}
if (IsReadIndicesUsage(stream.Version))
{
Use16bitIndices = stream.ReadInt32();
}
if (IsReadIndexBuffer(stream.Version))
{
if (IsReadIndexBufferFirst(stream.Version))
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadSubMeshes(stream.Version))
{
m_subMeshes = stream.ReadArray <SubMesh>();
}
if (IsReadBlendShapes(stream.Version))
{
Shapes.Read(stream);
}
if (IsReadBindPosesFirst(stream.Version))
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(stream.Version))
{
m_boneNameHashes = stream.ReadUInt32Array();
RootBoneNameHash = stream.ReadUInt32();
}
if (IsReadMeshCompression(stream.Version))
{
MeshCompression = stream.ReadByte();
}
if (IsReadStreamCompression(stream.Version))
{
StreamCompression = stream.ReadByte();
}
if (IsReadIsReadable(stream.Version))
{
IsReadable = stream.ReadBoolean();
KeepVertices = stream.ReadBoolean();
KeepIndices = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadIndexFormat(stream.Version))
{
if (IsReadIndexFormatCondition(stream.Version))
{
if (MeshCompression == 0)
{
IndexFormat = stream.ReadInt32();
}
}
else
{
IndexFormat = stream.ReadInt32();
}
}
if (IsReadIndexBuffer(stream.Version))
{
if (!IsReadIndexBufferFirst(stream.Version))
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadVertices(stream.Version))
{
if (IsReadVertexData(stream.Version))
{
if (MeshCompression != 0)
{
m_vertices = stream.ReadArray <Vector3f>();
}
}
else
{
m_vertices = stream.ReadArray <Vector3f>();
}
}
m_skin = stream.ReadArray <BoneWeights4>();
if (IsReadBindPoses(stream.Version))
{
if (!IsReadBindPosesFirst(stream.Version))
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
}
if (IsReadVertexData(stream.Version))
{
if (IsReadOnlyVertexData(stream.Version))
{
VertexData.Read(stream);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(stream);
}
else
{
m_UV = stream.ReadArray <Vector2f>();
m_UV1 = stream.ReadArray <Vector2f>();
m_tangents = stream.ReadArray <Vector4f>();
m_normals = stream.ReadArray <Vector3f>();
m_colors = stream.ReadArray <ColorRGBA32>();
}
}
}
else
{
m_UV = stream.ReadArray <Vector2f>();
if (IsReadUV1(stream.Version))
{
m_UV1 = stream.ReadArray <Vector2f>();
}
if (IsReadTangentSpace(stream.Version))
{
m_tangentSpace = stream.ReadArray <Tangent>();
}
else
{
m_tangents = stream.ReadArray <Vector4f>();
m_normals = stream.ReadArray <Vector3f>();
}
}
if (IsReadAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadCompressedMesh(stream.Version))
{
CompressedMesh.Read(stream);
}
LocalAABB.Read(stream);
if (IsReadColors(stream.Version))
{
if (!IsReadVertexData(stream.Version))
{
m_colors = stream.ReadArray <ColorRGBA32>();
}
}
if (IsReadCollisionTriangles(stream.Version))
{
m_collisionTriangles = stream.ReadUInt32Array();
CollisionVertexCount = stream.ReadInt32();
}
if (IsReadMeshUsageFlags(stream.Version))
{
MeshUsageFlags = stream.ReadInt32();
}
if (IsReadCollision(stream.Version))
{
CollisionData.Read(stream);
}
}
public static void Do(Actor r)
{
// Remember old position
Vector2 oldpos = r.position;
// Get collision side
CollisionData col = collisions.CheckCollision(r);
// Do gravity
r.velocity += Physics.gravity;
// Do vertical friction
if (r.velocity.Y < -Physics.friction.Y)
{
r.velocity += Physics.friction * Vector2.UnitY;
}
else
if (r.velocity.Y > Physics.friction.Y)
{
r.velocity -= Physics.friction * Vector2.UnitY;
}
else
{
r.velocity *= Vector2.UnitX;
}
// Do horizontal friction
if (r.velocity.X < -Physics.friction.X)
{
r.velocity += Physics.friction * Vector2.UnitX;
}
else
if (r.velocity.X > Physics.friction.X)
{
r.velocity -= Physics.friction * Vector2.UnitX;
}
else
{
r.velocity *= Vector2.UnitY;
}
// Update position and/or velocity
if (collisions.NextPositionFreeX(r))
{
r.position += r.velocity * Vector2.UnitX;
}
else
{
int sign = Math.Sign(r.velocity.X);
Vector2 p = new Vector2(r.position.X, r.position.Y);
while (collisions.PositionFree(r, p))
{
p.X += sign;
}
p.X -= sign;
r.position = p;
r.velocity = r.velocity * Vector2.UnitY;
}
if (collisions.NextPositionFreeY(r))
{
r.position += r.velocity * Vector2.UnitY;
}
else
{
int sign = Math.Sign(r.velocity.Y);
Vector2 p = new Vector2(r.position.X, r.position.Y);
while (collisions.PositionFree(r, p))
{
p.Y += sign;
}
p.Y -= sign;
r.position = p;
r.velocity = r.velocity * Vector2.UnitX;
}
}
private void HandleTriggerCollision(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if (m_justWarped | !IsOpenForTeleport)
{
return;
}
PlayerController player = specRigidbody.GetComponent <PlayerController>();
if (player && !IsBellyExitDoor)
{
m_justWarped = true;
player.SetInputOverride("arbitrary warp");
StartCoroutine(HandleWarp(player));
return;
}
else if (player && IsBellyExitDoor)
{
StartCoroutine(HandleExitFloor());
m_justWarped = true;
return;
}
}
internal CollisionEvent(Guid actorId, ColliderEventType eventType, CollisionData collisionData)
: base(actorId)
{
_eventType = eventType;
_collisionData = collisionData;
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadLODData(reader.Version))
{
m_LODData = reader.ReadAssetArray <LOD>();
}
if (IsReadUse16bitIndices(reader.Version))
{
Use16bitIndices = reader.ReadInt32() > 0;
}
if (IsReadIndexBuffer(reader.Version))
{
if (IsReadIndexBufferFirst(reader.Version))
{
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadSubMeshes(reader.Version))
{
m_subMeshes = reader.ReadAssetArray <SubMesh>();
}
if (IsReadBlendShapes(reader.Version))
{
Shapes.Read(reader);
}
if (IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadAssetArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(reader.Version))
{
m_boneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
if (IsReadMeshCompression(reader.Version))
{
MeshCompression = (MeshCompression)reader.ReadByte();
}
if (IsReadStreamCompression(reader.Version))
{
StreamCompression = reader.ReadByte();
}
if (IsReadIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
KeepVertices = reader.ReadBoolean();
KeepIndices = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadIndexFormat(reader.Version))
{
if (IsReadIndexFormatCondition(reader.Version))
{
if (MeshCompression == 0)
{
IndexFormat = reader.ReadInt32();
}
}
else
{
IndexFormat = reader.ReadInt32();
}
}
if (IsReadIndexBuffer(reader.Version))
{
if (!IsReadIndexBufferFirst(reader.Version))
{
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadVertices(reader.Version))
{
if (IsReadVertexData(reader.Version))
{
if (MeshCompression != 0)
{
m_vertices = reader.ReadAssetArray <Vector3f>();
}
}
else
{
m_vertices = reader.ReadAssetArray <Vector3f>();
}
}
if (IsReadSkin(reader.Version))
{
m_skin = reader.ReadAssetArray <BoneWeights4>();
}
if (IsReadBindPoses(reader.Version))
{
if (!IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (IsReadVertexData(reader.Version))
{
if (IsReadOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(reader);
}
else
{
m_UV = reader.ReadAssetArray <Vector2f>();
m_UV1 = reader.ReadAssetArray <Vector2f>();
m_tangents = reader.ReadAssetArray <Vector4f>();
m_normals = reader.ReadAssetArray <Vector3f>();
m_colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
}
else
{
m_UV = reader.ReadAssetArray <Vector2f>();
if (IsReadUV1(reader.Version))
{
m_UV1 = reader.ReadAssetArray <Vector2f>();
}
if (IsReadTangentSpace(reader.Version))
{
m_tangentSpace = reader.ReadAssetArray <Tangent>();
}
else
{
m_tangents = reader.ReadAssetArray <Vector4f>();
m_normals = reader.ReadAssetArray <Vector3f>();
}
}
if (IsReadAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadCompressedMesh(reader.Version))
{
CompressedMesh.Read(reader);
}
LocalAABB.Read(reader);
if (IsReadColors(reader.Version))
{
if (!IsReadVertexData(reader.Version))
{
m_colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
if (IsReadCollisionTriangles(reader.Version))
{
m_collisionTriangles = reader.ReadUInt32Array();
CollisionVertexCount = reader.ReadInt32();
}
if (IsReadMeshUsageFlags(reader.Version))
{
MeshUsageFlags = reader.ReadInt32();
}
if (IsReadCollision(reader.Version))
{
CollisionData.Read(reader);
}
if (IsReadMeshMetrics(reader.Version))
{
m_meshMetrics = new float[2];
m_meshMetrics[0] = reader.ReadSingle();
m_meshMetrics[1] = reader.ReadSingle();
}
#if UNIVERSAL
if (IsReadMeshOptimized(reader.Version, reader.Flags))
{
MeshOptimized = reader.ReadBoolean();
}
#endif
if (IsReadStreamData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
StreamData.Read(reader);
}
}
void _spheroDevice_CollisionDetected(CollisionData data)
{
// Collision detected !
Debug.WriteLine("Collision ! ");
}
private void OnElevatorTriggerEnter(SpeculativeRigidbody otherSpecRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if (m_isArrived == Tribool.Ready)
{
if (otherSpecRigidbody.GetComponent <PlayerController>() != null)
{
if (GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER)
{
bool flag = true;
for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++)
{
if (!GameManager.Instance.AllPlayers[i].healthHaver.IsDead)
{
if (!sourceSpecRigidbody.ContainsPoint(GameManager.Instance.AllPlayers[i].SpriteBottomCenter.XY(), 2147483647, true))
{
flag = false;
break;
}
}
}
if (flag)
{
DoDeparture();
}
}
else
{
DoDeparture();
}
}
}
}
private void Start()
{
collisionData = new CollisionData();
}
private void HandleFlightCollider(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if (!GameManager.Instance.IsLoadingLevel && IsValidForUse())
{
PlayerController component = specRigidbody.GetComponent <PlayerController>();
if (component && component.IsFlying && !m_isLoading && !GameManager.Instance.IsLoadingLevel && !string.IsNullOrEmpty(targetLevelName))
{
m_timeHovering += BraveTime.DeltaTime;
if (GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER)
{
PlayerController otherPlayer = GameManager.Instance.GetOtherPlayer(component);
if (component.IsFlying && !otherPlayer.IsFlying && !otherPlayer.IsGhost)
{
m_timeHovering = 0f;
}
}
if (m_timeHovering > 0.5f)
{
m_isLoading = true;
if (IsSecretGlitchFloorPit)
{
GameManager.Instance.InjectedFlowPath = "secretglitchfloor_Flow";
ExpandUtility.RatDungeon = DungeonDatabase.GetOrLoadByName("Base_ResourcefulRat");
ExpandUtility.RatDungeon.LevelOverrideType = GameManager.LevelOverrideState.NONE;
ExpandPrefabs.InitCanyonTileSet(ExpandUtility.RatDungeon, GlobalDungeonData.ValidTilesets.PHOBOSGEON);
}
component.LevelToLoadOnPitfall = targetLevelName;
component.ForceFall();
// GameManager.Instance.LoadCustomLevel(targetLevelName);
}
}
}
}
public override void RespondToCollision(CollisionData collisionData)
{
this.IsDestroyed = true;
}
private void SpawnEnemies(string[] selectedEnemyGuids)
{
if (useGlitchedActorPrefab)
{
IntVector2 pos = specRigidbody.UnitCenter.ToIntVector2(VectorConversions.Floor);
if (aiActor.IsFalling && !IsGlitchedLJ)
{
return;
}
if (GameManager.Instance.Dungeon.CellIsPit(specRigidbody.UnitCenter.ToVector3ZUp(0f)) && !IsGlitchedLJ)
{
return;
}
RoomHandler roomFromPosition = GameManager.Instance.Dungeon.GetRoomFromPosition(pos);
List <SpeculativeRigidbody> list = new List <SpeculativeRigidbody>();
list.Add(specRigidbody);
Vector2 unitBottomLeft = specRigidbody.UnitBottomLeft;
for (int i = 0; i < ActorPrefabSpawnCount; i++)
{
if (IsGlitchedLJ)
{
if (transform.position.GetAbsoluteRoom() != null)
{
ChaosGlitchedEnemies m_GlitchedEnemyDatabase = new ChaosGlitchedEnemies();
RoomHandler CurrentRoom = transform.position.GetAbsoluteRoom();
IntVector2 actorPosition = specRigidbody.UnitCenter.ToIntVector2(VectorConversions.Floor) - CurrentRoom.area.basePosition;
m_GlitchedEnemyDatabase.SpawnGlitchedSuperReaper(CurrentRoom, actorPosition);
Destroy(m_GlitchedEnemyDatabase);
return;
}
}
else
{
if (ActorObjectTarget == null)
{
return;
}
AIActor.AwakenAnimationType AnimationType = AIActor.AwakenAnimationType.Default;
AIActor aiactor = null;
GameObject CachedTargetActorObject = Instantiate(ActorObjectTarget);
bool ExplodesOnDeath = false;
bool spawnsGlitchedObjectOnDeath = false;
if (UnityEngine.Random.value <= 0.25f)
{
ExplodesOnDeath = true;
}
if (UnityEngine.Random.value <= 0.15f)
{
spawnsGlitchedObjectOnDeath = true;
}
ChaosGlitchedEnemies m_GlitchedEnemyDatabase = new ChaosGlitchedEnemies();
aiactor = AIActor.Spawn(m_GlitchedEnemyDatabase.GenerateGlitchedActorPrefab(CachedTargetActorObject, ActorOverrideSource, ExplodesOnDeath, spawnsGlitchedObjectOnDeath), specRigidbody.UnitCenter.ToIntVector2(VectorConversions.Floor), roomFromPosition, true, AnimationType, true);
Destroy(m_GlitchedEnemyDatabase);
if (aiactor == null)
{
return;
}
if (aiActor.IsBlackPhantom)
{
aiactor.BecomeBlackPhantom();
}
if (aiactor)
{
aiactor.specRigidbody.Initialize();
Vector2 a = unitBottomLeft - (aiactor.specRigidbody.UnitBottomLeft - aiactor.transform.position.XY());
Vector2 vector = a + new Vector2(Mathf.Max(0f, specRigidbody.UnitDimensions.x - aiactor.specRigidbody.UnitDimensions.x), 0f);
aiactor.transform.position = Vector2.Lerp(a, vector, (ActorPrefabSpawnCount != 1) ? i / (ActorPrefabSpawnCount - 1f) : 0f);
aiactor.specRigidbody.Reinitialize();
a -= new Vector2(PhysicsEngine.PixelToUnit(extraPixelWidth), 0f);
vector += new Vector2(PhysicsEngine.PixelToUnit(extraPixelWidth), 0f);
Vector2 a2 = Vector2.Lerp(a, vector, (ActorPrefabSpawnCount != 1) ? i / (ActorPrefabSpawnCount - 1f) : 0.5f);
IntVector2 intVector = PhysicsEngine.UnitToPixel(a2 - aiactor.transform.position.XY());
CollisionData collisionData = null;
if (PhysicsEngine.Instance.RigidbodyCastWithIgnores(aiactor.specRigidbody, intVector, out collisionData, true, true, null, false, list.ToArray()))
{
intVector = collisionData.NewPixelsToMove;
}
CollisionData.Pool.Free(ref collisionData);
aiactor.transform.position += PhysicsEngine.PixelToUnit(intVector).ToVector3ZUp(1f);
aiactor.specRigidbody.Reinitialize();
if (i == 0)
{
aiactor.aiAnimator.FacingDirection = 180f;
}
else if (i == ActorPrefabSpawnCount - 1)
{
aiactor.aiAnimator.FacingDirection = 0f;
}
HandleSpawn(aiactor);
list.Add(aiactor.specRigidbody);
Destroy(CachedTargetActorObject);
}
}
}
if (list.Count > 0)
{
for (int j = 0; j < list.Count; j++)
{
for (int k = 0; k < list.Count; k++)
{
if (j != k)
{
list[j].RegisterGhostCollisionException(list[k]);
}
}
}
}
}
else if (spawnPosition == SpawnPosition.InsideCollider)
{
IntVector2 pos = specRigidbody.UnitCenter.ToIntVector2(VectorConversions.Floor);
if (aiActor.IsFalling)
{
return;
}
if (GameManager.Instance.Dungeon.CellIsPit(specRigidbody.UnitCenter.ToVector3ZUp(0f)))
{
return;
}
RoomHandler roomFromPosition = GameManager.Instance.Dungeon.GetRoomFromPosition(pos);
List <SpeculativeRigidbody> list = new List <SpeculativeRigidbody>();
list.Add(specRigidbody);
Vector2 unitBottomLeft = specRigidbody.UnitBottomLeft;
for (int i = 0; i < selectedEnemyGuids.Length; i++)
{
AIActor orLoadByGuid = EnemyDatabase.GetOrLoadByGuid(selectedEnemyGuids[i]);
AIActor aiactor = AIActor.Spawn(orLoadByGuid, specRigidbody.UnitCenter.ToIntVector2(VectorConversions.Floor), roomFromPosition, false, AIActor.AwakenAnimationType.Default, true);
if (aiActor.IsBlackPhantom)
{
aiactor.ForceBlackPhantom = true;
}
if (aiactor)
{
aiactor.specRigidbody.Initialize();
Vector2 a = unitBottomLeft - (aiactor.specRigidbody.UnitBottomLeft - aiactor.transform.position.XY());
Vector2 vector = a + new Vector2(Mathf.Max(0f, specRigidbody.UnitDimensions.x - aiactor.specRigidbody.UnitDimensions.x), 0f);
aiactor.transform.position = Vector2.Lerp(a, vector, (selectedEnemyGuids.Length != 1) ? i / (selectedEnemyGuids.Length - 1f) : 0f);
aiactor.specRigidbody.Reinitialize();
a -= new Vector2(PhysicsEngine.PixelToUnit(extraPixelWidth), 0f);
vector += new Vector2(PhysicsEngine.PixelToUnit(extraPixelWidth), 0f);
Vector2 a2 = Vector2.Lerp(a, vector, (selectedEnemyGuids.Length != 1) ? i / (selectedEnemyGuids.Length - 1f) : 0.5f);
IntVector2 intVector = PhysicsEngine.UnitToPixel(a2 - aiactor.transform.position.XY());
CollisionData collisionData = null;
if (PhysicsEngine.Instance.RigidbodyCastWithIgnores(aiactor.specRigidbody, intVector, out collisionData, true, true, null, false, list.ToArray()))
{
intVector = collisionData.NewPixelsToMove;
}
CollisionData.Pool.Free(ref collisionData);
// aiactor.transform.position += PhysicsEngine.PixelToUnit(intVector);
aiactor.transform.position += PhysicsEngine.PixelToUnit(intVector).ToVector3ZUp(1f);
aiactor.specRigidbody.Reinitialize();
if (i == 0)
{
aiactor.aiAnimator.FacingDirection = 180f;
}
else if (i == selectedEnemyGuids.Length - 1)
{
aiactor.aiAnimator.FacingDirection = 0f;
}
HandleSpawn(aiactor);
list.Add(aiactor.specRigidbody);
}
}
for (int j = 0; j < list.Count; j++)
{
for (int k = 0; k < list.Count; k++)
{
if (j != k)
{
list[j].RegisterGhostCollisionException(list[k]);
}
}
}
}
else if (spawnPosition == SpawnPosition.ScreenEdge)
{
for (int l = 0; l < selectedEnemyGuids.Length; l++)
{
AIActor orLoadByGuid2 = EnemyDatabase.GetOrLoadByGuid(selectedEnemyGuids[l]);
AIActor spawnedActor = AIActor.Spawn(orLoadByGuid2, specRigidbody.UnitCenter.ToIntVector2(VectorConversions.Floor), aiActor.ParentRoom, false, AIActor.AwakenAnimationType.Default, true);
if (spawnedActor)
{
Vector2 cameraBottomLeft = BraveUtility.ViewportToWorldpoint(new Vector2(0f, 0f), ViewportType.Gameplay);
Vector2 cameraTopRight = BraveUtility.ViewportToWorldpoint(new Vector2(1f, 1f), ViewportType.Gameplay);
IntVector2 bottomLeft = cameraBottomLeft.ToIntVector2(VectorConversions.Ceil);
IntVector2 topRight = cameraTopRight.ToIntVector2(VectorConversions.Floor) - IntVector2.One;
CellValidator cellValidator = delegate(IntVector2 c) {
for (int num2 = 0; num2 < spawnedActor.Clearance.x; num2++)
{
for (int num3 = 0; num3 < spawnedActor.Clearance.y; num3++)
{
if (GameManager.Instance.Dungeon.data.isTopWall(c.x + num2, c.y + num3))
{
return(false);
}
if (GameManager.Instance.Dungeon.data[c.x + num2, c.y + num3].isExitCell)
{
return(false);
}
}
}
return(c.x >= bottomLeft.x && c.y >= bottomLeft.y && c.x + spawnedActor.Clearance.x - 1 <= topRight.x && c.y + spawnedActor.Clearance.y - 1 <= topRight.y);
};
Func <IntVector2, float> cellWeightFinder = delegate(IntVector2 c) {
float a3 = float.MaxValue;
a3 = Mathf.Min(a3, c.x - cameraBottomLeft.x);
a3 = Mathf.Min(a3, c.y - cameraBottomLeft.y);
a3 = Mathf.Min(a3, cameraTopRight.x - c.x + spawnedActor.Clearance.x);
return(Mathf.Min(a3, cameraTopRight.y - c.y + spawnedActor.Clearance.y));
};
Vector2 b = spawnedActor.specRigidbody.UnitCenter - spawnedActor.transform.position.XY();
IntVector2?randomWeightedAvailableCell = spawnedActor.ParentRoom.GetRandomWeightedAvailableCell(new IntVector2?(spawnedActor.Clearance), new CellTypes?(spawnedActor.PathableTiles), false, cellValidator, cellWeightFinder, 0.25f);
if (randomWeightedAvailableCell == null)
{
Debug.LogError("Screen Edge Spawn FAILED!", spawnedActor);
Destroy(spawnedActor);
}
else
{
spawnedActor.transform.position = Pathfinder.GetClearanceOffset(randomWeightedAvailableCell.Value, spawnedActor.Clearance) - b;
spawnedActor.specRigidbody.Reinitialize();
HandleSpawn(spawnedActor);
}
}
}
}
else if (spawnPosition == SpawnPosition.InsideRadius)
{
Vector2 unitCenter = specRigidbody.GetUnitCenter(ColliderType.HitBox);
List <SpeculativeRigidbody> list2 = new List <SpeculativeRigidbody>();
list2.Add(specRigidbody);
for (int m = 0; m < selectedEnemyGuids.Length; m++)
{
Vector2 vector2 = unitCenter + UnityEngine.Random.insideUnitCircle * spawnRadius;
if (GameManager.Instance.CurrentLevelOverrideState == GameManager.LevelOverrideState.CHARACTER_PAST && SceneManager.GetActiveScene().name == "fs_robot")
{
RoomHandler entrance = GameManager.Instance.Dungeon.data.Entrance;
Vector2 lhs = entrance.area.basePosition.ToVector2() + new Vector2(7f, 7f);
Vector2 lhs2 = entrance.area.basePosition.ToVector2() + new Vector2(38f, 36f);
vector2 = Vector2.Min(lhs2, Vector2.Max(lhs, vector2));
}
AIActor orLoadByGuid3 = EnemyDatabase.GetOrLoadByGuid(selectedEnemyGuids[m]);
AIActor aiactor2 = AIActor.Spawn(orLoadByGuid3, unitCenter.ToIntVector2(VectorConversions.Floor), aiActor.ParentRoom, true, AIActor.AwakenAnimationType.Default, true);
if (aiactor2)
{
aiactor2.specRigidbody.Initialize();
Vector2 unit = vector2 - aiactor2.specRigidbody.GetUnitCenter(ColliderType.HitBox);
aiactor2.specRigidbody.ImpartedPixelsToMove = PhysicsEngine.UnitToPixel(unit);
HandleSpawn(aiactor2);
list2.Add(aiactor2.specRigidbody);
}
}
for (int n = 0; n < list2.Count; n++)
{
for (int num = 0; num < list2.Count; num++)
{
if (n != num)
{
list2[n].RegisterGhostCollisionException(list2[num]);
}
}
}
}
else
{
Debug.LogError("Unknown spawn type: " + spawnPosition);
}
}
private void OnCollision(CollisionData data)
{
SimpleData sd = new SimpleData(this);
sd.ObjectId = data.HitComponentId.ObjectId;
sd.AgentInfo = ScenePrivate.FindAgent(sd.ObjectId)?.AgentInfo;
sd.SourceObjectId = ObjectPrivate.ObjectId;
bool isAgentPunch = (data.HitControlPoint != ControlPointType.Invalid);
if (!enabled)
{
// No events are sent while disabled, just manage agentsInTrigger
if (data.Phase == CollisionEventPhase.TriggerExit)
{
if (agentsInTrigger.ContainsKey(sd.ObjectId) && !isAgentPunch)
{
agentsInTrigger.Remove(sd.ObjectId);
}
}
else if (data.Phase == CollisionEventPhase.TriggerEnter)
{
if (sd.AgentInfo != null && !isAgentPunch && !agentsInTrigger.ContainsKey(sd.ObjectId))
{
agentsInTrigger[sd.ObjectId] = sd.AgentInfo;
}
}
return;
}
if (data.Phase == CollisionEventPhase.TriggerExit)
{
if (sd.ObjectId == ObjectId.Invalid)
{
if (userLoggedOut > 0)
{
// This object has left the scene and it was a user whose events were managed in the user subscription.
--userLoggedOut;
}
else
{
// Object that was destroyed while inside the collision volume
SendToAll(OnObjectExit, sd);
}
return;
}
// We determine agent or not on exit by whether they are in the agentsInTrigger Dictionary
// This helps handle the case where a user logs out from within the trigger volume - after which their AgentInfo will be null.
AgentInfo storedInfo;
if (agentsInTrigger.TryGetValue(sd.ObjectId, out storedInfo))
{
// Use the stored info, in case the user has logged out.
sd.AgentInfo = storedInfo;
if (isAgentPunch)
{
SendToAll(OnAgentPunchExit, sd);
}
else
{
SendToAll(OnAgentExit, sd);
agentsInTrigger.Remove(sd.ObjectId);
if (agentsInTrigger.Count == 0)
{
SendToAll(OnLastAgentTriggerExit, sd);
}
}
}
else
{
SendToAll(OnObjectExit, sd);
}
}
else if (data.Phase == CollisionEventPhase.TriggerEnter || data.Phase == CollisionEventPhase.Invalid)
{
if (sd.AgentInfo != null)
{
if (isAgentPunch)
{
SendToAll(OnAgentPunchEnter, sd);
}
else
{
SendToAll(OnAgentEnter, sd);
// Only track agents in the object if it is an enter event.
if (data.Phase == CollisionEventPhase.TriggerEnter)
{
if (agentsInTrigger.Count == 0)
{
SendToAll(OnFirstAgentTriggerEnter, sd);
}
agentsInTrigger[sd.ObjectId] = sd.AgentInfo;
}
}
}
else
{
SendToAll(OnObjectEnter, sd);
}
}
}
public void OnHit(GameObject projectile, CollisionData collisionData)
{
this.GetComponent <Renderer>().material.color = GetRandomColor();
}
public void Hover(CollisionData point)
{
pointOfInterestComponent.Hover(point);
}
public JumpChargeState(ref PlayerData playerData, ref PlayerPositionData positionData, ref CollisionData collisionData, ref AerialMoveData aerialMoveData, ref IncrementCartridge incr)
{
this.c_playerData = playerData;
this.c_positionData = positionData;
this.c_aerialMoveData = aerialMoveData;
this.c_collisionData = collisionData;
this.cart_increment = incr;
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
if (HasLODData(writer.Version))
{
writer.WriteAssetArray(LODData);
}
else
{
if (HasUse16bitIndices(writer.Version))
{
writer.Write(Use16BitIndices);
}
if (IsIndexBufferFirst(writer.Version))
{
writer.WriteArray(IndexBuffer);
writer.AlignStream(AlignType.Align4);
}
writer.WriteAssetArray(SubMeshes);
}
if (HasBlendShapes(writer.Version))
{
if (HasBlendChannels(writer.Version))
{
Shapes.Write(writer);
}
else
{
writer.WriteAssetArray(BlendShapes);
writer.AlignStream(AlignType.Align4);
writer.WriteAssetArray(ShapeVertices);
}
}
if (HasBindPose(writer.Version))
{
if (IsBindPoseFirst(writer.Version))
{
writer.WriteAssetArray(BindPose);
}
}
if (HasBoneNameHashes(writer.Version))
{
writer.WriteArray(BoneNameHashes);
writer.Write(RootBoneNameHash);
}
if (HasBonesAABB(writer.Version))
{
writer.WriteAssetArray(BonesAABB);
VariableBoneCountWeights.Write(writer);
}
if (HasMeshCompression(writer.Version))
{
writer.Write((byte)MeshCompression);
}
if (HasStreamCompression(writer.Version))
{
writer.Write(StreamCompression);
}
if (HasIsReadable(writer.Version))
{
writer.Write(IsReadable);
writer.Write(KeepVertices);
writer.Write(KeepIndices);
}
if (IsAlignFlags(writer.Version))
{
writer.AlignStream(AlignType.Align4);
}
if (HasIndexFormat(writer.Version))
{
if (IsIndexFormatCondition(writer.Version))
{
if (MeshCompression == MeshCompression.Off)
{
writer.Write((int)IndexFormat);
}
}
else
{
writer.Write((int)IndexFormat);
}
}
if (!HasLODData(writer.Version))
{
if (!IsIndexBufferFirst(writer.Version))
{
writer.WriteArray(IndexBuffer);
writer.AlignStream(AlignType.Align4);
}
}
if (HasVertexData(writer.Version))
{
if (!IsOnlyVertexData(writer.Version))
{
if (MeshCompression != MeshCompression.Off)
{
writer.WriteAssetArray(Vertices);
}
}
}
else
{
writer.WriteAssetArray(Vertices);
}
if (HasSkin(writer.Version))
{
writer.WriteAssetArray(Skin);
}
if (HasBindPose(writer.Version))
{
if (!IsBindPoseFirst(writer.Version))
{
writer.WriteAssetArray(BindPose);
}
}
if (HasVertexData(writer.Version))
{
if (IsOnlyVertexData(writer.Version))
{
VertexData.Write(writer);
}
else
{
if (MeshCompression == MeshCompression.Off)
{
VertexData.Write(writer);
}
else
{
writer.WriteAssetArray(UV);
writer.WriteAssetArray(UV1);
writer.WriteAssetArray(Tangents);
writer.WriteAssetArray(Normals);
writer.WriteAssetArray(Colors);
}
}
}
else
{
writer.WriteAssetArray(UV);
if (HasUV1(writer.Version))
{
writer.WriteAssetArray(UV1);
}
if (HasTangentSpace(writer.Version))
{
writer.WriteAssetArray(TangentSpace);
}
else
{
writer.WriteAssetArray(Tangents);
writer.WriteAssetArray(Normals);
}
}
if (IsAlignVertex(writer.Version))
{
writer.AlignStream(AlignType.Align4);
}
if (HasCompressedMesh(writer.Version))
{
CompressedMesh.Write(writer);
}
LocalAABB.Write(writer);
if (!HasVertexData(writer.Version))
{
writer.WriteAssetArray(Colors);
}
if (HasCollisionTriangles(writer.Version))
{
writer.WriteArray(CollisionTriangles);
writer.Write(CollisionVertexCount);
}
if (HasMeshUsageFlags(writer.Version))
{
writer.Write(MeshUsageFlags);
}
if (HasCollision(writer.Version))
{
CollisionData.Write(writer);
}
if (HasMeshMetrics(writer.Version))
{
writer.Write(MeshMetrics[0]);
writer.Write(MeshMetrics[1]);
}
#if UNIVERSAL
if (HasMeshOptimization(writer.Version, writer.Flags))
{
if (IsMeshOptimizationFlags(writer.Version))
{
writer.Write((int)MeshOptimizationFlags);
}
else
{
writer.Write(MeshOptimized);
}
}
#endif
if (HasStreamData(writer.Version))
{
writer.AlignStream(AlignType.Align4);
StreamData.Write(writer);
}
}
public void init(AttachedEffectData effectData, Transform parent, Vector3 position, float yAngle = 0.0f)
{
data = effectData;
nowCollisionData = null;
position += data.pos;
removeParent = false;
_ani = null;
type = data.type;
if (data.type == TYPE_PREFAB)
{
gameObject = GameManager.resourceManager.getPrefabFromPool(GameManager.info.effectData[data.id].resource);
_ani = gameObject.animation;
if (collisionData.TryGetValue(data.id, out nowCollisionData) == false)
{
BoxCollider collider = gameObject.GetComponentInChildren <BoxCollider>();
if (collider == null)
{
collider = gameObject.GetComponent <BoxCollider>();
}
if (collider != null)
{
#if UNITY_EDITOR
// if(BattleSimulator.nowSimulation == false) Debug.Log("충돌박스 없음!!!!");
#endif
collider.enabled = false;
}
if (GameManager.info.effectData[data.id].hasCollider == false)
{
nowCollisionData = null;
}
else
{
nowCollisionData = new CollisionData(GameManager.info.effectData[data.id]);
collisionData.Add(data.id, nowCollisionData);
}
}
if (data.option == false)
{
removeParent = true;
GameManager.resourceManager.setPrefabToPoolDelay(gameObject.animation.clip.length, data.id, gameObject);
}
}
else if (data.type == TYPE_EFFECT)
{
particleEffect = GameManager.me.effectManager.getParticleEffect(data.id, GameManager.info.effectData[data.id].resource);
particleEffect.start(position, null, data.attachToParent);
gameObject = particleEffect.gameObject;
if (collisionData.TryGetValue(data.id, out nowCollisionData) == false)
{
if (particleEffect.boxCollder == null)
{
particleEffect.boxCollder = gameObject.GetComponentInChildren <BoxCollider>();
if (particleEffect.boxCollder != null)
{
particleEffect.boxCollder.enabled = false;
}
}
if (GameManager.info.effectData[data.id].hasCollider == false)
{
nowCollisionData = null;
}
else
{
nowCollisionData = new CollisionData(GameManager.info.effectData[data.id]);
collisionData.Add(data.id, nowCollisionData);
}
}
}
else if (data.type == TYPE_INDY_EFFECT)
{
particleEffect = GameManager.me.effectManager.getParticleEffect(data.id, GameManager.info.effectData[data.id].resource);
gameObject = particleEffect.gameObject;
particleEffect.start(position, null, data.attachToParent);
particleEffect.setTimeLimit(data.timeLimit);
if (collisionData.TryGetValue(data.id, out nowCollisionData) == false)
{
if (particleEffect.boxCollder == null)
{
particleEffect.boxCollder = gameObject.GetComponentInChildren <BoxCollider>();
if (particleEffect.boxCollder != null)
{
particleEffect.boxCollder.enabled = false;
}
}
if (GameManager.info.effectData[data.id].hasCollider == false)
{
nowCollisionData = null;
}
else
{
nowCollisionData = new CollisionData(GameManager.info.effectData[data.id]);
collisionData.Add(data.id, nowCollisionData);
}
}
}
// else if(data.type == TYPE_TK2D_ANI_SPRITE)
// {
// sprite = GameManager.me.effectManager.getAnimatedSprite();
//
// gameObject = sprite.gameObject;
// transform = sprite.transform;
//
// gameObject.SetActive(true);
//
// sprite.Play(sprite.GetClipIdByName(data.id),0.0f);
//
// sprite.CurrentClip.wrapMode = tk2dSpriteAnimationClip.WrapMode.Loop;
// }
transform = gameObject.transform;
if (data.attachToParent)
{
if (removeParent)
{
position = parent.position;
position += data.pos;
transform.position = position;
}
else
{
transform.parent = parent;
position.x = 0; position.y = 0; position.z = 0;
position += data.pos;
transform.localPosition = position;
}
}
else
{
transform.parent = GameManager.me.mapManager.mapStage;
position.z = data.pos.z;
transform.position = position;
}
_q = transform.localRotation;
_v = _q.eulerAngles;
_v.x = 0.0f;
_v.y = yAngle;
_v.z = 0.0f;
_q.eulerAngles = _v;
transform.localRotation = _q;
}
private void HandleTriggerCollision(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if (m_triggered)
{
return;
}
PlayerController player = specRigidbody.GetComponent <PlayerController>();
if (player)
{
StartCoroutine(Trigger());
}
}
private void Player_OnCollideH(On.Celeste.Player.orig_OnCollideH orig, Player self, CollisionData data)
{
// Prevent dust particles / footstep sounds
MarioClearPipeInteraction interaction = self.Get <MarioClearPipeInteraction>();
bool inClearPipe = interaction != null && interaction.CurrentClearPipe != null;
if (!inClearPipe)
{
orig(self, data);
}
}
public override void Update()
{
base.Update();
if (Charge > 0 && base.Scene.OnInterval(fresh ? 0.5f : 0.1f))
{
bool collided = false;
foreach (FakeWall wall in Scene.Tracker.GetEntities <FakeWall>())
{
if (wall.Collider.Collide(this))
{
collided = true;
}
}
if (!collided)
{
Level.ParticlesFG.Emit(particle, Hold.IsHeld ? 2 : 1, Position + particleOffset, Vector2.One * 5f);
}
}
if (dead)
{
return;
}
if (swatTimer > 0f)
{
swatTimer -= Engine.DeltaTime;
}
hardVerticalHitSoundCooldown -= Engine.DeltaTime;
base.Depth = 100;
if (base.Scene.OnInterval(0.5f) && Running && Charge > 0)
{
Charge -= DischargeRate / 2;
}
string newSprite;
ParticleType newParticle = P_Low;
if (DischargeRate == 0)
{
newSprite = "infinite";
newParticle = P_Infinite;
}
else if (fresh && Charge == MaxCharge)
{
newSprite = "fresh";
newParticle = P_Full;
}
else if (Charge > MaxCharge / 2)
{
newSprite = "full";
newParticle = P_Full;
}
else if (Charge > MaxCharge / 5)
{
newSprite = "half";
newParticle = P_Half;
}
else if (Charge > 0)
{
newSprite = "low";
newParticle = P_Low;
}
else
{
newSprite = "empty";
}
if (sprite.CurrentAnimationID != newSprite)
{
sprite.Play(newSprite);
particle = newParticle;
if (newSprite == "empty")
{
Audio.Play("event:/classic/sfx0", Position);
Level.ParticlesFG.Emit(particle, 30, Position + particleOffset, Vector2.One * 10f);
}
else if (newSprite != "infinite" && newSprite != "full" && newSprite != "fresh")
{
Audio.Play("event:/classic/sfx1", Position);
}
}
if (Hold.IsHeld)
{
if (!Running)
{
Running = true;
fresh = false;
}
prevLiftSpeed = Vector2.Zero;
LastHeld = this;
}
else
{
if (OnGround())
{
float target = (!OnGround(Position + Vector2.UnitX * 3f)) ? 20f : (OnGround(Position - Vector2.UnitX * 3f) ? 0f : (-20f));
Speed.X = Calc.Approach(Speed.X, target, 800f * Engine.DeltaTime);
Vector2 liftSpeed = base.LiftSpeed;
if (liftSpeed == Vector2.Zero && prevLiftSpeed != Vector2.Zero)
{
Speed = prevLiftSpeed;
prevLiftSpeed = Vector2.Zero;
Speed.Y = Math.Min(Speed.Y * 0.6f, 0f);
if (Speed.X != 0f && Speed.Y == 0f)
{
Speed.Y = -60f;
}
if (Speed.Y < 0f)
{
noGravityTimer = 0.15f;
}
}
else
{
prevLiftSpeed = liftSpeed;
if (liftSpeed.Y < 0f && Speed.Y < 0f)
{
Speed.Y = 0f;
}
}
}
else if (Hold.ShouldHaveGravity)
{
float num = 800f;
if (Math.Abs(Speed.Y) <= 30f)
{
num *= 0.5f;
}
float num2 = 350f;
if (Speed.Y < 0f)
{
num2 *= 0.5f;
}
Speed.X = Calc.Approach(Speed.X, 0f, num2 * Engine.DeltaTime);
if (noGravityTimer > 0f)
{
noGravityTimer -= Engine.DeltaTime;
}
else
{
Speed.Y = Calc.Approach(Speed.Y, 200f, num * Engine.DeltaTime);
}
}
previousPosition = base.ExactPosition;
MoveH(Speed.X * Engine.DeltaTime, onCollideH);
MoveV(Speed.Y * Engine.DeltaTime, onCollideV);
if (base.Right > (float)Level.Bounds.Right)
{
base.Right = Level.Bounds.Right;
CollisionData data = new CollisionData
{
Direction = Vector2.UnitX
};
OnCollideH(data);
}
else if (base.Left < (float)Level.Bounds.Left)
{
base.Left = Level.Bounds.Left;
CollisionData data = new CollisionData
{
Direction = -Vector2.UnitX
};
OnCollideH(data);
}
else if (base.Bottom > (float)Level.Bounds.Bottom && SaveData.Instance.Assists.Invincible)
{
base.Bottom = Level.Bounds.Bottom;
Speed.Y = -300f;
Audio.Play("event:/game/general/assist_screenbottom", Position);
}
else if (base.Top > (float)Level.Bounds.Bottom)
{
RemoveSelf();
}
Player entity = base.Scene.Tracker.GetEntity <Player>();
BatteryGate templeGate = CollideFirst <BatteryGate>();
if (templeGate != null && entity != null)
{
templeGate.Collidable = false;
MoveH((float)(Math.Sign(entity.X - base.X) * 32) * Engine.DeltaTime);
templeGate.Collidable = true;
}
}
if (!dead)
{
foreach (BatteryCollider batteryCollider in base.Scene.Tracker.GetComponents <BatteryCollider>())
{
batteryCollider.Check(this);
}
Hold.CheckAgainstColliders();
if (!ignoreBarriers)
{
foreach (SeekerBarrier entity in base.Scene.Tracker.GetEntities <SeekerBarrier>())
{
entity.Collidable = true;
bool flag = CollideCheck(entity);
entity.Collidable = false;
if (flag)
{
entity.OnReflectSeeker();
Die();
}
}
}
}
if (hitSeeker != null && swatTimer <= 0f && !hitSeeker.Check(Hold))
{
hitSeeker = null;
}
}
