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>();
</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;
</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!