Jump to content
Unity Insider Forum

Maurice94

Members
  • Content Count

    13
  • Joined

  • Last visited

  • Days Won

    2

Maurice94 last won the day on January 12

Maurice94 had the most liked content!

Community Reputation

4 Neutral

About Maurice94

  • Rank
    Member
  • Birthday 06/15/1994

Profile Information

  • Gender
    Male
  • Location
    Germany
  • Interests
    C#

Recent Profile Visitors

151 profile views
  1. Und musst du die Klasse nicht mit [System.Serializable] kennzeichnen?
  2. Ich hatte neulich auch noch ein ähnliches Problem. Bei mir ging es jedoch darum, Listen vom Typen Scriptable Object zu speichern. Es lief ähnlich ab wie bei dir - ich konnte meine Dateien im Savefile speichern, hatte jedoch Schwierigkeiten die Dateien wieder ordnungsgemäß zu importieren, bzw. zu laden. Ich habe mich dazu entschieden, das Problem erstmal bei Seite zu schieben, da ich mich zu lange mit dem Thema aufgehalten habe und schon fast die Freude am Projekt verloren habe. Meine Recherche hat mir zumindest die Antwort gegeben, dass bestimmte Typen nicht serializable sind und man einen kleinen Umweg gehen muss, um das Resultat zu erzielen, was man sich wünscht. Es wurde häufiger vom "Wrapping" und von Helferklassen gesprochen. Ich kann dir leider keine Antwort auf deine Frage geben, wollte dich aber fragen, ob du schon versucht hast, deine Dateien mit JsonUtility zu speichern? Mit JSON habe ich bisher immer gute Erfahrungen gesammelt.
  3. Stimme dir zu in dem Punkto - ich hätte direkt die saubere Variante aufführen sollen.
  4. ....im Grunde wollte ich ihm ja auch nur das Prinzip von Verschachtelung näher bringen, weil er meinte, dass er mehr Informationen benötigen würde und der Typ alleine nicht ausreicht. Deine Variante würde so aussehen:
  5. @Sascha Klar, man kann die Informationen auch direkt ins Scriptable Object integrieren und dann mit Referenz dazu Verknüpfungen machen. Im Grunde läuft es ja auf das gleiche Resultat hinaus, oder nicht? Ob das Objekt nun die Informationen aus Quelle A, oder Quelle B erhält spielt doch keine direkte Rolle? Ich selbst trenne bestimmte Sachen gerne voneinander - aber das ist wohl einfach meine eigene, chaotische Art und Weise. Bisher hat immer alles bestens funktioniert. Zum anderen Punkt möchte ich sagen, dass ich niemals die Liste als Referenz für andere Aufgaben nehmen würde. Ich würde die Liste lediglich in einer Art Preload-Szene als einmalige Referenz nutzen, um Informationen ins Spiel zu laden. Alles weitere passiert unabhängig zu dieser Liste, indem sich Objekte ganz normal Referenzen zueinander holen. Meistens leite ich von Liste zu Liste weiter.
  6. @Herbstmond Zunächst einmal würde ich deinem Scriptable Object ein Enum für die Typen hinzufügen. Dann prüfst du im Objekt, was Gebrauch von deinem Datencontainer machen will, von welchem Gentypen es ist. Sollte das Objekt dann also im Awake erfahren haben, von welchem Gentypen es ist, kannst du doch im Start direkt individuelle Logik für jeden Typen dazu schreiben. Alles was das Objekt vom Enum wissen will ist doch, von welchem Typen es ist, um dann seine seine eigene Identität definieren zu können. Hier ein Beispiel für dich: Ich habe es jetzt hier im Beispiel nicht verdeutlicht, aber du solltest auf jeden Fall Gebrauch von Switches machen, wenn du auf diese Art und Weise prüfst. Ich hoffe aber du verstehst, dass das Enum nicht so viele Informationen halten muss. Es genügt, den Grundtypen vorzugeben um dann alles andere davon abzuleiten. Wie @devandart bereits erwähnt hat, könnte ein leeres GameObject eine Liste vom Typen deines Scriptable Objects halten. In dieser Liste speicherst du ganz einfach alle Objekte, die im Spiel existieren. Du kannst es so einrichten, dass sich das Objekt nicht zerstört, wenn du eine neue Szene lädst. Das gibt dir den Vorteil, dass du von überall und zu jedem Zeitpunkt Informationen aus dieser Liste entnehmen kannst, bzw. immer eine Referenz zur Liste findest, da das Objekt in jeder Szene existiert. Grüße, Maurice
  7. Nur weil du zwei Spieler hast bedeutet das nicht, dass die Variablen automatisch static sein müssen. Wenn zwei Spieler dein Spiel zur gleichen Zeit im gleichen Raum / Netzwerk spielen, teilen beide Spieler die gleichen lokalen Daten, da sie ja beide das gleiche Programm öffnen. Du schickst dann einfach Funktionen übers Netzwerk (auch RPC genannt), die an eine gewisse Logik gebunden sind. Diese Funktionen sind in der Lage, bei allen Spielern im Netzwerk zum gleichen Zeitpunkt ausgeführt zu werden. Sprich, selbst wenn deine Variable private wäre, könntest du über RPC's die lokalen Variablen aller Spieler im gleichen Netzwerk verändern / beeinflussen, so wie du es willst.
  8. Das Problem lässt sich relativ leicht lösen. Du musst einfach das TMPro Namespace importieren. Schreib einfach oben bei deinen Namespaces: using TMPro; Dadurch bekommst du Zugriff auf die Klassen vom TextMesh. Darunter auch auf die TextMeshProUGUI-Klasse, die du benötigst. Du deklarierst dann einfach anstelle vom normalen Text ein TextMeshProUGUI Feld. Sollte ohne Probleme funktionieren! Hier nochmal ein Bild 🙂
  9. Okay, das kann ich natürlich nachvollziehen. Da alles so schnell ging und ich innerhalb kürzester Zeit das Problem beheben konnte, dachte ich, dass es womöglich einfach am besten wäre, den Beitrag zu löschen um anderen Leuten nicht den Platz, bzw. die Aufmerksamkeit für Ihre Probleme wegzunehmen. Ich kann das Problem nochmal aufgreifen. Es ging darum, dass ich versucht habe, die Karten in meiner Hand je nach Anzahl flexibel und dynamisch anzupassen. Wenn ich also 2 Karten in der Hand habe, ist Karte 1 an Position Vector(-1, 0, 0) und Karte 2 z.B an Position Vector(0, 0, 0). Sollte nun aber Karte 2 aus meiner Hand verschwinden, möchte ich, dass die andere Karte automatisch ein Stück nach rechts rückt. Und sollte meiner Hand dann wieder eine weitere Karte hinzugefügt werden, möchte ich halt immer wieder die automatische Veränderung der Position erreichen, so dass auch bei einer größeren Anzahl von Karten, alle Karten ihre Positionen anpassen. Da ich diese Logik an iTween knüpfen wollte, musste ich kurz überlegen. Die Lösung dafür hat dann wie folgt ausgesehen. Unter dem Code gehe ich nochmal spezifisch auf den Code ein. public void DrawCardFromDeck() { if (Input.GetKeyDown(KeyCode.Space)) { if (Master_Hand.childCount == 0) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 1) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if(Master_Hand.childCount == 2) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if(Master_Hand.childCount == 3) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(2).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 4) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_Neutral, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(2).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(3).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 5) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_minus1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_Neutral, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(2).gameObject, iTween.Hash("position", Position_1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(3).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(4).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 6) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_minus2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_minus1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(2).gameObject, iTween.Hash("position", Position_Neutral, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(3).gameObject, iTween.Hash("position", Position_1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(4).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(5).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 7) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_minus3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_minus2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(2).gameObject, iTween.Hash("position", Position_minus1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(3).gameObject, iTween.Hash("position", Position_Neutral, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(4).gameObject, iTween.Hash("position", Position_1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(5).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(6).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 8) { Temp = PhotonNetwork.Instantiate("Network_Card_Prefab", Deck_Childs[Deck_Childs.Count - 1].transform.position + new Vector3(0, 1, 0), Quaternion.identity); iTween.MoveTo(Master_Hand.GetChild(0).gameObject, iTween.Hash("position", Position_minus4, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(1).gameObject, iTween.Hash("position", Position_minus3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(2).gameObject, iTween.Hash("position", Position_minus2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(3).gameObject, iTween.Hash("position", Position_minus1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(4).gameObject, iTween.Hash("position", Position_Neutral, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(5).gameObject, iTween.Hash("position", Position_1, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(6).gameObject, iTween.Hash("position", Position_2, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Master_Hand.GetChild(7).gameObject, iTween.Hash("position", Position_3, "time", 1f, "easeType", iTween.EaseType.easeInOutSine)); iTween.MoveTo(Temp, iTween.Hash("position", Position_4, "time", 2f, "easeType", iTween.EaseType.easeInOutSine)); //Vector3 Temp_Position = Master_Hand.position + new Vector3(8, 0, 0); //iTween.MoveTo(Master_Hand.gameObject, iTween.Hash("position", Temp_Position, "time", 1f, "easeType", iTween.EaseType.easeOutSine)); Temp.transform.SetParent(Master_Hand); } else if (Master_Hand.childCount == 9) { return; } } } Ich habe zunächst einmal 9 individuelle Transforms in der Szene positioniert. Dann instantiate ich eine Karte, die sich zur Position des besagten Transforms bewegt. Bevor all das passiert, wird immer geprüft, wie viele Childs aktuell in der Hand sind. Je nachdem, wie das Resultat ausgeht, werden all die Childobjekte im gleichen Zug ein Stück nach links bewegt. Es kommt also eine neue Karte dazu und die anderen wandern im gleichen Atemzug zur nächstgelegenen Position. Ich weiß, dass diese Methode etwas grob ist - aber sie hat für den Moment das erfüllt, was ich bewirken wollte. Demnach kann es ja gar nicht so schlecht gewesen sein. Entschuldige nochmal, dass ich den Beitrag gelöscht habe. Ich hoffe, dass ich nachträglich erklären konnte, was mein Anliegen gewesen ist. Liebe Grüße, Maurice
  10. Das Problem wurde gelöst - weiter unten im Beitrag könnt ihr eine genauere Beschreibung des Problems und eine potenzielle Lösung von mir finden.
  11. @Kojote Guten Morgen und danke für deine Rückmeldung. Die Meldung ist noch ziemlich aktuell, ja. Ich konnte jedoch einen Weg finden, meine Idee umzusetzen. Was ich nun gemacht habe ist folgendes: ich habe zunächst einmal den Rendermode vom Canvas von Screen Space Overlay auf World Space gesetzt und direkt über meinem Spielfeld positioniert, so dass die Kamera das exakte Erscheinungsbild wie oben rendert. Da meine UI Elemente nun in der Gamewelt existieren, können sie also auch auf Collider Events und Trigger reagieren. Ich habe meinem UI Handkarten Prefab also einen Box Collider und einen Rigidbody hinzugefügt. Wenn ich nun die OnDrag-Funktion benutze und meine Karten auf dem World Canvas bewege, kann ich die Box Collider vom Spielfeld ansprechen und von dort aus OnTriggerEnter, etc. ausführen. Ich habe es nun so eingefädelt, dass... sobald ich mein UI Element dragge, ein Bool auf true gesetzt wird, um erstmal zu signalisieren: "Okay, wir draggen gerade!" - sofern dies gegeben ist und ich mich im Trigger vom Spielfeld befinde und meine linke Maustaste loslasse (die ja noch gedrückt ist, da ich am draggen bin), instantiate ich meine 3D Variante der Karte an einer von mir bestimmten Position.. gibt 3 Felder, einfach 3 Transforms die quasi Spawnpunkte sind. Deine Lösung hört sich jedoch auch interessant an! Vielleicht spiele ich damit auch mal rum. Danke erstmal, dass du überhaupt was geschrieben hast 🙂
  12. Guten Abend gemeinsam! Ich stehe aktuell vor einem Problem, beziehungsweise weiß ich, wie ich mein Vorhaben umsetzen kann, bin jedoch mit dem Weg und der Ausführung nicht zufrieden. Um kurz zu erklären, was ich aktuell versuche und an welchem Punkt ich mich befinde, hier eine kleine Skizze meiner Hierarchie: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ - UI Canvas (mein Canvas, der meine Handkarten im Screen Space Overlay Modus über das 3D Spielfeld im Hintergrund rendert) - Player 1 Hand (leeres Gameobjekt, das eine horizontale Layoutgruppe und einen Content Size Fitter als Komponenten trägt, um die Childs (die Handkarten) ordnungsgemäß anzuordnen) - Player 2 Hand (selbiges gilt hier, nur für die entgegengesetzte Seite) - 3D Environment (leeres Objekt, was lediglich als Gruppenparent für die Umgebung dient) - Player 1 Battlefield (einfach ein 3D Cube, den ich so geformt habe, dass er einem Spielfeld entspricht - liegt auf dem Layer "Player1Side, um später mit Raycasting genau diesen Layer ansprechen zu können") - Player 2 Battlefield (genau das Gleiche wie für die Spielseite von Player 1 - Layer: "Player2Side") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Ich arbeite mit integrierten Interfaces, um meine UI Elemente per Drag and Drop steuern zu können. IBeginDragHandler, IDragHandler, IEndDragHandler! Mein Problem ist jedoch, dass diese Interfaces lediglich mit dem UI funktionieren und sich nicht auf normale 3D Gameobjekte wie z.B einen Cube übertragen lassen. Ich kann also nicht einfach ein UI Element auf einen Cube ziehen und vom Cube aus die OnDrop() Funktion aufrufen. Um es präziser zu formulieren: ich möchte eine Karte aus meiner Hand draggen (was ja auch funktioniert) und sobald ich die Karte auf dem Feld in der Scene fallen lasse, beziehungsweise droppe, möchte ich eine 3D Variante von dieser Karte instantiaten. Das ist nicht das Problem - ich bin in der Lage Prefabs an bestimmten Stellen zu instantiaten. Ich weiß jedoch nicht, wie ich mein UI Setup mit der Gamewelt, beziehungsweise meinem 3D Spielfeld verbinden kann. Ich habe bereits versucht, die Layermaske des Spielfeldes über simples Raycasting anzusprechen, indem ich in der OnBeginDrag() Function die Property blockRaycasting von der CanvasGroup-Komponente deaktiviere, um quasi mit meiner Maus auch durch die Karte, die ich gerade dragge, raycasten zu können. Ich kann auch Objekte unterhalb meiner Karte erkennen. Aber wie kriege ich es hin, dass etwas passiert, sobald ich die Maus dann loslasse. Es geht wirklich nur um diesen speziellen Moment, den Rest kann ich lösen. Als ich mein Projekt komplett in 2D aufgesetzt habe, hat alles einwandfrei funktioniert. Das hat aber auch daran gelegen, dass ich RectTransforms als DropZones für meine Karten benutzen konnte. RectTransforms sind nämlich im Gegensatz zu 3D Objekten in der Lage, die OnDrop Funktion aufzurufen. Aber das ist mir zu statisch und ich hatte vor, das ganze Projekt in 3D UND 2D aufzusetzen um es etwas dynamischer zu gestalten. Ich füge nochmal ein Bild bei, was meine Szene abbildet. Vielen vielen Dank an die Leute, die sich die Zeit nehmen, darüber nachzudenken und mir gegebenenfalls eine Antwort auf meine Frage geben können! Liebe Grüße, Maurice
×
×
  • Create New...