Awalé Programmeerwedstrijd

[Sjaaky]

Programmeer Challenge Jeu Awalé

Dit jaar organiseert het bedrijf waar ik werk voor het eerst een programmeer Challenge. Bij deze programmeerwedstrijd is het de bedoeling dat engines van verschillende deelnemers het spel Awalé tegen elkaar spelen.

Het van oorsprong Afrikaanse spel Awalé zou wel eens het oudste bordspel ter wereld kunnen zijn. Zijn geschiedenis gaat duizenden jaren terug. Door het almaar groeiende aantal toeristen dat door Afrika trekt, wordt Awalé ook op andere continenten steeds bekender en populairder.

Spelregels

In het kort. Awalé is een bordspel dat begint met een bord met 2x6 velden gevuld met elk 4 zaden. Een beurt bestaat uit 2 delen, het zaaien en het eten. Zaaien doe je door alle zaden uit één veld te pakken en deze per stuk tegen de klok in te verdelen in de andere velden. Als in het veld waar je het laatste zaadje zaait zich aan de zijde van de tegenstander bevindt, dan moet je zaden uit dit veld eten als er twee of drie zaden op liggen. Zolang aan deze condities wordt voldaan, gaat men één voor één alle velden af met de wijzers van de klok mee om ook hier zaden te eten. Degene die als eerste meer dan 24 zaden heeft gegeten heeft gewonnen.

Aard en doel van Awale

Het spel wordt gespeeld tussen twee tegenstanders die om beurten ‘zaden zaaien’ op het speelbord en (indien van toepassing) ‘eten’ van het speelbord.
Het is de bedoeling van elke speler om meer zaden te eten dan de tegenstander. Het spel gaat net zo lang door tot dat een van beide spelers niet meer kan zaaien. De speler die gedurende het gehele spel de meeste zaden gegeten heeft is winnaar.
Als beide spelers evenveel zaden hebben gegeten is het spel remise.

Beginopstelling

Het speelbord bestaat uit twee zijden van elk zes velden. Elke speler heeft een zijde ter beschikking.
De speelstukken bestaan uit 48 zaden met identieke waarde en eigenschappen.
Een veld is een locatie op het speelbord waarin zich 0 tot en met 48 zaden kunnen bevinden (het aantal zaden binnen een veld moet altijd een geheel getal zijn). Een veld grenst links en rechts aan één ander veld, met uitzondering van het eerste en laatste veld. Het meest linkse veld grenst aan de linkerkant met het veld van de tegenstander hier tegenover. Het meest rechtse veld grenst aan de rechterkant met het veld van de tegenstander hier tegenover.
Bij het begin van het spel is ieder veld gevuld met vier zaden.

Zaaien

De aan zet zijnde speler kiest een van zijn/haar gevulde velden en neemt alle zaden uit dit veld in zijn/haar hand. Daarna gaat hij/zij tegen de wijzers van de klok in langs alle velden en zaait in ieder veld één zaadje totdat alle in de hand genomen zaden gezaaid zijn. Mocht hierbij het startveld weer aangedaan worden, wordt hier niet gezaaid en wordt met zaaien vervolgd in het direct hierop volgende veld. Het is op deze manier mogelijk dat in een beurt meerdere malen één zaadje in één en hetzelfde veld wordt gezaaid.
Als alle velden van de tegenstander leeg zijn en de aan zet zijnde speler heeft ten minste één mogelijkheid om een zet te doen waarbij ten minste één veld van de tegenstander wordt gevuld met ten minste één zaadje, dan is de speler verplicht deze zet te doen.

Eten

De fase waarin zaden gegeten mogen worden volgt iedere zet nadat de speler het zaaien heeft afgerond.
Bij het bepalen of er zaden en (indien van toepassing) welke zaden gegeten worden gaat men als volgt te werk: men begint bij het veld, waar men in de zaaifase is geëindigd met zaaien van het laatste zaadje. Indien dit veld zich aan de zijde van de tegenstander bevindt, dan wordt dit veld leeg gegeten als er twee of drie zaden op liggen. Zolang aan deze condities wordt voldaan, gaat men één voor één alle velden af met de wijzers van de klok mee om ook hier zaden te eten.
Gegeten zaden worden uit het spel genomen. Er wordt bijgehouden hoeveel zaden door iedere speler gegeten worden.

Einde van het spel

Het spel is afgelopen wanneer een van beide spelers niet meer kan zaaien. Als de andere speler nog zaden op zijn zijde heeft, worden deze aan zijn totaal van gegeten zaden toegevoegd.
Wanneer een identieke positie zich voor de tweede keer voordoet wordt het spel beëindigd. De zaden die zich dan nog op het bord bevinden worden buiten beschouwing gelaten.

Het schrijven van een engine

De engine moet geschreven worden in C# 1.1, 2.0, Java JDK 5 of 6. Dit is een console applicatie die opgestart wordt met als enige parameter de url naar de webservice van de gameserver.
Van de gameserver krijgt één van de spelers het signaal dat de eerste zet gedaan mag worden. Na het doen van de eerste zet krijgt de andere partij te horen welke zet dit was en mag daarop antwoorden. De precieze specificaties van de webinterface zijn nog niet bekend. Zodra de exacte specs (waaronder de wsdl) bekend zijn worden ze hier uiteraard gepost. Maar ook zonder deze specs zijn er een genoeg interessante zaken te programmeren en te bediscussieren.

Er zijn verschillende methoden die je kunt gebruiken voor de AI van je Awalé engine. Voor programmeurs die nog nooit iets met AI gedaan hebben, volgen hier een paar technieken en links in de goede richting.

Minimax

Minimax is een manier om de beste volgende zet te bepalen. Meer hierover op http://en.wikipedia.org/wiki/Minimax_theorem
Om de de zoekboom van minimax te beperken is kunnen alpha-beta pruning en een transposition table gebruikt worden.

Alpha beta pruning

Alpha beta pruning zorgt ervoor dat kansloze beslissingen niet verder doorgerekend worden. Meer hierover op http://en.wikipedia.org/wiki/Alpha-beta_pruning

Transposition table

Het is mogelijk om met verschillende moves op dezelfde stelling uit te komen. Om dezelfde stelling (op een ander punt in de zoekboom) niet steeds opnieuw te evalueren kun je een transposition table gebruiken. Meer hierover http://en.wikipedia.org/wiki/Transposition_table

Neurale netwerken

Neurale netwerken zijn ontworpen naar analogie van het menselijk brein en kan getraind worden op vanalles en nog wat. Meer hierover http://nl.wikipedia.org/wiki/Neuraal_netwerk

Genetisch programmeren

Genetisch programmeren is gebaseerd op het idee van evolutie. Je begint met willekeurige engines die tegen elkaar spelen. De winnaars gaan door naar de volgende generatie, bovendien creëer je nieuwe engines door eigenschappen van winnende engines met elkaar te combineren. Door steeds de winnaars door te laten gaan zullen de engines steeds beter worden. Meer hierover http://nl.wikipedia.org/wiki/Genetisch_algoritme

Pondering

Geen AI techniek, maar wel een mogelijkheid om jouw engine voordeel te geven tov de opponent. Met pondering wordt bedoeld dat je ook 'denkt' in de tijd van de tegenstanders. Elke engine wordt uitgevoerd op een eigen fysieke machine, dus je hebt de hele processor voor jezelf. Het zou zonde zijn deze niet te gebruiken

Meedoen

Je kunt meedoen door je hier http://www.tjip-challenge.com/ik_doe_mee.html in te schrijven.
De introductiebijeenkomst is al zaterdag 23 juni (aanstaande zaterdag), dus wees er snel bij.
Meer informatie vind je op deze site: http://www.tjip-challenge.com

Waarom dit topic

Het doel van dit topic is om de technische kanten van de wedstrijd te bespreken. De belangrijkste component is het bespreken van mogelijke strategieën, zodat dit een leerzaam topic over AI mbt bordspelen wordt. Daarnaast is het al een discussie op zich hoe je het beste een Awalé bord kunt representeren en hoe je daar efficiënt zetten op doorvoert. Hoe efficiënter, hoe meer zetten je vooruit kunt denken en daarmee haal je dus winst tov de tegenpartij .

update 16-07-2007

De nieuwe spelregels staan online. Hierin zijn een aantal puntjes opgenomen die in dit forum naar boven zijn gekomen.
- De link naar de wsdl (2.2.1)(wsdl)
- Je mag je tegenstander alleen leeg eten als dat de enige mogelijke zet is (4.3.3)
- Code blijft eigendom van de deelnemer (5.3)

De finale is verzet naar zaterdag 29 september 2007.
ps. Er is toestemming van de crew.

[ Voor 6% gewijzigd door Sjaaky op 16-07-2007 15:09 ]

[ambi]

http://www.awari.cs.vu.nl/
http://s.helan.free.fr/awele/

[Creepy]

ambi schreef op donderdag 21 juni 2007 @ 09:41:
http://www.awari.cs.vu.nl/
http://s.helan.free.fr/awele/

Ga je ook nog inhoudelijk wat zeggen of laat je het bij deze twee links? Dit is dus niet de bedoeling.

[djc]

Altijd een beetje jammer als de te gebruiken programmeertalen beperkt worden in zo'n wedstrijd. Er zijn nog zoveel andere talen waarin je dit zou kunnen schrijven!

[pagani]

Het is natuurlijk stiekem gewoon ook een wervingsactie voor c#-ers en java-ers.

Overigens had je er ook wel bij mogen vermelden dat als je je IT cv op monsterboard zet je het spel opgestuurd krijgt met de hele wedstrijduitleg (zo kwam ik achter deze wedstrijd)

[sopsop]

Ik zie nergens iets staan over eigendom van de ingezonden code. Bij dit soort acties staat vaak in de kleine lettertjes dat de ingezonden deelnames eigendom van de organisator worden. Wellicht verstandig om dat iig even expliciet te maken.

[Janoz]

Manuzhai schreef op donderdag 21 juni 2007 @ 10:24:
Altijd een beetje jammer als de te gebruiken programmeertalen beperkt worden in zo'n wedstrijd. Er zijn nog zoveel andere talen waarin je dit zou kunnen schrijven!

Meestal wordt er maar 1 taal geaccepteerd. Daarnaast gaat het bij een dergelijke wedstrijd meer over de algoritmen dan over de daadwerkelijke taal. Wanneer je je probleem in de ene taal op zou kunnen lossen dan moet je dat in de andere taal ook wel lukken. Met .net en java heb je alvast een enorme dekking mbt beschikbare kennis bij deelnemenrs (en nee, php is geen serieuze optie bij een dergelijk turnbased communiserende console applicatie)

[Sjaaky]

@ambi:
Deze online spellen zijn handig om een gevoel te krijgen met het spel. Awalé/Awari/... bestaat in verschillende varianten met subtiele verschillen in regels. Ik weet niet of deze online varianten exact dezelfde regels implementeren.
Het spel Awalé is 'uitgeplugd'. Dat wil zeggen dat voor elke bordpositie de optimale volgende zet bekend is. Wij hebben beperkingen opgelegd dat de uiteindelijk gecompileerde code niet meer dan 1MB(1048576 bytes) mag zijn om te zorgen dat er geen complete lookuptables van het spel worden gebruikt. Dat neemt volgens de site van de vu nogal wat data in. Om te voorkomen dat mensen externe databases gaan benaderen, heeft de pc waarop een awale engine draait geen internet verbinding.

@Manuzhai:
Samen met de punten die Janoz aandraagt, is de reden om de programmeertalen te beperken tot c# en java dat wij daar ervaring mee hebben. Bovendien moeten we voor elke taal een omgeving inrichten waarin de engine gecompileerd en uitgevoerd moet worden.

@sopsop:
Eigendom van de code blijft bij de deelnemers.

[ Voor 12% gewijzigd door Sjaaky op 21-06-2007 15:10 ]

[Plons_de_Kikker]

De deelnemers mogen op 1 MB aan gecompileerde source uitkomen.

Betekent dit dat deze 1 MB volledig uit class files moet bestaan. Of mag het programma ook gebruik maken van andere bestanden die binnen deze 1 MB vallen?

[djc]

Janoz schreef op donderdag 21 juni 2007 @ 11:14:
Meestal wordt er maar 1 taal geaccepteerd. Daarnaast gaat het bij een dergelijke wedstrijd meer over de algoritmen dan over de daadwerkelijke taal. Wanneer je je probleem in de ene taal op zou kunnen lossen dan moet je dat in de andere taal ook wel lukken. Met .net en java heb je alvast een enorme dekking mbt beschikbare kennis bij deelnemenrs (en nee, php is geen serieuze optie bij een dergelijk turnbased communiserende console applicatie)

Beetje jammer dat je mij ongeveer al bij voorbaat classificeert als een PHP'er. Ik zou eerder denken aan Python, Ruby, misschien Haskell, OCaml? En *juist* als het alleen maar over het algoritme gaat zou ik liever een taal gebruiken waarbij ik niet allemaal line noise zoals statische typering hoef op te nemen (misschien een beetje een flamebait, maar goed).

[Anoniem: 224082]

Ik wilde toch nog even de regel over het slaan van alle zaden van de tegenstander ter discussie brengen.

Volgens mij zijn er 2 varianten: voor de live toernooien wordt gespeeld dat de zet is toegestaan maar geen zaden slaat (dus alle zaden die normaal gesproken geslagen zouden zijn blijven liggen als het de tegenstander anders na het slaan geen zaden meer heeft).

Voor computerwedstrijden wordt doorgaans de regel aangehouden dat de zet alleen is toegestaan als er geen andere optie is (dus vergelijkaar met de regel dat je de tegenstander alleen mag verhongeren als je geen andere keus hebt)

In het laatste geval is de regel heel simpel: de tegenstander moet nog zaden hebben na jouw zet. Heb je daardoor geen legale zetten dan mag je al je zetten doen en krijg je daarna alle zaden op het bord. De eerste regel is mss wat lastiger te implementeren omdat zetten niet zo makkelijk zijn terug te nemen.

De regel die op de introductiebijeenkomst was voorgesteld is natuurlijk nog simpeler te coden, maar verpest het spel wel een beetje. Ik heb vanochtend nog een potje gespeeld waar het na een zet of 20 (net begonnen) 5-4 voor mn tegenstander stond, waarna ik al haar stenen kon slaan en dan met 43-5 zou winnen. (speelden we uiteraard niet op erg hoog niveau ) Dat is echter tegenstrijdig met de regel dat je iemand niet bewust mag verhongeren en die regel is er ook met een reden (anders is het puur een kwestie van zorgen dat je meer vrije zetten krijgt dan je tegenstander er kan doen en em dan verhongeren en dus winnen). Met de regel op deze manier is verhongeren dus opeens wel weer mogelijk, wat een erg ingrijpende wijziging op het spel is.

Als het een bewuste keuze is om het spel een beetje aan te passen dan lijkt me dit niet de meest geschikte manier, als het geen bewuste keuze is lijkt het me beter een bestaande regel te gebruiken. Aangezien het de bedoeling is dat het winnende programma getest wordt tegen een afrikaanse topspeler lijkt me de laatste variant beter om te voorkomen dat de winnaar met laptop en al wordt opgegeten om zn rare ideeen over dit spel

[Sjaaky]

"Het is niet toegestaan om bestanden te lezen of te schrijven."
De reden hiervoor is om te zorgen dat je geen bestand met resultaten uitrekent in partij 1 en deze weer gaat gebruiken in volgende partijen. Embedded resources in .net bevinden zich wat dat betreft een beetje op de grens. Deze kun je wel lezen, maar niet schrijven. Daarom hebben we besloten dat embedded resources ook niet toegestaan zijn.
Als je een vaste datastructuur met gegevens in je programma wilt gebruiken kun je deze in code uitschrijven en als een struct of class statisch initialiseren. Dat is voor de jury ook een stuk prettiger .

[Matango]

http://www.myriad-online....s/awale/english/rules.htm

Ik heb toevallig net het spel gekocht en lang gezocht naar de meest algemene (en speelbare) regels.
Bovenstaande beschrijving gebruikt deze regels, maar beschrijft niet alle uitzonderingen. Dit linkje doet dat wel. Let vooral op de al vermelde regel van het uithongeren van je tegenstander en de loop of 'Krou'.

[Anoniem: 224115]

Anoniem: 224082 schreef op zondag 24 juni 2007 @ 14:05:
Dat is echter tegenstrijdig met de regel dat je iemand niet bewust mag verhongeren en die regel is er ook met een reden (anders is het puur een kwestie van zorgen dat je meer vrije zetten krijgt dan je tegenstander er kan doen en em dan verhongeren en dus winnen). Met de regel op deze manier is verhongeren dus opeens wel weer mogelijk, wat een erg ingrijpende wijziging op het spel is.

Dat lijkt me wel erg simpel gesteld. Als je meer vrije zetten hebt, betekent het alleen dat je je tegenstander kan dwingen om een zaad op jouw helft te spelen, voordat jij het omgekeerde doet. Maar meestal heb je niet genoeg vrije zetten voordat je tegenstander heel zijn helft heeft leeggespeeld.

En wat betreft de wedstrijd in Senegal: Ik denk dat de winnaar zijn/haar programma nog vast eventueel kan aanpassen voor vertrek.


(leuke google-ads trouwens )

[Anoniem: 224082]

Het is niet makkelijk, maar zo eindigen alle potjes wel. Het aantal stenen dat je pakt door verhongeren is dan vaak veel hoger dan wat je hebt kunnen pakken voor het is afgelopen waardoor het veel belangrijker is dat je de uithonger strijd wint dan dat je wat zaden veroverd. Als je mag verhongeren moet je evaluatie-funcie een hele hoge waarde toekennen aan het aantal zetten dat je kan doen zonder de tegenstander te feeden, terwijl zonder verhongeren het toekennen van een hoge waarde daaraan juist averechts lijkt te werken. Het is dus niet puur een kwestie van de regels even aanpassen...

Zonder de regel dat je alles mag slaan kan je door uithongeren hooguit 15 stenen krijgen, en dat is heel erg onwaarschijnlijk (5,4,3,2,1,0 stenen in de vakjes, maar is lastig een pad naar die situatie toe te bedenken) Denk dat als je er een steentje of 5 a 6 mee krijgt dat het al veel is. Dan moet je dus al minstens 20-23 staan voor het kan. Das wat anders dan dat je bij 4-5 al kan winnen door 39 zaden te slaan in 1 beurt, wat op heel veel manieren kan.

[ Voor 27% gewijzigd door Anoniem: 224082 op 25-06-2007 14:28 ]

[Corniel]

Afgelopen zaterdag was er een kickoff. Zeer gezellig, maar bovenal ook zeer nuttig. Er is beloofd om de wsdl te publiceren: linkje.

Verder nog een stukje code in C# om duidelijk te maken wat de gameserver eigenlijk verwacht:

C#:

using System;

namespace Tjip.Game.Awale.Server
{
    /// <summary>
    /// Represents the status of the Awale server.
    /// </summary>
    public enum GameServerStatus
    {
        /// <summary>
        /// The server has no tournament loaded.
        /// </summary>
        Initializing,
        /// <summary>
        /// A tournament has been loaded but the current round has not been started.
        /// </summary>
        Loaded,
        /// <summary>
        /// A tournament has been started and player can start to play.
        /// </summary>
        Playing,
        /// <summary>
        /// The current round or the tournament has finished.
        /// </summary>
        Finished
    }
    /// <summary>
    /// Represents the status of the players match.
    /// </summary>
    public enum MatchStatus
    {
        /// <summary>
        /// There is no match available for the player.
        /// </summary>
        None,
        /// <summary>
        /// The match has not been started.
        /// </summary>
        Waiting,
        /// <summary>
        /// The match is currently playing.
        /// </summary>
        Playing,
        /// <summary>
        /// The player has won the match.
        /// </summary>
        Won,
        /// <summary>
        /// The players match was ended in a draw.
        /// </summary>
        Draw,
        /// <summary>
        /// The player has lost the match.
        /// </summary>
        Lost
    }
    /// <summary>
    /// Represents the information on who should start the match.
    /// </summary>
    public enum MatchStart
    {
        /// <summary>
        /// The player should start the match.
        /// </summary>
        Player,
        /// <summary>
        /// The players opponent starts the match.
        /// </summary>
        Opponent,
        /// <summary>
        /// The match has already finished.
        /// </summary>
        Finished
    }
    /// <summary>
    /// Interface for the users awale gameserver.
    /// <remarks>
    /// The server will start the match with this board layout.
    /// ==opponent==
    /// -------------------------------------
    /// | (5) | (4) | (3) | (2) | (1) | (0) | == field
    /// |  4  |  4  |  4  |  4  |  4     4  | == grains
    /// |------------------------------------
    /// |  4  |  4  |  4  |  4  |  4  |  4  | == grains
    /// | (0) | (1) | (2) | (3) | (4) | (5) | == field
    /// -------------------------------------
    /// ==player==
    /// </remarks> 
    /// </summary>
    public interface IGameServer
    {
        /// <summary>
        /// Method for checking the status of the server.
        /// </summary>
        /// <returns>Returns an enum representing the current status of the game server.</returns>
        GameServerStatus GetServerStatus();
        /// <summary>
        /// Method for retreiving the players unique tournament identifier.
        /// <remarks>This method is only valid when a tournament has been loaden on the gameserver.</remarks> 
        /// </summary>
        /// <param name="login">The users unique login name.</param>
        /// <returns>The players uinique id in the current loaded tournament.</returns>
        string Logon(string login);
        /// <summary>
        /// Method for checking the status of the current match of the player.
        /// </summary>
        /// <param name="playerId">The players unique identifier.</param>
        /// <returns>An enum representing the match status.</returns>
        MatchStatus GetMatchStatus(string playerId);
        /// <summary>
        /// Method for starting the match.
        /// </summary>
        /// <param name="playerId">The players unique identifier.</param>
        /// <returns>An enum representing the player who should start.</returns>
        MatchStart StartMatch(string playerId);
        /// <summary>
        /// Method for executing a move for the player.
        /// </summary>
        /// <param name="playerId">The players unique identifier.</param>
        /// <param name="field">The players field to move.</param>
        /// <returns>An enum representing the match status after the move.</returns>
        MatchStatus Move(string playerId, int field);
        /// <summary>
        /// The player forfeits the match.
        /// </summary>
        /// <param name="playerId">The players unique identifier.</param>
        void Resign(string playerId);
        /// <summary>
        /// Method for retreiving the opponents last move.
        /// </summary>
        /// <param name="playerId">The players unique identifier.</param>
        /// <returns>
        ///  0..5 : for the opponenets move.
        /// -1    : the opponent has not moved yet.
        /// -2    : the game has finished.
        /// </returns>
        int GetMove(string playerId);
    }
}

Hopelijk verduidelijkt dit de wsdl-interface aanzienlijk. Merk op dat er (waarschijnlijk) nog twee webmethods gaan komen: GetTime() (of als outparam bij Move) en Move(string playerId, int field, string log). Ik heb contact overgehad met de persoon die de gameserver maakt. Defintieve bevestiging hierover zal ik ook hier melden.

Omtrent het al dan niet laten verhongeren: Sjaaky en ik hebben daar mogen met een derde collega nog even kort overleg over, voordat we met een definitieve beslissing komen.

[Soultaker]

Kun je trouwens nog inzending insturen? Of had je je dan vorige week moeten inschrijven?

[Anoniem: 224115]

Op de introductiebijeenkomst zeiden de organisatoren dat mensen zich nog steeds konden inschrijven voor de wedstrijd. Ze moedigden het zelfs aan.
Nog niemand heeft trouwens een inzending gestuurd voor zo ver ik weet. Eerst moet de gameserver online komen, dan kunnen mensen hun programma daar testen.
En volgens mij kun je wachten met je inzending insturen tot de finaledag ergens in september (of was het oktober?).

[Pete]

Ben je verplicht als je je inschrijft om ook echt wat in te leveren?

En moet je bij de finaledag/voorrondedagen aanwezig zijn?

[NaliXL]

Even een vraagje: tijdens de introductiebijeenkomst heb ik gevraagd of het altijd verplicht is om te oogsten wanneer dat mogelijk is. Het antwoord was dat dat niet verplicht is. Uit de wsdl maak ik echter op dat het (nog) niet mogelijk is om het aantal te oogsten velden op te geven:

XML:

- <s:element name="Move">
- <s:complexType>
- <s:sequence>
  <s:element minOccurs="0" maxOccurs="1" name="playerId" type="s:string" /> 
  <s:element minOccurs="1" maxOccurs="1" name="field" type="s:int" /> 
  </s:sequence>
  </s:complexType>
  </s:element>

[Corniel]

Hmm NaliXL, dan heb ik je vraag toen niet goed begrepen denk ik. Ik dacht dat je bedoelde dat je, als er een zet was die eten toestond, díe moest uitvoeren. Maar nu lees ik uit je vraag dat je zelf mag bepalen hoeveel je eet, als je een 'eet'-zet doet. Dat is niet het geval. Als je een zet uitvoert is die maar op één manier af te handelen. Hopelijk is het nu duidelijk. Zo niet, dan hoor ik het wel.

@mstassen: Zaterdag 6 oktober 2007.

@phsmit: Dat zien we wel graag, maar het is niet verplicht. Risico is natuurlijk wel dat je als je programma niet goed werkt, het een typisch geval is van: jammerdebammer. Wij gaan je prog. niet fixen op de dag zelf.

[Anoniem: 224115]

Corniel schreef op woensdag 27 juni 2007 @ 10:37:
@mstassen: Zaterdag 6 oktober 2007.

Dat is wel jammer.
Zaterdag 6 oktober is namelijk ook de dag van de universitaire voorrondes van het bapc, het studentenprogrammeerkampioenschap van de benelux, daar doe ik ook aan mee...
Ik weet niet hoveel studenten er onder de deelnemers zijn, de groep leek me diverser dan ik aanvankelijk dacht, maar waarschijnlijk toch wel wat studenten die graag programmeren. Die moeten dan kiezen.

Maar dan doe ik misschien net als phsmit ook vanaf afstand mee, want bij het universiteitskampioenschap moet ik echt aanwezig zijn. Hopelijk werkt mijn programma dan in 1 keer.

[Anoniem: 224115]

Is het zeker dat de finale op 6 oktober plaatsvindt?
Op http://www.tjip-challenge.com/de_wedstrijd.html staat namelijk dat de finale in september is.

[Sjaaky]

We overwegen momenteel om de finale een weekend eerder te doen. Dat zou dan 29 september worden. Maar hierover horen jullie meer als het definitief is.

[Anoniem: 224115]

Ok, een week vroeger zou heel mooi zijn.

[Anoniem: 224082]

Zou idd jammer zijn als dit op dezelfde dag valt. Ik vind het ook altijd leuk om aan die voorrondes mee te doen.

[Anoniem: 224115]

Aha, ik lees net dat de finaledag met een week vervroegd is. Fantastisch. Ik ga meteen beginnen met coden.

[Soultaker]

Is er trouwens iets bekend over:
• hoe tijd gemeten wordt, en hoeveel tijd je mag gebruiken;
• hoeveel geheugen je mag gebruiken, en
• of multiprocessing toegestaan is, dan wel zin heeft (meerdere cpu's/cores beschikbaar)?

En zijn er criteria voor remise? (Bijvoorbeeld als het spel eindigt met elke speler exact 1 zaad in zijn meest linker kuiltje, dan blijf je oneindig gedwongen zetten.) En als er zo ook een eind aan het spel komt, is het dan remise of wint dan degene met de meeste zaden? Of worden de overgebleven zaden eerst nog verdeeld?

Verder zag ik een Resign methode; geef je daarmee het spel op, of alleen de overgebleven zaden? Zodra ik 25 van de 48 zaden heb, heb ik gegarandeerd gewonnen, en zou ik best het spel willen beëindigen, maar natuurlijk niet als ik daarmee de wedstrijd opgeef.

[ Voor 10% gewijzigd door Soultaker op 04-07-2007 00:59 ]

[Anoniem: 224115]

Er kan geen oneindige lus ontstaan vanwege deze regel:

Sjaaky schreef op donderdag 21 juni 2007 @ 09:31:
Het spel is afgelopen wanneer een van beide spelers niet meer kan zaaien. Als de andere speler nog zaden op zijn zijde heeft, worden deze aan zijn totaal van gegeten zaden toegevoegd.
Wanneer een identieke positie zich voor de tweede keer voordoet wordt het spel beëindigd. De zaden die zich dan nog op het bord bevinden worden buiten beschouwing gelaten.

Ik neem aan dat onder identieke positie wordt verstaan dat er in elk vakje evenveel zaadjes zitten én dat dezelfde speler aan zet is.

edit: Dus in jouw situatie wint degene met de meeste zaadjes zonder die 2 zaadjes op het bord mee te rekenen.

[ Voor 7% gewijzigd door Anoniem: 224115 op 05-07-2007 17:00 ]

[Plons_de_Kikker]

Soultaker schreef op woensdag 04 juli 2007 @ 00:58:
Is er trouwens iets bekend over:
• hoe tijd gemeten wordt, en hoeveel tijd je mag gebruiken;
• hoeveel geheugen je mag gebruiken, en
• of multiprocessing toegestaan is, dan wel zin heeft (meerdere cpu's/cores beschikbaar)?

Ik ben ook wel benieuwd wanneer de test server online komt...

[NaliXL]

Even uit nieuwsgierigheid: is de te winnen reis voor 1 of voor 2 personen? (niet dat ik verwacht te winnen)

Met nog maar een tweetal maanden te gaan: ben inmiddels wel erg benieuwd naar de testserver...

[alienfruit]

Een leuk boek over vergelijkbare spellen: http://www.anthrosource.n...525/aa.1961.63.6.02a00490

[Sjaaky]

De testserver is inmiddels online! Gebruik deze url naar de webservice:
http://test.tjipchallenge.com/awale/GameTestServer.asmx

Je speelt tegen een randomengine, of te wel een engine die willekeurige zetten doet. We hebben gemerkt dat er nog wel een paar bugs in zitten. Zo zijn nog niet alle regels geïmplementeerd. Daar wordt aan gewerkt. Er is in ieder geval iets om het protocol goed tegen te testen.

[Soultaker]

Ik heb al wat zitten proberen met de SOAP interfaces, maar ik zag een aantal rare dingen:
• Je kunt altijd GetMove doen en dan krijg je een zet terug, ook als het eigenlijk je eigen beurt is. Is dat de bedoeling? Of doet de AI momenteel gewoon een random (geldige?) zet als daarom gevraagd wordt, simpelweg om te testen?
• Als ik Resign krijg ik altijd een HTTP 500 Internal Server Error. Doe ik iets fout, of is dit niet geïmplementeerd?
• Puur nieuwsgierigheid: krijgen jullie niet een heleboel dode sessies van mensen die een spel beginnen en dan afsluiten, of gooien jullie die na een periode van in activiteit weg?

Verder zag ik nergens documentatie van hoe de interface hoort te werken (op een hoger nivo dan de WSDL specificeert). Klopt dat, of heb ik wat gemist? (Ik ga er nu maar vanuit dat je met een random naam mag inloggen, en de teruggestuurde identifier als playerId moet gebruiken.)

[Corniel]

Soultaker schreef:
Ik heb al wat zitten proberen met de SOAP interfaces, maar ik zag een aantal rare dingen:
Je kunt altijd GetMove doen en dan krijg je een zet terug (..) Of doet de AI momenteel gewoon een random (geldige?) zet als daarom gevraagd wordt, simpelweg om te testen?

Het is niet de bedoeling dat je een nieuwe move terugkrijgt. Ik zal kijken wat er mis gaat.

Als ik Resign (..)

Ik denk dat dat idd niet geimplementeerd is op de test server.

Krijgen jullie niet een heleboel dode sessies van mensen die een spel beginnen en dan afsluiten, of gooien jullie die na een periode van in activiteit weg?

Heel veel is er tot op heden niet getest. Daarnaast: SOAP sessions zijn standaard 120 seconden als ik het wel heb. Wel wordt er per nieuw spel een XML bestand aangemaakt en weggeschreven op de server. Dus daar ruim ik af en toe wat in op.

Verder zag ik nergens documentatie van hoe de interface hoort te werken (..)

Volgens mij staat er in een eerder bericht van mij in deze draad een Interface met commentaar. Daar staat duidelijk in wat er verwacht wordt. Als er vragen zijn wil ik die natuurlijk best beantwoorden.

En even voor de duidelijkheid: deze testserver werkt iets anders dan de echte server: Normaal gesproken moet er een toernooi worden aangemaakt en paringen, voordat een toernooi kan starten . Deze testserver maakt als iemand inlogt direct een toernooi aan met één ronde tegen de random engine. Deze opzet maakt het ook mogelijk dat er meerdere tests tegelijk gehouden worden.

Maar meld fouten gerust, dan zal ik - of sjaakie - die verwerken.

[Soultaker]

Corniel schreef op donderdag 16 augustus 2007 @ 10:07:
Volgens mij staat er in een eerder bericht van mij in deze draad een Interface met commentaar. Daar staat duidelijk in wat er verwacht wordt. Als er vragen zijn wil ik die natuurlijk best beantwoorden.

Ah, stom van me; ik had allleen naar de link in de topicstart gekeken. De versie met commentaar maakt alles duidelijk.

[Plons_de_Kikker]

Corniel schreef op donderdag 16 augustus 2007 @ 10:07:
[...]

Het is niet de bedoeling dat je een nieuwe move terugkrijgt. Ik zal kijken wat er mis gaat.

Heb je inmiddels al gevonden waar het mis gaat? Volgens mij worden er nog steeds zetten teruggeven elke keer. Verder viel het me ook op dat er elke keer na 1 of 2 zetten al een winnaar 'Won' gegeven wordt.

[...]

Ik denk dat dat idd niet geimplementeerd is op de test server.

Gebeurt dit alsnog?

En even voor de duidelijkheid: deze testserver werkt iets anders dan de echte server: Normaal gesproken moet er een toernooi worden aangemaakt en paringen, voordat een toernooi kan starten . Deze testserver maakt als iemand inlogt direct een toernooi aan met één ronde tegen de random engine. Deze opzet maakt het ook mogelijk dat er meerdere tests tegelijk gehouden worden.

Dit is uiteraard wel zo handig. Ik denk echter wel dat het belangrijk is dat de testserver de echte server zo dicht mogelijk benaderd. Dit om problemen tijdens de wedstrijd te voorkomen. Is het misschien een idee om een java file te kunnen uploaden, waarna deze automatisch gecompiled wordt en tegen zichzelf gaat spelen? Of om de deelnemers een account te geven op de (gekopieerde?) game omgeving, zodat ze zelf in de 'echte' omgeving kunnen testen?

[Corniel]

Er is vandaag een grote update gedaan. Als het goed zitten alle regels er nu in. Resign is geimplenteerd en de speelstatus - waar iets mis ging, is gefixt.

Er zijn nogal wat vragen binnengekomen waarom niet exact dezelfde implentatie is gekozen voor de testserver en de wedstrijdserver. Er zijn twee belangrijke redenen:

1. Iemand die direct inlogt moet direct kunnen spelen, bij de wedstrijdserver worden paringen rondens en spelers beheerd, dat management gedeelte is ongewenste/onnodige overhead in het test geval.
2. We kunnen niet afdwingen dat maar een deelnemer tegelijk test, er moest dus iets geregeld worden waarmee je kan garanderen dat spelers geen last hebben van elkaar.

Verschillen
Door deze verschillende implementaties zijn er een aantal verschillen:

• De testserver is altijd in playing modus. Bij inloggen wordt direct een toernooi gemaakt met een ronde, en een ronde tegen random engine. Deze partij wordt ook direct gestart.
• Je krijgt bij het vragen om een zet altijd een nieuwe zet terug. Het is nogal veel werk om dat af te vangen voor iets wat een goed programmeur nooit zou doen. In de wedstrijd situatie krijg je nogmaals je laatste zet terug.
• Speel tempo is 200 minuten ipv van 2.
• De random speler let niet op, of hij moet feeden. Als hij verzaakt, verliest hij.

Logging
Op http://test.tjipchallenge.com/awale/log kan je de xml log vinden van de gespeelde partijen. Dit is een geserialiseerde representatie van het toernooi dat je speelt. Hier zou in iedergeval genoeg informatie moeten staan om te annalyseren wat er mis gaat.

Hopelijk zijn nu alle problemen en onduidelijkheden weggenomen. O ja, er was nog een vraag over de WSDL:

Als ik met behulp van WSDL2Java de WSDL http://test.tjipchallenge.com/awale/GameTestServer.asmx?WSDL omzet naar java files, dan wordt het webadres verkeerd omgezet. Dit wordt in de java files namelijk http://test.tjipchallenge.com/awale/GameTestServer.asmx in plaats van http://test.tjipchallenge.com/awale/GameTestServer.asmx?WSDL.

Dit is een klein 'conflict' tussen de Java en MS wereld. De '?WSDL' heeft MS toegevoegd om de exacte gegenereerde WSDL te laten zien. In de Java wereld is dit niet gebruikelijk. Sowieso - zie reglement - moeten de applicaties door middel van een parameter kunnen worden opgestart die de server-URL bevat, dus je code moet er zo uitzien dat je dit adres kan overschrijven.

[W4rlock]

De server lijkt zich inderdaad beter aan de regels te houden! Kreeg zojuist wel de volgende SOAP exception:

Server was unable to process request.The process cannot access the file 'C:\AwaleData\test.blaat.xml' because it is being used by another process.

[ Voor 6% gewijzigd door W4rlock op 30-08-2007 20:08 ]

[Anoniem: 84650]

Corniel schreef op maandag 25 juni 2007 @ 16:24:
[..] Merk op dat er (waarschijnlijk) nog twee webmethods gaan komen: GetTime() (of als outparam bij Move) en Move(string playerId, int field, string log). Ik heb contact overgehad met de persoon die de gameserver maakt. Defintieve bevestiging hierover zal ik ook hier melden.

Hoe staat het met deze eventuele extra methodes?

Daarnaast heb ik nog een lijst met vragen, waarvan sommige al eerder gesteld zijn:

1. Op wat voor soort machine wordt de applicatie uitgevoerd? Bijvoorbeeld: welke CPU, hoeveel cores, hyperthreading, hoeveel geheugen, snelheid geheugen, grootte L1 + L2 cache, operating system, java server vm of java client vm.
2. Vraag al eerder gesteld: Hoe wordt de tijd gemeten?
3. Bij welke situatie geeft de StartMatch methode de waarde 'Finished' terug?
4. Bij welke situatie geeft de Move methode de waarde 'Waiting' of 'None' terug? Moet de Move method call dan opnieuw worden uitgevoerd?
5. Wacht de Move methode op de zet van de tegenstander voordat deze een waarde retourneert? (aangezien Move ook Won/Draw/Lost kan teruggeven)
6. Wacht de GetMove methode op de zet van de tegenstander voordat deze een waarde retourneert? Of moet je regelmatig pollen?
7. Welke waarde moet je meegeven als 'login' parameter bij het Logon request? Of wordt dit op de dag van de challenge gespecificeerd?
8. Is het uitvoeren van een Move method call na een gefinished spel een reden om de partij direct verloren te verklaren? (zie spelregels: 3.1.3)
9. Als op de testserver direct een match wordt gestart, wie is dan als eerste aan de beurt? Dit wordt namelijk teruggegeven bij de StartMatch method call, en er is geen manier om dat op te vragen.
10. Java gebruikt standaard maar 25% van het beschikbare systeemgeheugen. Naar ik aanneem heeft .Net deze limitatie niet. Voor Java zijn command-line opties beschikbaar om deze limiet te verhogen. Is het mogelijk een batch-file mee te leveren die de Java applicatie start met de juiste opties voor geheugen, client/server VM en performance-optimalisatie?
11. Vraag al eerder gesteld: Wordt onder 'identieke positie' verstaan dat er in elk vakje evenveel zaadjes zitten én dat dezelfde speler aan zet is? Of dat alleen in elk vakje evenveel zaadjes zitten?
12. Vraag al eerder gesteld: Is de te winnen reis voor 1 of voor 2 personen?

Het lijkt me ook handig dat de overige tot nu toe onbeantwoorde vragen in dit topic van een antwoord worden voorzien .

@ Sjaaky of Corniel: Als jullie op een aantal vragen al antwoord hebben, post dat aub zo snel mogelijk. Het duurt nog slechts 4 weken... m.a.w. de antwoorden hoeven niet verzameld te worden voordat ze gepost worden.

[ Voor 4% gewijzigd door Anoniem: 84650 op 01-09-2007 21:52 ]

[Anoniem: 84650]

Bugreports test gameserver

Als de laatste move van de random engine ongeldig is (niet feeden als dit wel moet), wordt deze move niet opgeslagen in het XML bestand. Zie: http://test.tjipchallenge...243d79f1881c5087ef9e9.xml

Ook wordt de laatste winnende move niet opgeslagen als gewonnen wordt:
http://test.tjipchallenge...74c9e96818afdca203122.xml

Hier doet mijn engine nog de move 3, deze is niet in het XML-bestand terug te vinden. Zonder deze move heeft mijn engine nog niet gewonnen, omdat de score nog 24 is.

Als de laatste zet ongeldig is komt er iets raars in het XML bestand terecht.
Onderin staat de laatste zet, positie 0. De FinishReason bovenin het bestand is echter: The player 'login' executed a move on field '5', the move is invalid. Maar, positie 5 is niet gezet, maar positie 0!
Zie: http://test.tjipchallenge...24993a3592b3c9f31ec42.xml

[mathijs van altvorst]

Hoi allemaal,

Mijn eerste bericht hier. Ik heb ondertussen de nodige tijd (10+ uur) gestoken in mijn Awale client en ben sinds enkele uurtjes in staat om wat te testen .

Corniel schreef op donderdag 30 augustus 2007 @ 10:33:
Logging
Op http://test.tjipchallenge.com/awale/log kan je de xml log vinden van de gespeelde partijen. Dit is een geserialiseerde representatie van het toernooi dat je speelt. Hier zou in iedergeval genoeg informatie moeten staan om te annalyseren wat er mis gaat.

De logs zijn gesorteerd op bestandsnaam. Totdat ik dat ontdekte was ik telkens aan het zoeken een bestand met de juiste datum/tijd ... erg tijdrovend.

Tip: gebruik de 'player id' die je ontvangt na succesvol inloggen om je bijbehorende logfile voor de partij te vinden.

[mathijs van altvorst]

Over oogsten.

Tijdens het testen kwam ik een situatie tegen die ik niet snapte

Veronderstel deze spelsituatie:

    /// ==opponent==
    /// -------------------------------------
    /// | (5) | (4) | (3) | (2) | (1) | (0) | == field
    /// |  0  |  4  |  4  |  4  |  4  |  6  | == grains
    /// |------------------------------------
    /// |  5  |  0  |  2  |  7  |  6  |  6  | == grains
    /// | (0) | (1) | (2) | (3) | (4) | (5) | == field
    /// -------------------------------------
    /// ==player==

De tegenstander is aan de beurt en zaait vanuit veld 1. Kan de tegenstander (na het zaaien) oogsten en zo ja wat wordt de nieuwe spelsituatie??

Ik verwacht dat de tegenstander na het zaaien twee granen uit veld 2 kan oogsten.
De volgende situatie zou dan ontstaan:

XML:

<Move User="1" Field="1" Position="5|0|0|7|6|6|0|1|5|5|5|0|6|2"/>

Ik neem aan dat ik het bij het verkeerde eind heb want vind in de logfile (4e zet):

XML:

<Move User="1" Field="1" Position="5|0|2|7|6|6|0|1|5|5|5|0|6|0"/>

Kan iemand mij vertellen of ik een denkfout maak?

[Soultaker]

Ik denk het wel; je had begrepen dat je alleen oogst uit het veld waarin je eindigt met zaaien? Om uit veld 2 (van player) te oogsten moet je dus veld 4 (van opponent) spelen.

[Sjaaky]

@_Daan_
1. Op wat voor soort machine wordt de applicatie uitgevoerd?
De wedstrijden worden gespeeld op een core2duo E6400 met 2GB geheugen. Alleen weten we nog niet of je de cpu en geheugen helemaal voor jezelf krijgt. Dat is uiteraard wel zo eerlijk en daar streven we ook naar. Maar bij veel inschrijvingen zullen we toch het aantal gelijktijdige partijen op
moeten schroeven om totale wedstrijdduur binnen de perken te houden.
Ik snap dat dit voor jullie op dit moment geen handig antwoord is, want het nut van meerdere berekeningthreads staat hiermee ook nog niet vast.
Als ik er meer over weet, dan horen jullie het.

2. Hoe wordt de tijd gemeten?
Dit is de wallclock time op de server. Als een speler Move() aanroept gaat de tijd van de tegenstander lopen.

3. Bij welke situatie geeft de StartMatch methode de waarde 'Finished' terug?
StartMatch geeft terug wie de eerste zet moet zetten. Als de partij afgelopen is geeft deze aanroep Finished terug.

4. Bij welke situatie geeft de Move methode de waarde 'Waiting' of 'None' terug? Moet de Move method call dan opnieuw worden uitgevoerd?
Move geeft alleen Lost, Won, Draw en Playing terug.

5. Wacht de Move methode op de zet van de tegenstander voordat deze een waarde retourneert? (aangezien Move ook Won/Draw/Lost kan teruggeven)
Nee, hiervoor zul je GetMove aan moeten roepen.

6. Wacht de GetMove methode op de zet van de tegenstander voordat deze een waarde retourneert? Of moet je regelmatig pollen?
Je moet pollen zolang GetMove -1 teruggeeft. Zie ook Corniel in "Awalé Programmeerwedstrijd". Dit mag niet te vaak, we denken aan max 10x/sec.

7. Welke waarde moet je meegeven als 'login' parameter bij het Logon request? Of wordt dit op de dag van de challenge gespecificeerd?
Hierin staat je naam of een alias en geef je door aan de wedstrijdleiding bij het inschrijven. Verzin wel iets unieks en praktisch, bijvoorbeeld je alias op GoT. We verwachten geen clashes en anders moet een van de partijen de code maar even aanpassen.

8. Is het uitvoeren van een Move method call na een gefinished spel een reden om de partij direct verloren te verklaren? (zie spelregels: 3.1.3)
Deze regel heeft betrekking op welk veld met zaden je oppakt. Dus als je een Move(1) aanroept terwijl daar 0 zaden inliggen. Of dat je
niet voert als dat verplicht is. Als je Move aanroept terwijl het niet je beurt is, of de wedstrijd al afgelopen is, zul je een exception terug krijgen.

9. Als op de testserver direct een match wordt gestart, wie is dan als eerste aan de beurt? Dit wordt namelijk teruggegeven bij de StartMatch method call, en er is geen manier om dat op te vragen.
Dat kan met de methode StartMatch(), deze geeft een MatchStart enum terug waarin de speler staat die begint.

10. Java gebruikt standaard maar 25% van het beschikbare systeemgeheugen. Naar ik aanneem heeft .Net deze limitatie niet. Voor Java zijn command-line opties beschikbaar om deze limiet te verhogen.
Is het mogelijk een batch-file mee te leveren die de Java applicatie start met de juiste opties voor geheugen, client/server VM en performance-optimalisatie?
Dat ga ik navragen.

11. Vraag al eerder gesteld: Wordt onder 'identieke positie' verstaan dat er in elk vakje evenveel zaadjes zitten én dat dezelfde speler aan zet is? Of dat alleen in elk vakje evenveel zaadjes zitten?
De zaden in het bord en de speler aan zet moeten beide hetzelfde zijn.

12. Vraag al eerder gesteld: Is de te winnen reis voor 1 of voor 2 personen?
Voor 1 persoon.

Naar je bugreport hierboven gaan we kijken.

@mathijs
Zie de reply van Soultaker. Als de tegenstander zaait vanuit veld 1 komt hij tijdens het uitzaaien niet eens aan de andere kant van het speelveld, dus mag hij sowieso niet eten.

[mathijs van altvorst]

Soultaker schreef op maandag 03 september 2007 @ 04:30:
Ik denk het wel; je had begrepen dat je alleen oogst uit het veld waarin je eindigt met zaaien? Om uit veld 2 (van player) te oogsten moet je dus veld 4 (van opponent) spelen.

Sjaaky schreef op maandag 03 september 2007 @ 15:54:
@mathijs
... Als de tegenstander zaait vanuit veld 1 komt hij tijdens het uitzaaien niet eens aan de andere kant van het speelveld, dus mag hij sowieso niet eten.

Aha, dat maakt een heleboel duidelijk.

Het was gisteren al laat en ik dacht: laat ik er mijn hoofd nu maar niet over breken

Thanks!!

[Anoniem: 84650]

@Sjaaky: Allereerst bedankt voor je volledige en snelle antwoord

Sjaaky schreef op maandag 03 september 2007 @ 15:54:
@_Daan_
1. Op wat voor soort machine wordt de applicatie uitgevoerd?
De wedstrijden worden gespeeld op een core2duo E6400 met 2GB geheugen. Alleen weten we nog niet of je de cpu en geheugen helemaal voor jezelf krijgt. Dat is uiteraard wel zo eerlijk en daar streven we ook naar. Maar bij veel inschrijvingen zullen we toch het aantal gelijktijdige partijen op
moeten schroeven om totale wedstrijdduur binnen de perken te houden.
Ik snap dat dit voor jullie op dit moment geen handig antwoord is, want het nut van meerdere berekeningthreads staat hiermee ook nog niet vast.
Als ik er meer over weet, dan horen jullie het.

Misschien is het mogelijk om vier identieke computers neer te zetten? Als er twee computers bezig zijn met de wedstrijd kunnen op de andere twee computers de volgende programma's worden gebouwd en klaargezet. Ze draaien dan niet gelijktijdig (wat mogelijk de gameserver zou beinvloeden), maar dit geeft wel een betere doorlooptijd.

[Soultaker]

mathijs van altvorst schreef op maandag 03 september 2007 @ 17:51:
Aha, dat maakt een heleboel duidelijk.

Het was gisteren al laat en ik dacht: laat ik er mijn hoofd nu maar niet over breken

Je kunt ook met dit programma oefenen; de demoversie speelt niet echt sterk, maar volgt wel exact de regels van deze contest, dus het is handig om een idee te krijgen van hoe het spel werkt.

[Corniel]

Via e-mail bereikte mij een aantal vragen over hoe een soap interface op te zetten. Zowel voor C# als voor Java zijn er verschillende tools (google eens op bijvoorbeeld Java2WSDL).

Daarnaast is nog niet iedereen bekend met het verschil tussen een WSDL en een webservice. Een WSDL is niets meer, en ook niets minder dan een contract wat je afspreekt op basis waarvan een webservice communiceert. Deze url’s zijn niet noodzakelijk hetzelfde (Bij MS zelfs per definitie niet).

Onze WSDL is op te vragen via :
http://test.tjipchallenge.com/awale/GameTestServer.asmx?WSDL

De service via:
http://test.tjipchallenge.com/awale/GameTestServer.asmx

Als je een tool gebruikt om code te generen gooi je daar dus het contract in, als je daadwerkelijk wilt communiceren, vertel je wat het adres is van de service. Voor hen die daar tot op heden moeite mee hadden, veel succes.

[Anoniem: 84650]

Corniel schreef op maandag 25 juni 2007 @ 16:24:
[..] Merk op dat er (waarschijnlijk) nog twee webmethods gaan komen: GetTime() (of als outparam bij Move) en Move(string playerId, int field, string log). Ik heb contact overgehad met de persoon die de gameserver maakt. Defintieve bevestiging hierover zal ik ook hier melden.

Weten jullie al meer over deze methodes?

Sjaaky schreef op maandag 03 september 2007 @ 15:54:
@_Daan_
[..]
10. Java gebruikt standaard maar 25% van het beschikbare systeemgeheugen. Naar ik aanneem heeft .Net deze limitatie niet. Voor Java zijn command-line opties beschikbaar om deze limiet te verhogen.
Is het mogelijk een batch-file mee te leveren die de Java applicatie start met de juiste opties voor geheugen, client/server VM en performance-optimalisatie?
Dat ga ik navragen.
[..]

Is er al een antwoord bekend?

Nog een vraag: is het toegestaan om JNI (Java) of een vergelijkbaar iets voor .Net te gebruiken? In de spelregels wordt het niet expliciet uitgesloten.

[ Voor 7% gewijzigd door Anoniem: 84650 op 13-09-2007 21:29 ]

[Anoniem: 84650]

Nog een bugreport:

Regel 4.3.3 uit de spelregels is niet correct geimplementeerd op de game-server. De regel luidt:

4.3.3 Indien er gekozen kan worden voor een veld om mee te zaaien
waarbij daarna volgens ‘ 4.4. Eten’ alle zaden aan de zijde van
de tegenstander worden gegeten, dan is dit alleen toegestaan
wanneer er geen andere zet mogelijk is.

Deze regel wordt wel goed gevolgd als de tegenstander na zijn zet geen zaden meer over heeft, voorbeeld:

Tegenstander aan zet:
* 1* [ 0] [ 0] [ 0] [ 0] [ 0]
[ 1] [ 0] [ 1] [ 5] [18] [ 0]

Situatie na zet van tegenstander:
[ 0] [ 0] [ 0] [ 0] [ 0] [ 0]
[ 0] [ 0] [ 1] [ 5] [18] [ 0]

Eigen zet:
[ 0] [ 0] [ 0] [ 0] [ 0] [ 0]
[ 0] [ 0] [ 1] [ 5] *18* [ 0]

Situatie na eigen zet:
[ 0] [ 0] [ 0] [ 0] [ 0] [ 0]
[ 0] [ 0] [ 1] [ 5] [ 0] [ 0]

Deze laatste zet is ongeldig, want deze neemt alle zaden van tegenstander weg, terwijl je opties hebt om te voeren die niet alle zaden oogst.

Hier een voorbeeld waar de gameserver het fout doet. Deze regel wordt niet goed gevolgd als de tegenstander na zijn zet nog wel zaden over heeft, voorbeeld:

Tegenstander aan zet:
* 2*  [ 0]  [ 0]  [ 0]  [ 0]  [ 1]  
[10]  [ 3]  [ 0]  [ 0]  [12]  [ 1]

Situatie na zet van tegenstander:
[ 0]  [ 0]  [ 0]  [ 0]  [ 0]  [ 1]  
[11]  [ 4]  [ 0]  [ 0]  [12]  [ 1]

Eigen zet:
[ 0]  [ 0]  [ 0]  [ 0]  [ 0]  [ 1]  
[11]  [ 4]  [ 0]  [ 0]  [12]  * 1*

Situatie na eigen zet:
[ 0]  [ 0]  [ 0]  [ 0]  [ 0]  [ 0]  
[11]  [ 4]  [ 0]  [ 0]  [12]  * 0* 

Dit is een ongeldige zet, want deze oogst alle zaden van de tegenstander terwijl er alternatieve zetten zijn. Zie ook het volgende spel met bovenstaande eindzetten: http://test.tjipchallenge...f40acba265333e3d97223.xml

Als deze bug niet gefixt wordt, kunnen jullie dan de spelregels aanpassen?

[Plons_de_Kikker]

Als het echt zo is als _Daan_ zegt, lijkt het me belangrijk dat dit gefixed wordt. De spelregels zijn hier ook erg duidelijk over:

- In regel 4.3.3 staat dat het nooit en te nimmer is toegestaan om een tegenstander uit te hongeren indien er andere zetten mogelijk zijn.

Het lijkt me in het belang van een sportieve wedstrijd om de server volgens de regels te laten spelen. Ik denk dat dit voor iedereen belangrijk is.

[Anoniem: 224082]

Volgens mij staan er nog een aantal vrij belangrijke vragen open:

*De regels
Hierover was op de introductiebijeenkomst al onduidelijkheid. Mag je nou wel of niet alle zaden van de tegenstander slaan als er zetten zijn waarbij de tegenstander wel zaden over houd?
Op 25 juni werd in deze thread gemeld dat er overlegd zou worden. Ik heb echter nog geen antwoord gelezen en kennelijk klopt de implementatie daarvan niet met wat de regels zeggen.

Het lijkt me nu een beetje laat om de regels nog te veranderen, ik heb het ook zo geimplementeerd dat je niet alle zaden mag slaan en ik zal niet de enige zijn aangezien het zo in de hier geplaatste regels staat. Zou dus leuk zijn als de server ook volgens die regels gaat spelen.

*De methode getTime()
komt die er nu wel of niet? Ook hierover zou nog duidelijkheid gegeven worden. Voor de structuur van de programmas maakt het uit of ze de tijd zelf bijhouden of dat ze em op kunnen vragen. Met nog een week te gaan lijkt het me tijd dat hierover duidelijkheid komt.

*Het geheugen bij java
Misschien niet dringend, maar wel leuk als daar even naar gekeken wordt. Wordt dit voor ons op de wedstrijdcomputers verhoogd, kunnen we het zelf in een batchfile verhogen of is het gewoon pech gehad als je java gebruikt?

[Anoniem: 233926]

Ben ook met spoed benieuwd naar de eerste twee punten van mijn voorganger (en ben ook van mening dat het een beetje laat is om de regels nog te gaan wijzigen).

Verder heb ik overigens d.d. 18 september gemerkt dat de Resign functie nog steeds niet goed werkt. Ik kreeg namelijk altijd terug dat de playerId niet zou kloppen ("not a member of this board" oid) terwijl ik met diezelfde playerId wél kon spelen.
(het maakt me verder weinig uit want ik zie het nut van de functie eerlijk gezegd sowieso niet in maar ok)

[Plons_de_Kikker]

Ik kwam tijdens het testen de volgende fout tegen in de random player / server:

Op het moment dat ik zou moeten beginnen, maar dat ik dat niet doe en een zet aan de tegenstander vraag, lijkt het erop dat de tegenstander inderdaad een zet gaat doen.

http://test.tjipchallenge...c4581b62565fa43aea0c0.xml

De tegenstander verliest vervolgens: 'The player 'random' executed a move when it wasn't his/her turn.'

Het lijkt me dat dit mijn fout is, en dat ik zou moeten verliezen hier.

[Anoniem: 233926]

Heb ik eveneens gemerkt inderdaad..

[Anoniem: 224082]

om het zoeken naar je eigen partijen in de logs te vergemakkelijken heb ik de vrijheid genomen een pagina te maken die de partijen gesorteerd weergeeft en een verkort overzicht van de partij uit de xml-files haalt.

http://hemminga-online.nl/~vincent/index.php

[Anoniem: 84650]

Anoniem: 224082 schreef op zaterdag 22 september 2007 @ 22:41:
om het zoeken naar je eigen partijen in de logs te vergemakkelijken heb ik de vrijheid genomen een pagina te maken die de partijen gesorteerd weergeeft en een verkort overzicht van de partij uit de xml-files haalt.

http://hemminga-online.nl/~vincent/index.php

Ziet er leuk uit!

Ik ben trouwens het meest benieuwd naar of de Java Server VM gebruikt wordt. De HotSpot Client VM is veel trager... Maar goed, het is inmiddels al weer 19 dagen terug dat deze vraag gesteld is

[Anoniem: 233926]

Anoniem: 224082 schreef op zaterdag 22 september 2007 @ 22:41:
http://hemminga-online.nl/~vincent/index.php

Anoniem: 84650 schreef op zaterdag 22 september 2007 @ 23:34:
Ziet er leuk uit!

Heb trouwens een vraag mbt de Java PC's die zometeen gereed staan. Is daar behalve de JDK ook AXIS2 al op geinstalleerd? Of moet dit bij je eigen project zitten? (en dat geldt eigenlijk voor alle toegestane externe jar's)

Verder vroeg ik me nog af of je programma zometeen heel het tournement moet blijven draaien, of dat het na een partij opnieuw opgestart mag/moet worden?

[Anoniem: 84650]

Anoniem: 233926 schreef op zondag 23 september 2007 @ 00:39:
[...]
Verder vroeg ik me nog af of je programma zometeen heel het tournement moet blijven draaien, of dat het na een partij opnieuw opgestart mag/moet worden?

Ik denk het laatste. Omdat er maar 2 pc's zijn en iedereen om de beurt zijn/haar engine daarop moet draaien. Als je het hele tournament door mag blijven draaien kun je alle resources van de mensen na jou gebruiken om alvast vooruit te denken...

Je kunt natuurlijk wel een daemon laten draaien die de boel flink bezig houdt nadat je aan de beurt geweest bent. Of de JVM aanpassen, zodat bepaalde classes ontzettend traag worden (en uiteraard weer terugzetten als je zelf weer aan de beurt bent).

Je kunt zoveel doen zonder de spelregels te overtreden

Wie maakt zijn engine eigenlijk in Java? En wie in .Net?

[Anoniem: 224082]

tja, ik hoop wel dat de tegenstanders in een partij op aparte computers gaan draaien. Het is anders op de dag zelf nog best mogelijk om je programma wat aan te passen zodat ie allerlei mooie getallen uitrekent terwijl je niet aan de beurt bent, het liefst in meerdere threads Lijkt me echter niet het doel van de wedstrijd.

Waar stond dat er maar 2 pc's zijn trouwens? Dan gaat het wel lang duren. Een voorzichtige schatting van 20 deelnemers en 9 rondes met 6 minuten per partij levert al een wedstrijd van 9 uur op, en dat is dan zonder de tijd die het kost om na iedere partij 2 nieuwe programmas op te starten...

Ik programmeer in java dus, zal ook wel gebleken zijn door mn vraag naar het geheugen voor java. Eigenlijk is dat altijd een nadeel volgens mij voor programmeerwedstrijden, maar blijf stug doorzetten

[ Voor 14% gewijzigd door Anoniem: 224082 op 23-09-2007 14:28 ]

[mathijs van altvorst]

Anoniem: 224082 schreef op zaterdag 22 september 2007 @ 22:41:
om het zoeken naar je eigen partijen in de logs te vergemakkelijken heb ik de vrijheid genomen een pagina te maken die de partijen gesorteerd weergeeft en een verkort overzicht van de partij uit de xml-files haalt.

http://hemminga-online.nl/~vincent/index.php

Goed bezig Vincent
Dat is zeker makkelijker!

Anoniem: 84650 schreef op zondag 23 september 2007 @ 12:56:
[...]
Wie maakt zijn engine eigenlijk in Java? En wie in .Net?

Mijn programma gebruikt het .NET framework.

[Soultaker]

Anoniem: 224082 schreef op zondag 23 september 2007 @ 14:06:
Ik programmeer in java dus, zal ook wel gebleken zijn door mn vraag naar het geheugen voor java. Eigenlijk is dat altijd een nadeel volgens mij voor programmeerwedstrijden, maar blijf stug doorzetten

Ik denk dat het ten opzichte van C# geen nadeel is. Ik gebruik zelf overigens ook Java.

[Anoniem: 84650]

Anoniem: 224082 schreef op zondag 23 september 2007 @ 14:06:
[..]
Waar stond dat er maar 2 pc's zijn trouwens? Dan gaat het wel lang duren. Een voorzichtige schatting van 20 deelnemers en 9 rondes met 6 minuten per partij levert al een wedstrijd van 9 uur op, en dat is dan zonder de tijd die het kost om na iedere partij 2 nieuwe programmas op te starten...
[..]

Hier (eerder in deze thread):

Sjaaky schreef op maandag 03 september 2007 @ 15:54:
@_Daan_
1. Op wat voor soort machine wordt de applicatie uitgevoerd?
De wedstrijden worden gespeeld op een core2duo E6400 met 2GB geheugen. Alleen weten we nog niet of je de cpu en geheugen helemaal voor jezelf krijgt. Dat is uiteraard wel zo eerlijk en daar streven we ook naar. Maar bij veel inschrijvingen zullen we toch het aantal gelijktijdige partijen op
moeten schroeven om totale wedstrijdduur binnen de perken te houden.
Ik snap dat dit voor jullie op dit moment geen handig antwoord is, want het nut van meerdere berekeningthreads staat hiermee ook nog niet vast.
Als ik er meer over weet, dan horen jullie het.
[..]

We hebben nog niets gehoord, het is dan ook nog maar 3 weken terug gevraagd.

[Plons_de_Kikker]

Ik vroeg me af of jullie ook nog wat pers uitgenodigd hebben? Altijd leuk als je gewonnen hebt en nog in de krant komt ook.

[Plons_de_Kikker]

Heb trouwens een vraag mbt de Java PC's die zometeen gereed staan. Is daar behalve de JDK ook AXIS2 al op geinstalleerd? Of moet dit bij je eigen project zitten? (en dat geldt eigenlijk voor alle toegestane externe jar's)

Het zou eerlijker zijn om deze al op de game pc te hebben staan. Dat is de enige manier om zeker te weten dat iedereen dezelfde heeft. Het zou wel handig zijn als dit nu alvast verteld wordt.

Verder vroeg ik me nog af of je programma zometeen heel het tournement moet blijven draaien, of dat het na een partij opnieuw opgestart mag/moet worden?

Ben ik ook benieuwd naar.

[Sjaaky]

Allereerst bedank voor de bugmeldingen en het geduld.

Anoniem: 84650 schreef op zaterdag 01 september 2007 @ 17:03:
-De laatste zet wordt niet opgeslagen.
-Onderin staat de laatste zet, positie 0. De FinishReason bovenin het bestand is echter: The player 'login' executed a move on field '5', the move is invalid. Maar, positie 5 is niet gezet, maar positie 0!

Beide opgelost.

GetTime(string playerId) is geïmplementeerd

C#:

/// <summary>
/// Gets the remaining time in milliseconds
/// </summary>
/// <param name="playerId">The players unique identifier.</param>
/// <returns></returns>
long GetTime(string playerId);

JNI ed zijn we inderdaad vergeten op te nemen.
JNI, unsafe code, COM interop, p/invoke, etc.. zijn allemaal verboden. Ik hoop dat jullie geen gebruik hebben van deze vrijheid. Het wordt voor de jury een stuk lastiger controleren wat er gebeurd als dat soort trucs worden uitgehaald. Bovendien is het voor het maken van een awale-engine absoluut niet nodig om dat soort technieken te gebruiken.

Regel 4.3.3 uit de spelregels is niet correct geimplementeerd op de game-server.

De bug op de testserver is opgelost.

Hierover was op de introductiebijeenkomst al onduidelijkheid. Mag je nou wel of niet alle zaden van de tegenstander slaan als er zetten zijn waarbij de tegenstander wel zaden over houd?

Als je een zet kunt doen waarbij je de tegenstander niet leeg eet, mag je de tegenstander niet leeg eten. Ik zie dat ik dat alleen in de startpost heb geupdate, niet echt duidelijk, sorry

Resign is gefixt.

Op het moment dat ik zou moeten beginnen, maar dat ik dat niet doe en een zet aan de tegenstander vraag, lijkt het erop dat de tegenstander inderdaad een zet gaat doen.

Ook gefixt.

tja, ik hoop wel dat de tegenstanders in een partij op aparte computers gaan draaien. Het is anders op de dag zelf nog best mogelijk om je programma wat aan te passen zodat ie allerlei mooie getallen uitrekent terwijl je niet aan de beurt bent, het liefst in meerdere threads Lijkt me echter niet het doel van de wedstrijd.

Pondering (denken in de tijd van de tegenstander) is toegestaan, zie de startpost. Daarom hebben we ook per speler een pc.

Je kunt natuurlijk wel een daemon laten draaien die de boel flink bezig houdt nadat je aan de beurt geweest bent. Of de JVM aanpassen, zodat bepaalde classes ontzettend traag worden (en uiteraard weer terugzetten als je zelf weer aan de beurt bent).

Ik denk dat we in dat soort gevallen hard na gaan denken over diskwalificatie.

De vragen over servers/geheugen/hoe op te starten staan dus nog open. Java en .Net krijgen evenveel geheugen. Met welke parameters de jvm wordt opgestart weten we nog niet precies.

[Anoniem: 84650]

Sjaaky schreef op maandag 24 september 2007 @ 16:50:
[..]
De vragen over servers/geheugen/hoe op te starten staan dus nog open. Java en .Net krijgen evenveel geheugen. Met welke parameters de jvm wordt opgestart weten we nog niet precies.

Suggestie:

code:

java -server -Xms512m -Xmx2048m

[Anoniem: 224082]

kan het zijn dat er nog een bug zit in de regel dat je moet feeden?

<Move User="1" Field="5" Time="130881381885" Position="2|1|1|2|18|0|24|0|0|0|0|0|0|0"/>
<Move User="0" Field="4" Time="130938258341" Position="3|2|2|3|0|2|36|0|0|0|0|0|0|0"/>

Ik kwam deze situatie tegen. Mijn programma speelt daar het veld met 18 seeds en speelt random daarmee leeg, De FinishReason is echter dat ik verloren heb omdat ik de tegenstander niet heb gefeed. Volgens mij kan dat echter ook niet... geen van de andere velden haalt de kant van de tegenstander.

Het lijkt wel goed te gaan als de tegenstander nog seeds heeft die geslagen worden als dat de enige mogelijkheid is, maar je kan em dus ook leegslaan als ie daarvoor al leeg was...

Nog een kleiner dingetje: als de tegenstander niet meer kan zetten dan krijg je alle seeds die er nog aan jouw kant liggen. Dit lijkt niet te gebeuren in de xml files. In de partij waarin het slaan wel goed ging was de score 25-0 terwijl het eigenlijk 48-0 is dan. Dat maakt in die situatie natuurlijk niet uit, maar als het 22-23 staat en de 22 hongert de ander uit dan wint ie met 25-23. Dan is het wel raar als de score 22-23 blijft.

[ Voor 23% gewijzigd door Anoniem: 224082 op 26-09-2007 10:46 ]

[Sjaaky]

Ga ik naar kijken.

-> opgelost

[ Voor 32% gewijzigd door Sjaaky op 26-09-2007 17:45 ]

[Anoniem: 84650]

Is er tijdens de laatste voorbereidingen voor de wedstrijd een internetverbinding beschikbaar?

Nog een vraag: worden de engines tegelijkertijd gestart?

En hoe vaak mag je pollen voor de zet van de tegenstander? 10x per seconde zoals eerder gesuggereerd? En wat gebeurt er als je vaker polled?

[ Voor 55% gewijzigd door Anoniem: 84650 op 28-09-2007 20:55 ]

[Sjaaky]

Ga er van uit dat er morgenochtend geen internet beschikbaar is.

Mocht het echt nodig (en dat zal best wel ) kunnen we altijd naar een normale werkplek gaan om daar dingen uit te zoeken, libraries te downloaden, onvoorziene problemen op te lossen.

Trouwens nog een mededeling!

De testserver start direct na het inloggen een partij. De echte server doet dit NIET. Dat betekent dat je na het inloggen moet vragen of er al een partij gestart is met GetMatchStatus(), zolang deze None of Waiting terug geeft moet je even (0.1 sec oid) slapen en dat nog een keer proberen.
Je kan datzelfde ook doen met GetServerStatus maar wij zorgen ervoor dat de clients pas op worden gestart als er een actieve ronde beschikbaar is.

10x per seconde vinden wij heel redelijk.
De engines worden tegelijk gestart.

--edit--

We gaan een run.bat gebruiken die door iedereen zelf ingeregeld kan worden met de juiste parameters etc..

[ Voor 11% gewijzigd door Sjaaky op 28-09-2007 21:46 ]

[Soultaker]

Op de huidige testserver verandert de match status anders niet meer zodra je gewonnen hebt. Werkt de echte server anders?

Of moet je eigenlijk StartMatch proberen?

[Plons_de_Kikker]

Soultaker schreef op vrijdag 28 september 2007 @ 22:21:
Op de huidige testserver verandert de match status anders niet meer zodra je gewonnen hebt.

Welke testserver gebruik jij? Bij mij verandert de match status in 'won' zodra ik gewonnen heb.

[Sjaaky]

Dat weet ik niet.
Maar als een partij afgelopen is mag je sowieso niet verder draaien (we killen het process). Dus dat gedeelte is niet heel erg van belang.

[ Voor 9% gewijzigd door Sjaaky op 28-09-2007 23:55 ]

[Anoniem: 224115]

Dus als een partij afgelopen is, kan een crash, verkeerde functie-aanroep of wat dan ook geen roet meer in het eten gooien, als je in gewonnen positie staat?

[Anoniem: 224082]

Is de einduitslag nog ergens beschikbaar? In de logs lijken alle partijen van het toernooi nog in de initialized-state http://test.tjipchallenge...64fc2bd4cf46004899980.xml

[Anoniem: 224115]

Ik zou ook nog wel een aantal partijen willen terugzien en de eindstand inderdaad.

[Soultaker]

Ik vond het erg leuk gisteren! De techniek had iets beter gekund, maar gelukkig werkte uiteindelijk alles met een mooie combinatie van last-minute hacks, handmatig starten/stoppen van programma's en score bijhouden met pen en papier.

Doordat er verschillende goede programma's meededen was het was nog erg spannend. Jammer dat er geen tijd was voor een volledige competitie (er is uiteindelijk een halve competitie gespeeld) maar desondanks zaten er een paar mooie partijen tussen.

Ik zou ze ook graag de partijen nog eens terug zien, niet in de laatste plaats omdat mijn programma in één van de partijen een ongeldige zet deed die ik niet kon verklaren (en dat kan ik niet uitstaan)! Overigens heb ik voor geïnteresseerden mijn programmacode ook online gezet: HTML source of awale.zip. (Ik denk dat eigenlijk alleen AI.java interessant is.)

[Anoniem: 224082]

Leuk om je code te zien, is een stuk beter leesbaar dan de mijne ben ik bang Hoop dingen lijken heel erg op wat ik ook gedaan heb. Heb ook een long als bord gebruikt, ook negatieve waardes voor ongeldige zetten ook een statische variabele voor de gegeten zaden. Ik durfde het alleen niet aan om erop te vertrouwen dat er nooit meer dan 31 seeds in een vakje komen, dus daar is mijn code iets ingewikkelder door geworden.

Heb verder tot 4 plies diep move ordering gedaan met korte searches, en heb een transposition table gebruikt, en Joost had een 18-ply openingsboek gemaakt waardoor we de eerste zetten heel snel en toch goed konden doen (na 8 seconde opstarttijd om em te unzippen )

Een "fout" waar ik pas heel laat achter kwam was dat ie op het eind weleens het partijeinde op een cruciaal moment over het hoofd wist te zien. Als hij bijvoorbeeld met 21-22 achter stond en zag dat ie 2 stenen kon slaan in 5 zetten maar ook zag dat ie op dezelfde manier na een rondje ook later die 2 stenen kon slaan dan zag ie dat als even goed, maar verloor vervolgens omdat er een herhaling van de stelling kwam. Door de evaluatie-functie te veranderen van alleen de geslagen stenen naar 100*[geslagen stenen]+[resterende searchdepth] was dat opgelost, en gaf ie ook hogere waardes aan paden waarin ie eerst voorstond en het later weggaf dan andersom, wat volgens mij ook wel gunstig is.

Jouw methode firstNonEmptyField lijkt trouwens eerder het tegenovergestelde te doen, wat een ongeldige zet zou verklaren, maar volgens mij roep je die alleen aan als je de tegenstander kan uithongeren, en naar wat ik me van de partij herinner was dat toen niet het geval.

[Soultaker]

Anoniem: 224082 schreef op zondag 30 september 2007 @ 23:21:
Ik durfde het alleen niet aan om erop te vertrouwen dat er nooit meer dan 31 seeds in een vakje komen, dus daar is mijn code iets ingewikkelder door geworden.

Door die aanname kan het rondzaaien van alle zaden met één enkele optelling afgehandeld worden. Als er niets geslagen wordt (wat meestal zo is) is daarmee ook de zet afgelopen. Als je dan op overflow moet checken wordt het allemaal veel ingewikkelder. Dat paste niet in mijn strategie van zo snel mogelijk in plaats van slim zoeken. Neemt niet weg dat ik 'm wel erg mooi vind; je kunt zo alle toestanden heel compact representeren.

Hoe doe je dat overflow checken trouwens, heb je daar een slimme manier voor, of ga je toch het hele veld rond en bij elk zaadje checken of je overflow krijgt?

Door de evaluatie-functie te veranderen van alleen de geslagen stenen naar 100*[geslagen stenen]+[resterende searchdepth] was dat opgelost, en gaf ie ook hogere waardes aan paden waarin ie eerst voorstond en het later weggaf dan andersom, wat volgens mij ook wel gunstig is.

Dat tweede weet ik niet, maar het lijkt me dat zo'n evaluatiefunctie de stabiliteit van je zoekalgoritme niet ten goede komt (en het is dan sowieso geen nul-som-spel meer). Geeft dat geen problemen als je waarden wil opslaan in je transpositietabel? Of compenseer je daar voor?

(Ik heb het iets anders opgelost, namelijk door bij iteratief zoeken weer te beginnen bij de beste zet van de vorige keer, en die alleen te vervangen als er een duidelijk betere zet is. Daardoor krijgt een zet die sneller voordeel oplevert de voorkeur boven een zet die evenveel waard is, maar waarvoor dat pas later duidelijk wordt.)

Jouw methode firstNonEmptyField lijkt trouwens eerder het tegenovergestelde te doen, wat een ongeldige zet zou verklaren, maar volgens mij roep je die alleen aan als je de tegenstander kan uithongeren, en naar wat ik me van de partij herinner was dat toen niet het geval.

Ik had daar sowieso een fout in; regel 67 (board >>= 5) ontbrak helemaal! Dat had ik gisteren tijdens de wedstrijd ook gezien (en heb ik dus vanmiddag aangepast). Maar waarom denk je dat 'ie het tegenovergestelde doet? In mijn bord-representatie zijn de laagste vijf bits veld 0 (het meest linker veld van de huidige speler) dus volgens mij klopt 'ie zo wel (hoewel ik het niet getest heb). Maar ik denk ook niet dat dat hét probleem was. Als je nog wat verdachts ziet, laat het vooral weten!

[Anoniem: 224115]

Ik vond het ook erg leuk om de code te lezen, en heb me suf gezocht naar een bug. Volgens mij is firstNonEmptyField trouwens wel goed gecode. Uiteindelijk heb ik wel een bug gevonden in de move-methode, regel 92:

091 // TODO: cache values for (field + count%11)%12?
092 for (field = (field + count%11)%12; field >= 6; field -= 1)

Om het slaan-gedeelte af te handelen wordt field hierin het veld waar het laatste zaadje wordt geplaatst in een beurt. Dat is althans de bedoeling. Maar als count, het aantal zaadjes dat in het beginkuiltje zit, nou 11 of 22 is, dan wordt het naar-veld, hetzelfde als het van-veld, terwijl het juist 11 stappen verder zou moeten zijn (of 1 terug). Nou levert dat meestal niet een probleem op, omdat 1 stap terug vaak je eigen bordhelft is en je dan sowieso niet kunt slaan.
Maar áls je veld nul speelt en áls er 11 of 22 zaden in zitten en áls er na het spelen 2 of 3 zaden in veld 11 terechtkomen, dan wordt verzuimd om die te slaan (en evt andere zaden in velden 10,9,...).

Dit zou best wel eens de bug geweest kunnen zijn, waardoor het bord bij jou anders werd, en je een illegale zet speelde. Die TODO is zo wel wat wrang.
Je had trouwens gister zelf al een bug gevonden in je code, was dat deze? Of was dat een andere?

Overigens wel toevallig dat je testpartij vanwege lang nadenken was afgebroken dmv een illegale zet op veld 5 waar nul zaden op waren. Nu had je weer illegaal op veld 5 vanwege nul zaden, maar dit keer dus je eigen code. (Gister overwoog ik nog serieus de optie dat die malafide client nog runde en die de verkeerde zet deed. Maar je had al verteld dat je bordrepresentatie anders was.)


edit: Ah, die bug die je gister gevonden had was dus wat anders.

edit2: ah, het gebeurt natuurlijk ook als je tegenstander zo'n zet doet. Vanwege je negamax, wat ik ook had. Ik zal eens kijken of ik mijn code ergens kan posten. Maar het blijft natuurlijk een zeldzame zet, die dan net voorkomt in de partij waar je met winst de top3 op gedeeld eerste plaats zou kunnen brengen.

[ Voor 9% gewijzigd door Anoniem: 224115 op 01-10-2007 00:43 ]

[Soultaker]

Anoniem: 224115 schreef op maandag 01 oktober 2007 @ 00:17:
Ik vond het ook erg leuk om de code te lezen, en heb me suf gezocht naar een bug. Volgens mij is firstNonEmptyField trouwens wel goed gecode. Uiteindelijk heb ik wel een bug gevonden in de move-methode, regel 92:

091 // TODO: cache values for (field + count%11)%12?
092 for (field = (field + count%11)%12; field >= 6; field -= 1)

Om het slaan-gedeelte af te handelen wordt field hierin het veld waar het laatste zaadje wordt geplaatst in een beurt. Dat is althans de bedoeling. Maar als count, het aantal zaadjes dat in het beginkuiltje zit, nou 11 of 22 is, dan wordt het naar-veld, hetzelfde als het van-veld, terwijl het juist 11 stappen verder zou moeten zijn (of 1 terug).

Geweldig! Ik moest nog even goed nadenken voordat ik doorhad wat je bedoelde, maar volgens mij is dit het inderdaad. Sterk gespot. Ik denk dat het zo wel klopt:

Java:

for (field = (field + (count - 1)%11 + 1)%12; fields >= 6; field -= 1)

(Of ik had die posities moeten precalculaten zoals de TODO suggereert, maar ik denk niet dat dat qua performance veel verschil gemaakt zou hebben).

Je had trouwens gister zelf al een bug gevonden in je code, was dat deze? Of was dat een andere?

Dat was de fout in firstNonEmptyField().

ah, het gebeurt natuurlijk ook als je tegenstander zo'n zet doet. Vanwege je negamax, wat ik ook had.

Inderdaad; in principe kan die bug ook nog wel andere potjes beïnvloed kan hebben, ook als dat veld niet daadwerkelijk gespeeld is, simpelweg omdat m'n AI aan bepaalde zetten in bepaalde situaties een verkeerd gevolg koppelt. (Aan de andere kant is de situatie met een veelvoud van elf zaden op het eerste veld wel vrij zeldzaam.)

Maar het blijft natuurlijk een zeldzame zet, die dan net voorkomt in de partij waar je met winst de top3 op gedeeld eerste plaats zou kunnen brengen.

Ja, en vervelend dat ik het niet eerder tegenkwam (maar zo gek is dat niet, want de random speler op de testserver gaf ook niet echt aanleiding om grote stapels op te bouwen). Waarschijnlijk was het slim geweest om ook tegen mezelf te testen (of tenminste niet alléén op de testserver) maar ik ben er ook niet heel uitgebreid mee bezig geweest na de eerst opzet.

Overigens lijkt het me behoorlijk waarschijnlijk dat zonder die illegal move Vincent en Joost ook gewoon gewonnen zouden hebben, want ik verloor bijvoorbeeld ook van Ed van Doorn (mijn enige andere verliespartij, geloof ik) waar zij wél van wonnen. Maar het blijft jammer om juist de match tegen de beste tegenstander zo te moeten eindigen. Ik ben in ieder geval blij dat ik nu een clue heb wát er überhaupt misging.

[Anoniem: 224082]

betekent
if((board&31) == 0)
dan niet dat het veld leeg is? Als jullie allebei denken dat ie klopt zal ik wel ergens iets helemaal verkeerd lezen

Ik heb dit zo opgelost, het blijft in 1 long staan en kan dus nog steeds met 1 optelling geupdate worden. Ik moet inderdaad het bord aflopen om te checken op overflow, maar doe dit alleen als er een veld met 24 of meer seeds is (een veld met zowel het 16 als het 8 bit op 1). Dit komt al zo weinig voor dat het nauwelijks trager wordt. (Die laatse for-loop had ws makkelijk uitgeschreven kunnen worden, maar de doMove functie was al lang de bottleneck niet meer)

code:

//opvragen overflow buffer
if(seeds>=24)
{
     //add 4*store (bit 60,61,62) to the number of seeds
     seeds+= (board>>58)&28;  
}

... doe zet ...

//checken op "overflow" na de zet
if((board&bits16)>0 && (((board&bits8)<<1)&(board&bits16))>0)
{
    for(int i = 0 ; i < 12 ; i++)
    {
         if(board==(board|b28[i]))
         {
               board &= ~four[i];   //4<<5*i
               board += store;      //1<<60
               break;
         }
    }
}

Het blijft met die evaluatie-functie nog steeds een zero-sum spel, want de tegenstander rekt dus liever het moment waarop jij slaat, of zal verkiezen eerder te slaan ipv later. -101 voor jou impliceert nog steeds +101 voor de tegenstander. De reden dat ik denk dat dit beter is is vanwege het horizon-effect, als jij als laatst geslagen hebt is de kans groot dat de tegenstander de volgende wordt (althans tegen een goede tegenstander) omdat slaan je bordpositie vaak verslechterd. Dus ook als je het niet kan zien, is het fijner als jij eerst slaat en de ander daarna. Het zal meerdere redenen gehad hebben, maar na deze verandering won ie van mn testprogramma op (fixed) diepte 22, terwijl ie daarvoor nooit van diepte 20 kon winnen. Hij verloor ook niet meer van lagere zoekdieptes, wat ie daarvoor af en toe nog wel deed (erg irritant )

Het lijkt wel heel erg toeval dan inderdaad dat het net tegen ons misging, want dit had in ieder partij kunnen gebeuren. Misschien kunnen ze onze programmas nog eens tegen elkaar laten spelen, ik ben ook wel benieuwd naar een volledige competitie van de top 6 of zo omdat kleurvoordeel nog best wat uit kon maken en de top volgens mij behoorlijk aan elkaar gewaagd was.

[Soultaker]

Anoniem: 224082 schreef op maandag 01 oktober 2007 @ 11:26:
betekent
if((board&31) == 0)
dan niet dat het veld leeg is? Als jullie allebei denken dat ie klopt zal ik wel ergens iets helemaal verkeerd lezen

Erm, het was laat blijkbaar. Je hebt helemaal gelijk; die was dus nog fout. Het begint me steeds meer te verbazen dat het nog zo goed ging zaterdag met alle bugs die er nu nog uitgevist worden.

Ik heb dit zo opgelost, het blijft in 1 long staan en kan dus nog steeds met 1 optelling geupdate worden. Ik moet inderdaad het bord aflopen om te checken op overflow, maar doe dit alleen als er een veld met 24 of meer seeds is (een veld met zowel het 16 als het 8 bit op 1). Dit komt al zo weinig voor dat het nauwelijks trager wordt. (Die laatse for-loop had ws makkelijk uitgeschreven kunnen worden, maar de doMove functie was al lang de bottleneck niet meer)

[knip: code]

Ah, dat ziet er wel mooi uit. De overhead valt zo inderdaad wel mee.

De reden dat ik denk dat dit beter is is vanwege het horizon-effect, als jij als laatst geslagen hebt is de kans groot dat de tegenstander de volgende wordt (althans tegen een goede tegenstander) omdat slaan je bordpositie vaak verslechterd.

Klopt. Dat probleem ben ik ook meer bij dit soort programma's tegengekomen.

Het lijkt wel heel erg toeval dan inderdaad dat het net tegen ons misging, want dit had in ieder partij kunnen gebeuren.

Klopt, maar ik heb ook het idee dat het grote-stapels-bouwen iets is wat vooral voorkomt bij twee goede spelers (die allebei niet makkelijk stenen weggeven), dus eigenlijk is het wel logisch dat het juist in die partij optrad.

Misschien kunnen ze onze programmas nog eens tegen elkaar laten spelen, ik ben ook wel benieuwd naar een volledige competitie van de top 6 of zo omdat kleurvoordeel nog best wat uit kon maken en de top volgens mij behoorlijk aan elkaar gewaagd was.

We kunnen ook de gameserver emuleren natuurlijk, of een Java interface definiëren analoog aan de gameserver en dan testen met wie wil (aangenomen dat alle geïnteresseerden met Java werken). Wel lastig als mensen in de tijd van de tegenstander willen denken.

[Anoniem: 224082]

ze zouden de source-code van de server beschikbaar stellen hoorde ik, dus dan zouden we die mss aan kunnen passen zodat we van thuis via internet kunnen spelen. Onze transposition table pikt namelijk ook al het geheugen in dat ie pakken kan, dus das dan ook nog een extra probleem als je 2 geheugen-intensieve programmas op 1 pc wil draaien.

en wat betreft dat grote-stapels bouwen, dat heb ik ons programma juist ook tegen zwakke spelers wel zien doen omdat ie daar dan enorme winsten mee kon halen, een sterke tegenstander laat je niet zomaar een hele rij stenen slaan op die manier... maar ik heb inderdaad ook wel de meeste bugs in potjes tegen een hoge zoekdiepte tegenstander gevonden omdat die dan toch wat meer de limieten van het algoritme opzoekt.

[ Voor 30% gewijzigd door Anoniem: 224082 op 01-10-2007 12:43 ]

[Sjaaky]

Wij willen, gezien het enthousiasme van alle deelnemers, het mogelijk maken dat mensen door kunnen gaan met het verbeteren van de engines.
We denken bijvoorbeeld aan een gameserver waarbij je kunt spelen tegen 1 van de zaterdag spelende engine (uiteraard met jullie toestemming). Of wellicht op 1 of andere manier dat 2 engines elkaar kunnen ontmoeten. Dit moeten we nog wel verder uitwerken.
Ik vond het (ondanks het gestress voor de wedstrijd ) zaterdag een erg leuke en leerzame dag. Ik heb een aantal keer met verbazing aangehoord hoever mensen zijn gegaan om hun engine te optimaliseren. De logfile viewer van Vincent was ook superhandig (ook voor ons )

We hadden meer dan 30 inschrijving, maar uiteindelijk bleven er 12 over. Dat niet iedereen mee kon doen was jammer. Dit lag mede aan de soap interface, die voor velen toch meer voeten in de aarde had dan dat we hadden verwacht. Van de andere kant hadden we ook niet veel meer deelnemers moeten hebben gezien de tijd en de mate van toernooiautomatisering .

Ik moet diegenen die de gespeelde potten terug willen zien helaas teleurstellen, die partijen zijn we kwijt. Blijkt dat door een samenloop van een onduidelijk 'manager'-gui en verkeerd bedacht procedure we bij het invoeren van een nieuwe ronde de vorige ronde overschreven.
Technischer:
Een toernooi is een object met daarin rondes, partijen en boarden, zeg maar zoals de xml eruit ziet die jullie voor een testpartij konden opvragen. Deze werd in 1 keer middels soap naar de server geschreven. Na het spelen van ronde 1 hadden we deze moeten teruglezen van de server voordat we de volgende ronde invoerden. Omdat we dat niet gedaan hebben schreven we bij elke nieuwe ronde de maagdelijke borden weer naar server. Dus slecht van ons (/mij), sorry daarvoor. (Ik ben blij dat de bug van Soultaker inmiddels gevonden is ).

De uitslag staat hier. We komen nog met een persbericht.

@vdeboer: Komen jullie allebei uit Delft? Dat willen we weten voor het persbericht. Stuur maar een dm.

[Anoniem: 224082]

Ah, goed dat de uitslag er iig nog is.
Wij komen allebei uit Delft ja. Misha spelt zijn naam trouwens zonder c

[NaliXL]

Ik vond het zaterdag een ontzettend leuke dag, ondanks dat mijn sh$%*tty programma niet eens meegedaan heeft . Gaat die re-match er nog komen? Of andere wedstrijden wellicht?

PS: ik sta niet in de ranglijst vermeld (Jaap van Wingerden) ???

[ Voor 16% gewijzigd door NaliXL op 01-10-2007 17:06 ]

[Soultaker]

NaliXL schreef op maandag 01 oktober 2007 @ 17:05:
Ik vond het zaterdag een ontzettend leuke dag, ondanks dat mijn sh$%*tty programma niet eens meegedaan heeft

Inderdaad, erg jammer dat je het niet goed werkend kreeg

Sjaaky schreef op maandag 01 oktober 2007 @ 15:22:
We hadden meer dan 30 inschrijving, maar uiteindelijk bleven er 12 over. Dat niet iedereen mee kon doen was jammer. Dit lag mede aan de soap interface, die voor velen toch meer voeten in de aarde had dan dat we hadden verwacht.

Misschien was het handiger geweest een interface (ik bedoel dus een echte interface zoals de taal Java die kent) te specificeren, zodat mensen alleen een klasse hoefden te schrijven die die interface implementeert, en dat jullie dan een stub aanleverden die de verbinding met de server regelt. Iets soortgelijks kun je ook voor C# doen. Dan zouden deelnemers er verder geen werk van hoeven maken.

Als je niet met SOAP bekend bent en uit moet gaan zoeken hoe al die libraries werken is het echt niet makkelijk. Ik kan me best voorstellen dat mensen daar over struikelden. Dat er nu mensen waren met vele megabytes aan libraries was ook niet echt makkelijk.

Ik moet diegenen die de gespeelde potten terug willen zien helaas teleurstellen, die partijen zijn we kwijt. Blijkt dat door een samenloop van een onduidelijk 'manager'-gui en verkeerd bedacht procedure we bij het invoeren van een nieuwe ronde de vorige ronde overschreven.

Ik was er al een beetje bang voor omdat jullie ze tijdens de wedstrijd ook niet konden vinden. Jammer, maar so be it.

[ Voor 9% gewijzigd door Soultaker op 01-10-2007 19:13 ]

[Sjaaky]

Soultaker schreef op maandag 01 oktober 2007 @ 19:12:
Misschien was het handiger geweest een interface (ik bedoel dus een echte interface zoals de taal Java die kent) te specificeren, zodat mensen alleen een klasse hoefden te schrijven die die interface implementeert, en dat jullie dan een stub aanleverden die de verbinding met de server regelt. Iets soortgelijks kun je ook voor C# doen.

Ik weet niet of alle deelnemers afvielen vanwege de soap-interface. We hebben overwogen om gewoon een bestand te lezen en stdout te gebruiken, zoals gebruikelijk is tijdens de ACM ICPC en voorronden. Dan hadden we wel zelf iets moeten ontwikkelen om te communiceren met de gameserver. Wij werken als bedrijf veel met soap en webservices, dus was de keuze daarvoor al snel gemaakt.
Het idee was om mensen kennis te laten maken met soap. Maar dat het zo veel problemen op zou leveren hadden we niet voorzien. Als er nog een TJIP Challenge komt, gaan we hierin meer tegemoet komen.

In de praktijk merk ik vaak (los van soap overigens) dat je heel snel klaar kunt zijn met de basisfunctionaliteit en dat het interfacen met andere systemen dan voor de problemen zorgt. Zo heb ik een keer (wel soap) een legacy delphi 6 applicatie moeten laten praten met een .net webservice van microsoft die wse 2.0 attachments gebruikte. Natuurlijk geen bestaande delphi implementatie van te vinden. Om die zelf te implementeren vond ik te ver gaan. Toen heb ik maar een .net com component geschreven die delphi kon gebruiken. Dat leverde weer problemen op byte niveau op met structs, maar die problemen kon ik toen wel van 2 kanten oplossen.

[Anoniem: 224082]

Ik ben trouwens zelf ook bezig een soortgelijke wedstrijd te organiseren voor Stratego

Daar maken we zelf een client die kan praten met een java programma dat een interface implementeerd of met een native dll bestand dat dezelfde methodes bevat. Dit laat de deelnemers vrijwel helemaal vrij welke taal ze gebruiken en ze hoeven alleen een aantal methodes te implementeren. Nu is dat voor deze wedstrijd ook iets belangrijker omdat onze doelgroep vooral de bestaande programmas zijn die in allerlei talen geschreven zijn en we het voor de deelnemers zo laagdrempelig mogelijk willen maken.

http://www.strategousa.or...ratego_World_Championship

[mathijs van altvorst]

De finale van afgelopen zaterdag was een geslaagde dag! Ik heb het goed naar de zin gehad ondanks dat ik onderaan geeindigd ben.

Ik ben zelf wel een voorstander van het delen van de source code. Ik zal een link naar mijn source code (C#) voor het einde van de week hier op het forum plaatsen.

Soultaker: fijn dat je jouw source code online hebt gezet. Ga hier vandeweek eens een keer rustig voor zitten. Ik denk dat ik er een heleboel van kan leren!!

[W4rlock]

Zaterdag was het inderdaad gezellig, ik moest helaas eerder vertrekken ivm andere verplichtingen, toch wel jammer om te zien dat mijn programma het zo slecht heeft gedaan... maargoed, ik had ook niet veel meer verwacht, had de "AI" nog de avond er voor in elkaar geflanst .

Soultaker schreef op maandag 01 oktober 2007 @ 19:12:
Als je niet met SOAP bekend bent en uit moet gaan zoeken hoe al die libraries werken is het echt niet makkelijk. Ik kan me best voorstellen dat mensen daar over struikelden. Dat er nu mensen waren met vele megabytes aan libraries was ook niet echt makkelijk.

Als je Java gebruikt heb je 3rd party libraries helemaal niet nodig. Je kunt gewoon de WSDL importeren mbv wsimport, vervolgens een GameServer instantie maken en gaan met die banaan... hoeveel simpeler wil je het maken?

[ Voor 32% gewijzigd door W4rlock op 01-10-2007 23:59 ]

[Plons_de_Kikker]

Ook ik vond de wedstrijd afgelopen zaterdag zeer geslaagd. Eigenlijk zou zoiets vaker georganiseerd moeten worden.

Als je Java gebruikt heb je 3rd party libraries helemaal niet nodig. Je kunt gewoon de WSDL importeren mbv wsimport, vervolgens een GameServer instantie maken en gaan met die banaan... hoeveel simpeler wil je het maken?

Als je het weet is het allemaal vrij eenvoudig inderdaad. Helaas staat wsimport niet echt bovenaan bij google, waardoor je er ook niet zomaar achter komt. Ik denk dat het een goed idee is om mensen hier wat mee te helpen door bijvoorbeeld een voorbeeld te geven.

[Soultaker]

Sjaaky schreef op maandag 01 oktober 2007 @ 20:26:
In de praktijk merk ik vaak (los van soap overigens) dat je heel snel klaar kunt zijn met de basisfunctionaliteit en dat het interfacen met andere systemen dan voor de problemen zorgt.

Ah. Eigenlijk was dat zaterdag ook het geval, met al die mensen (inclusief mezelf) die hun main loop niet goed hadden gestructureerd (eerst wachten op de server, dan inloggen, dan wachten op een ronde). Met puur de beschikbare methoden specificeren ben je er nog lang niet, en de hele interface specificeren is natuurlijk tricky ongeacht wat voor middleware je gebruikt.

W4rlock schreef op maandag 01 oktober 2007 @ 23:57:
Als je Java gebruikt heb je 3rd party libraries helemaal niet nodig. Je kunt gewoon de WSDL importeren mbv wsimport, vervolgens een GameServer instantie maken en gaan met die banaan... hoeveel simpeler wil je het maken?

Komt 'ie nu mee. Werkt dat wel met Java SE, of heb je daar EE voor nodig? Ik heb dat tooltje in ieder geval niet bij mijn JDK meegekregen.

Verder heb ik dat ook nergens kunnen vinden; ja, nu kan ik het wel vinden als ik op wsimport zoek, maar als je er niet mee bekend bent zijn dat soort dingen niet zo triviaal. Ik ram nu ook zo een CORBA client en server in elkaar als het moet, maar dat komt omdat ik er al uren tijd in heb gestoken (CORBA wordt over het algemeen als veel ingewikkelder dan SOAP beschouwd). Kortom: dat een professional het snel kan, betekent niet dat het voor iedereen makkelijk is.

Overigens vind ik het niet direct verkeerd dat er voor een SOAP interface gekozen was. Dit soort dingen uitzoeken en werkend krijgen is onderdeel van de uitdaging, en je had er weken de tijd voor. Het is echter wel jammer als een aantal mensen hierdoor helemaal niet mee konden doen.

[Plons_de_Kikker]

Overigens vind ik het niet direct verkeerd dat er voor een SOAP interface gekozen was. Dit soort dingen uitzoeken en werkend krijgen is onderdeel van de uitdaging, en je had er weken de tijd voor. Het is echter wel jammer als een aantal mensen hierdoor helemaal niet mee konden doen.

Hoewel het inderdaad niet voor iedereen even makkelijk is, had je er inderdaad ruim een maand de tijd voor. Zelf heb ik ook nog een aantal vragen voorgelegd aan Corniel, waarop ik telkens binnen een aantal uren al antwoord heb gekregen. Tijdens de introductie-bijeenkomt is er ook aangegeven dat mensen contact op mochten nemen met Tjip bij problemen. Daarnaast was dit forum er ook nog eens. Het was dus voor iedereen die even doorzette prima mogelijk om die interface te implementeren.

[Anoniem: 224082]

Naar aanleiding van het feit dat we een aantal keer op 0-9 kwamen in het toernooi heeft Joost trouwens het openingsboek nog doorzocht op het grootste offer dat er in zat:

na de zettenreeks:
5 2 3 4 1 5 2 2 3 3 2 5 3 4 1 0

is dit de bordpositie
score: 0-10
1 11 0 0 1 10
0 10 1 1 1 2

de tegenstander staat dan maar liefst 10 punten voor. Op diepte 22 vind hij deze bordpositie echter ook +10 waard, en vanaf 24 zelfs +11, lijkt dus nog te kloppen ook

[NaliXL]

Iemand heeft het woord "re-match" in zijn mond gehad na de wedstrijd. Iemand al plannen gemaakt o.i.d.?

[Corniel]

NaliXL schreef op woensdag 03 oktober 2007 @ 17:12:
Iemand heeft het woord "re-match" in zijn mond gehad na de wedstrijd.

Yep, we hebben plannen - de winnaars wilden een paper gaan schrijven geloof ik - en die willen vast ook partij-data hebben.

Daarnaast lijkt het ons ook heel leuk om wat meer te zien. Een toernooi is ook niet heel veel voor zoveel werk. Daarom mógen mensen een geupdate versie sturen. Vooral voor René Wareman en Jaap van Wingerden is dat dé uitgelezen kans, om hun engine echt te laten testen.

Als men dat doet, wel graag de aanlogprocedure als deze nog niet klopte. Hieronder in pseudo code wat we verwacht(t)en. (Ja dat hadden we veel eerder kunnen/moeten doen)

C:

serverstate = proxy.GetServerStatus();
switch(surverstate)
{
    case Initializing:
    case Loaded:
        // Be patiant and try again.
        break;
    case: Finished:
        // Stop trying.
        break;
    case Playing: 
        id = proxy.Logon("my name");
        
        // NOW Logon.
        gamestate = proxy.GetMatchStatus(id);
        switch(gamestate)
        {
            case None:
            case Waiting:
                // Be patiant and try again.
                break;
            case Won:
            case Draw:
            case Lost:
                // Game has ended, you may try again.
                break;
            case Playing:
                startplayer = proxy.StartMatch(id);
                // Do moves, etc.
        }
}