Programming Contest Nieuwe Stijl: Contest 1 *uitslagen!*

[NMe]

--selecteer--IndexInhoudsopgaveInleidingDe opdrachtDetailsDe regels en andere afsprakenWat kan ik eigenlijk winnen?Om je op weg te helpenTot slot...

Programming Contest Nieuwe Stijl: Contest I

Inhoudsopgave

• 1: Inhoudsopgave
• 2: Inleiding
• 3: De opdracht
• 4: Details
• 5: De regels en andere afspraken
• 6: Wat kan ik eigenlijk winnen?
• 7: Om je op weg te helpen
• 8: Tot slot...

« ·^

Inleiding

In het verleden zijn er, zoals jullie wellicht wel weten, een aantal pogingen geweest om in dit subforum een contest van de grond te krijgen. Helaas strandden die topics meestal vroeg, of in het geval van de meest recente poging laat. Naar aanleiding van een opleving in interesse onder de gebruikers hebben we vanuit de crew besloten om zelf eens een contest op te gaan zetten. We hopen door het zaakje wat strakker te regelen te kunnen zorgen dat iedereen geïnteresseerd blijft.

« ·^

De opdracht

Goed, nu ik je interesse gewekt heb wil je natuurlijk graag weten wat de bedoeling is. Lees gerust verder.

Het is de bedoeling dat jullie een soort van Tetris-AI gaan maken. Eén voor één komen er blokjes voorbij, en het is de bedoeling dat jouw programma die op de meest geschikte plaats neerzet. Dit is verder niet tijdsgebonden; elke speler krijgt een vooraf bepaalde set met blokjes in een vooraf bepaalde volgorde.

Hoe kunnnen we dan zien wie er het beste programmeert? Simpel: bij het laten vallen van de stenen kun je punten uitdelen. Om het eerlijk te houden moet iedereen daarvoor wel dezelfde scoretabel hanteren. We hanteren de volgende puntenlijst:

• Het plaatsen van een blokje: 10 punten
• 1 lijn: 50 punten
• 2 lijnen: 150 punten
• 3 lijnen: 300 punten
• 4 lijnen: 500 punten
• 5 lijnen: 750 punten

Uiteraard gelden de punten voor het wegspelen van lijnen slechts wanneer je het genoemde aantal lijnen tegelijk wegspeelt. De 10 punten voor het plaatsen van een blok komen nog bovenop de lijnbonussen.

Een lijn die je wegspeelt wordt verwijderd uit het speelveld; eventuele "zwevende blokjes" vallen niet naar beneden maar blijven "zweven":

De score zal bijgehouden worden door een parser die we zelf schrijven, maar je kan natuurlijk zelf ook de score bijhouden in je eigen programma. Let wel; de score die jouw programma aangeeft zal door ons niet bekeken en/of vertrouwd worden.

« ·^

Details

Om te voorkomen dat jullie simpelweg een willekeurige Tetris-AI van het internet plukken, maken we de uiteindelijke set met blokken iets exotischer dan de standaardset. Bovendien zullen we de exacte set blokken pas vrijgeven na de sluitingsdatum van de contest, om het zo wat spannender te houden.

De blokken zullen aangeleverd worden in tekstbestanden, met een numerieke naam, oplopend van 0.txt tot en met 9.txt. In deze bestanden kunnen blokken op de volgende manier gedefinëerd worden:

010
1X1

Een 1 geeft, uiteraard, aan dat op die plaats een deel van het blokje zit, en een 0 dat er op die plaats niets zit. De X geeft, naast het feit dat er op die plaats een deel van het blokje zit, ook het rotatiepunt aan waaromheen een blokje geroteerd kan worden. De maximale grootte van de blokjes die wij aanleveren is 5 bij 5, en de verschillende rijen die het blokje vormen worden gescheiden door enters. "Enters" definiëren we zoals dat in Windows gebruikelijk is, dus een carriage return, gevolgd door een linefeed.

Naast de 10 blokjes krijg je nog een ander tekstbestand van ons aangeleverd met de naam game.txt. In dit bestand staan in een willekeurige - maar door ons bepaalde - volgorde de nummers van de blokjes die een voor een voorbij komen. Deze getallen zijn verder nergens door gescheiden; aangezien er maar 10 blokjes zijn betekent één getal gewoon één blokje. Het aantal blokjes in dit bestand is in principe variabel, maar hou er rekening mee dat er een sequentie van wel 100.000 blokjes voor zou kunnen komen.

Natuurlijk zijn er ook details nodig voor het speelveld. Het speelveld is 15 vakjes breed en 40 regels hoog. Wanneer je een blokje niet kwijt kan zonder boven die 40 regels uit te komen, verlies je het spel en leveren de resterende blokjes in onze invoerfile je geen punten meer op. Om blokjes te laten passen mag je ze roteren, maar niet spiegelen.

Om een en ander uit de speelsituatie wat te verduidelijken:

Bewegen (LEFT/RIGHT) en roteren (CW/CCW) doe je in het grijze vlak. Je bent tijdens het roteren en move-en dus vrij van alle onderliggende blokken. Drop je je blokje naast het speelveld (dus "op" de rand, het gearceerde gedeelte) dan is het spel voorbij en krijg je geen punten meer. Komt je blokje na het droppen boven het speelveld uit (dus hoger dan 40) dan is het eveneens afgelopen. Je bent vrij om "buiten het speelveld" left/right te gaan maar veel nut heeft het niet gezien je toch weer terug moet als je je blokje in het speelveld wil droppen.

Wij zullen natuurlijk je inzending moeten kunnen controleren op valide zetten. Daarom zal je programma de volgende commando's, gescheiden door enters, moeten opslaan in een bestand genaamd output.txt:

• MOVE LEFT
• MOVE RIGHT
• ROTATE CW
• ROTATE CCW
• DROP
• NEW BLOCK
• DISCARD

De move-commando's lijken me duidelijk: die worden gebruikt om een blokje één positie naar links te verplaatsen. Rotate CW en CCW zijn respectievelijk nodig voor het rechtsom of linksom roteren van een blok. Het drop-commando laat een blokje naar beneden vallen, en ook het commando om aan te geven dat het volgende blok aangevraagd wordt lijkt me duidelijk. Het is in onze Tetris-implementatie niet mogelijk om een blok langzaam naar beneden te laten zakken. Je plaatst en roteert je blokje dus boven het speelveld en dropt het als het in de juiste positie is in het speelveld.

Het DISCARD commando komt je waarschijnlijk wat onbekend voor. Dat kan kloppen, we hebben het namelijk zelf verzonnen. Je kan het DISCARD commando gedurende je programma 5 keer gebruiken om een blokje in de "prullenbak" te gooien. Het zal dan niet geplaatst worden. Je kan na het geven van een discard commando vervolgens gewoon om een nieuw blokje vragen. Het is raadzaam om zuinig met je discards om te gaan, als ze op zijn, zijn ze op.

Wees echt zuinig op je discards. Het niet gebruiken van een discard levert je wanneer je game over bent 400 bonuspunten per ongebruikte discard op. Er zijn dus situaties denkbaar waarin een discard iets is waar je van kunt profiteren, maar in de meeste gevallen zul je moeten kijken voor een andere oplossing, als je tenminste het hoogst mogelijke aantal punten wilt halen.

Wanneer een blokje geïntroduceerd wordt in het veld na een NEW BLOCK commando dient het in de standaardrotatie te staan zoals in de files gedefiniëerd is. Het rotatiepunt van het blokje wordt precies in het midden van het speelveld geplaatst, dus de X uit de blokjesfile wordt gepositioneerd op de achtste kolom.

Samengevat dient jouw uitvoer er dus altijd als volgt uit te zien:

NEW BLOCK
MOVE LEFT/RIGHT of ROTATE CW/CCW
MOVE LEFT/RIGHT of ROTATE CW/CCW
MOVE LEFT/RIGHT of ROTATE CW/CCW
...
DROP
NEW BLOCK
MOVE LEFT/RIGHT of ROTATE CW/CCW
...
DROP
NEW BLOCK
DROP
NEW BLOCK
DISCARD
NEW BLOCK
MOVE LEFT/RIGHT of ROTATE CW/CCW
...
DROP

En omdat diagrammen meestal duidelijker zijn dan teksten:

« ·^

De regels en andere afspraken

Uiteraard zijn er aan deze contest wat regeltjes verbonden. Om alles eerlijk te laten verlopen hebben we de volgende spelregels in gedachten:

1. Inzendingen voor de contest stuur je naar [e-mail]; neem daarbij in de subjectregel de tekst "Inzending PRG Contest" op en vernoem in de email zelf je nickname. Zet de bestanden niet ergens publiek neer voordat de sluitingsdatum is bereikt, om het zo voor iedereen leuk te houden. Stuur bovendien geen code op waar je niet 100% achter staat. Je eerste inzending is de enige inzending die telt, een tweede inzending zullen we niet in ogenschouw nemen.
2. De sluitingsdatum van de contest is 1 februari 2007. Elke inzending die binnenkomt ná 31 januari om 23:59:59 is helaas uitgesloten van deelneming, zonder uitzondering.

   We hebben bewust een datum gekozen die nog redelijk ver in de toekomst ligt, zodat niemand echt tijdsdruk zal ondervinden en zoveel mogelijk mensen mee kunnen doen, dus ik denk niet dat een strakke deadline een probleem zal zijn.

3. Neem in je mailtje een zip- of rar-file op met daarin een uitvoerbare versie van je programma én je programmacode. In het geval van scripttalen zoals PHP is één bestand uiteraard voldoende.
4. Je mag elke programmeertaal gebruiken die je wilt, met uitzondering van Brainfuck.
5. Samenwerken mag, maar meld het wel even als je dit doet. Neem in je inzendingsmailtje de nicknames van alle programmeurs op.
6. De ingestuurde zipfiles worden na de contest publiek gemaakt, inclusief je sourcecode. Als je hiertegen bezwaar hebt, dan kun je beter niet meedoen. Uiteraard staat het je vrij om elke willekeurige opensource licentie aan je code te verbinden en de credits liggen uiteraard gewoon bij jou.
7. Het geven van foute uitvoer betekent sowieso dat je game over bent en je na dat punt geen punten meer krijgt, en zal in een zwaar geval zelfs leiden tot diskwalificatie en foltering door zeef.

   Een NEW BLOCK commando mag bijvoorbeeld pas na een DROP commando gegeven worden, en niet eerder. Verplaatsingen door de "muren" heen zijn natuurlijk ook niet goed.

8. Alle genoemde tekstbestanden bevinden zich in dezelfde directory als het uitvoerbare bestand van je programma.
9. Als je programma langer dan twee uur nodig heeft om te runnen op de pc die je score berekent, dan heb je pech. Na twee uur wordt je applicatie gestopt en alleen de uitvoer die op dat moment in je output.txt bestand zit wordt gebruikt voor het berekenen van je score. Je kan ervan uit gaan dat de pc waarop je programma gerund wordt sneller is dan de gemiddelde consumentenpc, maar probeer je programma zo snel mogelijk te houden.
10. Het heeft geen zin om bij moderators te gaan vragen naar de lijst met blokjes en de volgorde in welke deze voor gaan komen. Deze files worden namelijk pas ná de sluitingsdatum überhaupt gemaakt, dus we kúnnen je die files niet geven, zelfs al zouden we het willen. Natuurlijk geven we uiteindelijk wel de precieze files vrij, samen met de uitslag van de contest, en niet eerder dan dat om zo een beetje de spanning erin te houden.

Behalve de winnaar in de categorie "hoogste score" zullen er nog winnaars zijn in de categoriën "kortste code" (waarbij uiteraard wel aan de eisen aan de opdracht voldaan dient te worden) en een derde categorie die we nog even geheim houden. Hierbij is het mogelijk dat één persoon in meerdere categoriën de winnaar is.

« ·^

Wat kan ik eigenlijk winnen?

Nou, dat is vrij simpel: niks. Het enige dat je mogelijk aan deze contest overhoudt is eeuwige roem en de eer om de eerste contest in dit nieuwe format gewonnen te hebben.

« ·^

Om je op weg te helpen

Om te zorgen dat jullie alvast van start kunnen gaan bieden we jullie graag twee testsets aan van invoerbestanden. Bedenk wel dat de uiteindelijke bestanden anders zullen zijn!

Uiteraard kunnen game.txt's eventueel nog op andere blokkensets losgelaten worden. Ook kun je voor testdoeleinden (aanbevolen zelfs!) je eigen blokkensets en game.txt bestanden maken. Helemaal leuk wordt het als de deelnemers onderling blokkensets en game.txt bestanden gaan delen en kijken wie het best scoort totdat de deadline gekomen is. Zo zijn je tests niet al te eentonig met altijd dezelfde blokjes en game.txt.

• Testset 1
• Testset 2

« ·^

Tot slot...

...willen we jullie natuurlijk heel veel succes wensen. We hopen dat je er plezier in gaat hebben om aan deze contest mee te doen, en natuurlijk hopen we dat je niet de enige bent. Hoe meer competitie, hoe beter!

Als jullie nog vragen hebben, stel ze dan maar gewoon in dit topic.

[Voor 255% gewijzigd door RobIII op 20-02-2007 01:53]

[NMe]

--selecteer--IndexInzendingenUitslagenAfsluiting

Inzendingen en uitslagen

Inzendingen

Hieronder vind je alle inzendingen die we binnen de deadline hebben ontvangen. De volgorde van deze lijst van inzendingen is alfabetisch en zegt niets over de behaalde score.

BBKingdom

Download: hier
Taal/omgeving: JAVA / Swing

Quote uit bijgaande email:

---

It is a zip file, inside is a readme.txt and a run.bat.

It is written in java, and I connected a swing gui output to the game.

The sources and in the directory bt/src.

---

EdwinG

Download: hier
Taal/omgeving: PHP

Gerco

Download: hier
Taal/omgeving: Java

Marcj

Download: hier
Taal/omgeving: Java / Ant

Quote uit bijgaande email:

---

Maar goed, ik heb wel even een nieuwe zip gemaakt voor de source code. Deze kan eenvoudig gebuild worden met elk programma die ant builds kan doen. Dit kan met ant zelf (http://ant.apache.org) of bijvoorbeeld met eclipse (welke ik zelf veel gebruik). Wanneer deze uitgepakt wordt in zijn eigen directory en in deze directory staat de 0.txt etc.., dan kan alles uitgevoerd worden door middel van ant.

---

.oisyn

Download: hier
Taal/omgeving: C++ / Visual C++ 2005

Quote uit bijgaande email:

---

Generator.exe is de app die je moet hebben. Om te compilen: solution openen in vc++ 2005. In release natuurlijk! De exe komt uiteraard in de Release folder terecht.

---

Soultaker

Download: hier
Taal/omgeving: C

Quote uit bijgaande email:

---

Bij deze ook mijn inzending voor de programming contest. Hoe 'ie werkt spreekt voor zich, maar hij schrijft zetten naar standard output, dus die moet waarschijnlijk even geredirect worden naar "output.txt".

---

The Fox NL

Download: hier
Taal/omgeving: C++ / Visual C++

Quote uit bijgaande email:

---

FoxTetrisAI.exe runnen in de map met de 0 t/m 9.txt en game.txt

Let op: dit programma stopt gewoon als ie klaar is, geen any key toestanden ofzo.
Max looptijd: ~110 minuten

---

zwippie

Download: hier
Taal/omgeving: Java (6.0)

Quote uit bijgaande email:

---

Hier dan mijn inzending voor de tetris contest.
Je hebt wel de Java 6.0 JRE nodig om het uit te voeren, ik hoop dat dat geen probleem is. Op 1.5 of lager zal het niet werken helaas.
In de readme.txt staat meer info.

---

« ·^

Uitslagen

And the votes are in! We hebben alle inzendingen twee keer volledig laten lopen; allereerst met een vrij complexe doch niet onoplosbare blokkenset met 110.000 zetten. Daarna is er gezien de algemene tendens van de scores een nieuwe run gedaan met een iets eenvoudigere blokkenset met 54.321 zetten, die een combinatie is van de testsets 1 en 2 die aan het begin van de contest door ons vrijgegeven zijn.

Na het runnen van de tests, wat overigens op mijn pc gebeurd is, zijn RobIII en ik ieder voor zich in de code van alle inzendingen gedoken, en hebben daar scores aan gehangen. We hebben daarbij onder andere gelet op coding style, de aanwezigheid (of in de meeste gevallen afwezigheid ) van goed, duidelijk commentaar, en de kwaliteit van het gebruikte algoritme. We hebben hier beiden voor iedereen punten aan toegekend, en op basis daarvan nog een categorie gevuld met scores.

En dan nu, zonder verder uitstel: de scores!

Scores bij de complexe blokkenset

1. Marcj met 2.801.900 punten.

   Marcj is de enige die deze blokkenset geheel tot het einde wist uit te spelen, en dat in slechts 48 minuten. Respect!

2. zwippie met 17.900 punten.

   Eigenlijk een diskwalificatie omdat deze inzending niet overweg kon met een blokje dat lege kolommen (met alleen nullen) bevatte, maar omdat het zaakje wel werkte na het verwijderen van die kolom is de entry toch meegeteld. Uiteraard betekende dit wel een puntenaftrek in de code-beoordeling. De applicatie gaf aan game over te zijn na 5 minuten.

3. The Fox NL met 15.610 punten.

   Na 57 minuten running time gaf te app aan game over te zijn.

4. Gerco met 12.940 punten.

   Deze inzending deed er 30 minuten over om game over te gaan.

5. bbkingdom met 6.620 punten.

   bbkingdom had van tevoren al per mail aangegeven dat er een bug in zijn code geslopen was en het zaakje daarom waarschijnlijk niet super zou draaien. Dit klopte redelijk aangezien de app zich na 7 seconden game over verklaarde.

6. EdwinG met 4.470 punten.

   Deze inzending gaf er na 3 minuten de brui aan en verklaarde zichzelf game over.

7. Soultaker met 3.030 punten.

   De Win32-versie van deze inzending liep vast na 8 minuten running time maar leverde wel netjes een te valideren uitvoerfile op.

8. .oisyn met 2.520 punten.

   .oisyn's app heb ik na 2 uur moeten cancelen, aangezien deze teveel tijd ervoor nam. Onze validators gaven echter beiden aan dat er na 37 drops een steentje buiten het veld werd geplaatst, en dus werd het spel "game over" verklaard.

Java-inzendingen werden uitgevoerd met JRE 6.0 (non-server) en de PHP-inzending met PHP 5.2.0.

Scores bij de eenvoudige blokkenset

1. Marcj met 2.079.960 punten.

   Running time: 31 minuten.

2. .oisyn met 1.644.410 punten.

   Running time: 17 minuten.

3. The Fox NL met 1.462.460 punten.

   Running time: 2 uur, waarna de app zichzelf cancelde.

4. Gerco met 1.447.510 punten.

   Running time: 15 minuten.

5. Soultaker met 1.053.360 punten.

   Running time: 2 uur, waarna ik de app cancelde.

6. zwippie met 605.700 punten.

   Running time: 2 uur waarna de app zichzelf cancelde.

7. EdwinG met 7.160 punten.

   Running time: 5 minuten, game over.

8. bbkingdom met 3.520 punten.

   Running time: 3 seconden, game over.

Java-inzendingen werden uitgevoerd met JRE 6.0 (non-server) en de PHP-inzending met PHP 5.2.0.

Beoordeling van de code

Onderstaande punten zijn berekend door het gemiddelde te nemen van de jury-beoordelingen. De punten zijn uitgedeeld op een schaal van 1 tot en met 10.

1. Marcj met een 9.

   Commentaar is zeer overvloedig aanwezig en duidelijk, evenals de code op zich. Bovendien wordt er overal waar dit relevant is op fouten gecontroleerd. Het algoritme voor het berekenen van de best haalbare score zit erg netjes in elkaar, maar dat was natuurlijk wel te verwachten van de winnaar uit beide voorgaande categoriën.

2. zwippie met een 8.

   Nette en goed gedocumenteerde code. Het zoekalgoritme zelf oogt slim; er zijn een aantal optimalisaties ingebouwd die ervoor zorgen dat vertakkingen in de zoekboom die zeer waarschijnlijk slecht aflopen meteen uitgefilterd worden. Dit geeft meer tijd voor het opzoeken van betere alternatieven.

3. Soultaker met een 7,5.

   De code is netjes en overzichtelijk, maar het commentaar valt op door de overvloedige afwezigheid ervan. De main loop is compact en leesbaar, maar dat lijkt, gezien de scores, ook een effect te hebben op de efficiëntie van het algoritme.

4. Gerco met een 7,5.

   De code is duidelijk en netjes ingedeeld in functionele gehelen. Hoewel het commentaar ontbreekt in enkele van de wat meer triviale klassen is het bij de klassen die er echt toe doen wel aanwezig en ook voldoende. Het gebruikte algoritme is geschreven met het oog op het feit dat continuïteit wel eens belangrijker zou kunnen zijn dan "gevaarlijke" constructies om zo vaak mogelijk 5 lijnen tegelijk weg te werken met het risico dat het spel snel voorbij is.

5. .oisyn met een 7,5.

   De code ziet er op zich netjes uit maar is lastig te doorgronden zo zonder commentaar. Foutcontrole is wel aanwezig maar blijkt, gezien de eerste testrun, niet helemaal perfect te werken. Wel is hier het concept toegepast dat een doodlopende tak in de zoekboom niet het einde van het spel hoeft te betekenen. .oisyn gaat terug naar een speelveld uit het verleden en neemt van daaruit een andere vertakking in de hoop dat die wel uit te spelen is.

6. The Fox NL met een 7+.

   In deze inzending werden arrays nogal geschuwd en in plaats daarvan werden bit-operaties op integers toegepast. Hoewel dat in theorie wel een betere performance op zou moeten leveren, is het van het soort micro-optimalisatie dat waarschijnlijk weinig invloed heeft op de snelheid waarmee het programma runt, en des te meer invloed heeft op de onderhoudbaarheid van de code. Dat laatste wordt nog eens verder bemoeilijkt door de rijkelijk gezaaide magic numbers.

7. EdwinG met een 6.

   De code is niet echt makkelijk leesbaar, en de indeling van functionaliteit in verschillende functies is niet helemaal optimaal. Bovendien is de code erg foutgevoelig; er zitten niet veel vangnetten in voor onder andere foute invoer.

8. bbkingdom met een 5+.

   De code oogt vrij onoverzichtelijk en is door vreemde naamgeving en ongebruikelijke constructies lastig te doorgronden. Verder maken de vele magic numbers de code slecht onderhoudbaar. Bovendien zijn er wat tienden van een punt in mindering gebracht omdat de in- en uitvoer niet in dezelfde map stonden als de executable.

« ·^

Afsluiting

Ik denk dat we Marcj wel tot de onbetwiste winnaar van deze contest mogen benoemen. Daarnaast willen we jullie graag bedanken voor het tot een succes maken van deze contest. Wij als crew hebben ons erg vermaakt met de organisatie, en we hopen dat dat ook voor jullie geldt voor wat betreft het meedoen. We hopen jullie allemaal weer terug te zien bij de tweede contest!

[Voor 161% gewijzigd door NMe op 08-02-2007 06:21]

[JochemK]

Leuk, misschien een contest waar ik ook aan mee kan doen, als ik m'n andere projecten een beetje beu ben.

Vraagje: wat let me om van te voren de hele set blokjes in te lezen? Op die manier kun je natuurlijk je plaatsgedrag beinvloeden, zodat je veel makkelijker een groot aantal lines kunt maken, en dus meer punten kunt scoren.

Ik besef me net dat als je dit op zou willen lossen je op de een of andere manier met een afgeschermd deel zou moeten kunnen werken, bijvoorbeeld door client / server te werken, waarbij de server pas een nieuw blok vrijgeeft op het moment dat er een DROP BLOCK is geweest. Volgens mij was dat alleen niet de insteek van de contest.

[.oisyn]

kingjotte schreef op dinsdag 14 november 2006 @ 15:08:
Vraagje: wat let me om van te voren de hele set blokjes in te lezen? Op die manier kun je natuurlijk je plaatsgedrag beinvloeden, zodat je veel makkelijker een groot aantal lines kunt maken, en dus meer punten kunt scoren.

Ja dat kan, het programmeerwerk daarvoor is echter niet makkelijker. Sterker nog, dat is een stuk moeilijker

Ik besef me net dat als je dit op zou willen lossen je op de een of andere manier met een afgeschermd deel zou moeten kunnen werken, bijvoorbeeld door client / server te werken, waarbij de server pas een nieuw blok vrijgeeft op het moment dat er een DROP BLOCK is geweest.

Met pipes werken lijkt me dan handiger (dan hoeft de app niets met netwerk code te doen en kan hij gewoon lezen/schrijven van/naar stdin/stdout)

[NMe]

We hebben er bewust voor gekozen om alle blokjes in één keer uitleesbaar te maken. Op die manier is de uitdaging voor de meer ervaren programmeurs er ook; zij kunnen dan vooruit gaan denken, wat, zoals .oisyn al zegt, een stuk lastiger is.

Een client/serverimplementatie zou, in elk geval naar mijn idee, teveel de focus van het echte "probleem" af halen.

[MrSleeves]

Is het misschien een idee om strafpunten aan een discard te hangen?

Wel leuk dit.. ik ga er over denken om mee te doen.

[Voor 11% gewijzigd door MrSleeves op 14-11-2006 15:18]

[Cloud]

Heel erg leuk initiatief! AI was een van de leukste vakken van de opleiding, maar natuurlijk ook een van de pittigste. Het lijkt me leuk om daar weer eens wat mee te gaan doen. Moet even zien hoeveel tijd ik heb, maar gezien de lekker ruime deadline denk ik dat dat wel goed zit..

iets met tvp enzo

[EdwinG]

Interesant, ik ga zeker meedoen aan deze contest.
Korte opmerking over het diagram: Vanuit 'NEW BLOCK' kan, neem ik aan, ook direct 'DROP' worden gebruikt?

[Creepy]

Geen probleem, dat kan.

[NMe]

MrSleeves schreef op dinsdag 14 november 2006 @ 15:18:
Is het misschien een idee om strafpunten aan een discard te hangen?

Daar was ik inderdaad over aan het denken. Even met Rob (als schrijver van de parser die jullie je score geeft ) overleggen, maar ga er voor het gemak maar even vanuit dat dit inderdaad het geval wordt.

EdwinG schreef op dinsdag 14 november 2006 @ 15:21:
Interesant, ik ga zeker meedoen aan deze contest.
Korte opmerking over het diagram: Vanuit 'NEW BLOCK' kan, neem ik aan, ook direct 'DROP' worden gebruikt?

Hmm, ja, uiteraard.

[Voor 4% gewijzigd door NMe op 14-11-2006 15:24]

[Anoniem: 183031]

Ik moet toegeven dat het een interessante opdracht is en ik ga er zeker eens naar kijken. Hoewel ik nog nooit iets met AI heb gedaan lijkt het me erg interessant dus aan de slag .

[PiepPiep]

Dit is verder niet tijdsgebonden; elke speler krijgt een vooraf bepaalde set met blokjes in een vooraf bepaalde volgorde.

Dus als ik dit goed begrijp mag een programma er een dag lang op staan stampen voordat die een uitkomst geeft?

[megamuch]

volgens mij mis ik 1 optie in het diagram en dat is namelijk helemaal niets doen.

Als ik New Block invoer, en het nieuwe block komt precies waar ik hem wil hebben, mag ik dan gelijk een DROP plaatsen?

[Justifier]

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
Naast de 10 blokjes krijg je nog een ander tekstbestand van ons aangeleverd met de naam <i>game.txt</i>. In dit bestand staan in een willekeurige - maar door ons bepaalde - volgorde de nummers van de blokjes die een voor een voorbij komen, gescheiden door enters.

De game.txt voorbeelden zijn toch anders, daar zit geen enter na elke blokje, of lees ik verkeerd?

[Megamind]

Leuk! Ik keek hier al naar uit

In de TS staat alleen:

In dit bestand staan in een willekeurige - maar door ons bepaalde - volgorde de nummers van de blokjes die een voor een voorbij komen, gescheiden door enters

Alleen in de game.txt van de voorbeelden staan ze gewoon allemaal achter elkaar. Ik neem aan dat je gewoon elk cijfer 1 voor 1 afloopt?

[Gerco]

Dit is een leuke contest, chapeau voor de bedenkers ervan!

Ik ga zeker proberen mee te doen, al moet ik toegeven dat dit probleem moeilijker wordt naar mate ik er langer over nadenk

[NMe]

PiepPiep schreef op dinsdag 14 november 2006 @ 15:28:
[...]

Dus als ik dit goed begrijp mag een programma er een dag lang op staan stampen voordat die een uitkomst geeft?

Liever niet, maar het aangeven van een tijdslimiet is vrij lastig. Ik denk dat het redelijk is om te zeggen dat het programma er op een hedendaagse consumentenpc er niet langer dan een half uur over mag doen bij een sequentie van 100.000 blokjes, maar hoe we het precies formuleren moeten we nog even overleggen.

Justifier schreef op dinsdag 14 november 2006 @ 15:30:
[...]

De game.txt voorbeelden zijn toch anders, daar zit geen enter na elke blokje, of lees ik verkeerd?

Foutje, ik zal het zo even aanpassen. De getallen worden inderdaad zo gepresenteerd als in de voorbeeldfiles is weergegeven.

[Creepy]

Foutje in de omschrijving inderdaad. Aangezien er maximaal maar 10 blokjes zijn (0 tot en met 9) kan het dus prima achter elkaar staan.
* Creepy mept -NMe-. Doe eens niet zo snel

[Voor 12% gewijzigd door Creepy op 14-11-2006 15:36]

[EdwinG]

megamuch schreef op dinsdag 14 november 2006 @ 15:28:
volgens mij mis ik 1 optie in het diagram en dat is namelijk helemaal niets doen.

Als ik New Block invoer, en het nieuwe block komt precies waar ik hem wil hebben, mag ik dan gelijk een DROP plaatsen?

Zie mijn vraag (en reactie van NME), direct DROP uitvoeren is toegestaan.

[MrSleeves]

Gerco schreef op dinsdag 14 november 2006 @ 15:35:
Ik ga zeker proberen mee te doen, al moet ik toegeven dat dit probleem moeilijker wordt naar mate ik er langer over nadenk

Dat probleem heb ik ook..

-NMe- schreef op dinsdag 14 november 2006 @ 15:35:
[...]

Liever niet, maar het aangeven van een tijdslimiet is vrij lastig. Ik denk dat het redelijk is om te zeggen dat het programma er op een hedendaagse consumentenpc er niet langer dan een half uur over mag doen bij een sequentie van 100.000 blokjes, maar hoe we het precies formuleren moeten we nog even overleggen.

Ook lastig om te programmeren. Het is wel heel erg AI als het programma steeds slordiger wordt als het in tijdsnood komt.

Daarbij is de ene taal natuurlijk sneller dan de ander (hoewel dat de keuze is van de programmeur natuurlijk).

[NMe]

MrSleeves schreef op dinsdag 14 november 2006 @ 15:39:
Ook lastig om te programmeren. Het is wel heel erg AI als het programma steeds slordiger wordt als het in tijdsnood komt.

Dat is natuurlijk geen vereiste. Je programma hoeft verder geen tijd bij te houden ofzo, of misschien juist wel en gewoon net voor de tijd om is domweg alle uitvoer die het al heeft gewoon outputten, maar het zou natuurlijk wel heel mooi programmeerwerk zijn als het programma zijn strategie kan aanpassen naarmate de tijd krapper wordt. Het zou natuurlijk wel netter zijn als je gewoon de gulden middenweg kiest en in je programma een evenwicht maakt tussen rekentijd en preciezie.

Daarbij is de ene taal natuurlijk sneller dan de ander (hoewel dat de keuze is van de programmeur natuurlijk).

Dat is inderdaad een keuze die de programmeur zelf maakt en niet iets waar wij rekening mee gaan houden in de tijdslimiet.

[Megamind]

Ik heb even die blokken bekenen en vooral die 9 in set 1 is leuk
Hebben jullie ook een maximale afmeting voor de final blokkenset?

[RobIII]

Megamind schreef op dinsdag 14 november 2006 @ 15:48:

Hebben jullie ook een maximale afmeting voor de final blokkenset?

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
De maximale grootte van de blokjes die wij aanleveren is 5 bij 5

[Voor 30% gewijzigd door RobIII op 14-11-2006 15:51]

[Cloud]

Megamind schreef op dinsdag 14 november 2006 @ 15:48:
Ik heb even die blokken bekenen en vooral die 9 in set 1 is leuk
Hebben jullie ook een maximale afmeting voor de final blokkenset?

Volgens de TS wel

Verder De maximale grootte van de blokjes die wij aanleveren is 5 bij 5, en de verschillende rijen die het blokje vormen worden gescheiden door enters. "Enters" definiëren we zoals dat in Windows gebruikelijk is, dus een carriage return, gevolgd door een linefeed.

edit:
snelle RobIII weer

[Voor 3% gewijzigd door Cloud op 14-11-2006 15:53]

[Megamind]

Oeps sorry, overheen gelezen

[NMe]

Ik heb de TS even aangepast. De belangrijkste wijzigingen zijn de introductie van een tijdslimiet en het feit dat het niet gebruiken van discards je bonuspunten oplevert.

-NMe- schreef op dinsdag 14 november 2006 @ 15:35:
[...]

Liever niet, maar het aangeven van een tijdslimiet is vrij lastig. Ik denk dat het redelijk is om te zeggen dat het programma er op een hedendaagse consumentenpc er niet langer dan een half uur over mag doen bij een sequentie van 100.000 blokjes, maar hoe we het precies formuleren moeten we nog even overleggen.

Het is wat ruimer geworden: op een meer dan gemiddelde pc mag je programma 2 uur staan stampen, daarna wordt het afgekapt en de tot dan toe uitgevoerde output wordt gebruikt om je score te berekenen.

[M-ThijZ]

Leuk initiatief! Ik ga zeker proberen om mee te doen! Als ik er zo vluchtig overheen lees lijkt me het roteren van een blokje me op het eerste gezicht best lastig trouwens.

[RobIII]

M-ThijZ schreef op dinsdag 14 november 2006 @ 16:00:
Leuk initiatief! Ik ga zeker proberen om mee te doen! Als ik er zo vluchtig overheen lees lijkt me het roteren van een blokje me op het eerste gezicht best lastig trouwens.

Dat was iig 1 van de "lastiger" punten van de parser/validator, maar eigenlijk is het, als je er even over nadenkt, best simpel

<hier stond een spoiler>

[Voor 20% gewijzigd door RobIII op 14-11-2006 16:06]

[DaCoTa]

Even vooruitlopend op de uiteindelijk set, komt daar een donut shape in? Dus:

code:

111      010
X01  of  X01
111      010

Oftewel, een blanco, omsloten door niet blanco's? Niet dat dat in principe uit moet maken bij een goede AI, just curious...

Oh ja, en het niet gebruiken van een discard 400 punten, terwijl met het plaatsen van alle blokjes al 5 miljoen punten te behalen zijn?

Leuke contest trouwens, ga zeker meedoen

[Voor 26% gewijzigd door DaCoTa op 14-11-2006 16:15]

[LauPro]

Een gecompileerde versie lijkt me overigens niet echt handig, dit zal namelijk sterk afhankelijk zijn van de architectuur die de maker gebruikt. Het lijkt me beter dat een inzending aan de hand van een Makefile moeten kunnen worden gecompileerd.

[Gerco]

LauPro schreef op dinsdag 14 november 2006 @ 16:17:
Een gecompileerde versie lijkt me overigens niet echt handig, dit zal namelijk sterk afhankelijk zijn van de architectuur die de maker gebruikt. Het lijkt me beter dat een inzending aan de hand van een Makefile moeten kunnen worden gecompileerd.

Als je Makefiles toestaat, moet je ook Visual Studio solutions, Eclipse projects etc toestaan. De meeste .NET/Java programmeurs hebben waarschijnlijk geen idee wat een Makefile is.

Daarnaast is het misschien handig om te zeggen dat je alleen een gecompileerde versie mag aanleveren als die op Platform X, OS Y draait. Anders alleen source.

[Voor 13% gewijzigd door Gerco op 14-11-2006 16:20]

[Creepy]

LauPro schreef op dinsdag 14 november 2006 @ 16:17:
Een gecompileerde versie lijkt me overigens niet echt handig, dit zal namelijk sterk afhankelijk zijn van de architectuur die de maker gebruikt. Het lijkt me beter dat een inzending aan de hand van een Makefile moeten kunnen worden gecompileerd.

Windows, Linux en Mac (OSX) hebben we tot onze beschikking, dus dat lijkt me niet zo'n probleem.
En als je expres een vage architectuur wilt gebruiken die we niet hebben en het is niet compileerbaar op een andere architectuur dan is dat prima: 0 punten want je zooi runt niet

Uiteraard moeten we de source eventueel ook kunnen compileren (Makefile, batch script, scons, qmake, <insert random IDE>, etc.) maar het scheelt gewoon een hoop gerommel voor ons als je een executable mee stuurt.

En aangezien het gros nog steeds met Windows werkt denk ik niet er veel executables tussen zullen zitten die we niet kunnen draaien.

[Voor 14% gewijzigd door Creepy op 14-11-2006 16:31]

[NMe]

DaCoTa schreef op dinsdag 14 november 2006 @ 16:13:
Even vooruitlopend op de uiteindelijk set, komt daar een donut shape in? Dus:

code:

111      010
X01  of  X01
111      010

Oftewel, een blanco, omsloten door niet blanco's? Niet dat dat in principe uit moet maken bij een goede AI, just curious...

Of het erin komt weet ik niet, zoals in de TS staat hebben we de blokjes nog niet gemaakt, en de sequentie ook nog niet. Hou maar rekening mee dat dergelijke blokjes wel mogelijk zijn.

Oh ja, en het niet gebruiken van een discard 400 punten, terwijl met het plaatsen van alle blokjes al 5 miljoen punten te behalen zijn?

Waarom niet? Het kan je net dat kleine beetje extra geven. In dezelfde geest zou je ook kunnen zeggen: "Ach, het maakt niet uit of ik 3 lijnen wegspeel of 4, het scheelt maar 200 punten".

[Dido]

Dit klinkt leuk

Maar het moet dus op een PC kunnen draaien? Zal wel weer Excel VBa worden dan

Hoewel het wel een leuke uitdaging is om dit in S/390 ASM of COBOL'74 te doen

[Voor 29% gewijzigd door Dido op 14-11-2006 16:37]

[Creepy]

Dido schreef op dinsdag 14 november 2006 @ 16:35:
Dit klinkt leuk

Maar het moet dus op een PC kunnen draaien? Zal wel weer Excel VBa worden dan

Hoewel het wel een leuke uitdaging is om dit in S/390 ASM of COBOL'74 te doen

ik heb een PS2, GBA, PSP en DC tot m'n beschikking die unsigned code kunnen runnen. Daarnaast nog een windows mobile 5 phone en een MSX2. En er zijn echt ladingen emulators beschikbaar dus leef je uit. Wel graag instructies erbij voor welk platform je het hebt gemaakt

En als je een echte uitdaging pakt ga je alsnog in brainfuck of whitespace aan de gang

[Voor 7% gewijzigd door Creepy op 14-11-2006 16:51]

[zwippie]

Leuk, een nieuwe contest! Altijd goed om de schaarse vrije tijd mee te vullen.

De donut stukjes waar Dacota het over heeft zijn best pittig. Je kunt de gaten pas vullen als de rij er boven is weggespeeld. Niet onmogelijk, wel moeilijk van te voren op te anticiperen.
Als er maar geen 2-in-1 stukjes zoals deze in komen, dan wordt het wel erg lastig:

code:

1101
100X
1011

Ook lastig is dat je niet langzaam kan droppen. Het wordt dan erg lastig om een stukje ergens tussen te laten kruipen, zoals je dat bij normaal Tetris wel kunt doen. Maar op zich kan ik me wel vinden in dit gedrag, het maakt het een stuk eenvoudiger te programmeren.

Heb er zin in! Mag het ook draaien op een Cell PS3 machine of op een nVidia G80 core?
Geen idee of zulke parallelle beesten zich goed lenen voor dit probleem eigenlijk.

[NMe]

Creepy schreef op dinsdag 14 november 2006 @ 16:43:
En er zijn echt ladingen emulators beschikbaar dus leef je uit.

Hier wil ik graag bij vermelden dat als iemand het in zijn hoofd haalt om een exotisch platform te ondersteunen, de kans groot is dat wij emulators nodig hebben. Emulators vertragen het proces doorgaans, dus hou daar rekening mee in verband met de tijdslimiet.

zwippie schreef op dinsdag 14 november 2006 @ 16:46:
Als er maar geen 2-in-1 stukjes zoals deze in komen, dan wordt het wel erg lastig:

code:

1101
100X
1011

1. Waarom zou dat lastiger zijn dan een simpele "donut"?
2. Pas op, je brengt ons nog op ideeën.

[Voor 28% gewijzigd door NMe op 14-11-2006 16:49]

[Gerco]

Zijn de blokjes altijd een eenheid of is elke combinatie mogelijk? Wat ik bedoel is het volgende: Zijn deze blokjes mogelijk?

Diagonaal connected:

code:

11100
100X0
11100

Disconnected:

code:

10001
10X01
10001

Is er ook zwaartekracht in het spel? MAW: Als ik de steun onder een deel van een blokje weghaal, valt dat stukje dan naar beneden? Of is het puur Tetris - alles schuift precies 1 regel naar beneden, ongeacht de natuurkundige mogelijkheid daarvan - ?

[Voor 34% gewijzigd door Gerco op 14-11-2006 16:55]

[DaCoTa]

Ja, zo ken ik er nog wel 1:

code:

10101
01010
10X01
01010
10101

Maar zoals ik zei, voor goede AI zou het niet uit moeten maken.

Waarom staat er geen laatste regelnummer?

Hmm, denk dat ik maar eens een scheersetje van Ockham ga lenen, denk dat ik hem nog nodig ga hebben

[Voor 21% gewijzigd door DaCoTa op 14-11-2006 16:56]

[Dido]

Creepy schreef op dinsdag 14 november 2006 @ 16:43:
ik heb een PS2, GBA, PSP en DC tot m'n beschikking die unsigned code kunnen runnen. Daarnaast nog een windows mobile 5 phone en een MSX2. En er zijn echt ladingen emulators beschikbaar dus leef je uit. Wel graag instructies erbij voor welk platform je het hebt gemaakt

Maar daar zie ik geen S/390 of AS/400 tussen staan (Z-series of I-series)

Maar me uitleven ga ik zeker doen

[Voor 30% gewijzigd door Dido op 14-11-2006 16:55]

[NMe]

Gerco schreef op dinsdag 14 november 2006 @ 16:51:
Zijn de blokjes altijd een eenheid of is elke combinatie mogelijk?

Alles is mogelijk. Je disconnected blokje zou je in principe "door" twee losstaande pilaren kunnen laten vallen.

Is er ook zwaartekracht in het spel? MAW: Als ik de steun onder een deel van een blokje weghaal, valt dat stukje dan naar beneden? Of is het puur Tetris - alles schuift precies 1 regel naar beneden, ongeacht de natuurkundige mogelijkheid daarvan - ?

Puur Tetris, geen zwaartekracht.

[.oisyn]

-NMe- schreef op dinsdag 14 november 2006 @ 16:55:
Puur Tetris, geen zwaartekracht.

Anders is het wel heel erg makkelijk om steeds 5 lijnen per keer weg te halen

[Creepy]

Dido schreef op dinsdag 14 november 2006 @ 16:55:
[...]

Maar daar zie ik geen S/390 of AS/400 tussen staan (Z-series of I-series)

Maar me uitleven ga ik zeker doen

Als je me de hardware kado doet mag je daarna zo'n entry inleveren hoor

[Bint]

??

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
Je mag elke programmeertaal gebruiken die je wilt, met uitzondering van Brainfuck

Creepy schreef op dinsdag 14 november 2006 @ 16:43:
[...]

En als je een echte uitdaging pakt ga je alsnog in brainfuck of whitespace aan de gang

Wel errug tof dat er eindelijk weer een contest komt. Ik hoop dat ik tijd ga hebben om mee te doen. Kijken of ik uberhaubt een oplossing kan inzenden, de uitdaging is in ieder geval groot genoeg!

[Creepy]

Note de smiley achter brainfuck en het woordje alsnog in mijn stukje

[Michali]

Leuke contest. Ik ga meedoen. Ik ben geen held in AI (heb er nog nooit serieus wat mee gedaan), dus ik ben benieuwd hoe ver ik ga komen. Sowieso erg leerzaam lijkt me.

[Soultaker]

Cool idee!

Begrijp ik nu goed dat een blokje strict boven het speelveld verplaatst/geroteerd wordt voordat 'ie gedropt wordt? (Waarom zijn er dan aparte commando's voor het verplaatsen/roteren i.p.v. een "DROP <kolom> <rotatie>" commando?)

[DaCoTa]

Hmm, als ik goed tel, 72ms per blokje om in 2 uur iig alle 100.000 blokken te kunnen plaatsen. Dat klinkt niet als heel veel, maar ik kan me vergissen

En on a different note: de niet zo consumentenpc, heeft die meerdere cores tot zijn beschikking?

[Voor 24% gewijzigd door DaCoTa op 14-11-2006 17:46]

[RobIII]

DaCoTa schreef op dinsdag 14 november 2006 @ 17:35:
En on a different note: de niet zo consumentenpc, heeft die meerdere cores tot zijn beschikking?

Uiteraard. Hoeveel is echter niet gespecificeerd

Overigens vind ik dit dingen die je code maar mooi moet "detecteren" en daar gebruik van maken als het beschikbaar is en anders dus "graceful" terugvallen naar 1-core-mode ofzo.

[Voor 25% gewijzigd door RobIII op 14-11-2006 19:18]

[seamus21]

Ik ga zeker wel meedoen aan deze contest. Had nog wel een opmerking over de manier waarop je de stukjes nou ergens tussen kan plaatsen.

Kan er meer info in de startpost over de rotatie mogelijkheden. Dat is zeker wel belangrijk bij een Tetris. Dit is trouwens nog best lastig uitdenken als je custom blokken gaat hanteren.

Leesvoer:

SRS, TGM, Wallkick

Of misschien begrijp ik de huidige uitleg van het plaatsen van de blokjes nog niet goed

Mooie SP trouwens en alvast dank aan de modjes die hieraan meegewerkt hebben en hieraan mee gaan blijven werken

[Voor 14% gewijzigd door seamus21 op 14-11-2006 18:17]

[Anoniem: 178962]

Ik ben erg benieuwd naar het eindresultaat, hopelijk is het een multi-threaded neural net oplossing.

Shit nou geef ik mijn strategie al weg

2 uur vind ik best wel kort trouwens, dan maar aan de slag in assembly ofzo om overhead te voorkomen.

Ben benieuwd of er ook losse personen hoog in de lijst zullen komen of dat het enkel teams zullen zijn.

[RobIII]

Anoniem: 178962 schreef op dinsdag 14 november 2006 @ 18:16:
2 uur vind ik best wel kort trouwens, dan maar aan de slag in assembly ofzo om overhead te voorkomen.

Ik vind 2 uur anders best wel lang. Zelfs in een 4GL moet dit prima te doen zijn in een half uur / uur.

[RobIII]

seamus21 schreef op dinsdag 14 november 2006 @ 18:13:

Of misschien begrijp ik de huidige uitleg van het plaatsen van de blokjes nog niet goed

Dat denk ik eerder

Je plaatst boven het veld je blokje ("NEW BLOCK", met de "X" op col. 8 (het midden van het veld)), roteert en moved al naar gelang wat je wil en vervolgens "drop" je het in het veld. Raak je een muur ("je valt er op") aan de zijkant dan ben je af.
Eenmaal losgelaten ("dropped") valt je blokje dus recht naar beneden en kun je niet meer bijsturen (om zo bijv. in hoekjes te komen).

Wat is er nog meer niet duidelijk? De X in de textfiles van de blokjes geeft aan wat het rotatiepunt is (niet dat het er heel veel toe doet, enkel voor positionering).

Zie ook even RobIII in "Programming Contest Nieuwe Stijl: Contes..."

[Voor 9% gewijzigd door RobIII op 14-11-2006 19:24]

[Michali]

Op welke positie begint een nieuwe blokje? Gewoon 0,0 (helemaal links boven in de hoek)?

[RobIII]

Michali schreef op dinsdag 14 november 2006 @ 18:39:
Op welke positie begint een nieuwe blokje? Gewoon 0,0 (helemaal links boven in de hoek)?

Uit de TS:

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
Het rotatiepunt van het blokje wordt precies in het midden van het speelveld geplaatst, dus de X uit de blokjesfile wordt gepositioneerd op de achtste kolom.

Le-zen mensen
In principe is de TS uitvoerig besproken door de crew en zul je aan de hand daarvan moeten werken; zie het als specificaties voor een app die je voor je werk moet schrijven; alles staat er (als het goed is ) in. De enige "wijziging" so far die we niet hadden voorzien is het aftrekken van punten voor een DISCARD.
Mis je iets dan is de kans dus groot dat je er langs leest. (Uiteraard mag je altijd vragen, maar ik adviseer jullie toch om écht goed te lezen)

Nog een algemene tip: Denk niet té Tetris. Hoewel het er wat van weg heeft heb je in Tetris andere mogelijkheden dan in deze contest. Zo kunnen blokjes niet "bijgestuurd" worden tijdens het vallen, begint een blokje "in" het veld bij Tetris itt "boven" het veld in deze contest en kunnen er hele "gemene" blokjes voorkomen (zoals een "O" vormig blok, of een "!" vorm of nog veel exotischer zoals b.v. "ruis" in 5x5 pixels). We zullen trachten, maar ik beloof niks , om de frequentie van de gemene blokjes in de game.txt dan wat lager te houden

[Voor 36% gewijzigd door RobIII op 14-11-2006 19:28]

[EdwinG]

Dat staat in de O.P. al aangegeven, de X staat in kolom 8.

[Michali]

Overheen gelezen

Ik zal het eens wat beter doornemen en geen vragen meer stellen

[Soultaker]

Een andere vraag: mogen we er vanuit gaan dat de blokjes random geselecteerd worden? (In game.txt komen dus alle mogelijke substrings van dezelfde lengte even vaak voor, met een gebruikelijke afwijking).

[DaCoTa]

RobIII schreef op dinsdag 14 november 2006 @ 18:02:
[...]

Uiteraard. Hoeveel is echter niet gespecificeerd

Overigens vind ik dit dingen die je code maar mooi moet "detecteren" en daar gebruik van maken als het beschikbaar is en anders dus "graceful" terugvallen naar 1-core-mode ofzo.

Daar ging ik al van uit, maar als het een single core zou worden, heeft multithreading weinig zin natuurlijk

Iemand een idee hoe in java multicore te detecteren?

[PiepPiep]

Dido schreef op dinsdag 14 november 2006 @ 16:55:
[...]

Maar daar zie ik geen S/390 of AS/400 tussen staan (Z-series of I-series)

Maar me uitleven ga ik zeker doen

Tja.. als je het echt met brute kracht wilt doen kan je altijd nog kijken of je een botnet kan regelen.. veel mensen hebben die nog thuis staan ook, of iig 1 computer van een botnet.

[djluc]

Is het geen idee om die blokjes in game.txt gewoon ergens mee te splitsen? Mochten jullie later een 2e editie bedenken is het wel eenvoudiger om later extra blokjes toe te voegen e.d.

[PiepPiep]

DaCoTa schreef op dinsdag 14 november 2006 @ 19:53:
[...]

Daar ging ik al van uit, maar als het een single core zou worden, heeft multithreading weinig zin natuurlijk

Iemand een idee hoe in java multicore te detecteren?

Ja kan tot een miljoen tellen, kijken hoelang dat duurt en daarna met 2 thread dat doen.. niet echt mooie oplossing eigenlijk, maar ik weet niets van java dus een beter idee heb ik niet

[PiepPiep]

Wat misschien ook nog een leuk idee is, als van de 20 inzendingen er nou 15 de hele reeks af krijgen, is om er dan nog een grotere reeks in te stoppen, kijken hoe ze dan verder komen.

[seamus21]

PiepPiep schreef op dinsdag 14 november 2006 @ 20:14:
Wat misschien ook nog een leuk idee is, als van de 20 inzendingen er nou 15 de hele reeks af krijgen, is om er dan nog een grotere reeks in te stoppen, kijken hoe ze dan verder komen.

Ik denk dat het al1 relevent als ze dan ook dezelfde score behalen na de eerste reeks.

[Janoz]

Staar je iig niet blind op die ene set. Zorg gewoon dat je implementatie werkt volgens de specificaties en niet volgens de aangeleverde sets. (Het staat natuurlijk niemand in de weg om eigen sets te maken.. Heck, desnoods kan men voor de tussentijdse competitie (en vergelijken van de concurentie) oplossingen hiervan samen met scores te posten.)

[Creepy]

seamus21 schreef op dinsdag 14 november 2006 @ 20:36:
[...]

Ik denk dat het al1 relevent als ze dan ook dezelfde score behalen na de eerste reeks.

En als dat het geval is wint de persoon met het minste aantal zetten

[Infinitive]

Ook een tip voor deelnemers: als je begint met het idee van multi-core en "uberfast assembler" in je hoofd, dan begin je verkeerd. Als je dusdanig veel rekenkracht nodig hebt dat je veeeel beter presteerd met een core erbij, dan zou ik wat meer aandacht gaan schenken aan het afsnoeien van je zoekruimte d.m.v. een slimme vuistregel of tactiek. En dat laatste is doorgaans makkelijker als je niet over meerdere cores of assembler hoeft na te denken...

[Creepy]

En let er ook op wat wij (de mods) de programma's draaien. Leuk als het via een botnet of op een gigantische multicore machine moet draaien maar een botnet gaan we niet opzetten en het lijkt me al heel wat als iemand er al een 4 of zelfs 2 core machine (HT en pro duo daargelaten) heeft staan.

Mocht de 2 uur tijd echt te kort zijn voor het gros van de programma's van stellen we de tijd bij of korten we de set in. Maar ik denk dat twee uur tijd zat is voor de gemaakte oplossing draaiend op een "consumenten" PC, tenzij er iemand echt een GBA oplossing instuurt

[Gerco]

Krijgen we ook toegang tot de puntenparser (of een online service die hetzelfde doet) om onze uitvoer (en puntentelling) te valideren? Dat zou de kans op foutieve uitvoer verminderen, lijkt me

[DaCoTa]

Creepy schreef op dinsdag 14 november 2006 @ 21:20:
En let er ook op wat wij (de mods) de programma's draaien. Leuk als het via een botnet of op een gigantische multicore machine moet draaien maar een botnet gaan we niet opzetten en het lijkt me al heel wat als iemand er al een 4 of zelfs 2 core machine (HT en pro duo daargelaten) heeft staan.

Daar heb je gelijk in, maar het gaat naast de competitie ook wel om het educatieve, in ieder geval voor mezelf. Dit probleem leent zich vrij goed voor parallellisatie en wil het wel aangrijpen om er dan ook gebruik van te maken, niet voor de performance, maar voor de ervaring.

[RobIII]

Soultaker schreef op dinsdag 14 november 2006 @ 19:33:
Een andere vraag: mogen we er vanuit gaan dat de blokjes random geselecteerd worden? (In game.txt komen dus alle mogelijke substrings van dezelfde lengte even vaak voor, met een gebruikelijke afwijking).

game.txt is gewoon een file waarin we 100000 "random' cijfers hebben geflikkerd.

djluc schreef op dinsdag 14 november 2006 @ 20:09:
Is het geen idee om die blokjes in game.txt gewoon ergens mee te splitsen? Mochten jullie later een 2e editie bedenken is het wel eenvoudiger om later extra blokjes toe te voegen e.d.

Dit begrijp ik niet helemaal. De game.txt file bevat enkel de volgorde waarin je de blokjes in je speelveld dient te plaatsen. Er is niets dat je tegenhoudt om zelf eenzelfde game.txt te genereren met willekeurige 0..9 cijfers erin. En dat kan 20, 200, 2 miljoen of 2 bagizilijoen cijfers zijn. De sets die wij leveren zijn enkel om mee te testen.
Ook de "blokjes definities" (0.txt t/m 9.txt) uit de aangeleverde sets zijn enkel om mee te stoeien en kunnen in de uiteindelijke competitie heel anders zijn (sterker: tel er maar op). Dat de aangeleverde eerste set erg verdacht veel lijkt op de blokjes uit Tetris is toeval

Gerco schreef op dinsdag 14 november 2006 @ 21:26:
Krijgen we ook toegang tot de puntenparser (of een online service die hetzelfde doet) om onze uitvoer (en puntentelling) te valideren? Dat zou de kans op foutieve uitvoer verminderen, lijkt me

De specs zijn (wat mij betreft) erg duidelijk. Een "puntenparser" (wij hanteren eerder "validator") moet aan de hand van die specs prima te schrijven zijn (sterker: de mijne is al klaar én geschreven aan de hand van die specs* ). We zouden die online kunnen plaatsen, maar ik zou daar voorlopig niet op rekenen. Een deel van de "contest" schuine streep "vingeroefening" is ook het begrijpend lezen van de opdracht en je aan specs houden (Als die ergens dubbelzinnig zouden zijn horen we dat uiteraard graag )

Nog een noot: denk er aan dat de geleverde game.txt's at random zijn gegenereerd. Het is daarom zeker niet onmogelijk dat je na 513 "zetten" al strandt en dat er simpelweg geen manier is om met de geleverde game.txt en blokjes combinatie verder te komen. Als iemand de geleverde game.txt bestanden helemaal "uitspeelt" wil dat nog niet zeggen dat het resultaat correct is (dat bepalen wij wel ). Er is bij de geleverde bestanden dus niet gekeken naar haalbaarheid ofzo.

Ook, en dat is al eerder gezegd, ben je uiteraard geheel vrij om je eigen blokjes en game.txt te verzinnen (waarbij je die laatste natuurlijk ook in "lengte" kunt variëren van 1 tot "oneindig") en daarmee vast aan het oefenen te slaan. En er is niets wat je let om die bestanden onderling uit te wisselen om resultaten te vergelijken of om tussentijdse "mini-competities" te houden.

* Uiteraard is dat niet helemaal eerlijk; wij hebben immers zelf de contest verzonnen en daarom sluit ik eventuele dubbelzinnigheden in de TS ook niet 100% uit. Daarbij; ik heb een "validator" geschreven, die hoeft dus niet zélf te denken maar verwerkt domweg gewoon een input file (jullie output.txt) en controleert of wat daarin staat kan/mag en telt dan de score op op het moment dat je game-over bent of de EOF is bereikt van je output.

[Voor 12% gewijzigd door RobIII op 17-11-2006 01:01]

[Anoniem: 178962]

Het aantal blokjes in dit bestand is in principe variabel, maar hou er rekening mee dat er een sequentie van wel 100.000 blokjes voor zou kunnen komen.

Wel handig zou het minimaal aantal blokjes wat binnenkomt ook vermeld zou worden, dit kan namelijk bij bepaalde strategieen erg praktisch zijn.

[RobIII]

Anoniem: 178962 schreef op dinsdag 14 november 2006 @ 21:46:
[...]


Wel handig zou het minimaal aantal blokjes wat binnenkomt ook vermeld zou worden, dit kan namelijk bij bepaalde strategieen erg praktisch zijn.

Je mag het minimum stellen op (theoretisch) 1. Alleen zou dat betekenen dat iedereen dezelfde score haalt in evenveel zetten. In de praktijk zal dus blijken dat we altijd een joekel van een set zullen aanleveren (10K+).

[Anoniem: 178962]

RobIII schreef op dinsdag 14 november 2006 @ 21:47:
[...]

Je mag het minimum stellen op (theoretisch) 1. Alleen zou dat betekenen dat iedereen dezelfde score haalt in evenveel zetten. In de praktijk zal dus blijken dat we altijd een joekel van een set zullen aanleveren (10K+)

Precies, in de praktijk.

Zoals ik zeg: Het is voor bepaalde strategieen erg handig te weten welke orde van grootte we moeten denken mbt de hoeveelheid blokjes. Als dat minimum 10K is dan is dat prima, maar geef dat dan aan?

[Anoniem: 178962]

RobIII schreef op dinsdag 14 november 2006 @ 18:35:
[...]

Ik vind 2 uur anders best wel lang. Zelfs in een 4GL moet dit prima te doen zijn in een half uur / uur.

Het is in principe in een paar ms te doen.

Echter wanneer je praat over een AI heb je het over iets wat beslissingen adhv variablen moet gaan maken. Meer tijd wil dus zeggen dat je meer mogelijkheden kunt verkennen en dus theoretisch aan een hogere score kunt komen.

Wanneer je een strategie hebt die gebaseerd is op een beginsel van 1 blokje dan heb je dus maar 12 min per blokje-strategie. Als je dan bijvoorbeeld 100.000 blokjes wilt wegspelen heb je (zoals al eerder vernoemd in het topic) maar weinig tijd per blokje.

Meer tijd is altijd beter, dus kan ik toch maar een poging doen te zeggen dat het weinig tijd is zodat jullie het verhogen

[RobIII]

Anoniem: 178962 schreef op dinsdag 14 november 2006 @ 21:53:
[...]
Meer tijd is altijd beter, dus kan ik toch maar een poging doen te zeggen dat het weinig tijd is zodat jullie het verhogen

Hier is een coole: Je tijd_per_blokje = 2_uur / FileLen(game.txt)
Voila: Adaptive Strategy AI

Serieus: Ik heb het even in de groep gegooid of we een minimum gaan stellen. Wat je wel met redelijke zekerheid kunt stellen is dat game.txt max. 2^31-1 aantal digits bevat (Maar ook de max. kom ik zometeen even op terug)

[Voor 4% gewijzigd door RobIII op 14-11-2006 21:59]

[Not Pingu]

Dit lijkt me een heel leuke contest. Ik heb al een globaal idee hoe ik het wil aanpakken en tot februari is zeker genoeg tijd. Erg leuk bedacht!

[djluc]

RobIII schreef op dinsdag 14 november 2006 @ 21:41:
[...]

Dit begrijp ik niet helemaal. De game.txt file bevat enkel de volgorde waarin je de blokjes in je speelveld dient te plaatsen.

Bijvoorbeeld een volgende contest waarin je meer bloktypen maakt o.i.d. Of bijvoorbeeld extra gegevens per vallend blokje.

[seamus21]

Om te voorkomen dat jullie simpelweg een willekeurige Tetris-AI van het internet plukken, maken we de uiteindelijke set met blokken iets exotischer dan de standaardset. Bovendien zullen we de exacte set blokken pas vrijgeven na de sluitingsdatum van de contest, om het zo wat spannender te houden.

Ik begrijp dat er niet met de standaard blokkenset gespeeld gaat worden en misschien komen er een aantal terug. zoals de x111 maar waarom als je toch met exotische blokken gaat spelen deze niet nu alvast geven?

Als je weet met wat voor blokkenset je gaat spelen dan kan je daar je AI beter op richten, Tenzij het precies zo bedoeld is dan wordt het nog een leuke klus om je AI voor te bereiden op nog onbekende blokken en deze zoveel mogelijk punten ermee te laten halen.

Hmz nou post ik waarschijnlijk weer wat obvious ik kan maar beter vast gaan proggen.

[Voor 5% gewijzigd door seamus21 op 14-11-2006 22:22]

[Creepy]

djluc schreef op dinsdag 14 november 2006 @ 22:11:
[...]
Bijvoorbeeld een volgende contest waarin je meer bloktypen maakt o.i.d. Of bijvoorbeeld extra gegevens per vallend blokje.

Bij een nieuwe contest horen nieuwe regels en dus is input en output ook aan te passen. Dat hoeft echt geen invloed te hebben op de contest nu

[Voor 46% gewijzigd door Creepy op 14-11-2006 22:25]

[Creepy]

seamus21 schreef op dinsdag 14 november 2006 @ 22:21:
[...]
Als je weet met wat voor blokkenset je gaat spelen dan kan je daar je AI beter op richten, Tenzij het precies zo bedoeld is dan wordt het nog een leuke klus om je AI voor te bereiden op nog onbekende blokken en deze zoveel mogelijk punten ermee te laten halen.

Bingo!

[seamus21]

Creepy schreef op dinsdag 14 november 2006 @ 22:22:
[...]

Bingo!

Krijg ik nou bonuspunten

[RobIII]

djluc schreef op dinsdag 14 november 2006 @ 22:11:
[...]
Bijvoorbeeld een volgende contest waarin je meer bloktypen maakt

10.txt, 11.txt, 12.txt etc...

djluc schreef op dinsdag 14 november 2006 @ 22:11:
o.i.d. Of bijvoorbeeld extra gegevens per vallend blokje.

Zoals?
En dan nog is dat zorg voor een latere contest. We kunnen nu wel hele file-formaten met blokjes en properties e.d. gaan zitten verzinnen maar het gaat uiteindelijk om een contest ("puzzel" if you will) die opgelost moet worden en niet om een compleet globalized en gestandaardiseerd blokjes-systeem

RobIII schreef op dinsdag 14 november 2006 @ 21:58:
Serieus: Ik heb het even in de groep gegooid of we een minimum gaan stellen. Wat je wel met redelijke zekerheid kunt stellen is dat game.txt max. 2^31-1 aantal digits bevat (Maar ook de max. kom ik zometeen even op terug)

Bij deze dus:
Minimum = 1
Maximum = 2^31-1

Ik zal het niet letterlijk herhalen wat er gezegd is maar het komt er op neer dat er minder gewauweld moet worden en meer geprogged

[Voor 27% gewijzigd door RobIII op 14-11-2006 22:55]

[Creepy]

seamus21 schreef op dinsdag 14 november 2006 @ 22:23:
[...]

Krijg ik nou bonuspunten

[Bint]

heb er vanavond al een beetje over na zitten denken, maar voor een simpel HBO studentje toch best wel pittig werk denk ik! Dit is *iets* moeilijk dan een listbox vullen met 100 regels, haha

[M-ThijZ]

Heb er alvast een object-georienteerd tintje aan gegeven:

code:

class Block
  BASEDIR = "data/blocks/"
    attr_reader :id
        
    def initialize(id)
        @id = id
        @ascii = File.read("#{BASEDIR}#{id}.txt")
    end
    
    def to_ascii
      @ascii
    end 
end

class Level
  BASEFILE = "data/game.txt"
  def self.load
    File.read("#{BASEFILE}").split(//).collect! { |b| Block.new(b.to_i)  } 
  end
end 

class Game
  def initialize
    @level = Level.load
    start
  end
  
  def start
    @level.each do |block|
      puts block.to_ascii
    end
  end
end

Dus nu heb ik een array met Block objecten overgehouden welke een voor een afgehandeld moeten worden. Nadat zo'n Block afgehandeld is neem ik aan dat het een bepaalde positie moet krijgen om zo een grid op te bouwen. Aan dat grid kan dan weer gevraagd worden of een bepaalde verplaatsing mogelijk is.

[RobIII]

M-ThijZ schreef op woensdag 15 november 2006 @ 00:00:
Heb er alvast een object-georienteerd tintje aan gegeven:

code:

<snip>

Dat stukje voldoet iig al niet aan de specs

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
8. Alle genoemde tekstbestanden bevinden zich in dezelfde directory als het uitvoerbare bestand van je programma.

Ik weet niet of je die paden "tijdelijk" er in hebt zitten ofzo, maar ik wil dus nogmaals benadrukken dat het goed lezen van de TS érg belangrijk is
Voldoet je app niet aan de specs uit de TS dan is de kans groot dat je inzending zonder pardon wordt "afgekeurd". We gaan namelijk niet voor alle inzendingen 8 pagina's readme's zitten doornemen met specifieke dingetjes die voor die inzending van belang zijn We moeten naast ons werk en de contest namelijk ook nog gewoon onze fora in de smiezen houden en slotjes uitdelen

[Voor 61% gewijzigd door RobIII op 15-11-2006 00:17]

[seamus21]

Om toch nog even terug te komen op mijn rotatievragen.

Stel ik heb een blok

11x11
10001

Heb zojuist new block gedaan en deze mik ik in mn veld. Ik move hem 5 keer naar rechts dan staat hij dus rechts aan de zijkant. Kan hij dan nog gedraaid worden? Of zit het dus zo dat je eerst al het draaien gewoon doet en dan pas moven en dan drop als hij boven de goede plek hangt.

In het geval dat je hem eerst kan moven, draaien, moven, moven, draaien, whatever dan zijn er volgens mij toch wel een aantal dingen van belang. Wat kan je wel niet waarheen draaien als iets aan de zijkant zit? En wat is de beginstand van het blok als new block gedaan wordt?

Is het roteren helemaal onafhankelijk van wat er al op het speelveld gevuld is? Als je bijvoorbeeld heel hoog zit en een exotisch blok past er wel fysiek in maar als je zou willen roteren kan dit niet in het speelveld waar het blok begint.

Het zal wel zo zijn dat je hem gaat draaien totdat je hem goed hebt en dan boven de juiste plek moved. En de beginorientatie zal wel zijn zoals het blok in het bestand gedefineerd staat maar imho komen deze dingen niet duidelijk genoeg naar voren in de SP.

[Voor 13% gewijzigd door seamus21 op 15-11-2006 00:47]

[DaCoTa]

Je kan draaien en moven tot je een ons weegt, als hij uitsteekt zodra je drop roept, ben je af.

[RobIII]

seamus21 schreef op woensdag 15 november 2006 @ 00:44:
Om toch nog even terug te komen op mijn rotatievragen.

Even een schets:



Bewegen (LEFT/RIGHT) en roteren (CW/CCW) doe je in het grijze vlak. Je blokje begint met rotatie = 0 waarbij de X van het blokje op kolom 8 (midden van het speelveld) wordt geplaatst.
Drop je je blokje naast het speelveld (dus "op" de rand, het gearceerde gedeelte) dan is het game-over. Komt je blokje na het droppen boven het speelveld uit (dus hoger dan 40) dan is het game-over. Je bent vrij om "buiten het speelveld" left/right te gaan maar veel nut heeft het niet gezien je toch weer terug moet als je je blokje in het speelveld wil droppen

DaCoTa schreef op woensdag 15 november 2006 @ 00:46:
Je kan draaien en moven tot je een ons weegt, als hij uitsteekt zodra je drop roept, ben je af.

Juistem! Uitsteekt of "op de rand" valt zeg maar.

seamus21 schreef op woensdag 15 november 2006 @ 00:44:
En wat is de beginstand van het blok als new block gedaan wordt?

<snip>

Het zal wel zo zijn dat je hem gaat draaien totdat je hem goed hebt en dan boven de juiste plek moved. En de beginorientatie zal wel zijn zoals het blok in het bestand gedefineerd staat maar imho komen deze dingen niet duidelijk genoeg naar voren in de SP.

Hey staat er toch écht in.
Dit is de laatste keer dat ik uit de TS quote, volgende keer verwijs ik alleen ernaar en mag je het zelf zoeken in de TS.

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
Wanneer een blokje geïntroduceerd wordt in het veld na een NEW BLOCK commando dient het in de standaardrotatie te staan zoals in de files gedefiniëerd is. Het rotatiepunt van het blokje wordt precies in het midden van het speelveld geplaatst, dus de X uit de blokjesfile wordt gepositioneerd op de achtste kolom.

Ik kan maar niet genoeg benadrukken hoe belangrijk het aandachtig lezen van de TS is.

seamus21 schreef op woensdag 15 november 2006 @ 00:44:
Is het roteren helemaal onafhankelijk van wat er al op het speelveld gevuld is? Als je bijvoorbeeld heel hoog zit en een exotisch blok past er wel fysiek in maar als je zou willen roteren kan dit niet in het speelveld waar het blok begint.

En hier staat niets over in de TS dus mag je (in principe) aannemen dat je daar vrij in bent (zie het schema hierboven).

[Voor 56% gewijzigd door RobIII op 15-11-2006 00:58]

[Soultaker]

Dat van dat rotatieblokje staat er wél lettterlijk in, maar dat erboven droppen was mij ook niet direct duidelijk. Ik ging er nu bijvoorbeeld nog steeds vanuit dat je tijdens het roteren binnen de grenzen van het veld moest blijven (er wordt inderdaad niets over gezegd, dus dan ga ik uit van de worst case; de TS verbiedt me ook niet om via TCP/IP met m'n Beowulf-cluster te verbinden, maar ik vermoed dat dat desondanks niet de bedoeling is ).

Misschien kan -NMe- dat plaatje even in de TS frotten, want dit onderdeel wijkt dermate af van 'normale' Tetris^TM dat er wel een paar bytes extra aan gespendeerd mag worden imo.

[Voor 23% gewijzigd door Soultaker op 15-11-2006 01:01]

[RobIII]

Soultaker schreef op woensdag 15 november 2006 @ 01:00:
maar dat erboven droppen was mij ook niet direct duidelijk. Ik ging er nu bijvoorbeeld nog steeds vanuit dat je tijdens het roteren binnen de grenzen van het veld moest blijven (er wordt inderdaad niets over gezegd, dus dan ga ik uit van de worst case;

Zie TS:

-NMe- schreef op dinsdag 14 november 2006 @ 14:50:
Je plaatst en roteert je blokje dus boven het speelveld en dropt het als het in de juiste positie is in het speelveld.

en

RobIII schreef op dinsdag 14 november 2006 @ 18:42:
Nog een algemene tip: Denk niet té Tetris. Hoewel het er wat van weg heeft heb je in Tetris andere mogelijkheden dan in deze contest. Zo kunnen blokjes niet "bijgestuurd" worden tijdens het vallen, begint een blokje "in" het veld bij Tetris itt "boven" het veld in deze contest

Maar ik geef toe dat dat enigszins "dubbelzinnig" is en niet duidelijk. Ik heb het schema in de TS gezet.

Soultaker schreef op woensdag 15 november 2006 @ 01:00:
Misschien kan -NMe- dat plaatje even in de TS frotten, want dit onderdeel wijkt dermate af van 'normale' Tetris^TM dat er wel een paar bytes extra aan gespendeerd mag worden imo.

Dat schema in de TS opnemen zal ik inderdaad voor zorgen; dat zal wel het e.e.a. verduidelijken.
Done

[Voor 63% gewijzigd door RobIII op 15-11-2006 01:23]

[seamus21]

Ondanks dat ik toch wel goed de TS had doorgelezen heb ik dus blijkbaar over de standaardrotatie heengelezen. Wel goed dat er een schema en uitleg in de TS is gekomen want dat was toch wel noodzakelijke info en was voor meerdere uitleggen vatbaar.

Jk_W schreef op woensdag 15 november 2006 @ 01:14:
Ik denk dat het niet een al te groot probleem moet zijn een werkende versie te krijgen....nu nog de beste werkende versie!

Ik ga voor de nog onbekende wincategorie.

[Voor 36% gewijzigd door seamus21 op 15-11-2006 01:16]

[Jk_W]

Ik ga hier ook aan mee doen, mits mijn studie het toe laat. Er is ruim tijd, dus als ik een begin kan krijgen, kan ik in de kerstvakantie de rest fixxen.

Ik denk dat het niet een al te groot probleem moet zijn een werkende versie te krijgen....nu nog de beste werkende versie!

[RobIII]

seamus21 schreef op woensdag 15 november 2006 @ 01:14:
Ik ga voor de nog onbekende wincategorie.

Meeste bugs?

[seamus21]

RobIII schreef op woensdag 15 november 2006 @ 01:22:
[...]

Meeste bugs?

Als dat de onbekende wincategorie is wordt het lastig een winnaar kiezen.

[zwippie]

De startpost is behoorlijk duidelijk, maar ik mis nog een stukje over het weghalen van een volle regel, de zwaartekracht dus. Nme maakte er ergens wel een opmerking over, maar misschien is het goed om ook in de start er bij te vermelden dat het dus om naive line clear gravity gaat. De klassieke tetris zwaartekracht dus.


Verder:

Ik wordt al weer gek van de i/j for-loops icm x/y coordinaten en formules die je op papier net even anders benadert dan in een array. Je draait ze zo makkelijk om soms...
Maar roteren gaat eigenlijk heel eenvoudig, zoals al ergens werd gezegd. Morgen verder.

[DaCoTa]

zwippie schreef op woensdag 15 november 2006 @ 01:47:
De startpost is behoorlijk duidelijk, maar ik mis nog een stukje over het weghalen van een volle regel, de zwaartekracht dus. Nme maakte er ergens wel een opmerking over, maar misschien is het goed om ook in de start er bij te vermelden dat het dus om naive line clear gravity gaat. De klassieke tetris zwaartekracht dus.

Wat een enorme nerd pagina trouwens Dat er zo ontzettend veel in zulk minitieus detail geschreven is over Tetris. Soms kan ik me echt verbazen over de mensheid... Maar aan de andere kant ook wel weer cool, dus tja, misschien ben ik dan zelf ook wel een bepaald percentage nerd, anders deed ik hier nu niet aan mee

Heb al allerlei ideeën, in ieder geval al een mooie representatie in mijn hoofd en heb de blokjes inmiddels ingelezen. Nu zorgen dat ze geroteerd worden, maar dat is inderdaad weer het standaard x,y,i,j, en potverdorie nu draait hij linksom en spiegelt de zooi terwijl ik rechtsom wil draaien gevloek. Zal wel meevallen gok ik, dit is pas het aanlooploodgieterwerk voordat de echt interessante materie zich aandient.

[RobIII]

zwippie schreef op woensdag 15 november 2006 @ 01:47:
De startpost is behoorlijk duidelijk, maar ik mis nog een stukje over het weghalen van een volle regel, de zwaartekracht dus. Nme maakte er ergens wel een opmerking over, maar misschien is het goed om ook in de start er bij te vermelden dat het dus om naive line clear gravity gaat. De klassieke tetris zwaartekracht dus.

Done.

[Voor 7% gewijzigd door RobIII op 15-11-2006 02:18]

[Anoniem: 178962]

Dat roteren is inderdaad lastig, maar gewoon even op papier doen en je ziet meteen hoe de translatie moet zijn.

Overigens een tipje: Niet on the fly gaan roteren, das alleen maar overhead en je hebt maar 2 uur voor de output. Je hebt 10 vaste blokken (hoewel je dus niet weet hoe die eruit zien) en kunt ze dus gerust van te voren roteren en opslaan.

Ook hoef je maar 1 rotatiealgoritme te gebruiken, namelijk 90 graden met de klok mee. Je kunt dan het resulaat van de vorige rotatie gebruiken om de volgende te berekenen.

En denk eraan: 3x met de klok mee roteren is hetzelfde als 1 tegen de klok in te roteren. Ik denk dus (maar weet het niet zeker) dat je het tegen de klok in roteren maar beter geheel kunt weglaten en enkel met de klok mee kunt gebruiken. Dat maakt qua score niets uit en scheelt je waarschijnlijk overhead (en denkwerk?)

Het is inderdaad hoe meer je ermee doet hoe lastiger het wordt.

Ik ben in ieder geval al zover dat ik een scriptje heb waarmee de resultaten gechecked kunnen worden en de score eruit komt rollen, nu eens hard gaan denken over hoe de 'AI' zal gaan werken.