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 werdenEin 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!
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ächenWir 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.
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.
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.
beenden das Spiel
Hinzufügen einer Punktzahl
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>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>Erstellen eines Spiels über Menü
Ö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>
public bool alive<span>;
</span> <span>// Use this for initialization
</span> <span>void Start () {
</span> alive <span>= true;
</span> <span>}
</span>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
Das fertige Projekt kann von Github heruntergeladen werden.
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.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 Einheit testen?
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!
Befehl zum Neustart des Servers
MySQL-Index
cad2012 Seriennummer und Schlüssel
So spielen Sie Videos mit Python ab
So lösen Sie das Problem, das Einschaltkennwort eines Win8-Computers zu vergessen
So verwenden Sie Return in der C-Sprache
Welche Methoden gibt es, um die IP in dynamischen VPS sofort zu ändern?
Die jüngsten Markttrends von Ripple
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
