Jolinah

Guten Abend, Wird ein neues Empty-Objekt erstellt, befindet sich dieses meistens an einer eher zufälligen Position oder aber bei 0,0,0. Wenn nun andere Objekte in das Empty gezogen werden, dann behalten diese ihre absolute Welt-Position bei, werden aber relativ zum Empty positioniert (da es nun untergeordnete Objekte sind). Das Empty stellt somit den Pivot-Punkt dar (was den Namen angeht habe ich schon alles mögliche gehört, in Unity wird es offiziell Pivot point genannt, zumindest heisst der Button oben in der Toolbar so, mit welchem zwischen Pivot-Punkt und Mittelpunkt gewechselt werden kann). Zum Beheben des Problems, können die untergeordneten Objekte nochmal aus dem Empty/Parent heraus gezogen werden (ohne die Position zu verändern). Anschliessend kann das Empty dorthin verschoben werden wo sich der Pivot-Punkt eigentlich befinden sollte. Werden die 4 Blöcke nun wieder in das Empty hinein gezogen, dann müsste der Pivot-Punkt stimmen. Ich hoffe das hilft

Auf dem Screenshot ist eine Fehlermeldung zu sehen. Es gibt keinen Animator auf dem "Wuerfeln"-Objekt, aber ein Script versucht darauf zuzugreifen. Andererseits sieht man auch, dass ein Animator und das Animation-Script auf dem Becher-Objekt sind, was eigentlich so klappen müsste. Weiterhin wäre es noch gut zu wissen ob das im AnimatorController wirklich Bool-Variablen sind oder Trigger. Im Falle von Trigger muss es heissen animator.SetTrigger("Wurf");

Hi Da die Strukturen etwas gemeinsam haben (Slots) empfiehlt es sich ein Interface und/oder eine Basisklasse einzuführen, welche die Slot-Logik beschreibt, z.B.: public interface IItemSlotContainer { IEnumerable<string> GetSlots(); IEnumerable<Item> GetItems(); Item GetSlotItem(string slotName); void SetSlotItem(string slotName, Item item); void CopySlotItems(IItemSlotContainer targetContainer); } Das Fenster selber könnte genau das gleiche Interface auch implementieren, und dann die Methode CopySlotItems verwenden, um die Items in das Ziel (Struktur) zu übertragen oder die Items von der Struktur zu laden, wenn das Fenster geöffnet wird. Alles was dann noch benötigt wird ist eine Referenz im Fenster auf die entsprechende Struktur, z.B.: public class WndAnimalTrap : MonoBehaviour, IItemSlotContainer { public IItemSlotContainer targetContainer; void OnWindowShow() { targetContainer.CopySlotItems(this); } void OnWindowClosing() { CopySlotItems(targetContainer); } } Wichtig dabei ist, dass die Items nicht an ein GameObject gebunden sein sollten, das heisst einfach normale C#-Klassen verwenden oder von ScriptableObject erben. Natürlich braucht es für die Darstellung der Items im GUI GameObjects. Aber diese könnten ja wiederum auf ein Item-Objekt verweisen, welches unabhängig vom GameObject ist und nur im RAM gehalten wird.

Hallo, Sind die Referenzpunkte wirklich in der Mitte der Räume? Auf dem Screenshot wirkt es nämlich nicht so, weil das Zentrum des Raums sich nicht mit einer Gitterlinie von Unity schneidet (welche bei normaler Einstellung auf 1 Unit pro Linie bzw. eine dicke/helle Linie alle 10 Units eingestellt ist). Es wäre noch hilfreich den falsch berechneten X-Wert vom 2. Raum zu sehen, dann lässt sich einfacher darauf schliessen was nicht stimmt Denn ansonsten sieht die Berechnung eigentlich richtig aus.

Guten Abend, Wenn ein Objekt per Script erstellt wird, dann hat es standardmässig kein Parent (ausser man gibt dieses bewusst an). Beim manuellen in die Szene ziehen, haben Sie es evtl. in das Canvas hinein gezogen? Das gleiche müsste auch per Script gemacht werden (parent = Canvas bzw. Grid oder sonst ein Container innerhalb des Canvas). Wenn mit Canvas gearbeitet wird, ist es besser Images zu verwenden und nicht SpriteRenderer, vor allem wegen dem Layout und dem Koordinatensystem. Normalerweise sollte das Canvas automatisch so skaliert werden, dass die Einheiten innerhalb des Canvas einem Pixel entsprechen. Somit muss manuell nichts mehr umgerechnet werden. Die Höhe/Breite im RectTransform entspricht dann ebenfalls Pixeln. Bei SpriteRenderer.size kommt es auf die Import-Einstellungen des jeweiligen Sprites an: "Pixels Per Unit". Diese ist normalerweise 100 Pixel pro Einheit. Das bedeutet eine Grösse von Vector2(1, 1) ist 100px * 100px. Somit müsste es funktionieren, wenn Sie die Werte einfach durch 100 teilen: new Vector2(0.16f, 0.08f).

Hallo Ich habe vor kurzem Substance Painter abonniert und zum Test ein kleines Schwert modelliert und danach in Painter bemalt. Ist jetzt nicht perfekt, aber ich dachte ich könnte es ja trotzdem mal hier reinstellen, falls es jemand gebrauchen kann. Wenn gewünscht, könnte ich den Rost entfernen oder im unteren Teil auch noch etwas Rost hinzufügen. Sword.unitypackage

Was es noch gibt sind die Methoden SendMessage und BroadcastMessage. Damit kannst du Methoden bei anderen MonoBehaviours ausführen lassen, allerdings läuft das über Reflection und kann je nachdem langsamer sein. public void OnDrag(PointerEventData eventData) { // Ruft die Methode bei allen MonoBehaviours auf dem selben GameObject auf (falls vorhanden) SendMessage("MyOnDrag", eventData, SendMessageOptions.DontRequireReceiver); // Ruft die Methode bei allen MonoBehaviours auf dem selben und untergeordneten GameObject auf (falls vorhanden) BroadcastMessage("MyOnDrag", eventData, SendMessageOptions.DontRequireReceiver); // Ruft die Methode bei allen MonoBehaviours auf dem selben und auf übergeordneten GameObjects auf (falls vorhanden) SendMessageUpwards("MyOnDrag", eventData, SendMessageOptions.DontRequireReceiver); } Aber es stellt sich die Frage, ob das ein Script ist, welches diese Events generell weiterleiten soll oder ob die Objekte an die du weiterleiten möchtest sowieso bekannt sind. Dann ginge es auch viel einfacher: public AnderesScript anderesScript; // Via Inspektor ein Objekt/Behaviour zuweisen public void OnDrag(PointerEventData eventData) { anderesScript.Methode(); }

Du kannst mit Linq auch nach Parzellennamen gruppieren: var parzellen = liste.GroupBy(item => item.GetParzellenname()); foreach (var parzelle in parzellen) { // Code der pro Parzellenname ausgeführt wird // parzelle enthält alle Einträge der jeweiligen Parzelle string parzellenName = parzelle.Key; float parzellenSumme = parzelle.Sum(item => item.Summebilden()); }

Wenn du mehrere Game-Objekte mit dem Tag "Player" hast, dann findet es irgendeines davon. Könnte sein dass er ein anderes Objekt gefunden hat, welches zufälligerweise auch einen Animator hat. Dann gibt es keine Exception, aber du arbeitest mit dem falschen Animator. Ich empfehle hier auch gameObject.GetComponentInParent<Animator>(); oder ein serialisiertes Field wie oben beschrieben. Das erste sucht in allen Parents bis zum Root nach einer solchen Komponente. Bei der zweiten Variante kannst du im Inspektor exakt angeben, welches Objekt / welcher Animator benutzt werden soll.

Hallo, Vermutlich liegt es daran, dass für das Drop nur das erste mögliche Objekt in betracht gezogen wird. Die darunterliegenden Objekte erhalten dann keine Benachrichtigung mehr. Dem kann abgeholfen werden, indem beim GameField-Objekt bei der Image-Komponente das Häkchen "Raycast Target" deaktiviert wird. Somit kommt das GameField nicht mehr für Maus-Eingaben in Frage, nur noch die darunter liegenden Buttons. Falls zwischen GameField und den Buttons nochmal ein Objekt ist, müsste dort das "Raycast Target" ebenfalls deaktiviert werden. Wenn Die Buttons auch von links nach rechts gezogen werden können, dann müsste beim ToolField das gleiche gemacht werden. Ansonsten könnte es noch an der Reihenfolge liegen. Beim OnDrag müsste evtl. das gezogene Objekt ganz nach vorne gebracht werden (z.B. via Z-Position oder in der Szene ganz nach unten verschieben, indem das Objekt während dem Draggen direkt als letztes Child des Canvas eingefügt wird, auf der gleichen Ebene wie GameField und ToolField.)

Solche Fehler können oft in OnGUI() passieren. Die Ursache ist, dass OnGUI() mehrmals pro Frame aufgerufen wird, z.B. einmal für eine Layout-Phase und dann um die GUI-Elemente effektiv zu zeichnen. Das heisst, zwischen mehreren OnGUI()-Aufrufen während dem gleichen Frame darf sich der Zustand auf keinen Fall verändern (z.B. die Anzahl Items). Da es nur bei einem Szenenwechsel passiert, kann es eigentlich auch nur Code sein, der bei einem Szenenwechsel ausgeführt wird. Das einzige was ich da sehe ist RemoveDublicates(). Evtl. kannst du den Aufruf dieser Methode in OnLevelFinishedLoading() mal auskommentieren, um zu schauen ob das Problem dort liegt. Je nach dem könntest du das GUI auch mit den neuen Canvas- und Image-Objekten etc. machen, statt mit OnGUI(), dort gibt es deutlich weniger Probleme dieser Art. Allerdings funktioniert es auch ganz anders als OnGUI() und da muss man sich natürlich zuerst wieder einarbeiten...

Event ist kleingeschrieben, weil das ein Sprachfeature von C# ist und somit ein Schlüsselwort. Also für C# hat das eine spezielle Bedeutung. Es weiss dann dass man ein Event definieren möchte. Ein Event ruft, wenn es ausgelöst wird eine bestimmte Funktion auf. Beim definieren eines Events muss man auch definieren wie die Funktion genau aussehen soll, die dann aufgerufen wird. System.Action<PointerEventData> bedeutet: Eine Funktion ohne Rückgabewert (Action), mit genau einem Parameter vom Typ PointerEventData. Um das Event auszulösen, benutzt man normalerweise den Code den ich in OnDrag() eingefügt habe. Im Prinzip könnte man auch direkt schreiben: if (Drag != null) { Drag(eventData); // <- löst das Drag-Event aus und übergibt das benötigte PointerEventData-Objekt } Die Zeile vor dem If ist nur eine lokale Variable namens handler und das Drag wird dieser handler-Variable zugewiesen. Danach wird das Event über die Variable ausgelöst. Das macht man in der Regel aus Gründen der Threadsicherheit, aber das ist erstmal nicht so wichtig. In deinem Fall musst du das Event nicht selber auslösen, da das OnDrag bereits durch Unity über das Interface aufgerufen wird. Ein Event kann dann mehrere Objekte haben die auf das Ereignis reagieren möchten. Beim Auslösen des Events werden automatisch alle Objekte benachrichtigt, die sich zuvor bei dem Event registriert haben. Das Objekt das darauf reagieren will, teilt dem Event sozusagen mit, welche Funktion vom Event aufgerufen werden soll, sobald es ausgelöst wird: // Das Event soll bei Auslösung MeineFunktion aufrufen // Ausgelöst wird das Event von der Quelle, dann wenn sie es für nötig hält bzw. in deinem Fall in OnDrag quelle.Event += MeineFunktion; private void MeineFunktion(PointerEventData eventData) { // Und MeineFunktion muss genau so aussehen, wie das Event es verlangt // bzw. wie das Event definiert wurde. In diesem Fall System.Action<PointerEventData> // was void Name(PointerEventData parameterName) entspricht. }

Lange Zeit hatte ich auch keine Ahnung wie man mit den Quaternions umgeht und ich verstehe sie vermutlich auch heute noch nicht 100%. Das Video oben hat diesbezüglich zum Verständnis beigetragen, danke dafür Meiner Meinung nach muss man sie aber auch nicht wirklich verstehen, sondern nur lernen was damit für Operationen möglich sind, um die gewünschten Rotationen zu erhalten. Und das sind gar nicht viele. Entscheidend ist, dass man 3D-Rotationen entweder mit 3 Winkeln um die entsprechenden Achsen (Euler) darstellen kann, oder als Quaternion. Diese haben nicht viel gemeinsam, aber man kann von einem System in das andere konvertieren. Das war auch der Grund dass das eulerAngles hinzugefügt werden musste, da du mit Euler-Rotationen arbeiten wolltest. Rotation.eulerAngles konvertiert ein Quaternion in eine Euler-Rotation (Vector3) mit den Drehwinkeln um die Achsen X, Y und Z. Da Instantiate jedoch eine Rotation in Form eines Quaternions erwartet, müssen die veränderten Euler-Winkel wieder in ein Quaternion konvertiert werden. Das geschieht mit Quaternion.Euler(Vector3 bzw. x, y, z). Dann gibt es die Konstante Quaternion.identity: Diese steht für keine Rotation, bzw. entspricht auch den Euler-Winkeln (0,0,0). Ausserdem gibt es weitere statische Methoden wie Quaternion.Angle, Quaternion.FromToRotation etc.. diese erklären sich aber fast von selber, wenn man die Dokumentation liest und die Multiplikation verstanden hat: Die Quaternion-Multiplikation Es können entweder 2 Quaternions miteinander multipliziert werden oder ein Quaternion und ein Vector3. Ausserdem ist die Quaternion-Multiplikation nicht kommutativ, das heisst es macht einen Unterschied ob a * b oder b * a geschrieben wird. Quaternion resultat = quaternion1 * quaternion2; Zuerst wird die 1. Rotation und danach die 2. Rotation angewendet. Das Resultat ist die End-Rotation, nachdem beide Rotationen nacheinander angewendet wurden. Vector3 resultat = quaternion * vector3; Damit kann ein Richtungsvektor relativ zu der Rotation erzeugt werden. Sagen wir auf der Y-Achse soll um 90° gedreht werden. In Unity zeigt die Z-Achse normalerweise nach vorne. Rotiert man nun 90° auf der Y-Achse dann zeigt die Z-Achse anschliessend nach Rechts. Multipliziert man also Quaternion.Euler(0, 90, 0) mit Vector3.forward (Z-Achse), dann erhält man einen Richtungsvektor der in die Richtung der Z-Achse zeigt, nachdem die Rotation angewendet wurde. In dem Fall bekommt man (1, 0, 0 = Vector3.right = Rechts) heraus, da die Z-Achse nach der Rotation wie oben beschrieben nach Rechts zeigt. Beim Transform kennt man ja z.B. die Properties transform.forward/right/up. Diese kann man auch so ausrechnen: Vector3 forward = transform.rotation * Vector3.forward; Vector3 right = transform.rotation * Vector3.right; Vector3 up = transform.rotation * Vector3.up; Hier noch ein paar Beispiele: // Objekt um eine beliebige globale Rotation drehen transform.rotation *= Quaternion.Euler(x, y, z); // Oder eine lokale Rotation in Bezug auf das Parent transform.localRotation *= Quaternion.Euler(x, y, z); // Objekt 10 Units 45° schräg nach Vorne bewegen. Es ist so, als würde man // das Objekt auf Y um 45° drehen und dann erst vorwärts bewegen, // nur wird das Objekt nicht gedreht, sondern nur die Position verändert. transform.position += (transform.rotation * Quaternion.Euler(0, 45, 0)) * new Vector3(0, 0, 10); // Objekt 10 Units nach Rechts bewegen (in das lokale Rechts des Objekts, nicht das der Szene) transform.position += transform.rotation * new Vector3(10, 0, 0); // Das geht natürlich auch einfacher über localPosition transform.localPosition += new Vector3(10, 0, 0); // Zuerst 30° um die Y-Achse drehen, danach noch zusätzlich 60° um die Z-Achse transform.rotation *= Quaternion.Euler(0, 30, 0); transform.rotation *= Quaternion.Euler(0, 0, 60); // oder transform.rotation *= Quaternion.Euler(0, 30, 0) * Quaternion.Euler(0, 0, 60);

Das liegt vermutlich an der Reihenfolge wie die Grafiken angezeigt werden oder an der Z-Position des Players. Wenn der Player vorher in der Hierarchy-Ansicht weiter unten war (nach anderen Sprites), dann wurde der Player als letztes angezeigt und somit über den anderen Sprites. Indem du ihn in die Kamera gezogen hast, die in der Hierarchy vermutlich weiter oben ist, hat sich dann auch die Anzeigereihenfolge verändert. Also entweder den Player in der Hierarchy wieder nach unten verschieben, oder bei der Image/SpriteRenderer-Komponente das "Order in Layer" z.B. mal auf 100 erhöhen, dann wird der Player evtl. wieder angezeigt. Wenn das nichts hilft, kannst du auch die Z-Position verändern.

Ah, das sind immer die übelsten Fehler... freut mich, dass es nun klappt. Hier in Bern (Schweiz) hat es noch nicht geregnet, aber der Herbst kommt sicher auch bald.. Danke, dir auch noch 'nen schönen Tag