Jump to content
Unity Insider Forum

Wie mache ich eine 2D-Plattformer Umgebung wiederholbar an den Rändern?


wARmAcH1n3
 Share

Recommended Posts

Ich möchte, dass eine 2D-Plattformer Map sich wiederholt. Damit meine ich, dass wenn ich am rechten Rand vorbei gehe, dass ich auf dem linken Rand wieder rauskomme. Genauso wie mit oben und unteren Rändern.

 

Ich habe mir überlegt, die gesamte Map, an die Ränder zu kopieren, so dass die Map immer durch die Kopien am den Rändern umschlossen ist. Und dann irgendwie durch die Gameobjekt.transform.position im Script den Spieler und die Feinde immer bei der Grenzüberschreitung wieder in die Mitte zu versetzen.

 

Gibt es da vielleicht einen einfacheren Weg? Dass die Map dann insgesamt dann 9 mal vorkommt in der Scene ist doch etwas unpraktisch.

Link to comment
Share on other sites

vor 5 Minuten schrieb Peanut:

Kommt drauf an wie groß die Map sein soll. Geht sie über einen zeigbaren Bildschirm ?

Was meinst du damit deinen Spieler und deine Feinde in die Mitt zu setzten? Sollen die nicht an den Rand?

Die Map ist größer als der Bildschirm, so ungefähr 2-4 mal die Bildschirmgröße. Die Gegner und der Player sollen sich frei bewegen innerhalb des Levels ohne Levelränder.

Das Problem ist wenn der Spieler zum Beispiel links vom rechten Rand ist und der Gegner rechts vom rechten Rand, dass der Gegner nicht in die Mitte versetzt wird, sondern erst wenn der Spieler über den rechten Rand geht, dann soll der Spieler und der Gegner in den mittleren Bereich unbemerkt versetzt werden (und am linken Rand rauskommen), um so das Gefühl zu erzeugen, dass die Map sich unendlich wiederholen kann, wenn man immer in eine Richtung geht.

So wie in diesen Spiel (mein Vorbild):

Teddy Boy

Link to comment
Share on other sites

  • 2 weeks later...

Ich habe es hingekriegt, ein Skript, das die Map kopiert und an die Tilemap angehängt ist. Die Position und die Ränder der Map stelle ich manuell ein.

            using UnityEngine;
            using UnityEngine.Tilemaps;
             
            public class GroundTilemapScript : MonoBehaviour
            {
                public GameObject tileMapPreflab;
                protected Tilemap tileMapComponent;
                protected Tilemap[] tileMapClone = new Tilemap[8];
                public Vector2Int tileMapPosition;
                public Vector2Int tileMapSize;
                protected static bool hasDone = false;
                public Grid grid;
                public float tileMapBorderLeftPosition;
                public float tileMapBorderRightPosition;
                public float tileMapBorderTopPosition;
                public float tileMapBorderBottomPosition;
             
                // Start is called before the first frame update
             
                void Awake()
                {
                    tileMapBorderLeftPosition = (float)tileMapPosition.x - (((float)tileMapSize.x) / 2f);
                    tileMapBorderRightPosition = (float)tileMapPosition.x + (((float)tileMapSize.x) / 2f);
                    tileMapBorderTopPosition = (float)tileMapPosition.y + (((float)tileMapSize.y) / 2f); ;
                    tileMapBorderBottomPosition = (float)tileMapPosition.y - (((float)tileMapSize.y) / 2f); ;
                }
             
                void Start()
                {
                    if(!hasDone)
                    {
                        tileMapComponent = tileMapPreflab.GetComponent<Tilemap>();
             
                        tileMapClone[0] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[0].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[0].transform.position = Vector2.left * tileMapSize.x + Vector2.up * tileMapSize.y;
                        tileMapClone[0].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[1] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[1].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[1].transform.position = Vector2.left * tileMapSize.x;
                        tileMapClone[1].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[2] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[2].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[2].transform.position = Vector2.left * tileMapSize.x + Vector2.down * tileMapSize.y;
                        tileMapClone[2].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[3] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[3].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[3].transform.position = Vector2.up * tileMapSize.y;
                        tileMapClone[3].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[4] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[4].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[4].transform.position = Vector2.down * tileMapSize.y;
                        tileMapClone[4].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[5] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[5].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[5].transform.position = Vector2.right * tileMapSize.x + Vector2.up * tileMapSize.y;
                        tileMapClone[5].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[6] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[6].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[6].transform.position = Vector2.right * tileMapSize.x;
                        tileMapClone[6].transform.position += tileMapComponent.transform.position;
             
                        tileMapClone[7] = Tilemap.Instantiate(tileMapComponent);
                        tileMapClone[7].transform.SetParent(grid.gameObject.transform);
                        tileMapClone[7].transform.position = Vector2.right * tileMapSize.x + Vector2.down * tileMapSize.y;
                        tileMapClone[7].transform.position += tileMapComponent.transform.position;
             
                        hasDone = true;
                    }
                }
             
                private void OnDrawGizmosSelected()
                {
                    Gizmos.color = Color.blue;
                    Gizmos.DrawWireCube((Vector2)tileMapPosition, (Vector2)tileMapSize);
                    Gizmos.DrawWireSphere((Vector2)tileMapPosition, 10f);
                }
             
            }

Das an die GameObjects (Feinde, Kugeln und andere) angehängte Skript. Es berechnet die kürzeste Entfernung zum Spieler aus den möglichen Transportpositionen und nutzt diese Position für den Transport:

            using UnityEngine;
             
            public class CheckObjectPositionScript : MonoBehaviour
            {
                protected GameObject player;
                protected SupanthaPaul.PlayerController playerCheck;
                private Vector3 objectPosition;
                private Vector3 playerPosition;
             
                // Start is called before the first frame update
                protected virtual void Start()
                {
                    player = FindAnyObjectByType<SupanthaPaul.PlayerController>().gameObject;
                    playerCheck = player.GetComponent<SupanthaPaul.PlayerController>();
                }
             
                // Update is called once per frame
                protected virtual void FixedUpdate()
                {
                    bool change = false;
                    objectPosition = transform.position;
                    playerPosition = player.transform.position;
             
                    float distanceObjectX = Mathf.Abs(objectPosition.x - playerPosition.x);
                    float distanceObjectXRight = Mathf.Abs((objectPosition.x + playerCheck.tileMapSize.x) - playerPosition.x);
                    float distanceObjectXLeft = Mathf.Abs((objectPosition.x - playerCheck.tileMapSize.x) - playerPosition.x);
                    float distanceObjectY = Mathf.Abs(objectPosition.y - playerPosition.y);
                    float distanceObjectYTop = Mathf.Abs((objectPosition.y + playerCheck.tileMapSize.y) - playerPosition.y);
                    float distanceObjectYBottom = Mathf.Abs((objectPosition.y - playerCheck.tileMapSize.y) - playerPosition.y);
             
                    if (distanceObjectX < distanceObjectXRight && distanceObjectX < distanceObjectXLeft)
                    {
                    }
                    else if (distanceObjectXRight < distanceObjectXLeft)
                    {
                        change = true;
                        objectPosition.x += (float)playerCheck.tileMapSize.x;
                    }
                    else
                    {
                        change = true;
                        objectPosition.x -= (float)playerCheck.tileMapSize.x;
                    }
             
                    if (distanceObjectY < distanceObjectYTop && distanceObjectY < distanceObjectYBottom)
                    {
                    }
                    else if (distanceObjectYTop < distanceObjectYBottom)
                    {
                        change = true;
                        objectPosition.y += (float)playerCheck.tileMapSize.y;
                    }
                    else
                    {
                        change = true;
                        objectPosition.y -= (float)playerCheck.tileMapSize.y;
                    }
                    transform.position = objectPosition;
             
                    if (change)
                        Debug.Log(gameObject.name +"    ");
             
             
                }
            }

Das dem Player beigefügte Skript:

                        playerPosition = transform.position;
                        if (playerPosition.x > tileMapBorderRightPosition)
                        {
                            playerPosition.x -= (float)tileMapSize.x;
                        }
                        else if (playerPosition.x < tileMapBorderLeftPosition)
                        {
                            playerPosition.x += (float)tileMapSize.x;
                        }
                        if (playerPosition.y > tileMapBorderTopPosition)
                        {
                            playerPosition.y -= (float)tileMapSize.y;
                        }
                        else if (playerPosition.y < tileMapBorderBottomPosition)
                        {
                            playerPosition.y += (float)tileMapSize.y;
                        }
                        transform.position = playerPosition;

 

spiel2.jpg

  • Like 1
Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
 Share

×
×
  • Create New...