Question How do I disable wallSlide if the player was touching the ground and wall when they jumped?

How do I disable wallSlide if the player was touching the ground and wall when they jumped? I don't like how the character grabs onto the wall if you're standing right next to it when they jump. I use another script not posted here that detects Collison on the left, right, and underneath the character for ground and wall checks. but I don't think the script was necessary to post, but i will upload if you need it.

Code (CSharp):

1. using System;
2. using System.Collections;
3. using System.Collections.Generic;
4. using UnityEngine;
5. using DG.Tweening;
6.  
7. public class Movement : MonoBehaviour
8. {
9.     private Collision coll;
10.     [HideInInspector]
11.     public Rigidbody2D rb;
12.     private AnimationScript anim;
13.  
14.     [Space]
15.     [Header("Stats")]
16.     public float speed = 10;
17.     public float jumpForce = 50;
18.     public float slideSpeed = 5;
19.     public float wallJumpLerp = 10;
20.     public float dashSpeed = 20;
21.  
22.     [Space]
23.     [Header("Booleans")]
24.     public bool canMove;
25.     public bool wallGrab;
26.     public bool wallJumped;
27.     public bool wallSlide;
28.     public bool isDashing;
29.  
30.     [Space]
31.  
32.     private bool groundTouch;
33.     private bool hasDashed;
34.  
35.     public int side = 1;
36.  
37.     [Space]
38.     [Header("Polish")]
39.     public ParticleSystem dashParticle;
40.     public ParticleSystem jumpParticle;
41.     public ParticleSystem wallJumpParticle;
42.     public ParticleSystem slideParticle;
43.  
44.     // Start is called before the first frame update
45.     void Start()
46.     {
47.         coll = GetComponent<Collision>();
48.         rb = GetComponent<Rigidbody2D>();
49.         anim = GetComponentInChildren<AnimationScript>();
50.     }
51.  
52.     // Update is called once per frame
53.     void Update()
54.     {
55.         float x = Input.GetAxis("Horizontal");
56.         float y = Input.GetAxis("Vertical");
57.         float xRaw = Input.GetAxisRaw("Horizontal");
58.         float yRaw = Input.GetAxisRaw("Vertical");
59.         Vector2 dir = new Vector2(x, y);
60.        
61.         Walk(dir);
62.         anim.SetHorizontalMovement(x, y, rb.velocity.y);
63.  
64.         if (coll.onWall && Input.GetButton("Fire3") && canMove)
65.         {
66.             if(side != coll.wallSide)
67.                 anim.Flip(side*-1);
68.             wallGrab = true;
69.             wallSlide = false;
70.         }
71.  
72.         if (Input.GetButtonUp("Fire3") || !coll.onWall || !canMove)
73.         {
74.             wallGrab = false;
75.             wallSlide = false;
76.         }
77.  
78.         if (coll.onGround && !isDashing)
79.         {
80.             wallJumped = false;
81.             GetComponent<BetterJumping>().enabled = true;
82.         }
83.        
84.         if (wallGrab && !isDashing)
85.         {
86.             rb.gravityScale = 0;
87.             if(x > .2f || x < -.2f)
88.             rb.velocity = new Vector2(rb.velocity.x, 0);
89.  
90.             float speedModifier = y > 0 ? .5f : 1;
91.  
92.             rb.velocity = new Vector2(rb.velocity.x, y * (speed * speedModifier));
93.         }
94.         else
95.         {
96.             rb.gravityScale = 3;
97.         }
98.  
99.         if(coll.onWall && !coll.onGround)
100.         {
101.             if (x != 0 && !wallGrab)
102.             {
103.                 wallSlide = true;
104.                 WallSlide();
105.             }
106.         }
107.  
108.         if (!coll.onWall || coll.onGround)
109.             wallSlide = false;
110.  
111.         if (Input.GetButtonDown("Jump"))
112.         {
113.             anim.SetTrigger("jump");
114.  
115.             if (coll.onGround)
116.                 Jump(Vector2.up, false);
117.             if (coll.onWall && !coll.onGround)
118.                 WallJump();
119.         }
120.  
121.         if (Input.GetButtonDown("Fire1") && !hasDashed)
122.         {
123.             if(xRaw != 0 || yRaw != 0)
124.                 Dash(xRaw, yRaw);
125.         }
126.  
127.         if (coll.onGround && !groundTouch)
128.         {
129.             GroundTouch();
130.             groundTouch = true;
131.         }
132.  
133.         if(!coll.onGround && groundTouch)
134.         {
135.             groundTouch = false;
136.         }
137.  
138.         WallParticle(y);
139.  
140.         if (wallGrab || wallSlide || !canMove)
141.             return;
142.  
143.         if(x > 0)
144.         {
145.             side = 1;
146.             anim.Flip(side);
147.         }
148.         if (x < 0)
149.         {
150.             side = -1;
151.             anim.Flip(side);
152.         }
153.  
154.  
155.     }
156.  
157.     void GroundTouch()
158.     {
159.         hasDashed = false;
160.         isDashing = false;
161.  
162.         side = anim.sr.flipX ? -1 : 1;
163.  
164.         jumpParticle.Play();
165.     }
166.  
167.     private void Dash(float x, float y)
168.     {
169.         Camera.main.transform.DOComplete();
170.         Camera.main.transform.DOShakePosition(.2f, .5f, 14, 90, false, true);
171.         FindObjectOfType<RippleEffect>().Emit(Camera.main.WorldToViewportPoint(transform.position));
172.  
173.         hasDashed = true;
174.  
175.         anim.SetTrigger("dash");
176.  
177.         rb.velocity = Vector2.zero;
178.         Vector2 dir = new Vector2(x, y);
179.  
180.         rb.velocity += dir.normalized * dashSpeed;
181.         StartCoroutine(DashWait());
182.     }
183.  
184.     IEnumerator DashWait()
185.     {
186.         FindObjectOfType<GhostTrail>().ShowGhost();
187.         StartCoroutine(GroundDash());
188.         DOVirtual.Float(14, 0, .8f, RigidbodyDrag);
189.  
190.         dashParticle.Play();
191.         rb.gravityScale = 0;
192.         GetComponent<BetterJumping>().enabled = false;
193.         wallJumped = true;
194.         isDashing = true;
195.  
196.         yield return new WaitForSeconds(.3f);
197.  
198.         dashParticle.Stop();
199.         rb.gravityScale = 3;
200.         GetComponent<BetterJumping>().enabled = true;
201.         wallJumped = false;
202.         isDashing = false;
203.     }
204.  
205.     IEnumerator GroundDash()
206.     {
207.         yield return new WaitForSeconds(.15f);
208.         if (coll.onGround)
209.             hasDashed = false;
210.     }
211.  
212.     private void WallJump()
213.     {
214.         if ((side == 1 && coll.onRightWall) || side == -1 && !coll.onRightWall)
215.         {
216.             side *= -1;
217.             anim.Flip(side);
218.         }
219.  
220.         StopCoroutine(DisableMovement(0));
221.         StartCoroutine(DisableMovement(.1f));
222.  
223.         Vector2 wallDir = coll.onRightWall ? Vector2.left : Vector2.right;
224.  
225.         Jump((Vector2.up / 1.5f + wallDir / 1.5f), true);
226.  
227.         wallJumped = true;
228.     }
229.  
230.     private void WallSlide()
231.     {
232.         if(coll.wallSide != side)
233.          anim.Flip(side * -1);
234.  
235.         if (!canMove)
236.             return;
237.  
238.         bool pushingWall = false;
239.         if((rb.velocity.x > 0 && coll.onRightWall) || (rb.velocity.x < 0 && coll.onLeftWall))
240.         {
241.             pushingWall = true;
242.         }
243.         float push = pushingWall ? 0 : rb.velocity.x;
244.  
245.         rb.velocity = new Vector2(push, -slideSpeed);
246.        
247.     }
248.  
249.     private void Walk(Vector2 dir)
250.     {
251.         if (!canMove)
252.             return;
253.  
254.         if (wallGrab)
255.             return;
256.  
257.         if (!wallJumped)
258.         {
259.             rb.velocity = new Vector2(dir.x * speed, rb.velocity.y);
260.         }
261.         else
262.         {
263.             rb.velocity = Vector2.Lerp(rb.velocity, (new Vector2(dir.x * speed, rb.velocity.y)), wallJumpLerp * Time.deltaTime);
264.         }
265.     }
266.  
267.     private void Jump(Vector2 dir, bool wall)
268.     {
269.         slideParticle.transform.parent.localScale = new Vector3(ParticleSide(), 1, 1);
270.         ParticleSystem particle = wall ? wallJumpParticle : jumpParticle;
271.  
272.         rb.velocity = new Vector2(rb.velocity.x, 0);
273.         rb.velocity += dir * jumpForce;
274.  
275.         particle.Play();
276.     }
277.  
278.     IEnumerator DisableMovement(float time)
279.     {
280.         canMove = false;
281.         yield return new WaitForSeconds(time);
282.         canMove = true;
283.     }
284.  
285.     void RigidbodyDrag(float x)
286.     {
287.         rb.drag = x;
288.     }
289.  
290.     void WallParticle(float vertical)
291.     {
292.         var main = slideParticle.main;
293.  
294.         if (wallSlide || (wallGrab && vertical < 0))
295.         {
296.             slideParticle.transform.parent.localScale = new Vector3(ParticleSide(), 1, 1);
297.             main.startColor = Color.white;
298.         }
299.         else
300.         {
301.             main.startColor = Color.clear;
302.         }
303.     }
304.  
305.     int ParticleSide()
306.     {
307.         int particleSide = coll.onRightWall ? 1 : -1;
308.         return particleSide;
309.     }
310. }

 

Time to start debugging! Here is how you can begin your exciting new debugging adventures:

It may be helpful to you to diagram the various states of your controller above to further reason about the problem.

At a minimum you may wish to isolate a subset of the states you are struggling with in order to clarify the problem while you debug it and get it working.

You must find a way to get the information you need in order to reason about what the problem is.

Once you understand what the problem is, you may begin to reason about a solution to the problem.

What is often happening in these cases is one of the following:

- the code you think is executing is not actually executing at all
- the code is executing far EARLIER or LATER than you think
- the code is executing far LESS OFTEN than you think
- the code is executing far MORE OFTEN than you think
- the code is executing on another GameObject than you think it is
- you're getting an error or warning and you haven't noticed it in the console window

To help gain more insight into your problem, I recommend liberally sprinkling

Debug.Log()

statements through your code to display information in realtime.

Doing this should help you answer these types of questions:

- is this code even running? which parts are running? how often does it run? what order does it run in?
- what are the values of the variables involved? Are they initialized? Are the values reasonable?
- are you meeting ALL the requirements to receive callbacks such as triggers / colliders (review the documentation)

Knowing this information will help you reason about the behavior you are seeing.

You can also supply a second argument to Debug.Log() and when you click the message, it will highlight the object in scene, such as

Debug.Log("Problem!",this);

If your problem would benefit from in-scene or in-game visualization, Debug.DrawRay() or Debug.DrawLine() can help you visualize things like rays (used in raycasting) or distances.

You can also call Debug.Break() to pause the Editor when certain interesting pieces of code run, and then study the scene manually, looking for all the parts, where they are, what scripts are on them, etc.

You can also call GameObject.CreatePrimitive() to emplace debug-marker-ish objects in the scene at runtime.

You could also just display various important quantities in UI Text elements to watch them change as you play the game.

If you are running a mobile device you can also view the console output. Google for how on your particular mobile target, such as this answer or iOS: https://forum.unity.com/threads/how-to-capturing-device-logs-on-ios.529920/ or this answer for Android: https://forum.unity.com/threads/how-to-capturing-device-logs-on-android.528680/

If you are working in VR, it might be useful to make your on onscreen log output, or integrate one from the asset store, so you can see what is happening as you operate your software.

Another useful approach is to temporarily strip out everything besides what is necessary to prove your issue. This can simplify and isolate compounding effects of other items in your scene or prefab.

Here's an example of putting in a laser-focused Debug.Log() and how that can save you a TON of time wallowing around speculating what might be going wrong:

https://forum.unity.com/threads/coroutine-missing-hint-and-error.1103197/#post-7100494

When in doubt, print it out!(tm)

Note: the

print()

function is an alias for Debug.Log() provided by the MonoBehaviour class.

 

Sometimes i think the auto paste just doesnt quite cut it... its almost like its not really related at all to what the poster asked... I didnt even see a mention of an issue, or error (bug), more so an inquiry... O,o

 

Are you asking for an idea? or the actual code to use?

If you just want an idea, the best thing to do in my opinion would be to disable wall slide when the player's Rigidbody2D has a positive Y velocity. I doubt you want to start clinging to the wall at any point during the upwards arch of a jump.

 

I dunno Homicide... when I see this wall of state:



and I read the user complaining about a state transition that leaves his player wall walking when he doesn't expect it...

That to me sounds like someone needs to do some state table debugging.

EDIT: And you DO notice that paras 2 and 3 are custom written to draw attention to this, right?

EDIT 2: I hope these are only made public for debugging purposes otherwise the Unity serialization is yet another potential area of bugs and confusion.

 

Thank you for the help! I will attempt everything you listed here. Thanks!