Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] Mehrdimensionales Array anhand mehrerer Werte durchsuchen aber wie?

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [Erledigt] Mehrdimensionales Array anhand mehrerer Werte durchsuchen aber wie?

    Hallo Community,

    Ich habe ein Array das ca. so aussieht.

    Index: 0 X: 0 Y: 0 Z: 0 Feldart: 1
    Index: 1 X: 0 Y: 0 Z: 1 Feldart: 1
    Index: 2 X: 0 Y: 1 Z: 0 Feldart: 1
    Index: 3 X: 0 Y: 1 Z: 1 Feldart: 1
    Index: 4 X: 1 Y: 0 Z: 0 Feldart: 1
    Index: 5 X: 1 Y: 0 Z: 1 Feldart: 1
    Index: 6 X: 1 Y: 1 Z: 0 Feldart: 1
    Index: 7 X: 1 Y: 1 Z: 1 Feldart: 1
    usw.

    jetzt möchte ich gerne anhand der einträge x,y und z bestimmte einträge raus suchen.
    z.b.
    habe ich Index: 89 x: 17 y: 12 z: 10 Feldart: 1
    und möchte davon nun alle Einträge raussuchen die angrenzende Koordinaten haben, also drunter,drüber, hinter, vor, link und rechts davon.

    Es muss doch eine Möglichkeit geben ähnlich wie array_keys.
    Im Grunde möchte ich schreiben:
    $suche_schlüssel = array_keys($array, 'x' => 18 'y' => 12 'z' => 10)

    Das dass so nicht geht ist mir klar, aber gibt es eine Möglichkeit die ich einfach bisher nicht gefunden habe dies so umzusetzen?

    Hoffe ihr könnt meinen Gedankengängen folgen und mir helfen.

    Mit lieben Grüßen
    Ladriel


  • #2
    Ich bin mir nicht sicher ob ich dich verstehe, aber angrenzend sind doch alle mit x+-1 oder y+-1 oder z+-1?!
    Zitat von nikosch
    Macht doch alle was Ihr wollt mit Eurem Billigscheiß. Von mir aus sollen alle Eure Server abrauchen.

    Kommentar


    • #3
      Ich würde es einfach mal mit programmieren versuchen. Da gibt es so Dinge wie Schleifen und sowas. Eine fertige Funktion für Deine Anforderung wirst du wohl kaum finden.

      Gruß

      Claus
      Pre-Coffee-Posts sind mit Vorsicht zu geniessen!

      Kommentar


      • #4
        Sieht mir auch nach einem Koordinatensystem aus. In dem Fall kennst du doch die umliegenden Arrays oder irre ich mich jetzt?
        Wenn nicht, würde mich interessieren was du da machst oder vor hast.

        Kommentar


        • #5
          Es muss doch eine Möglichkeit geben ähnlich wie array_keys.
          Nein, muss es nicht.
          --

          „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
          Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


          --

          Kommentar


          • #6
            Hallo Community,

            Danke für diesen weniger produktiven Kommentar Thallius den werd ich mir gleich an die Wand nageln.

            Natürlich kenne ich die umliegenden Arrays Fuel, mein Ziel ist es aber das der Server diese nach der Erstellung Automatisch befüllt.
            Um das zu bewergstelligen muss er eigenständig den Index ermitteln um am jeweiligen Feld Änderungen vorzunehmen.
            Im Grunde ist es ein kleiner Weltengenerator.
            Aber vielen dank das du dir meine Frage angesehen hast.

            Und natürlich auch Danke an den Rest, dann muss es wohl oder übel doch die ungünstige alternative über die Schleifen sein.
            Wollte die Rechenlast vermeiden die dabei auftritt und dachte ich frag mal. ^^

            Kommentar


            • #7
              na dann gneerier mal welten.
              bei offtopic und den fortgeschjrittenen tummeln sich neuerdings array_functionen die wohl sowas alles super können sollen. kannste ja mal anschauen.

              wieso du ein index hast, bei x/y/z keine ahnung. kannste dich ja mal über php/matrix schlau machen, bietet ja vorteile wennman bspw. entfernungen im raum berechnen kann.

              Kommentar


              • #8
                So damit ihr jetzt vllt versteht was ich lieber ohne Schleifen gehabt hätte hier meine Spielerei dazu.

                PHP-Code:
                function feld_index_suchen($gesuchter_wert$durchsuchendes_array$durchsuchender_schluessel)
                {
                    
                $such_ergebnis = array();
                   
                    foreach( (array) 
                $durchsuchendes_array as $suche)
                    {
                        if(isset(
                $suche[$durchsuchender_schluessel]) && $suche[$durchsuchender_schluessel] == $gesuchter_wert$such_ergebnis[] = $suche;
                    }
                   
                    return 
                $such_ergebnis;
                }

                $erster_durchgang = (feld_index_suchen($x_wert$karte'x'));
                $zweiter_durchgang = (feld_index_suchen($y_wert$erster_durchgang'y'));
                $dritter_durchgang = (feld_index_suchen($z_wert$zweiter_durchgang'z'));
                echo 
                $dritter_durchgang['0']['id']; 
                Moma nen Index um das ganze inklusive verschiedener Eigenschaften der einzelnen Felder in eine Datenbank zu schreiben und wieder heraus zu holen. Sonst müsste man jedes Feld einzeln in die Datenbank schreiben.
                Und danke für den Tipp mit PHP/Matrix werd ich mir mal anschauen.

                Kommentar


                • #9
                  das hier vielleicht mal als Beispiel

                  http://phpforum.de/archiv_61763_rech..._anzeigen.html

                  Kommentar


                  • #10
                    Moma nen Index um das ganze inklusive verschiedener Eigenschaften der einzelnen Felder in eine Datenbank zu schreiben und wieder heraus zu holen.
                    wenn ich das richtig verstanden habe ist dein feld durch x/y/z hinreichend deffiniert.
                    ein KEY `index` (`x`, 'y`, 'z') könnte ein versuch wert sein.
                    das mit den feldern einzeln verstehe ich nicht.
                    //edit
                    @Fuel: hatte einen link zu ner lib gefunden, welche einem wohl den kram abnimmt.

                    Kommentar


                    • #11
                      Naja nehmen wir eine 3 Dimensionale Karte mit den Werten:
                      Länge 100
                      Breite 100
                      Höhe 20

                      Daraus ergeben sich 200.000 Felder
                      Diese bekommen bisher folgende Eigenschaften
                      Feld_id
                      Standpunkt anhand der Koordinaten x,y,z
                      Feldart (Erde/stein/wasser/etc..)

                      Als erstes wird eine Standartkarte generiert:

                      PHP-Code:
                      $karten_laenge 99;
                      $karten_breite 99;
                      $karten_hoehe 19;
                      $id_array 0;
                      $karte = array();

                      for (
                      $x 0$x <= $karten_laenge$x++)
                      {
                          for (
                      $y 0$y <= $karten_breite$y++)
                          {
                              for (
                      $z 0$z <= $karten_hoehe$z++)
                              {
                                  if (
                      $z == 0// Unterste Reihe
                                  
                      {
                                      
                      $feld_art 1;
                                  }
                                  
                                  elseif (
                      $z 10// über dem Meeresspiegel (Luft)
                                  
                      {
                                      
                      $feld_art 0;
                                  }    
                                  
                                  else
                                  {
                                      
                      $feld_art 2// Erde
                                  
                      }
                                  
                      $id_array += 1;
                                  
                      $karte[] = array('id' => $id_array'x' => $x'y' => $y'z' => $z'art' => $feld_art);
                              }
                          }

                      Wie man sieht wird die Karte Säule für Säule generiert, nun will man aber natürlich keine vorgefertigten Karten sondern "per Zufall" Vorkommen an Stein, Erzen, Wasser etc..

                      Damit aber jeder Spieler ca. die gleichen Startbedingungen hat gibt es immer eine Bestimmte Anzahl an Vorkommen z.B. 25 Steinvorkommen.

                      Also "per Zufall" 25 Felder raussuchen und dort dann "zufällig große Vorkommen generieren lassen. (Den Code muss ich noch schreiben)

                      Um dies zu machen brauchte ich aber die Eindeutige ID der Nachbarfelder die ich anhand der Koordinaten abfragen musste dafür die Funktion im vorherigen Post.

                      Damit ich nachdem die Karte komplett ist nun aber nicht pro Spieler 200.000 Felder und später noch mehr in die Datenbank schreiben muss.

                      Wird aus dem Array ein String gemacht und dieser als Textdatei in die Datenbank geschrieben sobald die Session beendet wird.
                      Loggt der Spieler sich wieder ein wird der String aus der Datenbank geholt und in ein Array umgewandelt um daraus die Map zu generieren.
                      Bzw. Wird das ganze in gewissen Abständen vom Server geholt um verschiedene Aktionen durchzuführen.

                      Das ist zwar rechenintensiver für den Server, reduziert aber den Datenbankverkehr erheblich.

                      Und falls ihr euch fragt warum keine vorgefertigten Lösungen ganz einfach so lern ich nichts dazu.

                      Kommentar


                      • #12
                        Das mit den Matrizen ist keine vorgefertigt Lösung. Es geht nur darum das Problem anders und besser zu lösen. In der 2D oder 3D Spieleprogrammierung geht nichts ohne Matrizen.

                        Es lohnt sich wenigstens mal einen Blick drauf zu werfen. Wenn du dadurch was lernen willst schreibst du dir halt deine eigene Bibliothek mit Matrizen.

                        Bei Matrizen geht es im großen und ganzen darum mehrere Objekte abzubilden, zu verschieben oder zu skalieren.

                        Kommentar


                        • #13
                          Wenn die „Karte“ ein regelmäßiger Würfel/Quader ist, brauchst Du nur einen inkrementierenden Zähler, die Seitenlängen und eine Modulooperation.
                          --

                          „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                          Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                          --

                          Kommentar

                          Lädt...
                          X