Seite 1 von 2
Variable für die Auswahl einer linkedlist
Verfasst: 17.12.2006 01:39
von 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
Verfasst: 17.12.2006 02:13
von #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.
Verfasst: 17.12.2006 02:18
von 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())
Verfasst: 17.12.2006 02:52
von #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
Verfasst: 17.12.2006 03:29
von 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.
Verfasst: 17.12.2006 11:11
von edel
#NULL hat geschrieben: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())
Verfasst: 17.12.2006 12:10
von #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
;...
;...
Verfasst: 17.12.2006 12:51
von Kaeru Gaman
#NULL hat geschrieben: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....
Verfasst: 19.12.2006 00:11
von 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
Verfasst: 19.12.2006 04:31
von #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.