Leaderboard

Echt jetzt? Das ist es? Du ballerst eine verschlüsselte Fehlerbeschreibung ohne Punkt und Komma raus. Da drin steht dann etwas von einer Plattform, einer AudioSource, OnCollisionEnter2D, einem RB2D und "natürlich" FixedUpdate und Update. Völlig ohne Zusammenhang! Jetzt versucht @Peanutdir zu helfen und fragt dich etwas. Deine Antwort darauf ist "Nein". Kurz darauf fällt dir ein, dass ein RB ja nach unten Fallen würde und dein FixedUpdate trotzdem nicht funktioniert. Jetzt gibt dir Peanut die Info, dass man die Gravity bei einem RB ja ausschalten kann und er würde gerne mehr über das Problem erfahren, weil er dir immer noch helfen will. Und was machst du? Du schreibst, dass du das Problem gefunden hast und bedankst dich. Klasse! Niemand weiß, was dein Problem war und niemand weiß, wie du es gelöst hast. Dafür ist ein Forum nicht da. Ein Forum dient nämlich auch als Nachschlagewerk. Es kann anderen Leuten helfen, indem sie nach erstmal nach einem Problem suchen und auch eine mögliche Lösung dazu finden. Dieser Thread ist verschwendet, denn man kann nicht erkennen was eigentlich dein Problem war und eine Lösung gibt es auch nicht. Aber mach du mal.

Dein Problem könnte sein, dass ein Destroy nicht sofort passiert, sondern erst nach ablauf des Update-Loops. Du zerstörst also den letzten Level, welcher aber bis zum Ende des Loops noch da ist, instanzierst einen neuen Level, hast jetzt also 2 Level gleichzeitig drin, suchst nach deinen Punkten, die jetzt 2 Mal drin sind, und findest die alten, schon gefundenen, Punkte. Jetzt erst wird der alte Level aus der Szene raus genommen und deine gefundenen Punkte sind weg. Was dir helfen könnte, wäre ein DestroyImmediate. Das wird aber ausdrücklich nicht empfohlen! https://docs.unity3d.com/ScriptReference/Object.DestroyImmediate.html Suchen die Punkte doch einfach mal im LateUpdate und guck ob dann alles in Ordnung ist.

Hallo, Welche Fehlermeldung du genau erhältst wäre schon hilfreich. Ich rate mal ins blaue. In der class MathQuestion hast du public List<int> fakeAnswers; eine Liste referenziert die aber noch auf null zeigt. In der anderen Classe greifst du mit question.fakeAnswers.Add(_result); auf die fakeAnswers Liste zu die noch nicht Initialisiert ist. In der class MathQuestion hättest du mit public List<int> fakeAnswers = new List<int>(); die Liste Initialisiert Sorry, Sascha war mal wie immer 1 Minute schneller😉 Gruß Jog

Ich finde Mermaid sehr interessant, um z.B. einen Talentbaum zu visualisieren. Hab mal ein Beispiel gemacht, hat gut funktioniert: graph TD SURV[Wildnis] --> SURV_P1 SURV[Wildnis] --> SURV_COM SURV[Wildnis] --> SURV_DIV SURV_P1[Giftresistenz I\n<font size=1>-20% Schaden durch Gift</font>] --> SURV_P2 SURV_P2[Giftresistenz I\n<font size=1>-35% Schaden durch Gift</font>] --> SURV_P3 SURV_P3[Giftresistenz I\n<font size=1>-40% Schaden durch Gift</font>] SURV_COM[Kompass\n<font size=1>Du kannst ein Kompass bauen</font>] SURV_DIV[Tauchen\n<font size=1>Du kannst 100% länger tauchen</font>] COMBAT[Kampf] --> COMBAT_HEALTH COMBAT[Kampf] --> COMBAT_ARROWS COMBAT_HEALTH[Lebenspunkte I] COMBAT_ARROWS[Zielen I\n<font size=1>Pfeile sind genauer</font>] X[Alchemie] --> AL1 X[Alchemie] --> PT1 AL1[Kräuterkunde I\n<font size=1>Stufe 1 Kräuter sammeln</font>] --> AL2 AL2[Kräuterkunde II\n<font size=1>Stufe 2 Kräuter sammeln</font>] --> AL3 AL3[Kräuterkunde III\n<font size=1>Stufe 3 Kräuter sammeln</font>] --> AL_MASTER PT1[Heiltränke I\n<font size=1>+20% wirksamer</font>] --> PT2 PT2[Heiltränke I\n<font size=1>+40% wirksamer</font>] --> AL_MASTER AL_MASTER[Alchemie Grossmeister\n<font size=1>Du erhältst beim brauen die doppelte Menge Tränke</font>]

Ich wollte nur noch mitteilen, dass es so geklappt hat! Die Startkoordinaten und die jeweiligen Bilddimensionen werden bei unterschiedlichen Monitorauflösungen neu berechnet! // Screensize der orthogonalen Kamera ist 6 // Kamera Units vertikal: Camerasize (6) * 2 = 12 Units werden von der Kamera vertikal erfasst // Kamera Units horizontal: 12 Units / 9 * 16 = 21.3333 Units werden von der Kamera horizontal erfasst float propX = 12f / 9 * 16 / sprite.GetComponent<SpriteRenderer> ().bounds.size.x; // Verhältnis von Screenbreite und Bildbreite float propY = 12f / sprite.GetComponent<SpriteRenderer> ().bounds.size.y; // Verhältnis von Screenhöhe und Bildhöhe int width = (int)(Screen.width / propX); int height = (int)(Screen.height / propY); int startX = (int)(Screen.width / 2 - width / 2); int startY = (int)(Screen.height / 2 - height / 2);

Hallo, es gibt etwas Neues vom Projekt. Bisher hatte ich nur eine Bevölkerungsgruppe, die Siedler. Alle Gebäude und Einrichtungen wurden von Siedlern bedient. Die Ausbaustufen der Häuser beinhalteten auch nur eine größere Anzahl von Siedlern. Ziel war es somit nur eine ausreichende Anzahl von Siedlern in der Stadt/Dorf zu haben. Durch die unterschiedlichen Bevölkerungsgruppen entsteht jetzt eine größere Dynamik. So besiedelt dann nach einem Aufstieg der Unterkünfte nur die nächste Bevölkerungsgruppe diese Unterkunft. Die vorhergehende Gruppe muss dann ausziehen. Desweiteren werden dann die Produktionsgebäude von unterschiedlichen Bevölkerungsgruppen bedient. So wird es neben den Siedlern dann Bauer, Arbeiter/Handwerker, Bürger und Gelehrte geben. Als Aufstiegsvoraussetzungen wird neben den Verschönerungen dann auch Bildung und Kultur geben.

Hallo, Ich wünsche euch allen, 12 Monate Gesundheit, 52 Wochen Glück, 365 Tage ohne Stress, 8784 Stunden Liebe, 527040 Minuten Freude, 31622400 Sekunden Programmieren ohne Bug, In diesem Sinne Frohe Weinachten.⛄ Gruß Jog

Moin, laut Doku ist die Methode jetzt öffentlich, daher greift BindingFlags.NonPublic jetzt nicht mehr. https://docs.unity3d.com/2021.3/Documentation/ScriptReference/EditorGUIUtility.SetIconForObject.html Heißt aber auch, du benötigst keine Reflection mehr und kannst die Methode direkt aufrufen: private void DrawIcon(GameObject gameObject, int idx) { GUIContent[] icons = GetTextures("sv_label_", string.Empty, 0, 8); GUIContent icon = icons[idx]; EditorGUIUtility.SetIconForObject(gameObject, icon.image); }

Hallo, ich möchte euch ein kleines Video meines Projektes zeigen. Wo stehe ich im Moment? Jack erhält zu Beginn des Spiels eine Begrüßung von Fuchs Eddi, ein paar Anweisungen und seine erste Aufgabe. Dabei geht es erstmal nur um das Anbauen und Ernten von Maiskolben.

Jeah, nach gut 20 Stunden Arbeit bin ich nun fertig und es funktioniert völlig fehlerfrei. Hätte ich nie gedacht und wollte schon aufgeben 😂 ☺️ Wer möchte kann das Script gerne nutzen, vielleicht hat ja auch noch jemand bedarf an sowas. Dazu einfach das Input Script dem EventSystem unter das "Input System UI Input Module"(Wichtig, da darf nichts anderes dazwischen sein) geben und die Tags "Horizontal Menu" und "Vertical Menu" hinzufügen und den entsprechenden Panels zuweisen. Das InputModule, welches man erstellt muss man entweder umbenennen in InputManager, oder in Script InputSO alle "InputManger" durch was anderes ersetzen. Das gleich gilt auf für die ActionMaps. Bei mehr als einer wird man allerdings noch mehr Anpassungen vornehmen müssen, sofern diese die Funktionalität auch benötigen. Wenn noch jemand Anmerkungen und Verbesserungen hat, gerne her damit 😁 Input.cs using UnityEngine; using UnityEngine.EventSystems; using UnityEngine.InputSystem; using UnityEngine.InputSystem.UI; using UnityEngine.UI; internal struct NavigationModel { public Vector2 move; public int consecutiveMoveCount; public MoveDirection lastMoveDirection; public float lastMoveTime; public AxisEventData eventData; public void Reset() { move = Vector2.zero; } } public class Input : BaseInputModule { public InputSO inputSO; private NavigationModel m_NavigationState; private string parentTag; private bool isDynamicList; protected override void OnEnable() { base.OnEnable(); inputSO.moveVector += SetInputDirection; inputSO.navigate += CheckDynamicListObject; inputSO.submit += SetParentOnSubmit; } protected override void OnDisable() { base.OnDisable(); inputSO.moveVector -= SetInputDirection; inputSO.navigate -= CheckDynamicListObject; inputSO.submit -= SetParentOnSubmit; } public void OnClick() { eventSystem.SetSelectedGameObject(eventSystem.firstSelectedGameObject); } private void ProcessNavigation(ref NavigationModel navigationState) { var usedSelectionChange = false; if (eventSystem.currentSelectedGameObject != null) { var data = GetBaseEventData(); ExecuteEvents.Execute(EventSystem.current.currentSelectedGameObject, data, ExecuteEvents.updateSelectedHandler); usedSelectionChange = data.used; } if (!eventSystem.sendNavigationEvents) return; var movement = navigationState.move; if (!usedSelectionChange && (!Mathf.Approximately(movement.x, 0f) || !Mathf.Approximately(movement.y, 0f))) { var time = Time.unscaledTime; var moveVector = navigationState.move; var moveDirection = MoveDirection.None; if (moveVector.sqrMagnitude > 0) { if(parentTag == "Horizontal Menu") { if (Mathf.Abs(moveVector.x) > Mathf.Abs(moveVector.y)) moveDirection = moveVector.x > 0 ? MoveDirection.Right : MoveDirection.Left; } else if (parentTag == "Vertical Menu") { if (Mathf.Abs(moveVector.x) < Mathf.Abs(moveVector.y)) moveDirection = moveVector.y > 0 ? MoveDirection.Up : MoveDirection.Down; } else if (Mathf.Abs(moveVector.x) > Mathf.Abs(moveVector.y)) moveDirection = moveVector.x > 0 ? MoveDirection.Right : MoveDirection.Left; else moveDirection = moveVector.y > 0 ? MoveDirection.Up : MoveDirection.Down; } if (moveDirection != m_NavigationState.lastMoveDirection) m_NavigationState.consecutiveMoveCount = 0; if (moveDirection != MoveDirection.None) { var allow = true; if (m_NavigationState.consecutiveMoveCount != 0) { if (m_NavigationState.consecutiveMoveCount > 1) allow = time > m_NavigationState.lastMoveTime + GetComponent<InputSystemUIInputModule>().moveRepeatRate; else allow = time > m_NavigationState.lastMoveTime + GetComponent<InputSystemUIInputModule>().moveRepeatDelay; } if (allow) { Selectable newBtn = eventSystem.currentSelectedGameObject.GetComponent<Selectable>().FindSelectable(moveVector); if (newBtn.transform.parent.tag != parentTag) return; var eventData = m_NavigationState.eventData; if (eventData == null) { eventData = new AxisEventData(eventSystem); m_NavigationState.eventData = eventData; } eventData.Reset(); eventData.moveVector = moveVector; eventData.moveDir = moveDirection; ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, eventData, ExecuteEvents.moveHandler); usedSelectionChange = eventData.used; m_NavigationState.consecutiveMoveCount = m_NavigationState.consecutiveMoveCount + 1; m_NavigationState.lastMoveTime = time; m_NavigationState.lastMoveDirection = moveDirection; } } else m_NavigationState.consecutiveMoveCount = 0; } else m_NavigationState.consecutiveMoveCount = 0; if (!usedSelectionChange && EventSystem.current.currentSelectedGameObject != null) { var submitAction = GetComponent<InputSystemUIInputModule>().submit?.action; var cancelAction = GetComponent<InputSystemUIInputModule>().cancel?.action; var data = GetBaseEventData(); if (cancelAction != null && cancelAction.WasPressedThisFrame()) ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.cancelHandler); if (!data.used && submitAction != null && submitAction.WasPressedThisFrame()) ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.submitHandler); } } public override void Process() { ProcessNavigation(ref m_NavigationState); if (parentTag != "Horizontal Menu" && parentTag != "Vertical Menu") { parentTag = eventSystem.currentSelectedGameObject.transform.parent.tag; UnityEditorInternal.ComponentUtility.MoveComponentDown(this); isDynamicList = false; } } public void SetInputDirection(Vector2 moveVector) { m_NavigationState.move = moveVector; } public void CheckDynamicListObject() { parentTag = eventSystem.currentSelectedGameObject.transform.parent.tag; if (!isDynamicList) { if (parentTag == "Horizontal Menu" || parentTag == "Vertical Menu") { isDynamicList = true; UnityEditorInternal.ComponentUtility.MoveComponentUp(this); } } } public void SetParentOnSubmit() { parentTag = eventSystem.currentSelectedGameObject.transform.parent.tag; } } InputSO.cs using UnityEngine; using UnityEngine.Events; using UnityEngine.InputSystem; [CreateAssetMenu(fileName = "AdvancedInput")] public class InputSO : ScriptableObject, InputManager.IMenuActions { public InputManager InputManager; public event UnityAction navigate; public event UnityAction<Vector2> moveVector; public event UnityAction submit; private void OnEnable() { if (InputManager == null) InputManager = new InputManager(); InputManager.Menu.SetCallbacks(this); InputManager.Menu.Enable(); } private void OnDisable() { InputManager.Menu.Disable(); } public void OnCancel(InputAction.CallbackContext context) { //throw new System.NotImplementedException(); } public void OnNavigate(InputAction.CallbackContext context) { navigate?.Invoke(); moveVector?.Invoke(context.ReadValue<Vector2>()); } public void OnSubmit(InputAction.CallbackContext context) { submit?.Invoke(); } }

Eigentlich wollte ich nur einen kleinen Retro-Plattformer erstellen. Jetzt wo ich damit begonnen habe, stellte sich schnell heraus, das es wohl doch ein etwas umfangreicheres Projekt werden wird. Daher bekommt es auch einen eigenen Kanal. Ich werde das Projekt diesmal englischsprachig halten. Da bekomme ich schon hin. Bekanntlicherweise halten sich ja die Dialoge in einem Plattformer in Grenzen. Nichtsdestotrotz werde ich die Spielbeschreibungen erstmal deutsch halten. Dann habe ich immer die Möglichkeit mich evtl. doch nur für eine rein deutsche Version zu entscheiden. Name: The cunning Fox Story: In einem dichten Wald voller Magie und Kreaturen lebte ein listiger Fuchs namens Max. Eines Tages hörte Max ein Gerücht über ein monströses Ungeheuer, das im Wald sein Unwesen trieb und alles verschlang, was ihm in den Weg kam. Max beschloss, das Ungeheuer zu finden und zu besiegen, aber er erkannte schnell, dass es nur eine Illusion war, die von einem Zauberer des Waldes erschaffen wurde. Max schmiedete einen Plan, um den Zauberer zu überlisten und seine Schätze zu stehlen. Hier ein Screen vom ersten Level:

Hallo, ich hatte in der letzten Zeit Lust, neben meinen größeren Projekten, etwas „Kleines“ zu erstellen. Dabei ist die Wahl auf einen vertikal Space-Shooter gefallen. Wie gesagt, nichts umfangreiches, eher etwas für Zwischendurch mal etwas rumballern. Daher sind es auch nur 10 Level und wenn man alles durchgespielt hat, dann sind es evtl. 30 Minuten Spielzeit. Das kleine Projekt nennt sich Boreas Nebula und ist wieder mit Unity umgesetzt. Ganz fertig ist es noch nicht, aber schon mal komplett spielbar. Hier der Download, falls ihr mal reinschauen wollt. Boreas 0.9.1 Hier ein paar Screens:

Nein Dein Projekt ist auch nur ein ganz normales C#-Programm, das von der darunter liegenden C++-Engine gestartet wird. Du hast keinen Zugriff auf die übliche Main-Methode und einen ganzen Haufen Engine-interner Dinge, aber abgesehen davon hast du da nicht so wirklich nennenswerte Einschränkungen. Wenn du diesen Satz also so meinst, dass der Code zum Erstellen von Objekten in einem MonoBehaviour stecken muss, dann: Nein. Objekte können Objekte können Objekte erstellen. Gar kein Problem. Wenn du den Satz aber so meinst, dass der initiale Impuls, dass irgendetwas passiert, aus Unity heraus kommen muss, dann hast du damit sogar Recht. Wenn du daraus aber wiederum ableitest, dass das in einem MonoBehaviour passieren muss, dann stimmt die Behauptung auch wieder nicht. Unity hat einen solchen Impuls, der einfach nur zum Programmstart irgendeinen Code ausführt - ähnlich einer Main-Methode. Dafür brauchst du dieses Attribut: [RuntimeInitializeOnLoadMethod] private static void InitializeStuff() { Debug.Log("Hello, World!"); } Das kannst du über eine parameterlose, statische Methode in einer beliebigen Klasse packen und ab dafür. Das Attribut hat auch noch einen optionalen Parameter, mit dem du bestimmen kannst, ob das vor dem Laden der ersten Szene passieren soll oder danach... oder noch woanders. In dieser Methode kannst du dann auch wunderbar auch verschiedene Events subscriben, z.B. auf das Wechseln zu einer anderen Szene. Du kannst auch mit dem PlayerLoopSystem deine eigene Update-Methode schreiben, die kein MonoBehaviour braucht, wobei es für simple Fälle meiner Meinung nach entspannter ist, einfach ein Gameobject zu bauen. Nachdem all das gesagt ist, finde ich es aber wichtig, zu erwähnen, dass das nicht heißt, dass du ab jetzt MonoBehaviour meiden solltest, solange etwas nicht sichtbar ist oder so. Ein GameObject definiert ein Stück weit, wie eine Szene funktioniert. Und das darfst du auch genau so nutzen. So als Beispiel: Ich habe ein Beispiel-Projekt für Soda (ein Asset-Store-Paket von mir) gebaut. Als Hinweis: Gerne anschauen, ich benutze es auch als Best Practices-Showcase, aber ohne Soda wird es nicht kompilieren. Dort habe ich jedenfalls ein Musik-System. In diesem System benutze ich das [RuntimeInitializeOnLoadMethod]-Attribut, um direkt bei Spielstart ein GameObject zu erzeugen. Dieses mache ich mit HideFlags unsichtbar, damit es im Editor nicht weiter auffällt, und mit DontDestroyOnLoad mache ich es "unverwundbar" gegen Szenenwechsel. Damit habe ich ein (wenn man nicht danach sucht...) unsichtbares GameObject, das von Anfang bis Ende der Laufzeit existiert. Diesem GameObject gebe ich eine AudioSource, das die Hintergrundmusik abspielt. Nun habe ich aber auch eine Komponente, die einen AudioClip referenzieren kann und die sich, solange sie enabled ist, in eine Liste einträgt. Wann immer sich eine solche Komponente einträgt, wird der AudioClip des letzten Elements der Liste von dieser AudioSource abgespielt. Wenn ich also eine neue Szene mache und da ist nichts drin, dann habe ich da Musik laufen, sofern der Player da etwas brauchbares in der Liste hat. Und damit komme ich endlich zu meinem Punkt: Wenn ich eine Musik-Komponente in meine leere Szene packe, dann habe ich eine leere Szene, die ihre eigene Musik vom globalen Musik-Player abspielen lässt. Diese Komponente ist für den Spieler unsichtbar, sie stellt keine unsichtbare Wand dar, gar nichts. Und trotzdem hat sie, in der Szene und als MonoBehaviour, ihre Daseinsberechtigung, weil sie dazu beiträgt, zu definieren, was genau in dieser Szene passiert. Es ist also völlig okay, eine MonoBehaviour-Klasse zu schreiben, um irgendwelche Dinge zu initialisieren oder um Daten einzutragen, die in der Szene relevant sein können. Es ist aber trotzdem sehr empfehlenswert, sich von der Idee zu lösen, die Unity einem initial leider vermittelt: Dass alles irgendwie in MonoBehaviours passieren muss.

Hallo Also entweder haben die Angestellten ja gespeichert, bei welchem Unternehmen sie sind oder die Unternehmen haben gespeichert, wer bei Ihnen arbeitet. Beim zweiten Fall kann das betroffene Unternehmen ja einfach seine Angestellte informieren und bei denen eine entsprechende Funktion aufrufen. Wenn die Angestellten sich ihr Unternehmen gemerkt haben, dann sende doch den Event, dass ein Unternehmen Lohnkürzungen vornimmt und entweder gibst du dem Event das Unternehmen als Parameter mit und iterierst dann durch alle Angestellten und schaust, ob deren Unternehmen mit dem des Events übereinstimmt. Wenn dies der Fall ist, rufst die Lohnkürzungsfunktion auf. Du kannst auch den Event ohne Parameter feuern und dabei eine globale Variable (kann natürlich auch So sein) setzen, in welchem das entsprechende Unternehmen hinterlegt wird. So mache ich das meist. Christoph

https://groups.google.com/g/google-admob-ads-sdk und hier mal gefragt?

Hallo, Selber kann man keine Themen Löschen. Aber man sollte wenn man eine Lösung gefunden hat die Lösung im Thema Posten. Dann haben Leute mit dem selben Problem auch etwas davon. PS. Eigentlich wollte ich eine Lösung für das Problem Posten, macht nun ja auch keinen sinn mehr, außerdem wenn man weiß, dass es gelöst wurde braucht man sich die Arbeit auch nicht mehr unnötiger weise zu machen. Gruß Jog

Also wörtlich übersetzt sagt dir Unity, dass die Timestamp Werte nicht wie erwartet sind und dass das Video höchstwahrscheinlich nicht richtig abgespielt wird. Wenn ich es richtig sehe, müsste die Meldung gelb sein und nicht rot. Also könnte das Video trotzdem laufen. Wie auch immer. Beim Umwandeln nach H.264 ist etwas schief gelaufen. Es könnte sein, dass Handbreak noch ein paar Einstellungsmöglichkeiten hat, die du probieren kannst. Es kann aber auch sein, dass man nur schlecht oder gar nicht von H.265 nach H.264 umwandeln kann. Es ist ja oft so, dass neuere Versionen irgendwelche Datenformate nicht zurück gewandelt werden könne, weil in ihnen Infos drin sind, die bei alten Formaten einfach nicht berücksichtigt werden. Ich würde an deiner Stelle mal ein Videobearbeitungsprogramm wie z.B. Premiere versuchen. Solche Programme müssten in der Lage sein alles zu wandeln bzw neu zu erstellen. Wenn aber das VR an sich eine Sache ist, die in H.264 nicht existiert, dann wird's nix! Versuch macht kluch!

Ich habe den Thread jetzt nicht noch einmal gelesen, aber ich kann mich erinnern, dass in dem Thread eine Stelle gab in der Stand das man das bei allen machen muss....kann mich auch täuschen.... Aber danke für deinen Beitrag. Bin mir sicher irgendeiner wird froh sein das es mal einer gelöst hat Es gibt einfach zu wenig Beiträge in deutsch und nicht alle können englisch...

Hallo, hier ein Zeitraffervideo vom Bau der Burg des Barons. Das Modell ist noch nicht fertig. Im Augenblick werden Erdlöcher ausgehoben, Marmor zum Bauort getragen und dann von den entsprechenden Arbeitern die Teile der Burg errichtet.

Empfehle ich dir nicht...sicher hat Unity so seine Eigenheiten, aber es ist für dich eine Plattform auf dem du aufbauen kannst. Erstelle doch einfach mal ein 3D Objekt und bewege es mit den Tasten Dann bewegst du es z.B. über Sin/Cos Dann fängst du an mit Arrays und erstellst GameObjekte die in diesem Array gespeichert werden Dann gehst du das Array durch und löscht das Objekt aus dem "Spielfeld" usw... So lernst du C# und gleichzeitig mit Unity umzugehen... ist meine Meinung...ich empfehle jedem Anfänger mal Snake zu programmieren. Du hast da so ziemlich alles was ein Spiel ausmacht. Ein Spielfeld...Futter für die Schlange...die Schlange die sich bewegt. Mache dir Gedanken wie der Computer es schafft die Schlange zu zeichnen und zu bewegen....einfach mal anfangen.

Das große Problem am "Programmieren lernen mit Unity" ist, dass du dabei 2 Dinge lernen musst/willst. Das Eine ist das Programmieren selbst. Also quasi eine Sprache zu erlernen. Aber eben nicht nur die Vokabeln sondern auch die richtige Anwendung. Das Andere ist die Besonderheit in Unity, die Objekte, Module und Funktionen zu steuern und Informationen über sie abzufragen. Wenn man sich Tutorials für Unity anschaut, dann wird mehr oder weniger das Können der Programmiersprache vorraus gesetzt und es geht meist nur um die Besonderheiten in Unity. Diese sind zwar alle mit der Programmiersprache verzahnt, aber sie sind eben Obendrauf! Wenn man das Programmieren nicht verstanden hat, kommt man mit den Besonderheiten in Unity nicht weit. Deswegen würde ich empfehlen entweder erstmal nur die Grundlagen des Programmierens zu lernen (unabhängig von Unity). Oder aber mit Unity zusammen, aber dann (egal ob das Projekt einem gefällt oder nicht) nach jedem Schritt zu schauen, ob man verstanden hat was da passiert. Einfach mal eine ähnliches Szenario aufbauen und das Gelernte gleich anwenden. Auch wenn es erst einmal sinnlos erscheint. Schritt für Schritt! Aber das musst du machen! Es einfach nur abtippen um dann zu sehen, dass es bei dir genauso funktioniert reicht nicht. Du musst es zerlegen und analysieren. Es wird dann bestimmt irgendwann Klick machen. Und dann ist alles klar! Es wird immer Dinge geben, die du erst mal nicht verstehst. Aber du wirst mit jedem Mal schneller zur Lösung kommen. Und dann kannst du das Wissen auf alles was du willst anwenden. Du bist bestimmt nicht dumm. Es hat einfach nur noch nicht "klick" gemacht!

Programmieren....programmieren...und wieder und immer wieder programmieren. Das ist der einzige Weg die Programmierung zu erlernen und ab und zu tut es gut mal ein paar Tage nicht zu programmieren damit die Synapsen Zeit habe sich zu verknüpfen 😃

Was ich ja sogesehen damit getan habe... Die Liste könnte bis ins unendliche gehen. Deswegen weiß ich nicht ob das so sauber ist. malzbie meinte damit die tatsächlichen Layer. Wenn du die sortingOrder-Eigenschaft genommen hast, ist das schon völlig in Ordnung so. In dem Moment, wo du mit einem Laufindex auf deine Liste zugreifst, solltest du keine LinkedList mehr nehmen. Kann gut sein, dass einige LinkedList-Implementationen deshalb gar keinen Index-Zugriff erlauben. Nimm einfach ne normale Liste. Wenn du nicht zehntausende Elemente hast, bringt dir ne LinkedList keinen Performance-Vorteil. Ich nenne die inzwischen "MonoBehaviour-Events", und ich glaube das machen viele so. Mach selber nen Raycast (oder vermutlich eher Physics2D.OverlapPointNonAlloc) und filtere dir dann das Objekt mit der höchsten sortingOrder raus.

Also: Ich würde dir empfehlen, nicht die Kapseln direkt zu animieren, sondern sie jeweils in ein Empty-Object rein zu tun. Dieses Empty animierst du dann für die Bewegungen! Jede Empty, also jede Kapsel bekommt einen eigenen Animator mit allen Animationen da drin verpasst. Nicht eine Animationsspur fürs steuern zweier unabhängige Objekte nutzen. Ds bedeutet aber nicht, dass du nicht auch Animationen für mehrere Objekte nutzen kannst. Du kannst schon Animationen erstellen, die in allen Animatoren genutzt werden können. Wie z.B. der Einflug der linken und rechten Kapsel. Die beginnt ja irgenwo unten und geht bis zu einer gewissen Höhe im Screen. In der Animation animierst du dann also nur die Y Achse. Wenn jetzt also das Einflugevent in beiden Animatoren gestartet wird, z.B. per Trigger, dann fliegen beide Kapseln in den Screen hinein. Egal wo sie sich auf der X Achse befinden, du animierst ja nur Y. Da du indeinem Fall aber auch irgendwann die andere Achse animieren willst, würde ich das dann doch nicht so machen, sondern wirklich separate Animationen erstellen und auch keys für alle Achsen erstellen.. Wie dem Auch sei. Das Empty wird animiert, die Kapsel selber wird nur mitgenommen. Sollte jetzt eine der Kapseln zerstört werden, dekativierst du einfach die Kapsel und schon ist sie nicht mehr sichtbar und treffbar. Wärend des Deaktivierens, blendest du an selber Stelle ne schöne Explosion ein. Das EmptyObject ist noch da, und kann machen was es will, man sieht es eh nicht.

Hallo, meine Überarbeitungen jetzt nochmal in einem kleinen Video beschrieben.

Jaaa, gib her, da kann man ja nicht nein sagen

Bei 3D Objekten, die in einem 3D Programm, wie z.B. Blender erstellt wurden, kommt die Position des Achsennullpunktes von dem Ersteller selbst. Den kann man in Blender usw. hinschieben wo man will und man kann ihn natürlich auch drehen und somit bestimmen was oben und was vorne ist. Bei den Grundobjekten von Unity ist das nicht so, da ist das Dingen wo es ist. Was du aber machen kannst: Erzeuge ein EmptyObject und ordne den Grundkörper diesem Empty unter. Die Transformwerte, die du jetzt bei dem Grundkörper siehst, sind Werte im Bezug auf den Vater. Schreibst du bei der Position 0,0,0, dann ist das Grundobjekt genau am Punkt des Empty. Du kannst jetzt also das Grundobjekt, also das Kind des Empty so verschieben, dass der Nullpunkt des Empty z.B. am unteren Rand des Kindes ist. Gibts du jetzt nicht dem Grundobjekt einen Collider und Rigidbody, sondern dem Vater, also dem Empty, dann ist der Vater das entscheidende, wenn es um Kollisionen und Kräfte geht. Das KindObjekt ist nur fürs aussehen da. Übrigens, du kannst im Szeneview oben in der Leiste einstellen, welchen Nullpunkt du sehen willst. Entweder den Zentrierten, oder den Wirklichen. (Global oder Local). Um den echten Nullpunkt zu sehen (Bei importierten Objekten, wie oben beschrieben) musst du auf Local gehen. Bei den Grundkörpern und einem EmptyObject ist sind beide Punkte natürlich identisch.

Moin, bei dir scheint der neue Input Manager aktiviert zu sein. Input.GetButton("...") ist aber InputManager(Old). Das kannst du hier ändern:

Gehste Window -> Packagemanager Wenn der auf ist, dann oben wo wahrscheinlich Packages:In Project steht, mal drauf klicken und dann Unity Registry auswählen. Jetzt sollten alle möglichen Packages zu sehen sein. Inputsystem suchen, anklicken und dann unten rechts auf Install klicken.

Freut mich sehr Ich muss das Lob aber auch zurück geben. Deine Fragestellungen sind sehr gut und ausführlich, und haben immer alle wichtigen Infos mit drin. Da muss man nicht raten, und das macht es sehr recht einfach, dir zu helfen

Ich verlinke Mal auf meine Antwort in einem anderen Thread: Meine Variable "velocity" ist ein Feld, also eine Variable, die Teil des Objekts ist. Deine Variable "movedirection" ist eine lokale Variable, die aufhört zu existieren, sobald die Methode (also Update) durchgelaufen ist. Es wird daher kein Wert von diesem Update in das nächste übernommen.

Moin! Ich erkläre einfach mal (TL;DR weiter unten). So sieht eine Variablendeklaration aus: Typ name Damit sagst du, dass ein Stückchen Speicher klargemacht werden soll, um da etwas reinzuspeichern. Was da reinkommt (ne Zahl, ein Satz, eine Referenz auf ein Objekt...), wird von "Typ" definiert. Der "name" ist dazu da, um ihn woanders im Code zu benutzen, um damit zu sagen, dass man genau diesen Wert auslesen oder ändern will. Wenn du eine Variablendeklaration in ein Objekt packst (also in einen class-Block, aber außerhalb der darin enthaltenen Methoden), dann wird es diese Variable so lange geben wie das Objekt, in dessen Klasse sie deklariert ist. Wird das Objekt gelöscht, wird der Speicher frei gemacht und zum Wiederverkauf angeboten. Die Variable gibt es dann nicht mehr. Packst du die Deklaration in eine Methode, dann wird beim Ausführen der Methode die Variable im Speicher erstellt, und wenn die Methode fertig ist, wird die Variable wieder gelöscht. Variablendeklarationen kann man erweitern, z.B. indem man der frischen Variable direkt einen Wert zuweist. Typ name = wert; Das ist das, was du in Start machst. Es ist eine Kombination aus einer Deklaration und einer Zuweisung und nennt sich "Initialisierung". Das bedeutet aber, dass du hier eine neue Variable deklarierst. Die heißt zwar genau wie deine Variable etwas weiter oben in der Klasse (nennt sich dann "Feld"), ist aber eine andere, neue Variable (nennt sich "lokale Variable", da in einer Methode deklariert). Kann auch gut dein dass dir deine IDE da gelb unterstreicht und dich darauf hinweist, dass hier Verwechslungsgefahr mit der anderen Variable besteht, weil sie denselben Namen hat. (Ab hier das TL;DR:) Was du eigentlich machen willst, ist keine neue Variable zu deklarieren, sondern der bestehenden Variable einen Wert zuweisen. Du musst dafür aus der Initialisierung eine normale Zuweisung machen, also die Deklaration entfernen. Kurz: statt Building Bakery = new Building(); machst du Bakery = new Building(); Damit meinst du dann die bereits in der Klasse deklarierte Variable. Deine Update-Methode nutzt dieses Feld bereits, aber es kriegt ja aktuell nirgendwo ein Objekt zugewiesen, da Start das Objekt in "seine eigene" Variable packt.

Moin! Wenn du da nicht noch einen Rigidbody drauf hast, der Faxen macht, dann sollten da keine (G-)Kräfte sein. Was du beschreibst, klingt am ehesten nach "ist nicht grounded" und dann fliegt man komisch auf Bodenhöhe durch die Gegend, aber da ich da keine horizontale Beschleunigung in der Luft sehe, ist das eher auch raus. Ich sehe den Fehler gerade nicht direkt, aber hier ein paar Tips zum Aufräumen, vielleicht hilft das schonmal: Du benutzt einen CharacterController - nutze gerne dessen isGrounded-Eigenschaft, anstatt selber zu checken. Ist meist verlässlicher. Immer nur einen CharacterController.Move-Aufruf pro Update. Für Dinge, die nicht linear, aber wichtig für's Gameplay sind, FixedUpdate statt Update nutzen.

Hallo Sascha, vielen Dank für die schnelle und umfangreiche Antwort. 👍🏼👍🏼👍🏼 Ich werde mir die Links und die empfohlenen Möglichkeiten mal in Ruhe ansehen und melde mich dann ob es so geklappt hat oder obs noch Fragen gibt...

Schon etwas her mit Photon, dass ich mal benutzt habe, aber in PUN2 soweit ich weiß, gibt es keine serverseitigen Sachen, weil ja Cloudbasiert ist, allerdings gibt es ein MasterClient (der diesen Lobby/Raum erstellt hat). Kannst mich gerne besseres belehren, weil ist schon auch lange her. Wenn es nicht automatisch synchronisiert wird, bist du dafür zuständig. Man kann RPC Methoden verwenden oder die Serializationsysteme mal anschauen, ob auch andere Wege gibt. Dein Grundgedanke muss so sein, dass, wenn ein Spieler etwas SELBER tut, dass auch bei anderen, die wichtigen Sachen genauso passieren muss. Beispiel, wenn du z.B. ein Item zu einem Slot bewegst, dann könntest du sowas wie SetItemSlot(slotId, item) als RPC machen. Die Bewegung des Items ist ja egal, aber das Setzen des Slots ist ist wichtig. Ab da sollte meist für jeden Spieler gleich sein. Spieler weiß über den SlotId bescheid, weiß um welches Item es geht. Kann also bei sich im Spiel im SetSlot den Slot mit Item versehen. Und schon sollte bei jedem synchron ablaufen. Sollte es so sein, dass auch Spieler nachträglich dazu kommen, müssen nur einfach die aktuelle Liste mit den Informationen gesendet werden. Ich weiß jetzt nicht, ob bei Photon sowas automatisch gibt. Aber dies auf jeden Fall über den Masterclient tun.

Moin! Du kannst dein Animation Window auf "Curves" umstellen, um die Tangenten deiner Keyframes zu bearbeiten. Aktuell sind sie horizontal, müssten aber parallel zur Kurve sein. Hier gibt's was zu lesen: https://docs.unity3d.com/Manual/animeditor-UsingAnimationEditor.html

Okay ... habs nun hinbekommen ... ich musste bei der Fragment Node in den Graph Settings im Grpah Inspector das Material auf "Sprite Custom Lit" stellen ... warum auch immer ...

Ein Smartphone selbst kann keine Videos aufzeichnen, sondern die Apps tun das in dem sie auf das Bild und Ton zugreifen. Das heißt du musst selber schreiben, wie du ein Video aufnehmen willst. Dafür gibt es bestimmt Libraries. Z.B. AVPro Movie Capture, aber kostet 200 Euro und ist für mehr komplexere Sachen gedacht.Das einzige was Unity tatsächlich eingebaut hat sind Screenshots. Wenn du selber wagen willst kannst du Mit Texture die Pixel form screen lesen. Das tust du ganz Zeit und packst dann in eine Liste. Ab da musst du mal schauen, was so man so benutzen kann um daraus ein Video zu machen. Mir fällt da spontan nichts ein.

@Sascha Danke für den Tipp. Gut zu wissen. Dann werde ich das auch nicht mehr verwenden 😅 @Peanut Auch ein Danke an Dich für deinen Tipp. Es funktioniert jetzt 😄 Leider war ich erstmal etwas verzeifelt, weil es meine XML Datei nicht finden wollte. (Deshalb hab ich bisher AssetDatabase verwendet.) Durch die Documentary hab ich dann endlich festgestellt, dass ich einen extra Resources Ordner brauche, wo ich den Ordner mit der Datei reinziehen muss. Dann hat es funktioniert und ich bin mehr als nur froh darüber ✌️😅

using UnityEditor; Du kannst diesen Namespace nicht in Scripts benutzen, die im Build landen. Es gibt die UnityEditor.dll in Builds schlicht nicht, deshalb kannst du sie dort auch nicht benutzen. AssetDatabase fällt damit raus.

Also ist deine Szene irgendwie kaputt gegangen? In dem Fall wäre eine NullReferenceException keine Überraschung - Objekte, die von anderen Objekten gebraucht werden, fehlen. Die anderen Objekte sind dann "unzufrieden", dass die referenzierten Objekte weg sind. So "Knopf X öffnet Tür Y" + "Tür Y ist weg" = "Knopf X weiß nicht, was er tun soll". Warum deine Szene kaputt ist, kann ich nicht sagen. Vielleicht vergessen zu speichern, vielleicht irgendein Plugin installiert, das Mumpitz macht. Für solche Fälle ist Versionierung ganz praktisch, aber das muss man auch erstmal lernen. Du musst jetzt jedenfalls deine Szene reparieren. Du hast irgendwo eine "Grid"-Komponente, die ein "ShapeStorage" referenziert. Diese Referenz (das, was du im Inspektor einstellst), ist kaputt. Eventuell, weil dein ShapeStorage-Objekt weg ist.

Hab den Fehler gefunden. Weil im Tutorial viele Variablen, Datentypen und Dateinnamen gleich sind, hab ich ein paar Dinge verwechselt. Das Verküpfen und Einlesen der XML Datei funktionieren jetzt 🥳 void Start() { ImportQuestions IQ = ImportQuestions.Load(sPath); //For each item in the List "item" foreach(QuestionsStructure Q in IQ.items) { //UnityEngine.Debug.Log(Q.index); print(Q.iIndexQuestion); } } [XmlRoot("QuestionCollector")] public class ImportQuestions { [XmlArray("Questions")] [XmlArrayItem("Q")] public List<QuestionsStructure> items = new List<QuestionsStructure>(); public static ImportQuestions Load(string sPath) { TextAsset _xmlFile = AssetDatabase.LoadAssetAtPath<TextAsset>("Assets/XML/Questions.xml"); XmlSerializer serializer = new XmlSerializer(typeof(ImportQuestions)); StringReader reader = new StringReader(_xmlFile.text); ImportQuestions item = serializer.Deserialize(reader) as ImportQuestions; reader.Close(); return item; } }

Hallo Ich habe ein Prefab, welche ich zur Laufzeit mit Instantiate() erzeuge. Das klappt alles ohne Probleme. Wenn ich allerdings zwei oder mehr Objekte erstelle und bei einem davon Werte ändere, ändern sich diese auch bei den ebenfalls erstellten Objekten. Ist das so gewollt oder habe ich ein Wahrnehmungsproblem und der Fehler liegt ganz woanders? Stimmt nicht, habe es praktisch in dem Moment entdeckt, als ich auf Absenden geklickt habe. Fehler muss bei mir liegen. Sorry. Christoph

Ah, jetzt verstehe ich's. Da hast du was vor. Ich haue jetzt ersteinmal ein paar Links aus der Dokumentation für dich rein: LOD: https://docs.unity3d.com/Manual/LevelOfDetail.html Graphics Performance: https://docs.unity3d.com/Manual/graphics-performance-profiling.html Render Pipelines: https://docs.unity3d.com/Manual/render-pipelines.html Jetzt zu den Links ein wenig Text: LOD ist klar, denn da findest du die Infos, wie es funktioniert und wie es eingestellt wird. Unity hilft dir bei der Erzeugung der Meshes leider nicht. Die Objekte musst du selber in einem 3D Programm deiner Wahl erstellen und via FBX nach unity bringen. Hast du die Dateien aber richtig benannt, baut unity dir dann gleich eine LOD Gruppe zusammen. Bei Graphics Performance geht es natürlich darum, was wieviel Leistung kostet und wie du das Ganze optimieren kannst. Gerade bei den Drawcalls kann man viel einsparen, wenn man weiß, wo man schrauben muss. Hier ist noch so ne Art Tutorial, welches dir helfen könnte. https://learn.unity.com/tutorial/optimizing-graphics-in-unity# Bei Render Pipelines geht es um die unterschiedlichen Renderer, denn Unity hat 3! Ich würde dir empfehlen, falls du es nicht schon eingestellt hast, dass du auf die URP (Universal Render Pipeline) wechselst. Die ist gerade für leistungsschwache Geräte optimiert. Da kommst du garnicht erst in Versuchung, irgendwelche Dinge zu nutzen, die das System überlasten. Jetzt noch zu deiner Hecke. Die ist natürlich ein Klopper! So wie ich es sehe, hast du da jede Menge Flächen, die alle teilweise transparente Grafiken drauf haben. Also ausgestanzte Blätter und Äste. Das ist nicht gut, denn diese überlagernden Transparenzen kosten viel Leistung. Muss es eine Hecke sein? Geht nicht auch ein Zaun? Du musst leider deine Erwartungen etwas runter schrauben. Und du musst dich langsam hoch tasten. Nimm die Hecke ersteinmal komplett aus der Szene raus und baue die wichtigsten Dinge. Nutze die Stats die du oben im Gameview ein- und ausblenden kannst: https://docs.unity3d.com/Manual/RenderingStatistics.html Nutze dann noch den Profiler um in die Details zu gehen. https://docs.unity3d.com/Manual/Profiler.html Der Profiler ist nicht so leicht zu verstehen, weil er dich mit Infos erschlägt. Den kannst du auch erst einmal ignorieren. Die Stats zeigen dir schon recht gut, was da los ist. Tja. Für leistungsarme Geräte zu bauen ist schon nicht leicht, wenn es dann auch noch VR ist, ist es doppelt so schwer. Jetzt hast du erst einmal was zu lesen. Mit all diesen Schlagwörtern findest du bestimmt auch gute Tuts bei Youtube.

Ich verstehe gar nicht, warum die Quest sich aufhängt. Das ist doch eigentlich nur ein Anzeigegerät, oder habe ich da was verpasst. Es ist ja so, dass die Quest im Endeffekt 2 hochauflösende Monitore sind. Es werden 2 Bilder über 2 Kameras erzeugt, die deine Augen simulieren und somit Stereo-Sehen ermöglichen. Da das alles Mal 2 ist, ist natürlich die Menge der berechneten Daten doppelt so groß wie am normalen Monitorl. Und irgendwann macht die Garffikkarte dann dicke Backen. Aber aufhängen sollte sich das System eigentlich nicht. Ich habe jedoch keine Erfahrung mit der Quest. Trotzdem. Es gilt so wenig Polygone wie möglich in der Szene zu haben und die Drawcalls so gering wie möglich zu halten. Das gilt immer, egal ob mit Quest oder ohne. Ein Nebel wird nicht viel helfen, denn der ist meist eine Nachbearbeitung des Bildes, also en Post-Effekt. Die Polygone sind dann schon berechnet. Was du aber machen kannst, ist LOD (Level of Detail) zu nutzen. Dabei brauchst du aber vom den Objekten mehrere Versionen, je nach dem wie viele Detailstufen du nutzen willst, sind es mehr oder weniger. Der Sinn dahinter ist der, dass ein weiter entferntes Objekt mit viel weniger Polygonen dargestellt wird, als das nahe Objekt. Weit entfernte Objekte sind kleiner zu sehen und die Details sind meist nicht mehr zu erkennen, deswegen kann man sie auch weg lassen. Je weiter das Objekt weg ist, umso weniger Polygone braucht man und das weiteste noch sichtbare Objekt kann dann sogar ein Bilboard sein, also einfach eine Fläche mit Foto des Objektes. Das wird z.B. in all den Spielen so gemacht, die viel Landschaft zu sehen haben. Sind die LOD-Stufen zu gering gewählt, sieht man meist ein Aufploppen der Objekte. Sind es ausreichend Stufen, fällt das nicht auf. Das ist natürlich viel Arbeit. Das Sichtfeld der Kameras zu verringer macht eigentlich keinen Sinn, weil dann die Immersion eingeschränkt wird. Aber von der Logik her ist ein kleineres Bild oder ein Bild in geringerer Auflösung immer schneller zu berechnen, als ein hochauflösendes, großes Bild. Das ist ja genau Teil deines Problems. Du hast doppel so viele Pixel, wie der Normalo an seinem Monitor, weil du 2 Bilder berechnen musst. Ich würde dir empfehlen einfach mal raus zu kriegen, wieviele Polygone denn da sein dürfen bis du auf deinem System Leistungseinbußen bemerkst. Also legst du immer neue Objekte mit durchschnittlichen Materialen/Shadern in dein Sichtfeld und guckst mal ab wann es einbricht. Diese Anzahl der Polygone ist dann deine Referenz, unter der du drunter bleiben musst.

Ja, man kann Licht und Schatten berechnen/backen. Das geht aber nur bei Objekten die Static sind, also sich nicht mehr im Raum bewegen. Dann gibt es noch Reflection Probes und Light Probes, die dir bei bewegilchen Objekten helfen können. Das alles kann ich nicht auf die Schnelle erklären, weil das ein großes Feld ist. Schau dir dazu mal die Dukumentation von Unity an und such mal nach Tutorials. Ein Material/Shader aber komplett vorzuberechnen geht so nicht, denn du willst dich ja in der Szene bewegen. Du musst halt schauen was für einen Shader du nutzen willst. Es gibt ganz einfache Shader, die nur den Texturkanal haben nicht glänzen oder spiegeln. Es gibt die Unlit Shader, die von selbst leuchten, also keine Lichtquelle nutzen. Dann kannst du sagen ob sie Schatten empfangen sollen oder nicht und ob sie schatten werfen oder nicht. Und noch vieles mehr. Übrigens: Die Quest berechnet das nicht. Sie zeigt es nur an. Das sind einfach nur 2 Kameras, die beide in einer gewissen Auflösung das Bild für deine 2 Guckeäugelchen aufnehmen und auf die 2 internen Monitore geben. Es wird also doppelt soviel Info verarbeitet und erzeugt, als wenn du mit einem normalen Monitor, der selben Auflösung das Spiel spielen würdest. Deswegen ist die Anzahl der Objekte und Polygone so wichtig. Und das wird dann mit den Lichtquellen Schattenwerfern und Shadereffekten nochmals multipliziert. Also Backe dein Licht und deinen Schatten und sei sparsam mit den Polygonen, Objekten und Effekten.

Hallo, jedes RPG Spiel benötigt an einer bestimmten Stelle ein Dungeon. Also habe ich mich heute mal rangemacht und einen Dungeon erstellt. Der Spieler muss durch diesen hindurchlaufen, da der eigentliche Weg an der Oberfläche durch einen Erdrutsch verschüttet wurde. Das Labyrinth ist noch nicht komplett fertig. Es fehlt noch an Interieur und Gegnern. Des Weiteren sind viele Gänge versperrt und müssen durch Schlüssel, die der Spieler finden muss, versperrt.

Hallo, heute möchte ich euch ein kleines Video vom Fantasiewald und ein paar neue Skills zeigen. Zwei neue Gegner (Steingolem und Ent) sind auch schon dabei. Download der Version 0.2.0: http://https//www.pchobbyspieleschmiede.de/orfaya/Orfaya%200.2.0.zip

Ist es möglich, dass jemand diese Zeile erklärt? Ability _ability = UnityEngine.Object.Instantiate((Ability)Resources.Load(_abilityName, typeof(Ability))) as Ability; Finde es schade, dass man auf alles genau eingeht und dann so eine Monsterzeile einfach unkommentiert lässt.

@Helishcoffe Oder halt Gizmos.DrawWireCube bzw Handles.DrawWireCube