Fügen Sie Pause, Hauptmenü und Spiel über Bildschirme in Einheit hinzu

Was sind die Schaltflächen, Text, Dropdowns usw., die beim Spielen eines Spiels zu sehen sind? All dies ist Teil des sogenannten User Interface (UI). Die meisten Spiele haben eine Art UI, die es den Spielern erleichtert, zwischen Levels zu wechseln und bestimmte Steuerelemente zu aktivieren (z. B. das Spiel in der Pause oder das Neustart eines Levels). In einem früheren Artikel, in dem beschrieben wird, wie Dodger in Einheit erstellt wird, haben wir eine kleine Schaltfläche erstellt, um das Spiel zu aktualisieren, wenn ein Spieler verloren ist.

In diesem Tutorial werden wir das auf die nächste Stufe bringen und den Benutzern ermöglichen, das Spiel zu pausieren oder neu zu starten und zwischen verschiedenen Szenen zu wechseln. Wir werden auch einen Blick darauf werfen, wie bestimmte UI -Elemente nur zu bestimmten Zeiten angezeigt werden können - z. B. wenn das Spiel angehalten wird oder wenn der Spieler stirbt/verliert.

Die meisten Spiele enthalten ein Pausemenü, ein Spiel über dem Bildschirm und ein Hauptmenü. Da dies einige der wenigen Elemente sind, die für ein "fertiges" Spiel erforderlich sind, werden wir alle drei in unseren Dodger -Klon einfügen. Darüber hinaus erstellen wir einen Anweisungsbildschirm, damit die Spieler die Steuerelemente lernen können, die sie verwenden können, bevor sie das Spiel spielen.

Das abgeschlossene Spiel kann auf itch.io.

gespielt werden

Key Takeaways

• Implementierung von Pause, Hauptmenü und Spiel über Bildschirme in Unity verbessert das Gameplay, indem es wesentliche UI -Steuerelemente und Szenenverwaltung bereitstellt.
• Verwenden Sie `time.timescale`, um das Spielstatus zu kontrollieren, es auf 0 zu setzen, um das Spiel zu pausieren, und 1, um wieder aufzunehmen, um effektive Pause -Menüfunktionen zu ermöglichen.
• Erstellen Sie unterschiedliche UI -Elemente wie Schaltflächen und Text für verschiedene Spielzustände und verwenden Sie Tags wie „Showonpause“, um ihre Sichtbarkeit zu verwalten.
• Entwickeln Sie eine Hauptmenüszene mit Optionen zum Starten des Spiels und nutzen die Szenemanager für Szenenübergänge zur Verbesserung der Benutzernavigation.
• Integrieren Sie ein Spiel über den Bildschirm mit Bewertungsanzeige- und Neustartoptionen unter Verwendung der Kollisionserkennung und UI -Updates, um die Spieler über das Spielende zu informieren.

Erstellen eines grundlegenden Pause -Bildschirms

Ein Pause-Bildschirm verfügt über eine Reihe von Steuerelementen, mit denen Spieler ein Level neu starten, zum Hauptmenü zurückkehren oder das Spiel nicht verurteilen können. Pause -Bildschirme sollten nur dann sichtbar sein, wenn das Spiel inneiert wird. In der Einheit sind wir im Allgemeinen in der Lage, zwischen einem pausten und unpauten Spiel zu unterscheiden, indem wir Time.timescale verwenden. Wenn die Zeitskala Null ist, wird das Spiel angehalten. Wenn es größer als Null ist, ist das Spiel nicht ausgelaugt (wir werden dies später besprechen). Fangen wir an!

Pause Text

erstellen

Erstens müssen wir einen Titel erstellen, der dem Spieler mitteilt, dass das Spiel stehen wird. Wir sollten ein Textobjekt erstellen, indem wir mit der rechten Maustaste im Hierarchiebereich klicken und UI -> Text auswählen. Nennen wir das neu erstellte Objekt Pausetext.

Wir müssen einen Titel erstellen, der dem Spieler mitteilt, dass das Spiel eine Pause ist. Wir sollten ein Textobjekt erstellen, indem wir mit der rechten Maustaste im Hierarchiebereich klicken und UI -> Text auswählen. Nennen wir das neu erstellte Objekt Pausetext.

Jetzt können wir das Textobjekt formatieren, damit es im Spielbildschirm besser aussieht. Um den Text eines Textobjekts zu ändern, müssen wir im Inspektorbereich im Textattribut "neuer Text" in den Inspektorbereich klicken. In dem Textattribut können wir den Text unseres Pause -Textes in „Pause“ ändern. Um mit dem Farbschema für das Spiel zu bleiben, sollten wir die Farbe des Textes in Weiß ändern. Dies kann erreicht werden, indem Sie unter das Farbobjekt klicken (wo schwarz oder eine andere Farbe ausgewählt werden kann) und White wählen.

Passen wir die Platzierung unseres Textes an. Der Pause -Text sollte horizontal auf dem Bildschirm zentriert sein und sich auf dem oberen Drittel des Spielbildschirms befinden. Der Pause -Text kann verschoben werden, indem die Werte von x und y innerhalb des RECT -Transform -Attributs geändert werden oder die vier Wege -Pfeile in den Maussteuerungen in der oberen linken Ecke des Unity -Editors verwendet werden. Bei Bedarf oder gewünscht, können wir auch die Textgröße ändern, indem wir den Wert ändern und die Größe der Breite und Höhenattribute ändern (unter RECT -Transformation).

Alles, was wir jetzt tun müssen, ist das Objekt so zu markieren, dass das Programm nach dem Hinzufügen von Code in der Lage ist, zu sagen, dass wir nur dieses Objekt zeigen möchten, wenn das Spiel pausiert wird. Wir können unter den Namen des Pause -Textes klicken, in dem er "nicht getagelt" heißt, und dann auf "Tag hinzufügen ..." klicken. Jetzt können wir ein Tag mit dem Namen "Showonpause" erstellen. Sobald dieses Tag erstellt wurde

Erstellen der pausierten Schaltflächen

Da wir den Pause -Text erstellt und ein neues Tag für Spielobjekte hinzugefügt haben, die bei der Pause angezeigt werden sollten, können wir die Schaltflächen erstellen, aus denen das pausierte Spielmenü ausgeht.

Wir erstellen drei verschiedene Schaltflächen: eine Wiedergabetaste, eine Neustart -Schaltfläche und eine Hauptmenü -Schaltfläche. Die Wiedergabetaste enthält das Spiel, der Neustart-Taste startet das Spiel neu und die Hauptmenü-Taste führt die Spieler zurück zum Hauptmenüszene des Spiels.

Beginnen wir, indem wir eine neue Schaltfläche erstellen (mit der rechten Maustaste in Hierarchie -> UI -> Taste) und "PlayButton" benennen. Wir sollten das Tag der Wiedergabetaste so einstellen, dass es nur dann angezeigt wird, wenn das Spiel pausiert wird. Setzen wir nun den Text der Wiedergabetaste auf "Spielen" ein. Dies kann durch Öffnen des Text -Child -Objekts im Inspektor (Klicken Sie auf die Dropdown -Liste neben der Wiedergabetaste in der Hierarchie und wählen Sie das Textobjekt aus) erfolgen und dann die Texteigenschaft in „Spielen“ ändern. Wir sollten die Wiedergabetaste mit der Mitte des Bildschirms so ausrichten, dass er unter dem Pause -Text steht.

Eine schnelle Möglichkeit, die beiden anderen Tasten zu erstellen, besteht darin, die Wiedergabetaste in der Hierarchie auszuwählen und zweimal zu duplizieren (Befehl / Strg D). Wir können die neuen Schaltflächen "Neustartbutton" und "MainMenubutton" nennen. Wir sollten auch jedem der neuen Schaltflächen den entsprechenden Text geben. Die Schaltfläche Neustart sollte "Neustart" und die Hauptmenü -Schaltfläche "Hauptmenü" sagen. Lassen Sie uns nun die Taste für Aktualisierung löschen, die im letzten Tutorial erstellt wurde. Wir können jetzt sehen, dass wir ein grundlegendes Pausemenü haben. Das Menü tut jedoch nichts, da wir den Objekten keinen Code angehängt haben.

Öffnen wir das Uimanager -Skript, das im letzten Tutorial erstellt wurde. Wir sollten unser Uimanager -Skript so bearbeiten, dass es wie der Code unten aussieht.

GameObject<span>[] pauseObjects;
</span>
	<span>// Use this for initialization
</span>	<span>void Start () {
</span>		Time<span>.timeScale = 1;
</span>		pauseObjects <span>= GameObject.FindGameObjectsWithTag("ShowOnPause");
</span>		<span>hidePaused();
</span>	<span>}
</span>
	<span>// Update is called once per frame
</span>	<span>void Update () {
</span>
		<span>//uses the p button to pause and unpause the game
</span>		<span>if(Input.GetKeyDown(KeyCode.P))
</span>		<span>{
</span>			<span>if(Time.timeScale == 1)
</span>			<span>{
</span>				Time<span>.timeScale = 0;
</span>				<span>showPaused();
</span>			<span>} else if (Time.timeScale == 0){
</span>				Debug<span>.Log ("high");
</span>				Time<span>.timeScale = 1;
</span>				<span>hidePaused();
</span>			<span>}
</span>		<span>}
</span>	<span>}
</span>

	<span>//Reloads the Level
</span>	public <span>void Reload(){
</span>		Application<span>.LoadLevel(Application.loadedLevel);
</span>	<span>}
</span>
	<span>//controls the pausing of the scene
</span>	public <span>void pauseControl(){
</span>			<span>if(Time.timeScale == 1)
</span>			<span>{
</span>				Time<span>.timeScale = 0;
</span>				<span>showPaused();
</span>			<span>} else if (Time.timeScale == 0){
</span>				Time<span>.timeScale = 1;
</span>				<span>hidePaused();
</span>			<span>}
</span>	<span>}
</span>
	<span>//shows objects with ShowOnPause tag
</span>	public <span>void showPaused(){
</span>		<span>foreach(GameObject g in pauseObjects){
</span>			g<span>.SetActive(true);
</span>		<span>}
</span>	<span>}
</span>
	<span>//hides objects with ShowOnPause tag
</span>	public <span>void hidePaused(){
</span>		<span>foreach(GameObject g in pauseObjects){
</span>			g<span>.SetActive(false);
</span>		<span>}
</span>	<span>}
</span>
	<span>//loads inputted level
</span>	public <span>void LoadLevel(string level){
</span>		Application<span>.LoadLevel(level);
</span>	<span>}
</span>

Jetzt, da wir den Code haben, den wir im Uimanager -Skript zugreifen müssen, können wir zur Einheit zurückkehren. Wählen Sie in Unity die Wiedergabetaste aus und fügen Sie die PUSECONTROL -Methode hinzu. Zu diesem Zweck können wir die Wiedergabetaste auswählen und das Uimanager -Spielobjekt in den Spielobjektraum unter dem Attribut "Onclick () im Inspektorbereich in den Spielobjektbereich ziehen. Wenn das Uimanager -Spielobjekt hinzugefügt wurde, können wir jetzt die zweite Dropdown -Down -Down -Stelle verwenden, um die Funktion pausecontrol (uimanager -> pausecontrol) auszuwählen.

Verwenden der gleichen Schritte können wir die Methode reload () zur Wiederstart -Taste und die Methode für Loadlevel () zur Hauptmenü -Taste hinzufügen. Da die Methode loellevel () einen String -Parameter nimmt, sollten wir "Mainmenu" in das Feld unter der Funktion "Funktion" eingeben.

Wenn wir jetzt das Spiel treffen, werden wir feststellen, dass die Play- und Neustart -Tasten funktionieren. Auch wenn wir P treffen, während das Spiel spielt, können wir das Spiel innehalten und nicht pause. Das einzige Problem ist, dass die Hauptmenü -Schaltfläche nicht funktioniert. Dies liegt daran, dass wir den Build -Einstellungen keine Szene namens "Mainmenu" hinzugefügt haben.

Erstellen einer Hauptmenüszene

Erstellen der Szene

Mit dem in der Spielszene erstellten Pausemenü können wir jetzt eine neue Szene erstellen, die als Hauptmenü des Spiels fungiert. Das Hauptmenü, das wir erstellen werden, ist einfach und enthalten nur einen Wiedergabetaste, der die Spieler zur Spielszene bringt.

Erstens sollten wir die aktuelle Szene retten, in der wir arbeiten, damit die Arbeit, die wir geleistet haben, nicht gelöscht werden, wenn wir eine neue öffnen. Erstellen wir eine neue Szene (Befehl / Strg N oder Datei -> neue Szene). Sobald die Szene geöffnet ist, speichern Sie es und nennen Sie sie "Mainmenu".

Hinweis: Wir nennen es „Mainmenu“, da dies die Zeichenfolgeneigenschaft ist, auf die wir die Hauptmenü -Schaltfläche in der Spielszene einstellen. Wenn wir einen anderen Namen wollten, können wir die String -Eigenschaft der an der Hauptmenüschaltfläche angehängten Loadlevel () -Funktion in der Spielszene ändern.

Erstellen des Menüs

Jetzt, da die Szene gerettet wurde, können wir damit beginnen, daran zu arbeiten. Beginnen wir mit der Auswahl des Hauptkamerasspielobjekts für Kameramameras und Ändern des Hintergrunds in dieselbe Farbe wie in der Spielszene (R: 0, G: 223, B: 255).

Für diese Szene müssen wir in der Lage sein, auf die Methode loellevel () im Uimanager -Skript zugreifen zu können. Dies bedeutet

Erstellen wir ein leeres Spielobjekt (klicken Sie mit der rechten Maustaste in Hierarchie -> leer erstellen) und nennen Sie es uimanager. Jetzt können wir das Uimanager -Skript zum Uimanager -Spielobjekt hinzufügen.

Wir können das einfache Menü erstellen, das den Text "Dodger" und eine Wiedergabetaste enthält. Wir erstellen mit dem Text (klicken Sie mit der rechten Maustaste in Hierarchie -> UI -> Text) und nennen Sie ihn "TitleText". Wir sollten den Text ändern, um „Dodger“ zu sagen und ihn ein wenig nach oben mit der Mitte des Bildschirms auszurichten. Setzen wir nun die Farbe des Titeltextes auf Weiß.

Mit dem erstellten und bearbeiteten Text können wir eine neue Schaltfläche erstellen und ihn "PlayButton" nennen. Wir sollten den Text des Kindertastes der Wiedergabetaste in "Spielen" ändern. Lassen Sie uns zum Schluss das Uimanager -Spielobjekt zum Onclick () -Matchnit der Taste () hinzufügen und die Funktion loellevel () auswählen. Der Parameter der Funktion loellevel () hängt davon ab, wie der Name der Spielszene aus dem letzten Tutorial heißt. Wir können den Namen der Spielszene finden, indem wir die Szene im Vermögensbereich finden.

Wenn wir das Spiel ausführen und auf die Wiedergabetaste klicken, werden wir feststellen, dass die Schaltfläche nicht funktioniert. Der Grund ist der gleiche wie es, als die Hauptmenü -Schaltfläche in unserer Spielszene nicht funktioniert hat: Wir haben die Mainmenu -Szene nicht den Build -Einstellungen hinzugefügt. Um unsere aktuelle Szene zu den Build -Einstellungen hinzuzufügen, können wir die Build -Einstellungen (Datei -> Build -Einstellungen) öffnen und auf aktuelle Hinzufügen hinzufügen.

beenden das Spiel

Damit das Spiel als „fertig“ angesehen wird, muss es ein Spiel über dem Bildschirm haben, damit die Spieler erkennen können, wann sie verloren haben. Wir werden dem Spiel auch einen Score -Gegenstand hinzufügen, damit die Spieler wissen, wie hoch sie erzielt haben.

Hinzufügen einer Punktzahl

Wir sollten unsere aktuelle Szene retten und die Spielszene öffnen. Wenn die Play -Szene geöffnet ist, können wir ein Textobjekt erstellen und "scoretext" nennen. Das Score -Textobjekt sollte an die Spitze des Bildschirms ausgerichtet sein. Mit dem ausgewählten Score -Text -Objekt können wir einen oberen Stretchanker hinzufügen, indem wir in die Eigenschaftseigenschaft angesehen und auf das Menü Anker klicken. Wir sollten auch den Text zentrieren und ihn weiß machen.

Die Bedingung, mit der wir die Punktzahl aktualisieren werden, sind Blöcke, die vom Bildschirm aussteigen (dh der Blöcke, den der Spieler bereits ausgewichen hat). Damit diese Bedingung aktiv ist

Erstellen wir ein leeres Spielobjekt und nennen Sie es "Bottomborder". Wir fügen einen BoxCollider2D an den unteren Rand hinzu und setzen die X -Größe auf eine große Zahl, die leicht über die Grenzen der Kamera hinausgeht. Jetzt können wir dem unteren Randobjekt einen starrbody2d hinzufügen und das Attribut der Schwerkraftskala auf 0 einstellen, damit das untere Randobjekt nicht fällt. Wir können das untere Randobjekt leicht unter dem Spieler ausrichten, um sicherzustellen, dass es außerhalb des Bildschirms ist.

Wir müssen ein neues Skript erstellen, um eine Punktzahl für den Spieler festzulegen. Erstellen wir ein neues C# -Skript mit dem Namen "PointCounter" in unserem Skriptsordner. Sobald das Pointcounter -Skript erstellt wurde

GameObject<span>[] pauseObjects;
</span>
	<span>// Use this for initialization
</span>	<span>void Start () {
</span>		Time<span>.timeScale = 1;
</span>		pauseObjects <span>= GameObject.FindGameObjectsWithTag("ShowOnPause");
</span>		<span>hidePaused();
</span>	<span>}
</span>
	<span>// Update is called once per frame
</span>	<span>void Update () {
</span>
		<span>//uses the p button to pause and unpause the game
</span>		<span>if(Input.GetKeyDown(KeyCode.P))
</span>		<span>{
</span>			<span>if(Time.timeScale == 1)
</span>			<span>{
</span>				Time<span>.timeScale = 0;
</span>				<span>showPaused();
</span>			<span>} else if (Time.timeScale == 0){
</span>				Debug<span>.Log ("high");
</span>				Time<span>.timeScale = 1;
</span>				<span>hidePaused();
</span>			<span>}
</span>		<span>}
</span>	<span>}
</span>

	<span>//Reloads the Level
</span>	public <span>void Reload(){
</span>		Application<span>.LoadLevel(Application.loadedLevel);
</span>	<span>}
</span>
	<span>//controls the pausing of the scene
</span>	public <span>void pauseControl(){
</span>			<span>if(Time.timeScale == 1)
</span>			<span>{
</span>				Time<span>.timeScale = 0;
</span>				<span>showPaused();
</span>			<span>} else if (Time.timeScale == 0){
</span>				Time<span>.timeScale = 1;
</span>				<span>hidePaused();
</span>			<span>}
</span>	<span>}
</span>
	<span>//shows objects with ShowOnPause tag
</span>	public <span>void showPaused(){
</span>		<span>foreach(GameObject g in pauseObjects){
</span>			g<span>.SetActive(true);
</span>		<span>}
</span>	<span>}
</span>
	<span>//hides objects with ShowOnPause tag
</span>	public <span>void hidePaused(){
</span>		<span>foreach(GameObject g in pauseObjects){
</span>			g<span>.SetActive(false);
</span>		<span>}
</span>	<span>}
</span>
	<span>//loads inputted level
</span>	public <span>void LoadLevel(string level){
</span>		Application<span>.LoadLevel(level);
</span>	<span>}
</span>

Das PointCounter -Skript sollte dem unteren Grenzspielobjekt hinzugefügt werden, sodass ein Block damit kollidiert wird, der Block zerstört und die Punktzahl aktualisiert wird.

Erstellen wir nun ein Skript mit dem Namen "PointUpdater", das den Score -Text aktualisiert. Wir können das PointUpdater -Skript in unserer IDE öffnen und tippen:

public <span>int score;
</span>
	<span>// Use this for initialization
</span>	<span>void Start () {
</span>		score <span>= 0;
</span>	<span>}
</span>
	<span>// Update is called once per frame
</span>	<span>void Update () {
</span>
	<span>}
</span>
	<span>//checks for entering a trigger
</span>	<span>void OnTriggerEnter2D(Collider2D other){
</span>		<span>//checks other collider's tag
</span>		<span>if(other.gameObject.tag == "Enemy"){
</span>			score<span>++;								//increments score
</span>			<span>Destroy (other.gameObject);				//destroys other collider's gameobject
</span>		<span>}
</span>	<span>}
</span>

Wir sollten das PointUpdater -Skript zum Score -Textspielobjekt hinzufügen. Das untere Grenzspielobjekt sollte zum Punktzählerwert hinzugefügt werden, damit die Punktzahl aktualisiert werden kann.

Erstellen eines Spiels über Menü

Um das Spiel zu beenden, müssen wir ein Spiel über dem Menü hinzufügen, das angezeigt wird, wenn der Spieler gestorben ist.

Öffnen wir das Playertroller -Skript in unserer IDE und unter der letzten Variablenerklärung hinzufügen:

public PointCounter pointCounter<span>;
</span>	<span>// Use this for initialization
</span>	<span>void Start () {
</span>		text <span>= gameObject.GetComponent<text>();
</text></span>    text<span>.text = "Score: 0";
</span>	<span>}
</span>
	<span>// Update is called once per frame
</span>	<span>void Update () {
</span>		text<span>.text = "Score: " + pointCounter.score.ToString();
</span>
	<span>}
</span>

Innerhalb des feindlichen Controller -Skripts fügen wir hinzu:

public bool alive<span>;
</span>	<span>// Use this for initialization
</span>	<span>void Start () {
</span>		alive <span>= true;
</span>	<span>}
</span>

Um das Menü auszurüsten, können wir ein neues Textspielobjekt erstellen und es "GameOvertext" nennen. Der Text sollte auf "Game Over" gesetzt und die Textfarbe weiß sein. Wir sollten das Spiel über Text so ausrichten, dass sie leicht über der Mitte des Bildschirms liegen. Um sicherzustellen, dass dieses Menü erst angezeigt wird, wenn der Spieler gestorben ist

Lassen Sie uns nun die Schaltflächen zur Neustart- und Hauptmenü duplizieren. Wir sollten die Schaltflächen in „FinRestartButon“ und „Finmainmenubutton“ umbenennen und das Showonfinish -Tag zu beiden Tasten hinzufügen.

Öffnen wir schließlich das Uimanager -Skript in unserer IDE und bearbeiten Sie es so, dass es wie der Code unten aussieht.

<span>void OnTriggerEnter2D(Collider2D other){
</span>
  <span>//Checks if other gameobject has a Tag of Player
</span>  <span>if(other.gameObject.tag == "Player"){
</span>    other<span>.gameObject.GetComponent<playercontroller>().alive = false;
</playercontroller></span>    Time<span>.timeScale = 0;
</span>  <span>}
</span><span>}
</span>

Schlussfolgerung

Wir haben unserem Spiel jetzt eine einfache Benutzeroberfläche hinzugefügt. Die Spieler können sich nun mit den Tasten durch die beiden Szenen bewegen. Wir haben auch Erfahrungen in der modularen Einheitentwicklung und der Trockencodierung gesammelt (nicht selbstverständlich). Die Art und Weise, wie wir den Score -Text erstellt haben

Fragen? Kommentare? Bitte lassen Sie sie unten!

Das fertige Projekt kann von Github heruntergeladen werden.

häufig gestellte Fragen (FAQs) zum Hinzufügen von Pause, Hauptmenü und Spiel über Bildschirme in Unity

Wie kann ich in Einheit eine Pause -Taste hinzufügen? Die Zeitskala ist ein globaler Multiplikator, der die Geschwindigkeit beeinflusst, mit der die Spielzeit fortschreitet. Indem Sie es auf Null setzen, halten Sie das Spiel effektiv an. Das an die Pause angehängte Skript sollte eine Funktion enthalten, die die Zeitskala zwischen 1 (normale Geschwindigkeit) und 0 (übernommen) umschaltet, wenn die Schaltfläche geklickt wird.

Wie kann ich ein Hauptmenü in Einheit erstellen? 🎜>

Erstellen eines Hauptmenüs in Einheit beinhaltet die Erstellung einer neuen Szene, die als Menü dient. Diese Szene sollte UI -Elemente wie Schaltflächen enthalten, mit denen der Spieler das Spiel starten, Einstellungen anpassen oder aufhören kann. Jede Schaltfläche sollte ein Skript anhängen, das beim Klicken die entsprechende Aktion ausführt. Zum Beispiel kann das Skript der Start -Taste die Spielszene laden, während das Skript der Beendigung der Button die Anwendung schließt. Der Bildschirm in Einheit ähnelt dem Hinzufügen eines Hauptmenüs. Sie müssen eine neue Szene erstellen, die als Spiel über dem Bildschirm dient, komplett mit UI -Elementen, die Optionen für den Spieler bieten, z. B. das Neustart des Spiels oder die Rückkehr zum Hauptmenü. Diese Elemente sollten Skripte anhängen, die beim Klicken die entsprechenden Aktionen ausführen. Diese Klasse bietet Funktionen zum Laden und Entladen von Szenen sowie zum Abfragen von Informationen über die aktuelle Szene. Um zu einer neuen Szene zu wechseln, können Sie die Szenemanager -Funktion verwenden. Loloadscene -Funktion, die entweder den Namen oder den Index der Szene übergeben, die Sie laden möchten.

Einheit bietet eine Vielzahl von Optionen, um das Erscheinungsbild von UI -Elementen anzupassen. Sie können Eigenschaften wie Farbe, Größe und direkt im Unity Editor anpassen. Für eine fortgeschrittenere Anpassung können Sie die leistungsstarken Animationsfunktionen des UI -Systems verwenden oder sogar Ihre eigenen benutzerdefinierten UI -Komponenten erstellen, indem Sie die vorhandenen Klassen erweitern. >

Hinzufügen von Soundeffekten zu UI -Elementen in der Einheit kann durch Anhängen einer AudiOSource -Komponente an das Element und das Konfigurieren eines Sounds erreicht werden, wenn das Element interagiert wird. Sie können beispielsweise eine Schaltfläche konfigurieren, um beim Drücken eines Klick -Tons zu spielen.

Wie kann ich meine Benutzeroberfläche in der Einheit auf verschiedene Bildschirmgrößen ansprechen? Durch das Einstellen des UI -Skalierungsmodus des Canvas Scaler in „skalieren mit Bildschirmgröße“ können Sie sicherstellen, dass Ihre UI -Elemente eine konsistente Größe und Layout über verschiedene Geräte hinweg behalten.

Wie kann ich meine Benutzeroberfläche in Einheit testen?

Testen Sie Ihre Benutzeroberfläche in Unity können direkt im Unity Editor durchgeführt werden. Die Spielansicht bietet eine Echtzeit-Vorschau Ihres Spiels, einschließlich aller UI-Elemente. Sie können mit Ihrer Benutzeroberfläche in der Spielansicht wie ein Spieler im tatsächlichen Spiel interagieren, sodass Sie die Funktionalität testen und nach Problemen überprüfen können. >

Optimierung Ihrer Benutzeroberfläche für die Leistung in Einheit kann eine Vielzahl von Strategien beinhalten, z. Ihre Benutzeroberfläche auf niedrigeren Geräten. Das Profiler -Tool von Unity kann eine wertvolle Ressource für die Identifizierung von Leistungs Engpässen in Ihrer Benutzeroberfläche sein.

Wie kann ich mehr über das UI -System von Unity erfahren? API -Referenzen und Best Practices. Darüber hinaus gibt es viele Online -Communities und Ressourcen, in denen Sie von anderen Einheitsentwicklern wie der Unity -Foren, dem Stack -Überlauf und verschiedenen Tutorial -Websites lernen können.

Das obige ist der detaillierte Inhalt vonFügen Sie Pause, Hauptmenü und Spiel über Bildschirme in Einheit hinzu. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!