Jump to content
Unity Insider Forum

Leaderboard


Popular Content

Showing content with the highest reputation since 05/27/2019 in all areas

  1. 2 points
  2. 2 points
    Was ich noch dazu sagen möchte: PlayerPrafs sind nicht dazu da, wie Variablen gehandhabt zu werden! Man liest die Werte mit Get aus und speichert sie in Variablen. Mit diesen Variablen wird dann gearbeitet, nicht mit den Playerprefs direkt. Erst wenn es Zeit ist, die Variablen auf die Platte zurück zu schreiben, weil jetzt das Spiel beendet wird oder ein Szenenwechsel stattfindet , werden sie mit Set geschrieben. Du machst mit der ws3FasterShooting komische Dinge. Du liest mit GetInt das Playerpref w3sFS aus und übergibst sie dieser Variable. Hat sie z.B. den Wert 1, dann soll sie in der Funktion den Wert 2 bekommen. Anstatt du aber jetzt ws3FasterShooting direkt beschreibst, speicherst du den Wert in w3sFS, nur um ihn direkt wieder auszulesen und der Variable ws3FasterShooting zu übergeben. Das ist schon mal nicht so dolle. Aber dein Problem, was da jetzt entsteht, ist: ws3FasterShooting hat jetzt den Wert 2 und somit ist die Bedingung für die nächste If Abfrage erfüllt. Da drin bekommt die Variable jetzt den Wert 3 und nun ist auch die Nächste If Abfrage erfüllt! Also entweder drehst du die If-Abfragen um, fängst also mit der Abfrage 3 an, dann die 2 dann die 1, denn kleiner kanns ja nicht werden, oder aber du nutzt else if. if(wert==1){ // ich bin 1 also mache was } else if(wert==2){ // ich bin nicht 1, ich bin 2 also mache was anderes } else{ // ich bin weder 1 noch 2 also mache das was noch übrig bleibt }
  3. 2 points
    Allem voran der übliche Hinweis dass hier keiner Anwalt ist und keiner dir eine richtige Rechtsberatung geben kann. Eigentlich kannst du nicht einfach geistiges Eigentum von anderen nehmen und für dein eigenes Werk verwenden. Da gibt's den Urheber des Werkes und den Rechteinhaber, von denen mindestens einer dir die explizite Erlaubnis geben muss. Etwas in Richtung Grauzone geht's dann bei Fair Use. Das ist amerikanisches Recht, nachdem du die Erlaubnis der Rechteinhaber nicht mehr brauchst, wenn du bei der Verwendung der Werke bestimmte Kriterien erfüllst. Unter anderem können Parodien darunter fallen. Das ist aber kein Recht, das weltweit gilt, und von einem deutschen Äquivalent wüsste ich nichts. Da müsste man dann auch mal schauen, ob die Rechte gelten, in denen du sitzt, in denen du vertreibst oder in denen die Rechteinhaber sitzen. China z.B. gibt kein Stück auf westliches Copyright. Entsprechend kopieren da alle wie wild alles mögliche, weil die Regierung da kein Problem mit hat. Was wollen westliche Firmen auch tun, außer Lobbyarbeit zu leisten, sodass die Politiker Sanktionen gegen Chin....oh. Der ganze Kram mit dem (internationalen) Urheberrecht ist ein wildes Dickicht aus völlig verschiedenen Rechtssystemen, von denen jedes einzeln genommene schon immer komplett undurchsichtig ist. Das ist ja auch das Problem mit Artikel 13/17... Nichtmal Anwälte schaffen es, da definitive Antworten zu gebe, geschweige denn irgendwelche Algorithmen. Aber egal. Meine Empfehlung ist: Lass es sein. Selbst, wenn es theoretisch Möglichkeiten gibt - mit der Verwendung anderer Leute geistigen Eigentums begibst du dich immer in eine Welt des Schmerzes.
  4. 2 points
    Hast du das auch wirklich so gemacht, wie der Sascha es geschrieben hat? Einem GameObjekt untergeordnet und dann das Vaterobjeket auf 1,1,0 skaliert???
  5. 2 points
  6. 2 points
    Hi, ich habe in den letzten zwei Jahren immer wieder an einem Flüssigkeit Simulations Shader gearbeitet und seit Mitte letzten Monats ist er jetzt im AssetStore erhältlich. Mit Fluid Flow kann man in Echtzeit simulieren wie beispielsweise Blut oder Farbe an einer Oberfläche herunter fließt. Es ist keine 100% physikalisch korrekte Simulation, sondern das Asset versucht mit möglichst geringen Performance Einbußen überzeugend Flüssigkeit zu simulieren. Dazu werden die Berechnungen mithilfe eines Compute Shaders auf die Grafikkarte ausgelagert. Compute Shader benötigen allerdings mindestens DirectX 11 oder OpenGL 4.3 support! Zudem sind Android und iOS momentan nicht unterstützt! Fluid Flow Echtzeit Flüssigkeit Simulation dynamisches Anpassen der Flussrichtung unterstützt animierte Objekte Tropfen* * werden asynchron von der GPU zur CPU gelesen. Dieses Feature gibt es erst seit Unity 2018.2, und mit OpenGL wird es nicht unterstützt! Demo (win): https://drive.google.com/drive/folders/1ewcJn2Cc56Pcg3IVXPgvDDYucfRrU2mg Asset Store: https://assetstore.unity.com/packages/vfx/shaders/fluid-flow-143786
  7. 2 points
    Ich muss da Jomnitech zustimmen du machst dir das leben schwerer als es sein muss. Stell dir vor du willst die Scallierung der Buttons ändern das dauert dann wieder unnötig lange. Ich würde tatsächlich mit den Unity Buttons mit verändertem Sprite arbeiten. Aber wenn du das tatsächlich so machen willst schau dir mal die Erweiterung: TextMeshPro im Unity Store an. (ist for free) Damit haste mehr UI-Optionen als in Vanilla Unity vielleicht geht es mit dem Tool besser. LG Peanut :3
  8. 1 point
    Ach, die Geschichte... Richtig. @Thariel Du hast natürlich Recht: Ein bewegtes GameObject ist nicht sofort an seiner neuen Position, sondern erst nach Ende des Frames. Da ein verschobenes Objekt letztendlich einiges mehr an Konsequenzen nach sich zieht, als man erwartet, arbeitet Unity alle Änderungen in der Szene in einem Rutsch ab. Dadurch müssen Dinge nicht doppelt und dreifach gemacht werden, wie es der Fall wäre, wenn diese Dinge nach jeder Transform-Änderung gemacht würden. In deinem Fall ist das natürlich schlecht. Du kannst diese Änderungen aber manuell auslösen, und zwar mit Physics.SyncTransforms. Das rufst du einfach nach dem Verschieben auf. Damit umgehst du zwar diese Optimierung, die es nicht ohne Grund gibt, aber wie immer gilt: Performance ist erst dann ein Thema, wenn es zum Problem wird. Optimalerweise würdest du dir eine eigene Datenstruktur bauen, die das Feld repräsentiert, und das ganze nicht über die Physik-Engine machen, aber wenn dein Spiel nicht zu groß ist, ersparst du dir mit dieser Methode einiges an Ärger. @Jomnitech Er löst den Raycast in Update aus - das heißt nicht, dass er das jeden Frame macht. FixedUpdate ändert hier auch nichts.
  9. 1 point
    Mit riesigen Zahlen kann Unity nicht umgehen, weil 32-bit floating point numbers im Koordinatensystem verwendet werden. Im Millionenbereich kann dir bereits die erste Nachkommastelle flöten gehen. Im 10-Milliarden-Bereich gibt's schonmal Ungenauigkeiten im dreistelligen Bereich. Aber davon mal abgesehen: Wenn dein Objekt auf die gegebene Distanz zu klein ist, um gesehen zu werden, dann ist es zu klein, um gesehen zu werden. Wenn dein Objekt plötzlich größer ist, hat es ja nicht mehr die richtige Größe. Du schaust ja auch nicht in den Nachthimmel und beschwerst dich, dass du Deimos nicht erkennen kannst.
  10. 1 point
    Ja, du musst jetzt noch die Keys in ihrer Eigenschaft anpassen. Die sind natürlich ersteinmal smooth. Klicke mit rechts auf den 2 Key, der abgehackt kommen soll und wähle Left Tangent - Constant . Jetzt sollte die Animation zu diesem Key hin so sein, wie du es wolltest. Wenn du die Animation nicht im Dope Sheet Modus sondern im Curves Modus anschaust, siehst du auch genau was da passiert.
  11. 1 point
  12. 1 point
    Darauf gibt es leider keine eindeutige Antwort. In C# gibt es ja, im Gegensatz zum nahen Verwandten Java, Properties. Das bedeutet in diesem Kontext, dass eine Zuweisung wie deine beliebig viele Seiteneffekte haben kann. Beim Setzen von transform.localScale könnten z.B. irgendwelche Hintergrund-Datenstrukturen der Szene neu berechnet werden - was genau passiert, könnte dann wiederum davon abhängen, ob du einen Renderer und/oder einen Collider auf dem GameObject hast. Kann natürlich auch sein, dass die Property schlau genug ist, gar nichts neu zu berechnen, wenn der neue Wert sowieso dem alten entspricht - so, wie du es oben vorschlägst. Nur eben in der Property anstatt außenherum. Leider gibt es keinen Weg, da einfach mal hineinzuschauen, wenn du keinen Source Code-Zugriff hast. Unity hat da in den letzten Jahren verstärkt optimiert, aber was genau da passiert... keine Ahnung. Es gilt also wie immer: Mach dir keinen Kopf um Performance, lass einfach ohne großen Drumherum den Code laufen und kümmer dich um Framerate, wenn sie anfängt, ein Problem darzustellen. In Sachen Code-Qualität würde ich sagen: Die beiden Varianten geben sich nicht sonderlich viel.
  13. 1 point
    Die Textur wird so groß in den Speicher geladen, wie sie ist. Die Skalierung in den Import Settings (und in der Transform-Komponente) haben darauf keinen Einfluss. Du kannst allerdings in den Import Settings auch eine Maximalgröße per Plattform festlegen, und das ist dann wirklich die Größe des Textur-Assets, wie es in den Build gepackt wird. Bei Texturgrößen gilt: So groß wie nötig, so klein wie möglich.
  14. 1 point
    Für Echtzeit-Daten verschlüsselst du nicht großartig. Da schickst du nur das hin, was der Client behauptet. Der Server hat immer das letzte Wort und setzt sich ggf. über die Aussagen des Clients hinweg. Sensitive Daten verschickst du da ja auch nicht wirklich. Verschlüsselung wird erst interessant, wenn du sensible Daten (Login-Daten) versendest oder es schwieriger machen willst, bei bestimmten Sachen zu schummeln, z.B. bei Highscores. Für diese Sachen benutzt du kein UNet (und auch nichts vergleichbares), weil diese Bibliotheken für Echtzeit-Datenaustausch da sind. Wenn du einmalig etwas zum Server schickst, wie Login-Daten oder Highscores, dann nutze einfach https.
  15. 1 point
    Für @Peanuts Idee brauchst du das eigentlich genau nicht. Ich weiß nicht, ob sie überhaupt funktioniert, aber deshalb finde ich die Idee sogar ganz gut. Geschwindigkeit vom Mittelpunkt weg oder hin solltest du mit den bereits vorhandenen Modulen hinkriegen. Es geht aber noch viel einfacher. Ist mir gerade aufgefallen, als ich das mal ausprobieren wollte. Du machst einfach bei deinem Partikelsystem "External Forces" an und Packst dir da, wo die Münzen hinsollen, ein "Particle System Force Field" hin. Das lässt du auf den Standardeinstellungen, außer: End Range: Das muss so groß sein, dass alle möglichen Spawnpunkte für Partikelsysteme abgedeckt sind. Gravity: Das kannst du höher einstellen, damit die Partikel stärker zum Mittelpunkt des Force Fields gezogen werden. Drag/Strength: Das stellst du auf etwas höheres als 0, damit die Partikel nicht immer wieder über das Ziel hinausschießen. Denk daran, dass die Sache mit "End Range" bedeutet, dass sowohl die Partikelsysteme, als auch das Force Field im UI-Canvas sein sollten.
  16. 1 point
    Mit den Parameter StartCoroutine(cameraShake.CamShake(.3f, .4f, 4)); sieht es nun so aus: cameraShake.mp4
  17. 1 point
    Das sind ja keine Fehlermeldunge, denn dann wären sie rot. Das sind Hinweise, die immer dann kommen, wenn die Variable private ist. Das System erkennt halt, dass du eine Variable deklariert hast, die aber eigentlich für nix nütze ist. Das wäre bei public variablen zwar nicht anders, aber da das System nicht weiß ob evtl. von einem anderen Script aus etwas damit geschieht, kommt dann eben keine Meldung. So ganz intelligent ist die Meldung nicht, weil sie sowas wie SetActive nicht erkennt. Aber in deinem anderen Beispiel ist maxHealth, wenn du es wirklich nur in der Start zur Übergabe eines Wertes nutzt, auch wirklich sinnlos. Da kannst du auch gleich currentHealth mit dem richtigen Wert beschreiben. Ob man das abschalten kann, weiss ich nicht. Aber selbst wenn nicht, die Meldungen kommen nur, wenn du ein Script bearbeitet hast und dann abspeicherst. Dabei werden all diese Dinge einmal überprüft und dir dann evtl. angezeigt. Danach kommt keine Meldung mehr. Die Meldung macht auch Sinn, da sie dir zu 95% dabei hilft Codeleichen zu entdecken.
  18. 1 point
    Themen löschen gibt's hier nicht. Stattdessen wäre es nett, wenn du deine Lösung für Leute zurücklassen könntest, die irgendwann in der Zukunft einmal dasselbe Problem haben und beim Suchen dieses Thema finden
  19. 1 point
    Geschafft: Das von @Jomnitech genannte Tutorial hat mich auf dem richtigen Weg gebracht. Ich habe nicht wie am Ende vorgeschlagen das Asset verwendet, sondern lieber etwas eigenes programmiert (da weis ich besser, was in meinem Spiel passiert). Wer das Video nicht gesehen hat: Die Camera wurde einen EmtyGame Objet "CameraHolder" untergeordnet. Somit kann ich dieses unabhängig von der Camera bewegen (welche ein eigenes Bewegungsscript hat). In meinem "PlyHealth.cs" Script habe ich folgenes eingebaut: Am Anfang: public CameraShake cameraShake; und in dem Abschnitt, welcher prüft, ob der Player getroffen wurde: bool shakeYes = cameraShake.cameraHolderShakeYes; if (!shakeYes) { StartCoroutine(cameraShake.CamShake(.2f, .5f, 4)); // Wackeln der Camera mit Script CameraShake.cs } Im Inspektor habe ich dann die entsprechende Zuweisung zum "CameraHolder" erstellt. Das "CameraHolder" Objekt hat folgendes Script: public class CameraShake : MonoBehaviour { public bool cameraHolderShakeYes = false; //Script PlyHealth.cs greift hierrauf zu Vector3 cameraHolderPos; private void FixedUpdate() { if (cameraHolderShakeYes) { transform.position = cameraHolderPos; } } // wird im Script PlyHealth.cs gestartet public IEnumerator CamShake(float duration, float magnitude, int steps) { cameraHolderShakeYes = true; Vector3 originalPos = new Vector3 (0,0,0); int shakeSteps = steps - 1; float stepDuration = duration / steps; float startCamHolderX = transform.position.x; float startCamHolderZ = transform.position.z; float targetCamHolderX; float targetCamHolderZ; for (int i = 1; i <= shakeSteps; i++) { targetCamHolderX = Random.Range(-1f, 1f) * magnitude; targetCamHolderZ = Random.Range(-1f, 1f) * magnitude; for (var time = 0.0f; time < stepDuration; time += Time.deltaTime) { var progress = time / stepDuration; cameraHolderPos.x = Mathf.Lerp(startCamHolderX, targetCamHolderX, progress); cameraHolderPos.z = Mathf.Lerp(startCamHolderZ, targetCamHolderZ, progress); yield return null; } startCamHolderX = targetCamHolderX; startCamHolderZ = targetCamHolderZ; magnitude *= 0.6f; yield return null; } float lastStepDuration = stepDuration + 0.1f; for (var time = 0.0f; time < lastStepDuration; time += Time.deltaTime) { var progress = time / stepDuration; cameraHolderPos.x = Mathf.SmoothStep(startCamHolderX, originalPos.x, progress); cameraHolderPos.z = Mathf.SmoothStep(startCamHolderZ, originalPos.z, progress); yield return null; } cameraHolderShakeYes = false; } Einige Anmerkungen: - die Variable "magnitude" reduziere ich zwischenzeitlich um einen sanfteren Auslauf des Effekt zu bekommen. - Vor der letzten Schleife habe ich die "stepDuration" für diesen Durchgang mit der Variablen "lastStepDuration" erhöht, da die Endposition 0,0,0 nie richtig eingenommen wurde. - ich habe es mit "Mathf.Lerp" und "Mathf.SmoothStep" probiert. Auch wenn der Unterschied minimal ist gefällt mir letzteres besser.
  20. 1 point
    Habe hierzu vor einer weile mal ein tut gesehen. Aber auch hier wird am Ende empfohlen ein bereits Existierendes Asset zu verwenden(kann man sich auf github runterladen), scheint also nicht so einfach zu sein einen sauberen Cam-Shake hinzubekommen.
  21. 1 point
    Ja hab ich aber hatte auch im übergeordneten Objekt die Rotation geändert aber das muss man im untergeordneten machen, jetzt sieht es super aus. Danke Leute.
  22. 1 point
    Ja... oder man rendert halt das Objekt flach, durch Skalierung auf 0. Dann spart man sich dem Umweg einer zusätzlichen Kamera
  23. 1 point
    Achso. Warum denn dann den Umweg gehen? Du kannst einfach dein Modell einem GameObject unterordnen und dieses auf (1, 1, 0) skalieren, also auf der Z-Achse komplett flach machen.
  24. 1 point
    Naja du kannst ja ne Variable implementieren die Speichert in welchem Lvl du bist und wenn du Game Over bist gehst du in die GameOverScene und überprüfst dann mit der Variable in welchem Lvl du warst und kannst dann so das gewünschte Lvl neu starten.
  25. 1 point
    Die Nachteile von Vererbung in Unity sind im Artikel ja beschrieben. Ist jetzt nicht so, dass das ganz böse wäre, wenn du Vererbung benutzt. Aber meiner Erfahrung nach sind Komponenten eben doch in gewissen Fällen ein Stück besser - insbesondere in Unity, das mit Komponenten super umgehen kann, mit Vererbung aber nicht immer optimal. Nachteile zur Komponenten-Variante sind mir eigentlich keine bewusst - außer, dass man Sachen wie Beobachtermuster verstanden haben muss, um damit richtig arbeiten zu können.
  26. 1 point
    Genau, wie du es bei "Die" gemacht hast. virtual in der Superklasse, override in der erbenden Klasse. Ich möchte dir aber gerne das hier ans Herz legen: http://blog.13pixels.de/2019/using-components-instead-of-inheritance-in-unity/
  27. 1 point
    Hi. Du kannst die UI auch als Prefab anlegen und diese in den verschiedenen Szenen einsetzen. Eine Änderung wäre dann in jeder Scene zu finden. Beim Game Over wäre die Möglichkeit zum nächsten Level zu gelangen nicht gut! Welche Probleme hast Du mit der Funktion Game Over? Hast Du schon verschiedene Szenen mit verschiedenen Level?
  28. 1 point
    Hallo und danke für eure Unterstützung! Ich habe das ursprüngliche Problem übrigens gelöst, indem ich im Canvas die Reference Resolution auf 1920x1080 gesetzt habe und den UI Scale Mode auf "Scale With Screen Size" festgelegt habe. Außerdem hab ich den Screen Match Mode auf Expand gesetzt (weiß nicht, ob das positiven Einfluss hatte). Selbstverständlich ist mir eure Meinung wichtig, daher habe ich darüber nochmal nachgedacht. Prinzipiell gebe ich euch Recht, dass die Art und Weise (selbst wenn's von der Performance her Toaster-Kompatibel ist ), nicht so praktisch ist. Allerdings waren meine Beispiele nur die halbe Wahrheit. Es soll am Ende eher in diese Richtung hier gehen: Unterschiedliche Schriftgrößen und 3D. Die normale Button-Beschriftung in Unity gibt das möglicherweise nicht her. Heißt auch, dass die Buttons dann nicht den gleichen Sprite nutzen könnten. (Hintergrund ist gleich, aber die Schrift ist anders.) TextMeshPro sieht allerdings interessant aus! Hab mir mal paar Beispiele angeschaut, und auf einem Blog hab ich das hier gesehen, was wirklich beeindruckend ist: Auf die Schnelle habe ich jetzt das hier hinbekommen: Ein UI-Image eingefügt, als Source Image diesen grünen Kasten verwendet und innerhalb des UI-Images ein UI-TextMeshPro-Element eingefügt und darin die Schrift reingeschrieben und Farbe + Größe mit tags definiert. Die Option TextMeshPro war bei mir übrigens schon standardmäßig drin. Wenn es keine 3D-Schrift ist, dann ist das auch kein so großer Untergang. Hätte sonst alles mit Photoshop gemacht, aber so werde ich mich nur auf die Hintergründe konzentrieren und die Schrift in Unity machen. Viele Grüße
  29. 1 point
    Hallo Forum, hier der ThreadStarter, So viele Wochenenden - und dann brachte eine entscheidende Zeile Code innerhalb einer halben Stunde das Ergebnis. Wer es brauchen kann, hoffentlich hat der Mann mit dem Hut nicht so viel zu meckern: using UnityEngine; /* Führt durch die Überlagerung von RotationDeltaSoll beziehungsweise über den smoothen Wert RotationDeltaLast ein Transform einem Target nach. Der Wert von RotationDeltaSoll wird anhand des Hilfsobjektes Eyes berechnet, welches korrekt ausgerichtet und dem Transform untergeordnet ist. Dadurch ist es nicht notwendig, daß das Transform bezüglich Vorne/Oben korrekt ausgerichtet ist. Benutzt wird die Unity-Funktion Quaternion.LookRotatin. */ public class LookAt1 : MonoBehaviour { public Transform NeckJoint; public Transform Eyes; public Transform Target; public bool Clamped; public float MaxY_Deg; public float MaxX_Deg; public float Acceleration; private Quaternion rotationDeltaLast; private void LateUpdate() { Quaternion RotationDeltasoll = MyLookAtDelta(Eyes, Target, Vector3.up); Vector3 v3 = RotationDeltasoll.eulerAngles; v3.y = MyClamp(v3.y, MaxY_Deg); v3.x = MyClamp(v3.x, MaxX_Deg); RotationDeltasoll.eulerAngles = v3; rotationDeltaLast = Quaternion.LerpUnclamped(rotationDeltaLast, RotationDeltasoll, Acceleration); NeckJoint.rotation = rotationDeltaLast * NeckJoint.rotation; } private float MyClamp(float f, float max) { if (f > 180) f -= 360; f = Mathf.Clamp(f, -max, max); if (Mathf.Abs(f) == max) Clamped = true; else Clamped = false; if (f < 0) f += 360; return f; } private Quaternion MyLookAtDelta(Transform correctTransform, Transform target) { return MyLookAtDelta(correctTransform, target.position - correctTransform.position, Vector3.up); } private Quaternion MyLookAtDelta(Transform correctTransform, Transform target, Vector3 up) { return MyLookAtDelta(correctTransform, target.position - correctTransform.position, up); } private Quaternion MyLookAtDelta(Transform correctTransform, Vector3 lookDirection) { return MyLookAtDelta(correctTransform, lookDirection, Vector3.up); } private Quaternion MyLookAtDelta(Transform correctTransform, Vector3 lookDirection, Vector3 up) { return Quaternion.LookRotation(lookDirection, up) * Quaternion.Inverse(correctTransform.rotation); } private Quaternion QDifference(Quaternion a, Quaternion b) { return b * Quaternion.Inverse(a); } } Ich benutze das Script in einer etwas anderen Form, für euch habe ich den Ballast raus genommen und nochmal überprüft. Ich denke, man könnte ohne das Hilfsobjekt auskommen, aber ich will endlich weiterkommen, und da es funktioniert ... Gruß von Lutz.
  30. 1 point
    Mal ohne gross auf das spezifische Problem ein zu gehen, was für mich danach aussieht als ob dein Background-Bild falsch skalliert, weil der Button immer gleich gross aussieht(oder Kameraeinstellung usw.), würde ich eher von dieser Technik abraten. Es macht es um einiges aufwändiger dinge zu platzieren, wie du ja selbst merkst, und spätere überarbeitung ist auch in meinen Augen mühseeliger. Das ganze jetzt rein performance Technisch machen zu wollen, denke ich ist hier etwas übertrieben. Wenn das nicht gerade auf einem Toaster laufen soll, sollte das kein Problem sein. Ausserdem wenn du, wie du sagst, eh alles die gleichen Buttons hast, teilen sich diese ja auch das ensprechende Sprite, was dann alles in einem rutsch ausgeführt wird. Korrigiert mich falls ich falsch liege, aber ich denke du baust hier Probleme wo keine sein müssten und es ist für mich kein gutes Fundament.
  31. 1 point
    == führt einen Vergleich durch. + zwischen zwei Strings konkateniert die Strings, schreibt sie also hintereinander. if (other2.tag == "Quader1" + "Quader2" + "Quader3" + "Quader4" + "Quader5") ist also gleichbedeutend mit if (other2.tag == "Quader1Quader2Quader3Quader4Quader5") Leider lässt sich das nicht mal eben innerhalb dieser einen Zeile fixen, weil OnTriggerEnter(2D) nur einmal aufgerufen wird, wenn ein neues Objekt den Trigger berührt. Dieses Objekt wird als Parameter übergeben (heißt bei dir "other2"). Welche Objekte sonst noch in deinem Trigger sind, ist OnTriggerEnter(2D) gänzlich egal. Du versuchst daher abzufragen, ob das eine neue Objekt alle fünf Tags hat, was natürlich nicht geht. Was du ja aber wirklich wissen willst ist, ob alle fünf Tags über Objekte im Trigger vertreten sind. Dafür musst du ein bisschen was dazu bauen. Erstmal die Frage: Brauchst du überhaupt fünf Tags? Ich lass die Sache mit "niemals überhaupt Tags benutzen" erstmal in der Kiste, aber ich vermute einfach mal, dass du immer nur ein Objekt pro Tag hast. Dass die fünf Objekte unterschiedliche Tags haben, benutzt du hier ja gar nicht, da du einfach nur schaust, ob alle fünf da sind. Du könntest dann einfach einen Tag "Quader" haben und schauen, ob (alle) fünf Objekte mit diesem Tag im Trigger sind. Um das zu machen, gibt es mehrere Möglichkeiten. Ich denke, eine einfach nachzuvollziehende ist ein Zähler. Dafür brauchst du eine int-Variable, die hochzählt, wenn ein "Quader"-Objekt den Trigger betritt, und wieder herunterzählt, wenn einer davon der Trigger wieder verlässt. Ist der Zähler bei 5 angekommen, wissen wir, dass alle 5 Objekte im Trigger sind. Das würde dann so aussehen: private int objectsInTrigger = 0; private void OnTriggerEnter2D(Collider2D other) { if (other.CompareTag("Quader")) { // Erhöhe um eins objectsInTrigger++; // Schaue ob es fünf sind if (objectsInTrigger == 5) { Debug.Log("Nächstes Level"); } } } private void OnTriggerExit2D(Collider2D other) { if (other.CompareTag("Quader")) { // Senke um eins objectsInTrigger--; } } Das kann man dann noch aufhübschen, z.B. indem man die 5 nicht hardcoded, sondern als Variable einfügt, die man im Editor setzen kann. Dann kannst du jedes Mal, wenn du dieses Script auf ein GameObject tust, eingeben, wie viele Quader benötigt werden. So kannst du mit demselben Script, ohne den Code abändern zu müssen, mehrere Level bauen, in denen verschieden viele Quader gebraucht werden. Sonst noch so: CompareTag ist besser als == "meinTag", da es dir eine Fehlermeldung wirft, wenn der Tag gar nicht existiert, z.B. weil du dich vertippt hast. Auch mit CompareTag sind Tags immer eine potentielle Fehlerquelle. Ich empfehle dringend, auf lange Sicht Tags komplett sein zu lassen. Wenn du mal Lust hast, kann ich erzählen, wieso... aber im Moment führt's einfach zu weit.
  32. 1 point
    Der erste Testlauf einer Kartengenerierung mit PerlinNoise ist erfolgreich abgeschlossen. Etwas mehr fein Tuning beim Algorithmus und mehr als 3 Kartenfeldtypen sollten es aber schon sein sonst ist das nicht sehr ansehnlich. Aber immerhin, es funktioniert und geht ins nächste NightlyBuild.
  33. 1 point
    so ich hab den Ritter aus der Daemonic Cathedrale ein wenig überarbeitet und die KI eingebaut .. der Kämpft jetzt mit Schild und wehrt Angriffe gerne mal ab .
  34. 1 point

Announcements

Hy, wir programmieren für dich Apps(Android & iOS):

Weiterleitung zum Entwickler "daubit"



×
×
  • Create New...