Jump to content
Unity Insider Forum
  • Announcements

    • Lars

      Allgemeine Forenregeln   03/13/2017

      Forenregeln Nimm dir bitte einen Moment um die nachfolgenden Regeln durchzulesen. Wenn du diese Regeln akzeptierst und die Registration fortsetzen willst, klick einfach auf den "Mit der Registrierung fortfahren"-Button. Um diese Registration abzubrechen, klick bitte einfach auf den "Zurück" Button deines Browsers. Wir garantieren nicht für die Richtigkeit, Vollständigkeit und Brauchbarkeit der Nachrichten und sind auch nicht dafür verantwortlich. Die Beiträge drücken die Meinung des Autors des Beitrags aus, nicht zwangsläufig das, wofür die Forensoftware steht. Jeder Nutzer, der denkt, dass ein veröffentlichter Beitrag unzulässig bzw. störend ist, ist aufgefordert uns unverzüglich per E-Mail zu kontaktieren. Wir haben das Recht störende Beiträge zu löschen und bemühen uns, das in einem realistischem Zeitraum zu erledigen (sofern wir beschlossen haben, dass die Löschung notwendig ist). Du akzeptierst, durchgehend während der Nutzung dieses Services, dass du dieses Forum nicht dazu missbrauchen wirst, Inhalte zu veröffentlichen, welche bewusst falsch und/oder verleumderisch, ungenau, beleidigend, vulgär, hasserfüllt, belästigend, obszön, sexuell belästigend, bedrohlich, die Privatsphäre einer Person verletzend oder in irgend einer Art und Weise das Gesetz verletzen. Des Weiteren akzeptierst du, dass du keine urheberrechtlich geschützte Inhalte ohne Erlaubnis des Besitzers in diesem Forum veröffentlichst. Mit dem Klick auf den "Mit der Registrierung fortfahren"-Button, akzeptierst du zudem unsere Datenschutzerklärung und stimmst der Speicherung deiner IP-Adresse und personenbezogenen Daten zu, die dafür benötigt werden, um dich im Falle einer rechtswidrigen Tat zurückverfolgen zu können bzw. permanent oder temporär aus dem Forum ausschließen zu können. Es besteht keine Pflicht zur Abgabe der Einwilligung, dies erfolgt alles auf freiwilliger Basis.   Zusatzinformationen Der Forenbetreiber hat das Recht, Nutzer ohne Angabe von Gründen permanent aus dem Forum auszuschließen. Des Weiteren hat er das Recht, Beiträge, Dateianhänge, Umfrage, Blogeinträge, Galleriebilder oder Signaturen ohne Angabe von Gründen zu entfernen. Mit der Registrierung verzichtest du auf alle Rechte an den von dir erstellten Inhalten, bzw. treten diese an das Unity-Insider.de und Unity-Community.de ab. Dies bedeutet im Klartext, dass das Unity-Insider.de und Unity-Community.de frei über deine Texte verfügen kann, sofern diese nicht wiederum die Rechte anderer verletzen. Es besteht weiterhin kein Anspruch von registrierten Nutzern bzw. ehemaligen registrierten Nutzern darauf, dass erstellte Inhalte und/oder die Mitgliedschaft (User) wieder gelöscht werden (Erhaltung der Konsistenz dieses Forums).   Einwilligungserklärung Wenn du mit der Speicherung deiner personenbezogenen Daten sowie den vorstehenden Regeln und Bestimmungen einverstanden bist, kannst du mit einem Klick auf den Mit der Registrierung fortfahren-Button unten fortfahren. Ansonsten drücke bitte Zurück. Stand: 07.03.2011

Garzec

Members
  • Content count

    231
  • Joined

  • Last visited

  • Days Won

    1

Garzec last won the day on February 2

Garzec had the most liked content!

Community Reputation

5 Neutral

About Garzec

  • Rank
    Advanced Member

Recent Profile Visitors

927 profile views
  1. Ability System aufbauen

    Hallo, ich würde mal gerne wissen, wie man ein Ability System aufbaut. Das Spiel selbst wäre 2D TopDown. Ich habe ein System mit Actions aufgebaut, je nachdem, welche Charakterklasse der Spieler auswählt, werden ihm dann bei Spielstart andere Fähigkeiten zugewiesen. public class Ability { public Ability(Action ability, int cooldown, Sprite icon) { AbilityToUse = ability; Cooldown = cooldown; AbilityIcon = icon; CurrentCooldown = Cooldown; } public Action AbilityToUse { get; set; } public float Cooldown { get; set; } public float CurrentCooldown { get; set; } public Sprite AbilityIcon { get; set; } public bool CheckAbilityReady() { return CurrentCooldown >= Cooldown; } public bool IsOnCooldown() { return CurrentCooldown < Cooldown; } public void ResetCooldown() { CurrentCooldown = 0; } public void IncreaseCooldown() { CurrentCooldown += Time.deltaTime; } } Die Fähigkeiten werden dann bei der Initialisierung der Charakterklasse gesetzt AbilityOne = new Ability(PlayerAbilityOne, CooldownAbilityOne, IconAbilityOne); AbilityTwo = new Ability(PlayerAbilityTwo, CooldownAbilityTwo, IconAbilityTwo); AbilityThree = new Ability(PlayerAbilityThree, CooldownAbilityThree, IconAbilityThree); AbilityFour = new Ability(PlayerAbilityFour, CooldownAbilityFour, IconAbilityFour); und durch die Wahl der Klasse definiert, hier mal als Beispiel der Cleric public class Cleric : CharacterClass { // anderes Zeug ... protected override int CooldownAbilityOne { get { return 3; } } protected override int CooldownAbilityTwo { get { return 7; } } protected override int CooldownAbilityThree { get { return 9; } } protected override int CooldownAbilityFour { get { return 35; } } protected override Sprite IconAbilityOne { get { return "PfadZumIcon"; } } protected override Sprite IconAbilityTwo { get { return "PfadZumIcon"; } } protected override Sprite IconAbilityThree { get { return "PfadZumIcon"; } } protected override Sprite IconAbilityFour { get { return "PfadZumIcon"; } } protected override void PlayerAbilityOne() { // Hier Code für Skill 1 } protected override void PlayerAbilityTwo() { // Hier Code für Skill 2 } protected override void PlayerAbilityThree() { // Hier Code für Skill 3 } protected override void PlayerAbilityFour() { // Hier Code für Skill 4 } } Und im Spiel selbst kann ich dann die Fähigkeiten nutzen und deren Cooldowns verwalten. Jetzt zu meiner Frage, macht man das so? Weil dadurch habe ich ja keine Monobehaviours und könnte im Code noch nicht auf Dinge im Spiel zugreifen, falls man mal beispielsweise 5 Projektile erzeugen will oder der Spieler sich heilen kann und man auf die HP zugreifen will. Gibt es einen besseren Weg? Mit Actions kenne ich mich leider nicht perfekt aus, sie dienen aktuell lediglich dazu, die Methoden als Parameter mitgeben zu können.
  2. Unity Remote 5 für Unity 2017

    Habe grade gesehen, dass man dafür Java / Android Zeugs installieren muss, also das JDK, NDK, etc. das muss ich erstmal machen, aber das benötigt man wohl nur, wenn man den Build direkt aufs Handy packen will.
  3. Unity Remote 5 für Unity 2017

    Ne, am PC bleibt das Spiel unverändert flüssig. Liegt wohl am Handy befürchte ich.
  4. Unity Remote 5 für Unity 2017

    Jeder sagt mir, dass es bei ihm geht. Also entweder habe ich eine Einstellung übersehen oder ich weiß auch nicht mehr weiter.
  5. Hallo, beim Testen des Android Spiels möchte ich gerne per Remote das Spiel auf dem Handy spielen. Eine Remoteverbindung wird aber anscheinend nicht hergestellt. Ich habe ein Huawei P9 Lite. Dort habe ich den Developer Modus aktiviert und verbinde das Handy mit dem Datenübertragungskabel. ich erhalte am Handy die Meldung, dass der Debugging Modus aktiviert ist. In Unity selbst stelle ich unter Edit -> Project Settings -> Editor "Any Android Device" ein. Laut Google / Youtube scheint Unity Remote 5 noch mit Unity 2017 zu funktionieren. Für den Spielstart habe ich beide Reihenfolgen ausprobiert. Zuerst die Engine, dann die App starten / Zuerst die App starten, dann die Engine. Starte ich das Spiel, erhalte ich selbst nach 10 Sekunden kein Bild auf dem Handy.
  6. Spielergesteuerte rotierende Tür

    Dank der freundlichen Hilfe von @Life Is Good sieht die Erzeugung des Pivots so aus protected void CreateDoorPivot(Transform doorTransform, Vector3 pivotPosition) { doorPivot = new GameObject().transform; Quaternion desiredRotation = transform.rotation; transform.rotation = Quaternion.identity; doorPivot.SetParent(transform); doorPivot.position = transform.localPosition + pivotPosition; transform.rotation = desiredRotation; doorPivot.SetParent(null); transform.SetParent(doorPivot); } Da bei den Türen mittlerweile eine große Logik mit Basisklassen vorhanden ist, hier mal das Repository für alle 4 verschiedenen Türen https://github.com/Garzec/Platformer/tree/master/Assets/Scripts/Environment/Objects/Doors
  7. Spielergesteuerte rotierende Tür

    Danke für deine Hilfe, die Rotationen etc. habe ich bereits fertig gehabt, da kann ich die Scripte hinterher auch mal zeigen. Ich hänge "nur" noch an der Erzeugung des Pivotpunktes (ja, den könnte man auch schon in der Szene setzen, aber ich möchte den Pivot per Code erzeugen). [SerializeField] Vector3 pivotPosition; // relative Position zur Tür // steht die Tür auf x bei 0, ist 6 Breit, muss der Pivot auf -3 stehen Transform doorPivot; // Der erzeugte Pivotpunkt private void Start() { doorPivot = new GameObject().transform; // Pivot erzeugen doorPivot.position = transform.localPosition + doorPivot.InverseTransformPoint(pivotPosition); // Pivotpunkt setzen transform.SetParent(doorPivot); // Tür zum Kind des Pivots machen } private void OnDrawGizmos() // Test Malroutine { Gizmos.color = Color.red; if (doorPivot != null) Gizmos.DrawWireSphere(doorPivot.position, 0.5f); Gizmos.DrawWireSphere(transform.position, 0.5f); } Laut den eingezeichneten Kugeln passt das, WENN die Tür in der Szene eine Rotation von 0,0,0 hat. Rotiere ich die Tür beispielsweise um -30 auf der Y Achse, so sieht das Ganze wie folgt aus Mit rotation und localRotation kam ich nicht weit. Kann mir jemand bei dem Rotationsproblem helfen?
  8. Autosteuerung mit Touch Controls

    Das mit dem Button habe ich noch nie gesehen cool. Und Wheelcollider hatte ich auch noch nie benutzt, werde ich mal machen. Danke
  9. Hallo, wenn ich bei einer TopDown Perspektive ein Objekt habe, das sich permanent vorwärts bewegt und nur nach rechts und links einschlagen kann (ein Auto), benötige ich bei den Buttons ein Event, womit ich den Button gedrückt halten kann. Anscheinend gibt es sowas nicht (?), habe also dem Button eine EventTrigger Komponente hinzugefügt und dort die Events PointerDown und PointerUp genommen. Daraus resultiert dann folgender Code public class PlayerInput : MonoBehaviour { public bool IsRotatingLeft { get; set; } public bool IsRotatingRight { get; set; } public void RotateLeft() { IsRotatingLeft = true; } public void StopRotationLeft() { IsRotatingLeft = false; } public void RotateRight() { IsRotatingRight = true; } public void StopRotationRight() { IsRotatingRight = false; } } Ich finde das sieht semi gut aus .. gibt es da einen besseren Weg? Den Spieler rotiere ich dann in seinem Movement Script public class PlayerMovement : MonoBehaviour { [SerializeField] GameObject inputHandler; private Rigidbody rigid; private PlayerInput input; private void Start() { rigid = GetComponent<Rigidbody>(); input = inputHandler.GetComponent<PlayerInput>(); } private void FixedUpdate() { rigid.velocity = transform.forward * 10; float finalRotationY = 0; if (input.IsRotatingLeft && !input.IsRotatingRight) // Auto nach links schwenken finalRotationY -= 3; if (input.IsRotatingRight && !input.IsRotatingLeft) // Auto nach rechts schwenken finalRotationY += 3; transform.Rotate(0, finalRotationY, 0); } } Gibt es eine Möglichkeit, mit dem Wagen ein wenig bogenförmiger zu lenken? Aktuell rotiert der Wagen ja direkt um seine Y-Achse, anstatt einen Bogen zu fahren.
  10. Spielergesteuerte rotierende Tür

    @Zer0Cool was möchtest du denn alles überarbeiten Kommt dir das gesamte Script völlig falsch vor? Deine ersten Vorschläge konnte ich problemlos anpassen.
  11. Spielergesteuerte rotierende Tür

    Wenn ich das mache, rotiert er auf 90 Grad und rotiert dann von 180 Grad zurück auf 0.
  12. Spielergesteuerte rotierende Tür

    Stimmt. Habe deinen Weg getestet. Jetzt macht die Tür bei jeder Interaktion etwas. Das Öffnen funktioniert korrekt, das Schließen noch nicht. Öffnet sich die Tür auf 90 Grad, so schließt sie sich von 180 Grad auf 90 Grad. Danach öffnet sie sich von 90 auf 180 Grad und schließt sich von 270 auf 180. usw.
  13. Spielergesteuerte rotierende Tür

    Achso, ja könnte man auch schreiben. Aktuell zähle ich diesen ja einfach beim Öffnen hoch und beim Schließen wieder runter.
  14. Hallo, aktuell baue ich Scripte für verschiedene Türen zusammen. Dabei habe ich noch ein Problem mit einer rotierenden Tür, die vom Spieler geöffnet / geschlossen wird. Der Spieler kann also mit der Tür interagieren und diese öffnet / schließt sich. Falls eingestellt, öffnet diese sich immer vom Spieler weg, je nachdem, ob er nun vor oder hinter ihr steht. Wie eine Saloon-Tür quasi. [SerializeField] Vector3 targetRotation; // Die Zielrotation beim geöffneten Zustand [SerializeField] float duration; // Rotationsdauer [SerializeField] bool isClosable; // kann man die Tür wieder schließen? [SerializeField] Vector3 pivotPosition; // Position des Pivotpunktes [SerializeField] bool opensAwayFromPlayer; // Saloon Tür? bool isActive = false; // Tür momentan "beschäftigt"? Transform doorPivot; Transform playerTransform; bool isOpen = false; // Tür Status void Start() // Pivotpunkt setzen { playerTransform = Globals.GetPlayerObject().transform; doorPivot = new GameObject().transform; doorPivot.position = pivotPosition; transform.SetParent(doorPivot); } IEnumerator DoorRotation() // Tür öffnen oder schließen { if (isActive) // Solange die Tür sich öffnet oder schließt nichts machen yield break; isActive = true; float counter = 0; // aktueller Rotationstimer Vector3 defaultAngles = doorPivot.eulerAngles; // die Rotation im geschlossenen Zustand Vector3 desiredRotation = targetRotation; // Ziel Rotation geöffnet if (opensAwayFromPlayer && PlayerIsBehindDoor(transform, playerTransform)) // Rotation umdrehen, falls der Spieler hinter der Tür steht desiredRotation = -desiredRotation; Vector3 openRotation = transform.eulerAngles + desiredRotation; // Die tatsächliche Rotation if (!isOpen) // Tür öffnen, falls geschlossen { while (counter < duration) { counter += Time.deltaTime; LerpDoorRotation(doorPivot, defaultAngles, openRotation, counter, duration); yield return null; } if (!isClosable) // Script zerstören, da es nicht mehr benötigt wird -> Tür ist nicht verschließbar Destroy(this); } else // Tür schließen { while (counter > 0) { counter -= Time.deltaTime; LerpDoorRotation(doorPivot, defaultAngles, openRotation, counter, duration); yield return null; } } isOpen = !isOpen; // Tür Status umschalten isActive = false; } bool PlayerIsBehindDoor(Transform door, Transform player) // Prüfen, ob der Spieler hinter der Tür steht { Vector3 doorTransformDirection = door.forward.normalized; Vector3 playerTransformDirection = (player.position - door.position).normalized; return Vector3.Dot(doorTransformDirection, playerTransformDirection) < 0; } void LerpDoorRotation(Transform doorPivot, Vector3 defaultAngles, Vector3 targetRotation, float counter, float duration) // Rotationsbewegung { doorPivot.eulerAngles = Vector3.Lerp(defaultAngles, targetRotation, counter / duration); } Aufrufen tue ich das Ganze über eine Methode namens `Interact()`. Diese startet eine Coroutine mit `DoorRotation()`. Steht der Spieler nun vor der Tür, so rotiert diese nach vorne, also +90 Grad. Möchte ich die Türe wieder schließen, so passiert beim nächsten Aufruf von `Interact()` nichts. Danach rotiert die Tür nicht zurück, sondern weiter, also auf 180 Grad. Danach passiert wieder nichts und danach weiter zu 270 Grad usw. Hat jemand eine Idee? Ich schätze es hat etwas mit der Zeile if (opensAwayFromPlayer && PlayerIsBehindDoor(transform, playerTransform)) desiredRotation = -desiredRotation; zu tun, aber ich brauche diese, damit die Rotation richtig berechnet wird, falls der Spieler hinter der Türe steht.
  15. Rotation um einen Pivotpunkt

    Hallo, für die Vollständigkeit würde ich mal das finale Script hier lassen, vielleicht kann es ja jemand gebrauchen. Vielleicht findet auch jemand Verbesserungen. Mit dem Script ist es jetzt ebenfalls möglich, die Tür so einzustellen, dass sie immer vom Spieler weg rotiert. Beispielsweise eine Saloon Tür. [SerializeField] private Vector3 targetRotation; [SerializeField] private float duration; [SerializeField] private bool closeAgain; [SerializeField] private float waitInterval; [SerializeField] private Vector3 pivotPosition; [SerializeField] private bool opensAwayFromPlayer; private Vector3 defaultRotation; private bool isActive = false; private Transform doorPivot; private Transform playerTransform; private void Start() { playerTransform = Globals.GetPlayerObject().transform; doorPivot = new GameObject().transform; doorPivot.position = pivotPosition; transform.SetParent(doorPivot); defaultRotation = doorPivot.eulerAngles; } private IEnumerator DoorRotation() { if (isActive) yield break; isActive = true; float counter = 0; Vector3 defaultAngles = doorPivot.eulerAngles; if (PlayerIsBehindDoor()) targetRotation = -targetRotation; Vector3 openRotation = transform.eulerAngles + targetRotation; while (counter < duration) { counter += Time.deltaTime; LerpDoor(defaultAngles, openRotation, counter); yield return null; } if (!closeAgain) Destroy(this); yield return new WaitForSeconds(waitInterval); while (counter > 0) { counter -= Time.deltaTime; LerpDoor(defaultAngles, openRotation, counter); yield return null; } isActive = false; } private void LerpDoor(Vector3 defaultAngles, Vector3 targetRotation, float counter) { doorPivot.eulerAngles = Vector3.Lerp(defaultAngles, targetRotation, counter / duration); } private bool PlayerIsBehindDoor() { Vector3 doorTransformDirection = transform.TransformDirection(Vector3.forward); Vector3 playerTransformDirection = playerTransform.position - transform.position; return Vector3.Dot(doorTransformDirection, playerTransformDirection) < 0; } public void Interact() { StartCoroutine(DoorRotation()); } Die Einstellungen im Inspector sind sehr überschaubar. Zusätzlich muss man die Tür nicht unbedingt um ihre y-Achse drehen. Man kann sie drehen und winden, wie man möchte.
×