Variable für die Auswahl einer linkedlist

[zoidberg]

Hallo!

Kann ich eine Variable einsetzen um eine Linkedlist anzusprechen?

Ein Beispiel:

Ich habe Player1() Player2() und Player3() als linkedlist und möchte beim wechsel zwischen den Spielern jede Procedure nur einmal schreiben und nur die passende Linkedlist auswählen.

Also wenn Player2 dran ist wäre das "ForEach Player2()......." Dies sollte etwa so "ForEach AktiverPlayer...." ersetzt werden wobei "AktiverPlayer" die Variable wäre mit der ich erkenne wer dran ist, und die in diesem Fall mit "Player2()" versehen wäre.

Ich mach das derzeit so, daß ich mit Select Case prüfe wer dran ist und dann alles dreimal fast identisch da stehen habe, nur jewils die Linkedlist ausgetauscht.

Vielen Dank!

Gruß, Zoidberg

[#NULL]

ich glaube nicht dass das geht, bin mir aber nicht sicher.

warum machts du es nicht andersherum. du könntest nur eine LL benutzen, und die struktur(?) die du benutzt bekommt dann noch eine feld mit der player-nummer. an den entsprechenden stellen, wo du die LL übergibts, übergibts du dann halt eben immer diese eine, und bei der verarbeitung beachtest du nur die elemente, die in ihrer stuktur die entsprechende player-id haben.

[tobe]

hi zoidberg,

meinst du so:

Code: Alles auswählen

Procedure DebugList(AktiverPlayer())
  ForEach AktiverPlayer()
    Debug AktiverPlayer()
  Next
EndProcedure

NewList Player()

AddElement(Player())
Player() = 1
AddElement(Player())
Player() = 2
DebugList(Player())

[#NULL]

du benutzt ja nur eine LL. ich denke meint wohl eher sowas:

Code: Alles auswählen

NewList a.l()
NewList b.l()

AddElement(a()) :: a()=101
AddElement(a()) :: a()=102
AddElement(a()) :: a()=103

AddElement(b()) :: b()=210
AddElement(b()) :: b()=220
AddElement(b()) :: b()=230

*currentLL()=@a()
ForEach *currentLL()
  Debug *currentLL()
Next

(aber diesen code bitte wieder vergessen, ist unfug)



..lieber so

Code: Alles auswählen

Structure myS
  player.l
  x.l
EndStructure
Global NewList a.myS()
Global currentPlayer.l

AddElement(a())
a()\player=1
a()\x=11
AddElement(a())
a()\player=1
a()\x=22

AddElement(a())
a()\player=2
a()\x=777
AddElement(a())
a()\player=2
a()\x=888


Declare addStuff()
Declare printStuff()


;------------------------- MAIN ---
For currentPlayer=1 To 2
  addStuff()
  printStuff()
Next
;----------------------------------





Procedure addStuff()
  AddElement(a())
  a()\player=currentPlayer
  a()\x= -Random(100)
EndProcedure



Procedure printStuff()
  Debug "currentPlayer: "+Str(currentPlayer)
  ForEach a()
    If a()\player=currentPlayer
      Debug a()\x
    EndIf
  Next
  Debug ""
EndProcedure

[Kaeru Gaman]

hi Zoidberg

muss es denn eine LL sein? ginge auch ein array?

vielleicht gibt es ja ein absolutes maximum, wieviele "elemente" bei einem player stehen können...

dann nimmst du dieses maximum als zweite dimension eines arrays,
und als erste die maximale anzahl player...
die elemente des array wären dann wie jetzt auch strukturierte felder.

mit Player(AktiverPlayer, ElementNr) kannst du dann jedes einzelne element ansprechen.

vorteil wäre dann ja außerdem, dass du "beliebig" viele player teilnehmen lassen könntest.
das wäre bei hardcoded absolut unmöglich, wie du ja siehst.
drei player, drei listen, drei routinen.

der nachteil wäre natürlich, dass du es selbst verwalten musst,
dass die reihe keine lücken hat und wieviele elemente aktuell pro player vorhanden sind,
wenn elemente während einer runde gelöscht werden.


der vorschlag von #NULL ist auch recht praktikabel,
jeder zugriff dauert halt drei mal so lange bei drei playern.

[edel]

du benutzt ja nur eine LL. ich denke meint wohl eher sowas:[...]

Es is aber egal ob er nur eine nutzt oder nicht, solange sich an der
Struktur nichts aendert kann man die Procedure mit jeder weiteren
LinkedList fuettern.

Code: Alles auswählen

Procedure DebugList(AktiverPlayer())
  ForEach AktiverPlayer()
    Debug AktiverPlayer()
  Next
EndProcedure

NewList Player()

AddElement(Player())
Player() = 1
AddElement(Player())
Player() = 2
DebugList(Player())

NewList Player1()

AddElement(Player1())
Player1() = 3
AddElement(Player1())
Player1() = 4
DebugList(Player1())

[#NULL]

>> ..kann man die Procedure mit jeder weiteren LinkedList fuettern

ja, aber eben nur explizit mit einem listen-bezeichner, dass heißt für jede LL muß der aufruf separat erfolgen. zoidberg geht es ja darum alle aufrufe nur einmal zu coden, mit einem platzhalter, den er vorher nur einmal mir der gewünschten LL belegt.

wenn die aufgaben für die einzelnen LLs identisch sind, könnte er den gesamtstart für die einzelnen aufgaben in eine procedure wrappen:

Code: Alles auswählen

Structure myS
  x.l
EndStructure
NewList a.myS()
NewList b.myS()

Declare doTheHoleJobWithThisList(currentLL.myS())
Declare addStuff( currentLL.myS(), xParam.l )
Declare printStuff( currentLL.myS() )

;################################### MAIN ####
doTheHoleJobWithThisList( a() )
Debug ""
doTheHoleJobWithThisList( b() )
;#############################################



; WRAPPER
Procedure doTheHoleJobWithThisList(currentLL.myS())
  addStuff(currentLL(), Random(100) )
  addStuff(currentLL(), Random(100) )
  addStuff(currentLL(), Random(100) )
  addStuff(currentLL(), Random(100) )
  printStuff(currentLL())
  SortStructuredList( currentLL(), 1, OffsetOf(myS\x), #PB_Sort_Long)
  Debug "---"
  printStuff(currentLL())
EndProcedure





; JOB 1
Procedure addStuff( currentLL.myS(), xParam.l )
  AddElement(currentLL())
  currentLL()\x = xParam
EndProcedure

; JOB 2
Procedure printStuff( currentLL.myS() )
  ForEach currentLL()
    Debug currentLL()\x
  Next
EndProcedure 

und wenn die aufgaben für die LLs variieren, kann er noch eine variable einführen, auf die in dem wrapper reagiert wird:

Code: Alles auswählen

;...
;...
Global currLL.l
;################################### MAIN ####
currLL=1
doTheHoleJobWithThisList( a() )
Debug ""
currLL=2
doTheHoleJobWithThisList( b() )
;#############################################



; WRAPPER
Procedure doTheHoleJobWithThisList(currentLL.myS())
  addStuff(currentLL(), Random(100) )
  addStuff(currentLL(), Random(100) )
  addStuff(currentLL(), Random(100) )
  addStuff(currentLL(), Random(100) )
  If currLL=2
    addStuff(currentLL(), 99999999 )
  EndIf
  
  printStuff(currentLL())
  SortStructuredList( currentLL(), 1, OffsetOf(myS\x), #PB_Sort_Long)
  Debug "---"
  printStuff(currentLL())
EndProcedure
;...
;...

[Kaeru Gaman]

ja, aber eben nur explizit mit einem listen-bezeichner, dass heißt für jede LL muß der aufruf separat erfolgen. zoidberg geht es ja darum alle aufrufe nur einmal zu coden, mit einem platzhalter, den er vorher nur einmal mir der gewünschten LL belegt.

so wie ich ihn verstanden hatte, würde er mit edels lösung durchaus zurecht kommen...

...ich hab mich auch noch nicht dran gewöhnt, dass man LLs als argumente übergeben kann....

[zoidberg]

Danke erstmal für die vielen Vorschläge. Ich bin leider noch zu sehr Anfänger um alles zu verstehen. Ich werde es mit #Null's Vorschlag versuchen eine Linked List zu verwenden und dort die Player ID als zusätzliches Feld anzugeben. So kann ich es auch als Variable abfragen.
Das mit dem Übergeben als Argumente sind für mich noch böhmische Dörfer. Ich muss erst noch mehr lernen. Mein derzeitiges Vorhaben ist auch erst mein insgesamt drittes "Projekt". Nach meinem Kindermemory habe ich ja erstmal mit einem Burgangriffsspiel erlernt wie man Dinge bewegt und Kollisisonen erkennt.
Nun versuche ich mit Linkedlists etwas zu experimentieren und versuche mich an Mau Mau, wobei ich da von Maw inspiriert wurde was ja auch hier im Forum vorgestellt wurde.

Danke!

Gruß, Zoidberg

[#NULL]

bei so ein paar player-daten (kleine liste), und einem spiel, wo nicht durchgängig allzuviel berechnet werden muß, wird es keine geschwindigkeits-nachteile haben, immer die gesamte LL zu durchsuchen. du solltest damit also ganz gut fahren.