void TakeDamage() { Debug.Log("taking damage"); meow.Play(); currentLives--; if (currentLives > 0) //test1 { animator.SetTrigger("DamageTaken"); } Debug.Log(currentLives); UpdateUI(); if (currentLives <= 0) { this.GetComponent <Collider2D> ().enabled = false; this.GetComponent <FollowObject> ().enabled = false; animator.SetTrigger("Dead"); //test1 uiScript.EndGame(); Destroy(gameObject, 2); //test1 } if (mainCam) { mainCam.addScreenShake(10); } remainingInvincibiltiyTime = invincibilityTime; //test Debug.Log(Physics2D.GetIgnoreCollision(collided, this.GetComponent <Collider2D>())); }
private void OnTriggerEnter2D(Collider2D other) { if (other.gameObject.tag == "Player") { Physics2D.GetIgnoreCollision(other.GetComponent <BoxCollider2D>(), gameObject.GetComponent <BoxCollider2D>()); } }
private void FixedUpdate() { // Checks if player is touching the ground m_Grounded = false; Collider2D[] colliders = Physics2D.OverlapCircleAll(m_GroundCheck.position, k_GroundedRadius, m_WhatIsGround); foreach (Collider2D temp_collider in colliders) { // Checks if collider and player are supposed to collide bool shouldCollide = !(Physics2D.GetIgnoreCollision(temp_collider, playerCollider) || Physics2D.GetIgnoreLayerCollision(temp_collider.gameObject.layer, gameObject.layer)); if (temp_collider.gameObject != gameObject && !temp_collider.isTrigger && shouldCollide) { m_Grounded = true; // Drops down platform if (dropDown && temp_collider.gameObject.layer == LayerMask.NameToLayer("EnvironmentObjects")) { StartCoroutine(DropDownPlatform(temp_collider)); } } } animator.SetBool("IsJumping", !m_Grounded); Move(horizontalMove); jump = false; dropDown = false; }
// Use this for initialization public virtual void Start() { origColor = GetComponent <Renderer>().material.color; Collider2D[] playerCollider = new Collider2D[ArtrobotController.artTrans. GetComponent <Rigidbody2D>().attachedColliderCount]; ArtrobotController.artTrans. GetComponent <Rigidbody2D>().GetAttachedColliders(playerCollider); rgdCollider = GetComponents <Collider2D>()[0]; playerTrigger = ArtrobotController.player.GetComponents <Collider2D>()[0]; Debug.Log("Collider count = " + ArtrobotController.artTrans.GetComponent <Rigidbody2D>().attachedColliderCount); foreach (Collider2D c in ArtrobotController.artTrans.GetComponents <Collider2D> ()) { Debug.Log("Ignoring Collision with collider " + c.name); Physics2D.IgnoreCollision(rgdCollider, c, true); Debug.Log("rgdCollider name = " + rgdCollider.name); } int num = 0; foreach (Collider2D c in ArtrobotController.artTrans.GetComponents <Collider2D>()) { Debug.Log("Ignore Collision = " + num + " " + Physics2D.GetIgnoreCollision(rgdCollider, c)); Debug.Log("rgdCollider is trigger = " + c.isTrigger); num++; } audio = GetComponent <AudioSource>(); }
/// <summary> /// </summary> /// <param name="collision">Any object trying to pass through a doorway</param> private void OnTriggerEnter2D(Collider2D collision) { // Charged Interaction is Correct and we are NOT ignoring them if ( !Physics2D.GetIgnoreCollision(collider1: collider, collider2: collision) && collision.gameObject.layer == gameObject.layer ) { // Play Power Down Sound doorSound.clip = doorOff; doorSound.Play(); // Disable Collisions with that Object Physics2D.IgnoreCollision( collider1: collider, collider2: collision, ignore: true ); // Do Not Evaluate Any Other Conditions return; } // Any Other Interaction { // Play Power Failure Sound doorSound.clip = doorFail; doorSound.Play(); // Do Not Evaluate Any Other Conditions return; } }
private void OnTriggerExit2D(Collider2D collision) { // Ignoring Collisions if (Physics2D.GetIgnoreCollision(collider1: collider, collider2: collision)) { // Play Power Up Sound doorSound.clip = doorOn; doorSound.Play(); // Reactivate Collisions Physics2D.IgnoreCollision( collider1: collider, collider2: collision, ignore: false ); // Do Not Evaluate Any Other Conditions return; } // Any Other Interaction { // Play No Sound // Do Not Evaluate Any Other Conditions return; } }
void SaveSettings() { oldAngularDrag = rb.angularDrag; oldLinearDrag = rb.drag; foreach (var collider in colliders) { oldIgnoreCollision[collider] = Physics2D.GetIgnoreCollision(collider, playerCollider); } }
protected void OnCollisionEnter2D(Collision2D coll) { if (isClimbing && coll.gameObject.tag == "Solid" && !Physics2D.GetIgnoreCollision(coll.collider, colli)) { Debug.Log("add " + coll.gameObject.name); Physics2D.IgnoreCollision(coll.collider, colli); ignoreColliderMap[coll.collider] = 0; } }
public override void ResolvePendencies() { if (apostleStatusVariables.isOnAir) { if (lastFramePositionWhileFalling >= rigidbody2D.position.y && rigidbody2D.velocity.y < 0) { distanceWhileFalling += lastFramePositionWhileFalling - rigidbody2D.position.y; } if (apostleStatusVariables.canJump && (rigidbody2D.velocity.y < 0 || MathHelpers.Approximately(rigidbody2D.velocity.y, 0, float.Epsilon))) { if (distanceWhileFalling >= minimumFallingDistanceForDamage) { apostle.TakeDamage(minimumDamageForFalling * distanceWhileFalling / minimumFallingDistanceForDamage); } distanceWhileFalling = 0; apostleStatusVariables.isOnAir = false; apostleController.RevokeControl(0.1f, true, ControlTypeToRevoke.AllMovement, monoBehaviour); } lastFramePositionWhileFalling = rigidbody2D.position.y; } else { lastFramePositionWhileFalling = 0; } if (!MathHelpers.Approximately(rigidbody2D.velocity.y, 0, float.Epsilon) && MathHelpers.Approximately(apostleController.VerticalMovement, 0, float.Epsilon) && apostleStatusVariables.isClimbingLadder) { PhysicsHelpers.ResetVelocityY(rigidbody2D); } if (!apostleStatusVariables.isClimbingStairs) { // PhysicsHelpers.IgnoreLayerCollision(rigidbody2D.gameObject.layer, LayerMask.NameToLayer("Stairs Ground"), // true); apostleCollisionHandler.SetLayerForCollisions(new[] { "Ground", "Ground Ignore" }); var leftRayCollider = apostleCollisionHandler.CastLeftwardRay(LayerMask.GetMask("Stairs Ground")).collider; var rightRayCollider = apostleCollisionHandler.CastRightwardRay(LayerMask.GetMask("Stairs Ground")).collider; if (leftRayCollider != null && !Physics2D.GetIgnoreCollision(capsuleCollider2D, leftRayCollider)) { PhysicsHelpers.IgnoreCollision(capsuleCollider2D, leftRayCollider, true); } else if (rightRayCollider && !Physics2D.GetIgnoreCollision(capsuleCollider2D, rightRayCollider)) { PhysicsHelpers.IgnoreCollision(capsuleCollider2D, rightRayCollider, true); } } }
/// <summary> /// Whether or not a collision can be considered a valid overlap with the ground. /// </summary> /// <param name="collider">The collider</param> /// <returns>True if this is a valid "ground" overlap.</returns> public bool IsOverlap(Collider2D collider) { if (collider == null) { return(false); } return((parentCollider == null || !Physics2D.GetIgnoreCollision(collider, parentCollider)) && // Collision isn't purposefully ignored, collider.CompareTag("Ground") && // Collider is a ground object, !collider.isTrigger); // & Collider isn't a trigger. }
void OnTriggerExit2D(Collider2D other) { if (other.gameObject.GetComponent <FloorTag>() != null) { if (Physics2D.GetIgnoreCollision(other, GetCollider())) { Physics2D.IgnoreCollision(other, GetCollider(), false); wantToJumpDown = false; } } }
void Update() { foreach (string tag in tags) { foreach (GameObject go in GameObject.FindGameObjectsWithTag(tag)) { if (!Physics2D.GetIgnoreCollision(go.GetComponent <BoxCollider2D>(), GetComponent <BoxCollider2D>()) && go != gameObject) { Physics2D.IgnoreCollision(go.GetComponent <BoxCollider2D>(), GetComponent <BoxCollider2D>()); } } } }
// private CircleCollider2D circle; public override void OnCollisionEnter2D(Collision2D c) { base.OnCollisionEnter2D(c); if (c.gameObject.tag == "Bullet") { killMonster(); Physics2D.GetIgnoreCollision(c.collider, GetComponent <BoxCollider2D> ()); } else if (c.gameObject.tag == "Player") { audio1.Stop(); inPursue = false; } Debug.Log(c.gameObject.tag); }
protected new void OnTriggerEnter2D(Collider2D other) { base.OnTriggerEnter2D(other); if (other.CompareTag("Player")) { if (col != null) { if (!Physics2D.GetIgnoreCollision(col, other)) { Physics2D.IgnoreCollision(col, other); } } } }
void OnTriggerEnter2D(Collider2D other) { if (other.CompareTag("Player")) { int id = other.gameObject.GetInstanceID(); if (!isIn.ContainsKey(id)) { isIn [id] = 0; } isIn [id] += 1; if (isIn [id] == 1) { bool isKlaus = other.name.CompareTo("Klaus") == 0; bool needDown; if (isKlaus) { needDown = OneWaySingleton.Instance.GetNeedDownKlaus(colliderOneWay); } else { needDown = OneWaySingleton.Instance.GetNeedDownK1(colliderOneWay); } if (!needDown) { MoveState State = other.GetComponent <MoveState>(); if (EstoyAbajo(State)) { if (!Physics2D.GetIgnoreCollision(colliderOneWay, State.colliders [0])) { for (int i = 0; i < State.colliders.Length; ++i) { Physics2D.IgnoreCollision(colliderOneWay, State.colliders [i], true); } if (other.name.CompareTo("Klaus") == 0) { OneWaySingleton.Instance.SetIsKlausOneWay(colliderOneWay, true); } else if (other.name.CompareTo("K1") == 0) { OneWaySingleton.Instance.SetIsK1OneWay(colliderOneWay, true); } } } } } } }
void OnTriggerEnter2D(Collider2D col) { if (col.gameObject.CompareTag("Player")) { Debug.Log("Era pra morrer"); col.transform.position = col.gameObject.GetComponent <PlayerCheckpoint>().currentCheckpoint.transform.position; } if (col.gameObject.CompareTag("Ghost")) { col.transform.position = col.gameObject.GetComponent <GhostCheckpoint>().spawnPoint.transform.position; col.GetComponent <Ghost_AI>().playerTrigger = false; Debug.Log(Physics2D.GetIgnoreCollision(col, playerCollider)); Physics2D.IgnoreCollision(col, playerCollider, false); } }
private void HandlePlayerClimb(float horizontal, float vertical) { CheckCanClimb(); if (PlayerMoveVertical(horizontal, vertical) && canPlayerClimbUp && !PlayerDiggingAnimation()) { isPlayerClimbing = true; } if (PlayerMoveHorizontal(horizontal, vertical) && canPlayerClimbUp) { isPlayerClimbing = false; } // Handle climbing animation speed if animation DIG is stoped if (isPlayerClimbing && !PlayerDiggingAnimation()) { Rigidbody2D.position = new Vector2(ladderPositionX, Rigidbody2D.position.y); Rigidbody2D.velocity = new Vector2(0, Rigidbody2D.velocity.y); animator.speed = Mathf.Abs(vertical); } else { animator.speed = 1; } // if player stop climbing set all players and ladders floor collisions to false foreach (Collider2D c in floorLaddersColliders.Values) { if (!isPlayerClimbing && c && Physics2D.GetIgnoreCollision(playerCollider2D, c)) { Physics2D.IgnoreCollision(playerCollider2D, c, false); } } // We clean the dictionary after set all floor colliders to false if (!isPlayerClimbing) { floorLaddersColliders.Clear(); resetCounter = 0; } // Set climping animation variables animator.SetBool("isClimbing", isPlayerClimbing); animator.SetFloat("climbSpeed", vertical); }
public static System.Func <RaycastHit2D, bool> IgnoreSelfCollisionPredicate(Collider2D collider) { if (collider == null) { return(hit => false); } else { return(hit => { var hitCollider = hit.collider; return hitCollider == collider || hitCollider.attachedRigidbody == collider.attachedRigidbody || Physics2D.GetIgnoreCollision(hitCollider, collider); }); } }
private void CheckLastPassedThrough() { if (m_LastPassThrough != null) { foreach (Collider2D myc2d in m_MyColliders) { foreach (Collider2D c2d in m_LastPassThrough) { if (Physics2D.GetIgnoreCollision(myc2d, c2d)) { Physics2D.IgnoreCollision(myc2d, c2d, false); } } } m_LastPassThrough = null; m_IsPassing = false; } }
// Update is called once per frame void Update() { OnGround = false; _groundColliders = Physics2D.OverlapCircleAll((Vector2)transform.position + bottomOffset, groundCheckRadius, groundLayer); foreach (Collider2D groundCollider in _groundColliders) { if (Physics2D.GetIgnoreCollision(bodyCollider, groundCollider)) { continue; } else { OnGround = true; } } _oneWayPlatform = Physics2D.OverlapCircle((Vector2)transform.position + bottomOffset, groundCheckRadius, oneWayPlatformLayer); }
public override void DoBeforeLeaving() { // ManagerPause.UnSubscribeOnPauseGame(OnPauseGame); //ManagerPause.UnSubscribeOnResumeGame(OnResumeGame); //Set ladder false _rigidbody2D.gravityScale = storeGravityScale; if (move.LadderTop != null) { if (Physics2D.GetIgnoreCollision(move.LadderTop.colliderOneTop, move.colliders[0])) { for (int i = 0; i < move.colliders.Length; ++i) { Physics2D.IgnoreCollision(move.LadderTop.colliderOneTop, move.colliders[i], false); } } } isForcing = false; anim.SetBool(AnimLadder, false); }
void SetCollideConnected() { if (!Application.isPlaying) { return; } for (int i = 0, l = m_OldCollisionStates.Count; i < l; ++i) { var pair = m_OldCollisionStates [i]; Physics2D.IgnoreCollision(pair.colliderA, pair.colliderB, pair.ignore); } m_OldCollisionStates.Clear(); var collidersA = ((Rigidbody2DExt)cachedRigidbody2D).GetColliders(); var collidersB = ((Rigidbody2DExt)connectedBody).GetColliders(); for (int i = 0, lI = collidersA.Count; i < lI; ++i) { var colliderA = collidersA [i] as Collider2D; for (int j = 0, lJ = collidersB.Count; j < lJ; ++j) { var colliderB = collidersB [j] as Collider2D; m_OldCollisionStates.Add(new Collider2DPair { colliderA = colliderA, colliderB = colliderB, ignore = Physics2D.GetIgnoreCollision(colliderA, colliderB) }); Physics2D.IgnoreCollision(colliderA, colliderB, !m_CollideConnected); } } m_CollideConnectedCached = m_CollideConnected; m_ConnectedBodyCached = connectedBody; }
void OnTriggerStay2D(Collider2D other) { if (other.CompareTag("Player")) { MoveState State = other.GetComponent <MoveState>(); bool isKlaus = other.name.CompareTo("Klaus") == 0; bool needDown; if (isKlaus) { needDown = OneWaySingleton.Instance.GetNeedDownKlaus(colliderOneWay); } else { needDown = OneWaySingleton.Instance.GetNeedDownK1(colliderOneWay); } if (EstoyArriba(State) && !needDown) { if (Physics2D.GetIgnoreCollision(colliderOneWay, State.colliders [0])) { if (State._rigidbody2D.velocity.y < 0) { for (int i = 0; i < State.colliders.Length; ++i) { Physics2D.IgnoreCollision(colliderOneWay, State.colliders [i], false); } if (other.name.CompareTo("Klaus") == 0) { OneWaySingleton.Instance.SetIsKlausOneWay(colliderOneWay, false); } else if (other.name.CompareTo("K1") == 0) { OneWaySingleton.Instance.SetIsK1OneWay(colliderOneWay, false); } } } } } }
// Update is called once per frame void Update() { affected.Clear(); hitColliders = Physics2D.OverlapCircleAll(transform.position, absorbRadius, layerMask); for (int i = 0; i < hitColliders.Length; i++) { if (hitColliders[i].tag == "Mana" && Physics2D.GetIgnoreCollision(collider, hitColliders[i])) { affected.Add(hitColliders[i].name); } else { Debug.Log("Eey, summat's wrong 'ere"); } } if (affected.Count != 0) { PullMana(transform.position, affected); } }
void OnCollisionEnter2D(Collision2D collision) { ship01Rigidbody.constraints = UnityEngine.RigidbodyConstraints2D.FreezeRotation; if (Physics2D.GetIgnoreCollision(ship01Collider, shadowCollider)) { Debug.Log("--- collision between shadow & boat is ignored \n"); } Collider2D collidee = collision.collider; if (collision.gameObject.tag == "Metaball_liquid") { //Debug.Log("contacting with water ---- \n"); //Physics2D.IgnoreCollision(ship01Collider, collidee, true); ship01Rigidbody.velocity = floatingSpeed * transform.up; //collision.enabled = false; //Vector3 impulse = collision.impulse; //ship01Rigidbody.AddForce(-impulse, ForceMode.Impulse);//refrain the boat from colliding impulses } // if(collision.gameObject.tag == "Player") // { // Debug.Log("ship01 colliding with player ---- \n"); // } }
public static void testForInfringement() { List <Collider2D> cols = new List <Collider2D>(); for (int i = 0; i < SceneManager.sceneCount; i++) { foreach (GameObject go in SceneManager.GetSceneAt(i).GetRootGameObjects()) { cols.AddRange(go.GetComponentsInChildren <Collider2D>(true)); } } Debug.Log(cols.Count); cols.TrimExcess(); ////Make sure we are not checking with the infringer //for (int i = 0; i < cols.Count; i ++) //{ // if (cols[i] == possibleInfringer) // cols.RemoveAt(i); //} //lets try to sketch out a custom collider. foreach (Collider2D col2d1 in cols) { foreach (Collider2D col2d2 in cols) { //if((col2d2.name == "ObjectColForOtherObjects" && col2d1.name.Contains("QuestionMarkBox"))) //{ // Debug.Log(col2d1); // //Debug.Log(col2d1.bounds.center); // //Debug.Log(col2d1.bounds); // Debug.Log(col2d2); // //Debug.Log(col2d2.bounds); // //Debug.Log(col2d2.bounds.center); // //Debug.Break(); //} if ( (col2d1.isActiveAndEnabled && !col2d1.isTrigger) && (col2d2.isActiveAndEnabled && !col2d2.isTrigger) && !Physics2D.GetIgnoreCollision(col2d1, col2d2) && !Physics2D.GetIgnoreLayerCollision(col2d1.gameObject.layer, col2d2.gameObject.layer) && col2d1 != col2d2 && (col2d1.GetType() != typeof(EdgeCollider2D) && col2d2.GetType() != typeof(EdgeCollider2D)) ) { Rect oneRect = new Rect(col2d1.bounds.min, new Vector2(col2d1.bounds.size.x, col2d1.bounds.size.y)); Rect twoRect = new Rect(col2d2.bounds.min, new Vector2(col2d2.bounds.size.x, col2d2.bounds.size.y)); if (col2d1.bounds.Intersects(col2d2.bounds) && (col2d2.GetComponent <Rigidbody2D>() != null || col2d2.gameObject.GetComponentInParent <Rigidbody2D>() != null)) { Debug.Log("Yeah"); Vector3 NormalizedDirection = (twoRect.position - oneRect.position).normalized; //Debug.Log(NormalizedDirection); int e = 0; foreach (Collider2D col2d3 in cols) { if (col2d3 != col2d1 && col2d3 != col2d2 && col2d3.enabled && !col2d3.isTrigger && !Physics2D.GetIgnoreLayerCollision(col2d2.gameObject.layer, col2d3.gameObject.layer) && col2d3.GetType() != typeof(EdgeCollider2D)) { while (col2d2.bounds.Intersects(col2d3.bounds)) { e++; Debug.Log(e); //KEEP MOVING. Were still in something. col2d2.GetComponentInParent <Rigidbody2D>().gameObject.transform.position += e * (NormalizedDirection + col2d2.bounds.extents); Debug.Log("noep"); } } } //LETS TRY USING RAYS. Ray testRay = new Ray(col2d1.bounds.center, NormalizedDirection); Debug.DrawRay(testRay.origin, testRay.direction, Color.blue, 1f); } //else //{ // if (col2d1.bounds.Intersects(col2d2.bounds) && col2d1.GetComponent<Rigidbody2D>() != null) // { // Vector3 NormalizedDirection = (oneRect.position - twoRect.center).normalized; // //Debug.Log(NormalizedDirection); // int e = 0; // foreach (Collider2D col2d3 in cols) // { // if (col2d3 != col2d1 && col2d3 != col2d2 && col2d3.enabled && !col2d3.isTrigger && !Physics2D.GetIgnoreLayerCollision(col2d1.gameObject.layer, col2d3.gameObject.layer) && col2d3.GetType() != typeof(EdgeCollider2D)) // { // if (col2d1.bounds.Intersects(col2d3.bounds)) // { // e++; // Debug.Log(e); // //KEEP MOVING. Were still in something. // col2d2.transform.position += e * (NormalizedDirection + col2d2.bounds.extents); // Debug.Log("noep"); // } // } // } // } //} } } } }
void FixedUpdate() { DrawDebug(); float frameTime = Time.deltaTime; if (frameTime <= 0) { return; } m_position = transform.position; Vector2 collisionPos = m_position + m_offset; Vector2 localVelocity; m_onGround = false; if (m_gravityScale > 0) { m_velocity.y -= s_gravity * m_gravityMultiplier * m_gravityScale * frameTime; localVelocity = new Vector2(0, m_velocity.y * frameTime); // Trace floor if (localVelocity.y < 0) { RaycastHit2D hit2D = Physics2D.BoxCast(collisionPos, m_size, 0, localVelocity, -localVelocity.y); if (hit2D) { m_position += localVelocity * hit2D.fraction + (hit2D.normal * 0.01f); m_velocity.y = 0; m_onGround = true; collisionPos.y = m_position.y + m_offset.y; if (hit2D.transform.GetComponent <MovingPlatform>() != null) { transform.SetParent(hit2D.transform); } else { transform.SetParent(null); } } } if (!m_onGround) { transform.SetParent(null); } } // Trace walking m_hitWall = false; m_hitCeiling = false; localVelocity = m_velocity * frameTime; for (uint resolveCount = 0; resolveCount < 3; resolveCount++) { float magnitude = localVelocity.magnitude; if (magnitude > 0.0f) { RaycastHit2D hit2D = Physics2D.BoxCast(collisionPos, m_size, 0, localVelocity, magnitude); bool collide = false; if (hit2D) { CollisionCreator collision = hit2D.transform.GetComponent <CollisionCreator>(); if (collision && collision.isOneway) { collide = false; } else { collide = !Physics2D.GetIgnoreCollision(hit2D.collider, m_collider); } } if (collide) { if (Mathf.Abs(hit2D.normal.x) > m_WallNormal) { m_hitWall = true; } else { // Debug.Log (hit2D.transform.name + ":" + hit2D.transform.position); m_hitCeiling = true; } m_wallDirection = Mathf.Sign(hit2D.normal.x); /* * if(m_hitWall) { * localVelocity.x = 0; * } * m_position += (localVelocity * hit2D.fraction);// + (hit2D.normal * 0.01f); * * collisionPos = m_position + m_offset; * localVelocity = -(1.0f * Vector2.Dot(hit2D.normal, localVelocity) * hit2D.normal) + localVelocity; * // localVelocity *= 1.0f - hit2D.fraction; */ collisionPos = m_position + (localVelocity * hit2D.fraction); // Hack - would be nice to remove this if (m_hitWall) { m_position.x += (localVelocity.x * hit2D.fraction) + (hit2D.normal.x * 0.01f); collisionPos.y = m_position.y; } else { collisionPos.x = m_position.x; } collisionPos += m_offset; localVelocity = -(1.0f * Vector2.Dot(hit2D.normal, localVelocity) * hit2D.normal) + localVelocity; } else { m_position += localVelocity; break; } } } m_velocity = localVelocity / frameTime; // Change this to distance travelled then we can modify the velocity internally transform.position = m_position; if (m_showDebug) { Debug.Log(Time.frameCount + " :" + transform.name + " :" + " OnGround:" + m_onGround + " HitWall:" + m_hitWall + " Ground=" + ((transform.parent == null) ? "null" : transform.parent.name)); } }
//Collision void OnTriggerEnter2D(Collider2D other) { switch (other.gameObject.tag) { case "GenericBullet": { if (other.gameObject.GetComponent <BulletObject>().CanHitPlayer) { Destroy(other.gameObject); if (characterState == CHARACTER_STATE.CHARACTERSTATE_NORMAL) { DecreaseCharacterHealth(other.gameObject.GetComponent <BulletObject>().BulletDamage *BerserkDamageModifier); if (characterHealth <= 0) { SceneManager.LoadScene("GameOver"); } } } goto default; } case "Ground": { if (Physics2D.GetIgnoreCollision(gameObject.GetComponent <Collider2D>(), other.gameObject.GetComponent <Collider2D>())) { Physics2D.IgnoreCollision(gameObject.GetComponent <Collider2D>(), other.gameObject.GetComponent <Collider2D>(), false); } goto default; } case "InvincibilityPowerup": { if (characterState == CHARACTER_STATE.CHARACTERSTATE_INVINCIBLE) { //If player already invincible, reset the timer InvincibilityTimer = InvincibilityTimeLimit; return; } characterState = CHARACTER_STATE.CHARACTERSTATE_INVINCIBLE; Destroy(other.gameObject); //Create a shield around player GameObject shield = Instantiate(Resources.Load("shield") as GameObject, gameObject.transform.position, gameObject.transform.rotation, gameObject.transform); Image shieldImage = shield.GetComponent <Image>(); var tempcolour = shieldImage.color; tempcolour.a = 0.5f; shieldImage.color = tempcolour; goto default; } case "HealthPowerup": { if (characterHealth >= characterHealthLimit) { return; } IncreaseCharacterHealth(20); if (characterHealth > characterHealthLimit) { characterHealth = characterHealthLimit; } Destroy(other.gameObject); goto default; } case "BerserkPowerup": { if (isBerserk) { return; } isBerserk = true; spriteRenderer.color = BerserkColour; Destroy(other.gameObject); //Modifiers BerserkDamageModifier = 0.75f; BerserkMovementModifer = 1.25f; BerserkShootSpeedModifier = 1.25f; goto default; } case "fall": { SceneManager.LoadScene("GameOver"); break; } case "Weapon": { Destroy(other.gameObject); //Check if player already has the weapon foreach (WeaponBase Weapon in WeaponsEquipped) { if (Weapon.WeaponName == other.name) { return; } } if (other.name == "LMG") { WeaponsEquipped.Add(new LMG()); } else if (other.name == "Minigun") { WeaponsEquipped.Add(new Minigun()); } else if (other.name == "Pistol") { WeaponsEquipped.Add(new Pistol()); } else if (other.name == "Revolver") { WeaponsEquipped.Add(new Revolver()); } else if (other.name == "Rifle") { WeaponsEquipped.Add(new Rifle()); } else if (other.name == "AK47") { WeaponsEquipped.Add(new AK47()); } else if (other.name == "Carbine") { WeaponsEquipped.Add(new Carbine()); } else if (other.name == "RPG") { WeaponsEquipped.Add(new RPG()); } //Equip the newly picked up weapon CurrentWeapon = WeaponsEquipped.Count - 1; break; } case "LevelEnd": { SceneTransition sceneTransition = new SceneTransition(); sceneTransition.Tolevelend(); break; } default: break; } if (other.gameObject.name == "IgnoreCollisionTrigger") { if (!Physics2D.GetIgnoreCollision(gameObject.GetComponent <Collider2D>(), other.gameObject.transform.parent.GetComponent <Collider2D>())) { Physics2D.IgnoreCollision(gameObject.GetComponent <Collider2D>(), other.gameObject.transform.parent.GetComponent <Collider2D>()); } } if (other.gameObject.tag == "Checkpoint") { respawnpoint = other.transform.position; Destroy(other.gameObject); lol++; PlayerPrefs.SetFloat("savecheckpoint", lol); PlayerPrefs.SetFloat("respawnhere", respawnpoint.x); PlayerPrefs.SetFloat("respawnhere1", respawnpoint.y); } }
public MoveResult Move(PlayerController.Direction D, bool ApplyPhysicsBetweenPlayers = true, bool RecordEvent = true, FixedTickValue MoveValue = null) { if (Freeze) { return(MoveResult.CannotMove); } //if (!CanMove()) return MoveResult.IsAnimating; MoveResult NeedToBeMoved = MoveResult.CannotMove; if (D != PlayerController.Direction.NONE) { var Direction = PlayerController.Directionf[(int)D]; Vector3 Dir3 = new Vector3(Direction.x, Direction.y, 0); // WALL HITS RaycastHit2D[] hits = Physics2D.RaycastAll(transform.position + (0.6f * Dir3), Dir3, 0.5f, wallmask); if (hits.Length != 0) { UpdatePositionBump(Direction); return(MoveResult.CannotMove); } // MOVABLE HITS RaycastHit2D[] hitsm = Physics2D.RaycastAll(transform.position + (0.6f * Dir3), Dir3, 0.5f, movablemask); hitsm = hitsm.Where(val => (val.collider.gameObject != this.gameObject)).ToArray(); // filter our own gameobject if (!ApplyPhysicsBetweenPlayers) { hitsm = hitsm.Where(val => (val.collider.gameObject.GetComponent <PlayerController>() == null)).ToArray(); // filter our own gameobject } if (hitsm.Length == 0) { NeedToBeMoved = MoveResult.CanMove; } else { foreach (RaycastHit2D hit in hitsm) { if (hit.collider.gameObject != this.gameObject) // not necessary should already be filtered { if (hit.collider != null) { // Detect if we are colliding with a player // If the player asked for the same direction than us last event // We dont execute the move and simply move this object because physic // is executed in a certain order var PC = hit.collider.GetComponent <PlayerController>(); var Mov = hit.collider.GetComponent <Movable>(); var mePC = GetComponent <PlayerController>(); if (Mov) { if (PC && mePC) { if (Physics2D.GetIgnoreCollision(mePC.GetComponent <BoxCollider2D>(), PC.GetComponent <BoxCollider2D>())) { NeedToBeMoved = MoveResult.CanMove; } else { NeedToBeMoved = Mov.Move(D, true, true, MoveValue); } } } } } } } if (NeedToBeMoved == MoveResult.CanMove) { UpdatePosition(Direction); if (RecordEvent && MoveValue != null) { MoveValue.AddObserver(new MoveValue(this, D)); } } if (D != PlayerController.Direction.NONE && NeedToBeMoved == MoveResult.CannotMove) { // Do a bump into wall animation UpdatePositionBump(Direction); } } return(NeedToBeMoved); }
protected override void FixedUpdateChild() { if (!ManagerPause.Pause) { if (!isForcing) { if (move.LadderTop != null) { if (!Physics2D.GetIgnoreCollision(move.LadderTop.colliderOneTop, move.colliders[0])) { for (int i = 0; i < move.colliders.Length; ++i) { Physics2D.IgnoreCollision(move.LadderTop.colliderOneTop, move.colliders[i], true); } } } #region Check ground isGround = Physics2D.OverlapCircleNonAlloc(groundCheck.position, groundRadiusTotal, result, whatIsGround) > 0; //Fix Loco for (int i = 0; i < result.Length; ++i) { if (result[i] != null) { if (result[i] == move.LadderTop) { isGround = false; break; } } } // anim.SetBool("isGround", isGround); #endregion float speedX = 0; float speedY = buttonMapAxis[VerticalAxis] * SpeedY; if (move.getOnPlatformLadder() != null) { if ((move.getOnPlatformLadder().velocity.y > 0 && speedY > 0) || (move.getOnPlatformLadder().velocity.y < 0 && speedY < 0)) { speedY = speedY * move.percentPlatformMoveSameDir + move.getOnPlatformLadder().velocity.y; } else if ((move.getOnPlatformLadder().velocity.y > 0 && speedY < 0) || (move.getOnPlatformLadder().velocity.y < 0 && speedY > 0)) { speedY = speedY * move.percentPlatformMoveOposDir + move.getOnPlatformLadder().velocity.y; } else { speedY = speedY + move.getOnPlatformLadder().velocity.y; } speedX = move.getOnPlatformLadder().velocity.x; } _rigidbody2D.velocity = new Vector2(speedX, speedY); anim.SetFloat(AnimLadderSpeed, Mathf.Abs(buttonMapAxis[VerticalAxis])); } else { if (move.getOnPlatformLadder() != null) { _rigidbody2D.velocity = move.getOnPlatformLadder().velocity; } } } }