Hey folks!
So I’m doing an infinitely scrolling background using 4 copies of the same sprite scrolling to the left, teleporting a distance to the right off-screen if the sprite passes a specific distance to the left and then scrolling to the left again.
Unfortunately, after a few circulations of the background(s), the sprites start to separate from each other, or, alternately, overlap; their movement and reset fall out of sync. This is not good, I do not like this, can anybody divine a means by which I can enforce perfect sync on my background?
The functionality is handled in two scripts, reproduced below…
THE MOVER!
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
// This component is used to move scenary and obstacles from the right of the screen to the left.
public class Mover : MonoBehaviour {
// statePlay: so this is a bit of a mess. Ideally we'd drive an OnUpdate function from the
// statePlay OnUpdate, but there are so many Movers switching from active to inactive and
// back that it seemed to make more sense to just get a bool in statePlay.
// On mature reflection, should have driven from statePlay to the object pool to the
// active movers. Ah well.
private StatePlay statePlay;
public enum MoverType
{ // Related switch gets appropriate speed from GC.
dummy,
background,
midground,
obstacleAir,
obstacleGnd,
airHeli,
airCloud,
airBalloons,
airHotBall,
custom,
}
public MoverType moveType;
[Header("Custom Speed only used")]
[Header("with Custom Move Type.")] // Wish there was a way to auto-wrap this stuff. Custom inspector?
public float customSpeed = 6.0f;
private Rigidbody2D RB2D;
public Vector2 moveMeDirection = new Vector2(-1, 0);
public bool goAlongSineWave = false;
public float sineFrequency = 20.0f; // Speed of sine movement
public float sineMagnitude = 0.5f; // Size of sine movement
// private Vector3 axis = Vector3.up;
// private Vector3 pos;
private void Awake()
{
RB2D = GetComponent<Rigidbody2D>();
}
// Use this for initialization
void Start () {
statePlay = GameObject.Find("TextScorePlay").GetComponent<StatePlay>();
}
// Update is called once per frame
void Update () {
float currentSpeedMultiplier = 1.0f;
switch (moveType)
{ // Probably should have done this in START - when no longer tweaking speeds, move it back there!
case MoverType.dummy:
Debug.LogWarning("Move Type set to Dummy! Switching to Background...");
moveType = MoverType.background;
break;
case MoverType.background:
currentSpeedMultiplier = GC.Inst.moveSpd.backgrnd;
break;
case MoverType.midground:
currentSpeedMultiplier = GC.Inst.moveSpd.midgnd;
break;
case MoverType.obstacleAir:
currentSpeedMultiplier = GC.Inst.moveSpd.airDefault;
break;
case MoverType.obstacleGnd:
currentSpeedMultiplier = GC.Inst.moveSpd.groundDefault;
break;
case MoverType.airHeli:
currentSpeedMultiplier = GC.Inst.moveSpd.airHeli;
break;
case MoverType.airCloud:
currentSpeedMultiplier = GC.Inst.moveSpd.airCloud;
break;
case MoverType.airBalloons:
currentSpeedMultiplier = GC.Inst.moveSpd.airBalloons;
break;
case MoverType.airHotBall:
currentSpeedMultiplier = GC.Inst.moveSpd.airHotBall;
break;
case MoverType.custom:
currentSpeedMultiplier = customSpeed;
break;
default:
break;
}
if (statePlay.amActive)
{
Vector2 moveOffset = moveMeDirection.normalized * GC.Inst.DTime() * currentSpeedMultiplier;
if (goAlongSineWave)
{
Vector2 sineOffset = new Vector3(0.0f, Mathf.Sin(Time.time * sineFrequency) * sineMagnitude);
RB2D.MovePosition(RB2D.position + sineOffset + moveOffset);
}
else
{
RB2D.MovePosition(RB2D.position + moveOffset);
}
}
}
}
THE RESETTER!
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ResetMovement : MonoBehaviour {
private Collider2D col;
private Transform tf;
public float groundHorizontalLength;
private Vector2 startPos;
private void Awake()
{
tf = GetComponent<Transform>();
startPos = tf.position;
col = GetComponent<Collider2D>();
groundHorizontalLength = col.bounds.size.x * 2;
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
if(tf.position.x < -groundHorizontalLength)
{
RepositionBackground();
}
}
public void RepositionBackground ()
{
// tf.position = new Vector2(groundHorizontalLength, tf.position.y);
Vector2 groundOffset = new Vector2(groundHorizontalLength * 2, 0);
tf.position = (Vector2) tf.position + groundOffset;
}
public void StartingPositions ()
{
tf.position = startPos;
}
}
Much appreciated for taking a look at this, and thank you in advance for any help you can give me.
–Rev
PS: I realise I could do a UV scroll as an alternative solution, but I’d like to find a specific answer to this issue if possible! Thank you!