AI Challenge: Ants!

[Toryu]

Bedankt voor de suggesties. Het gaat nog steeds erg moeizaam, ik maak zoveel stomme fouten

[ Voor 80% gewijzigd door Toryu op 22-11-2011 21:47 ]

[Marce]

Ik ben er een uur of drie mee bezig geweest deze avond, ik ben met c++ aan de slag gegaan op ubuntu, ik heb het zover gekregen dat ik ze een kant op kon sturen (n,e,s,w), maar verder ben ik niet gekomen, zelfs collision tussen 2 ants nog niet. Kan pas in het weekend weer verder

We gaan het wel zien..

[Toryu]

Tijdens path plannen is dat vrij lastig, maar voor de eerstvolgende move is dat vrij eenvoudig te doen.

Het starter package begon met:

code:

            if(!state.grid[loc.row][loc.col].isWater)
            {
                state.makeMove(state.myAnts[ant], d);
                break;
            }

Als je dat veranderd naar:

code:

            if(!state.grid[loc.row][loc.col].isWater && state.grid[loc.row][loc.col].ant == -1)
            {
                state.makeMove(state.myAnts[ant], d);
                break;
            }

botsen ze niet meer

Zo nu ben je ongeveer even ver als mij Ik probeer datgene wat Bolukan gisteren zei te implementen, maar ik zie nog niet helemaal hoe dat gaat werken.

[Janoz]

Ik moet zeggen dat ik dit wel een leuke pot vind . Nog maar eens even kijken of ik komende week nog tijd vind om enkele aanpassingen door te voeren. Mijn AI presteert heel wisselend. Aan het begin loop ik vaak iets achter bij het verzamelen van voedsel en daardoor in grootte van de kolonie. Ook moet ik nog eens even gaan kijken dat ik niet teveel kamikaze acties uit loop te halen.

[Corniel]

Janoz schreef op woensdag 23 november 2011 @ 22:27:
Ik moet zeggen dat ik dit wel een leuke pot vind (..)

Daar kan ik me iets bij voorstellen. Hoewel (zoals je zelf aangeeft) wel iets te veel kamikaze speelt. Dat is leuk als het goed gaat, maar het kan ook heel slecht aflopen...

[H!GHGuY]

Toryu schreef op woensdag 23 november 2011 @ 21:33:
Tijdens path plannen is dat vrij lastig, maar voor de eerstvolgende move is dat vrij eenvoudig te doen.

Het starter package begon met:

code:

            if(!state.grid[loc.row][loc.col].isWater)
            {
                state.makeMove(state.myAnts[ant], d);
                break;
            }

Als je dat veranderd naar:

code:

            if(!state.grid[loc.row][loc.col].isWater && state.grid[loc.row][loc.col].ant == -1)
            {
                state.makeMove(state.myAnts[ant], d);
                break;
            }

botsen ze niet meer

Klopt niet. Zoek even uit waarom dit niet waar is...

[Corniel]

H!GHGuY schreef op donderdag 24 november 2011 @ 12:40:
[...]

Klopt niet. Zoek even uit waarom dit niet waar is...

Dit klopt wel degelijk, tenminste als je na dat je een zet van een ant hebt doorgegeven direct de state update.

[Janoz]

Nu weet ik niet hoe de c++ code in elkaar steekt, maar als met -1 wordt bedoeld dat er nu geen mier staat, dan is de code maar gedeeltelijk juist. Alle nog te behandelen mieren zullen immers nog op hun oude plek staan. Die plekken worden dan ook ten onrechte als 'bezet' terug gegeven.

[Soultaker]

H!GHGuY schreef op donderdag 24 november 2011 @ 12:40:
Klopt niet. Zoek even uit waarom dit niet waar is...

Ik geef het op, leg maar uit als je het zo goed weet...?

Janoz schreef op donderdag 24 november 2011 @ 16:20:
Nu weet ik niet hoe de c++ code in elkaar steekt, maar als met -1 wordt bedoeld dat er nu geen mier staat, dan is de code maar gedeeltelijk juist. Alle nog te behandelen mieren zullen immers nog op hun oude plek staan.

Klopt, maar de claim was alleen dat de code voorkomt dat mieren tegen elkaar botsen. Dat lijkt me juist, ook al is de code iets te conservatief.

[Toryu]

state.makeMove is:

code:

void State::makeMove(const Location &loc, int direction)
{
    cout << "o " << loc.row << " " << loc.col << " " << CDIRECTIONS[direction] << endl;

    Location nLoc = getLocation(loc, direction);
    grid[nLoc.row][nLoc.col].ant = grid[loc.row][loc.col].ant;
    grid[loc.row][loc.col].ant = -1;
};

Iedere keer als je een move maakt, wordt je grid dus meteen geüpdatet.

[Caelorum]

Soultaker schreef op donderdag 24 november 2011 @ 17:18:
[...]
Ik geef het op, leg maar uit als je het zo goed weet...?
[...]

Dit zijn van die leuke subtiele verschillen in de starterkits. In de c# variant hoef je die niet te proberen, omdat als je de volgende situatie hebt het helemaal verkeerd gaat:

x	x	x
mier 1	x	mier 2
x	x	x

Mier 1 gaat naar rechts en mier 2 gaat naar links. De grid wordt namelijk zo ver ik weet in de C# starterkit niet elke keer geupdate na elke move van de mier ^^

[ Voor 5% gewijzigd door Caelorum op 24-11-2011 21:26 ]

[Corniel]

Caelorum schreef op donderdag 24 november 2011 @ 21:25:
Mier 1 gaat naar rechts en mier 2 gaat naar links. De grid wordt namelijk zo ver ik weet in de C# starterkit niet elke keer geupdate na elke move van de mier (..)

Nu gebruik ik weinig tot niets uit de starterkit, maar los daarvan: met zoiets moet je zelf rekening houden als je zeker wilt weten dat het goed gaat, toch? En dan kan het wel degelijk goed zijn (zoals reeds betoogd).

Maar hoe is het bij de anderen met de voortgang? Ik ben nu al een week aan het tweaken, maar echt grote verbeteringen zitten er op dit moment niet in. Wel een paar serieuze bugs, maar vreemd genoeg maken die fixes de engine niet veel sterker...

[Corniel]

Ik bedacht me dat het wellicht aardig was om een stukje van mijn eigen framework te laten zien. Een van de dingen die ik graag wilde (uit Unit Test oogpunt onderandere) was een struct maken van een instruction.

Net alleen voer ik ik mijn engine hiermee op de verschillende momenten gedurende het spel, de enige op haar beurt geeft de zetten weer af bij een IMoveReceiver. In een unittest worden ze aan een lijst toegevoegd waar ik Asserts op kan doen, in een match wordt de ToString() van de instruction gebruikt om naar de Console Out te schrijven. Ter leering ende vermack:

C#:

using System.Collections.Generic;

namespace Ants
{
    public interface IBot
    {
        /// <summary>Initializes the bot.</summary>
        void Initialize(IEnumerable<Instruction> instructions);

        /// <summary>Update the bot.</summary>
        void Update(IEnumerable<Instruction> instructions);

        /// <summary>Let do some turns.</summary>
        void DoTurn(IMoveReceiver receiver);
    }

    public interface IMoveReceiver
    {
        /// <summary>Receive a move.</summary>
        void Receive(Instruction move);
    }
}

C#:

using System;
using System.Collections.Generic;
using System.Text;

namespace Ants
{
    public class Instruction : IEquatable<Instruction>
    {
        /// <summary>Represents the GO instruction.</summary>
        public static readonly Instruction Go = new Instruction() { Type = InstructionType.go };
        /// <summary>Represents the READY instruction.</summary>
        public static readonly Instruction Ready = new Instruction() { Type = InstructionType.ready };
        /// <summary>Represents the END instruction.</summary>
        public static readonly Instruction End = new Instruction() { Type = InstructionType.end };

        /// <summary>Constructor.</summary>
        /// <remarks>Sets some defaults.</remarks>
        private Instruction()
        {
            this.Value = -1;
            this.Row = -1;
            this.Col = -1;
            this.Color = -1;
        }
        
        /// <summary>Gets and set the type.</summary>
        public InstructionType Type { get; set; }

        /// <summary>Gets and set the value.</summary>
        public long Value { get; set; }

        /// <summary>Gets and set the row.</summary>
        public int Row { get; set; }
        
        /// <summary>Gets and set the column.</summary>
        public int Col { get; set; }

        /// <summary>Gets and set the color.</summary>
        public int Color { get; set; }

        /// <summary>Gets and set the dirction.</summary>
        public DirectionType Direction { get; set; }

        /// <summary>Represents the instruction as System.String.</summary>
        public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append(this.Type);
            if (this.Value >= 0)
            {
                sb.Append(' ').Append(this.Value);
            }
            else if (this.Row >= 0 && this.Col >= 0)
            {
                sb.Append(' ').Append(this.Row).Append(' ').Append(this.Col);
                if (this.Color >= 0)
                {
                    sb.Append(' ').Append(this.Color);
                }
                else if (this.Direction != DirectionType.X)
                {
                    sb.Append(' ').Append(this.Direction);
                }
            }
            return sb.ToString();
        }

        /// <summary>Gets a hash code.</summary>
        public override int GetHashCode()
        {
            return ToString().GetHashCode();
        }
        
        /// <summary>Implements equals.</summary>
        public override bool Equals(object obj)
        {
            if (obj is Instruction)
            {
                return Equals((Instruction)obj);
            }
            return false;
        }
        
        /// <summary>Implements equals.</summary>
        public bool Equals(Instruction other)
        {
            if (object.Equals(other, null)) { return false; }
            return
                this.Type == other.Type &&
                this.Value == other.Value &&
                this.Row == other.Row &&
                this.Col == other.Col &&
                this.Color == other.Color;
        }

        /// <summary>Equals operator.</summary>
        public static bool operator ==(Instruction inst0, Instruction inst1)
        {
            if (!object.Equals(inst0, null))
            {
                return inst0.Equals(inst1);
            }
            return object.Equals(inst1, null);
        }
        /// <summary>Don't equals operator.</summary>
        public static bool operator !=(Instruction inst0, Instruction inst1)
        {
            return !(inst0 == inst1);
        }

        /// <summary>Parses an instruction.</summary>
        public static Instruction Parse(string line)
        {
            var instr = new Instruction();
            var tp = InstructionType.None;

            string[] tokens = line.Split();

            if (tokens.Length > 0)
            {
                tp = (InstructionType)Enum.Parse(typeof(InstructionType), tokens[0]);

                if (TokenLength[tp] == tokens.Length)
                {
                    if (tokens.Length == 2)
                    {
                        if (tp == InstructionType.player_seed)
                        {
                            instr.Value = long.Parse(tokens[1]);
                        }
                        else
                        {
                            instr.Value = (int)uint.Parse(tokens[1]);
                        }
                    }
                    if (tokens.Length == 4)
                    {
                        if (tp == InstructionType.o)
                        {
                            instr.Direction = (DirectionType)Enum.Parse(typeof(DirectionType), tokens[3]);
                        }
                        else
                        {
                            instr.Color = (int)uint.Parse(tokens[3]);
                        }
                    }
                    if (tokens.Length == 3 || tokens.Length == 4)
                    {
                        instr.Row = (int)uint.Parse(tokens[1]);
                        instr.Col = (int)uint.Parse(tokens[2]);
                    }

                    instr.Type = tp;
                    return instr;
                }
            }
            throw new ArgumentException(string.Format("The line '{0}' is not a valid instruction.", line));
        }

        /// <summary>Parses a multi line input.</summary>
        public static List<Instruction> ParseMultiLine(string text)
        {
            var list = new List<Instruction>();

            var lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

            foreach(var line in lines)
            {
                list.Add(Instruction.Parse(line));
            }
            return list;
        }

        /// <summary>Creates a move based on a row, a column and a direction.</summary>
        public static Instruction CreateMove(int row, int col, DirectionType dir)
        {
            return new Instruction()
            {
                Type = InstructionType.o,
                Row = row,
                Col = col,
                Direction = dir,
            };
        }
        
        /// <summary>Helper for parsing instructions.</summary>
        private static Dictionary<InstructionType, int> TokenLength = new Dictionary<InstructionType, int>()
        {
            { InstructionType.None, 0 },
            
            { InstructionType.ready, 1 },
            { InstructionType.go, 1 },
            { InstructionType.end, 1 },

            { InstructionType.player_seed, 2 },
            { InstructionType.players, 2 },
            { InstructionType.cols, 2 },
            { InstructionType.rows, 2 },
            { InstructionType.turntime, 2 },
            { InstructionType.loadtime, 2 },
            { InstructionType.viewradius2, 2 },
            { InstructionType.attackradius2, 2 },
            { InstructionType.spawnradius2, 2 },

            { InstructionType.turn, 2 },
            { InstructionType.turns, 2 },

            { InstructionType.f, 3 },
            { InstructionType.r, 3 },
            { InstructionType.w, 3 },
            { InstructionType.d, 4 },
            { InstructionType.a, 4 },
            { InstructionType.h, 4 },

            { InstructionType.o, 4 },
        };
    }
}

[ Voor 2% gewijzigd door Corniel op 24-11-2011 23:48 . Reden: extra interface toegevoegd. ]

[Corniel]

Hmm, het is een beetje stil hier?!

Dan nog maar een bijdrage van mijn kant. Heel handig voor mini debugging, de volgende kaart:

code:

rows 8
cols 8
players 2
m 0.......
m %%......
m ........
m ...%%...
m ....1...
m ........
m ........
m *.......

Geschikt voor twee bots. Dit is prettig als je array even in je debugger wilt bekijken.

[Bolukan]

Ik heb het gevoel dat je posts - Corniel - zo overweldigend zijn dat niemand meer durft

Zijn er ook ideeen hoe je een (gecoordineerde) fight moet aansturen. Is dat een kwestie van alle combinaties van zetten brute-forcen? En hoe beslis je dan? Iemand ideeen (hoeft niet geimplementeerd/proven) hoe je dat zou aanpakken. Welke onderdelen optimaliseer je? Wat zijn de tricky zaken?
Ik ben vooral benieuwd of er meerdere oplossingen mogelijk zijn, bijvoorbeeld a la diffusion smell, of met partiele optimalisatie (niet gecoordineerde afweging tussen ants met toch goed gedrag).

PS: Op het aichallenge forum staat een aardige thread over een neural network.

[ Voor 10% gewijzigd door Bolukan op 28-11-2011 23:15 ]

[Azer]

Ik ben ook afgelopen weekend begonnen met mijn bot. Het gaat aardig goed, ik heb het A * path finding algoritme geimplementeerd en ik ben nu op zoek naar ideeën voor een goede aanvalstrategie. Ik stuur natuurlijk al mieren af op vijandelijke ant hills, maar het is natuurlijk beter om aan te vallen met een gezamelijke groep van mieren. Eigenlijk zoek ik dus een goed flocking algoritme.

Mijn username in de GoT ranglijst is trouwens Viincenttt

[Corniel]

Bolukan schreef op maandag 28 november 2011 @ 23:12:
Ik heb het gevoel dat je posts - Corniel - zo overweldigend zijn dat niemand meer durft (..)

Hmm, ik ben me van geen kwaad bewust.

Zijn er ook ideeën hoe je een (gecoördineerde) fight moet aansturen.

Bedoel je hiermee, ant(s) v.s. ant(s), of aanvallen op een hill? Ik neem aan het eerste. Daar heb ik wel ideeën over. Ik heb iets geïmplementeerd, dat werkt redelijk, maar ik zag dat ik van de nummer een toch nog redelijk soepel verloor (gek, heel gek. )

Ik gebruik geen smell, dat lijkt me niet nuttig. Ik bepaal hoe sterk de tegenstand maximaal kan zijn op een kandidaat tile en als ik sterker ben, ga ik er heen. Anders niet. Wat ik nog moet/wil doen, is ook zorgen dat als ik twee of meer mieren heb, die niet naast elkaar staan, maar een vijandige ant kunnen sandwichen, dat detecteren. Mijn huidige aanpak heeft dát namelijk niet door.

Maar nu ben ik met performance bezig, en het debuggen van wat storende fouten.

[boe2]

Ben nu ook een avond bezig geweest, maar heb nog niet veel bereikt. Ben begonnen vanuit de starterkit en ben nu volop dingen aan het aanpassen, al lijkt het beter om volledig from scratch te herbeginnen zodra ik de werking volledig doorheb. Momenteel heb ik een wrapper voor de Ant klasse genaamd "ManagedAnt" waarin de huidige queue met instructies en doel wordt bijgehouden van iedere gekende ant op het bord. In de starterkit wordt iedere ant immers iedere beurt volledig nieuw geinitialiseerd lijkt me zo

Men ingame nick geef ik nog niet door, men ants zijn nog veel te debiel

[SaphuA]

.

[ Voor 138% gewijzigd door SaphuA op 31-01-2022 15:53 ]

[boe2]

De server draait mono om c# te compilen, dus je moet zelf geen 4.0 code zitten kloppen idd

[Corniel]

Boeboe schreef op dinsdag 29 november 2011 @ 00:26:
Ben begonnen vanuit de starterkit en ben nu volop dingen aan het aanpassen, al lijkt het beter om volledig from scratch te herbeginnen zodra ik de werking volledig doorheb (..)

Herkenbaar, dat is ook wat ik gedaan heb. Initieel kost het iets meer tijd, maar je snapt beter wat er gebeurt.

In de starterkit wordt iedere ant immers iedere beurt volledig nieuw geïnitialiseerd lijkt me zo (..)

Tja, dat zijn drie int properties, dus dat is op zich ook weer niet zo'n ramp, detecteren of je hem nog hebt kost wellicht zelfs meer tijd. (Ik doe het wel hoor, daar niet van)

Men ingame nick geef ik nog niet door, men ants zijn nog veel te debiel

So what? Je bent net begonnen, dan is het niet heel onlogisch dat ie nog niet zoveel doet. We zijn niet allemaal zoals Sjaakie. Zijn eerste versie haalde een top van 70,0. Gewoon melden je nick, anderen kunnen dan ook makkelijker advies geven op basis van wat ze zien.

SaphuA schreef op dinsdag 29 november 2011 @ 10:39:
Ik merk wel dat mijn code een behoorlijke zooi aan het worden is met zo'n beetje alle logica in 1 klasse (..)

Ben zelf op dit moment aan mijn derde grote refactor bezig. Kom elke keer weer diepe krochten tegen waar obsolete, invalid, en unused code rondzwerft.

Hebben jullie nog een taktiek voor razen? Op dit moment stuur ik gewoon een lange stream van ants naar de enemy hill tot ie kapot is (..)

Dat is redelijk effectief blijkt in praktijk. Zorg wel dat ze zich niet doodlopen op een nuttige verdediging.

[ Voor 0% gewijzigd door Corniel op 03-12-2011 21:39 . Reden: micro typo ]

[Corniel]

Ook versie 1.15 (die nu online staat en een score heeft van rond de 76.0 is) is nu te downloaden:
www.corniel.nl/download/Ants/Truusje

[Bolukan]

Hmmm, geen source

[Corniel]

Bolukan schreef op dinsdag 29 november 2011 @ 23:13:
Hmmm, geen source

Nope, dat doe ik pas na de challenge.

[D-Raven]

Het ligt momenteel een beetje stil aan mijn kant. Druk met andere dingen. Wil nog wel wat dingen verbeteren maar A* gebruiken icm responsive behavior is vrij klote .


Ow en wat betreft bagger code. Check!

[PiepPiep]

Ik ben wel al zover dat ik zelf de input/output doe, maar verder is hij net ietsje slimmer dan het C# voorbeeld.
Hij stapt bijvoorbeeld niet op een andere mier, en ik heb toegevoegd dat hij 10% kans heeft om een actie niet te doen.

code:

WWW
WxW
...

Hier blijft het voorbeeld naar beneden en boven bewegen, maar de mijne doet soms als hij beneden staat een stapje omzij waardoor hij los komt.
Dit heeft echter geen voordeel genoeg om echt vaak van de voorbeelden te winnen.

Wat ik wel al bedacht had en in dit topic nog niet gezien heb is het volgende (even in pseudo code, gaat om het idee) :

code:

MaximumTijd = DieWaardeDieJeVanDeServerKrijgt - 10%
BeginTijd = VraagTijdOp
ForEach Ant
    Ant.DoeJeDing
    If VraagTijdOp - BeginTijd > MaximumTijd
        BreekUitForEach

Dit heeft als groot voordeel dat het botje niet door zijn tijd heen zal gaan als je de DoeJeDing klein genoeg houd.
Als ik nog zin krijg om iets als A* oid te maken dan zorg ik dat DoeJeDing bijvoorbeeld alleen een stap doet.
Daarna voeg ik na de ForEach nog een ForEach toe die elke ant telkens een klein stukje laat berekenen tot de tijd bijna op is.

[SaphuA]

.

[ Voor 99% gewijzigd door SaphuA op 31-01-2022 15:52 ]

[Corniel]

SaphuA schreef op woensdag 30 november 2011 @ 11:53:
Zo, Corniel, je nieuwste versie is een hele vebetering (..)

@SaphuA: Dank! Maar met welke versie werkte je, en op wat voor map? Mijn versies voor 1.15 waren zeer slecht in het exploren op maze-maps. In open mappen is de vooruitgang tussen 1.11 en 1.15 niet zo groot (nog steeds niet slecht). En deze versie heeft nu een score van 76.5, dus nét geen top-100.

Als je wilt verbeteren zal je er toch een keertje voor moeten gaan zitten en herschrijven denk ik. En veel testen. Er zijn zoveel kleine foutjes die je kan maken.

[SaphuA]

.

[ Voor 104% gewijzigd door SaphuA op 31-01-2022 15:52 ]

[Toryu]

pff wat een drama is het. Ik probeer nog steeds mijn ants statefull te maken, maar het wil maar niet lukken. Ik kom steeds maar rare dingen tegen waarvan ik de oorzaak niet kan vinden.

[Corniel]

Toryu schreef op woensdag 30 november 2011 @ 16:29:
pff wat een drama is het. Ik probeer nog steeds mijn ants statefull te maken, maar het wil maar niet lukken (..)

Ik doe het volgende. Bij het afhandelen van de instructies:

C#:

        /// <summary>Updates own ant.</summary>
        public override AntsAnt OnUpdateOwnAnt(AntsAnt ant)
        {
            if (this.Ants.Get(ant) == ant.Color)
            {
                ant = this.OwnAnts.Get(ant);
            }
            else
            {
                this.Ants.Set(ant, ant.Color);
                this.OwnAnts.Add(ant);
            }
            ant.IsUpdated = true;

            return ant;
        }

En als alle instructies verwerkt zijn:

C#:

        public override void OnUpdateAfter()
        {
            // Remove not updated ants.
            for (int i = this.OwnAnts.Count - 1; i >= 0; i--)
            {
                if (this.OwnAnts[i].IsUpdated)
                {
                    this.OwnAnts[i].IsUpdated = false;
                }
                else
                {
                    this.OwnAnts.Remove(this.OwnAnts[i]);
                }
            }
        }

Wellicht heb je er iets aan?!

[Toryu]

Dank je. Het is hier nu ook gelukt, denk ik. Uiteindelijk was het heel simpel op te lossen, maar heeft me wel weer heel wat tijd gekost.

Nu maar eens nadenken hoe ik exploring ga implementeren

[Corniel]

Zojuist versie 16 geupload:

• Strategy selection refactoring
• Distance to unknown fix
• Performance updates
• Static defence (her)toegevoegd
• Explore mechanisme opnieuw op de schop (blijft het meest tricky

Versie 15 piekte op 76.85 (plt. 105)

Het zou mooi zijn als ik de top 100 zo kunnen inrollen richting de deadline.

Hoe gaat het met de rest?

[Bolukan]

Strategy selection refactoring
Qu'est-ce que c'est?

[Herko_ter_Horst]

C'est le stukje code herschrijven dat de strategie selecteert, je pense.

[Bolukan]

Selecteren van een strategie, wat is dat voor functie?
(Ik meen het serieus, op basis waarvan verander je van strategie?)
Edit: Thx voor hier onder. Klinkt als een goede aanpak.

Heb even Transposition table zitten lezen om het fighting efficienter door te rekenen.

En diffusion is hier natuurlijk fantastisch uitgebeeld.

[ Voor 101% gewijzigd door Bolukan op 02-12-2011 10:49 ]

[Corniel]

Bolukan schreef op donderdag 01 december 2011 @ 23:10:
Selecteren van een strategie, wat is dat voor functie?
(Ik meen het serieus, op basis waarvan verander je van strategie?)

C#:

public abstract class Strategy
    {
        protected Strategy(Truusje bot){ /* .. */ }

        public Truusje Bot { get; set; }
        protected int[,] Scores { get; set; }

        public virtual void Initialize(){ /* .. */ }

        public virtual void OnUpdateInit() { }

        public virtual AntsFood OnUpdateFood(AntsFood food) { return food; }
        public virtual AntsWater OnUpdateWater(AntsWater water) { return water; }

        public virtual AntsHill OnUpdateOwnHill(AntsHill hill) { return hill; }
        public virtual AntsHill OnUpdateEnemyHill(AntsHill hill) { return hill; }

        public virtual AntsAnt OnUpdateOwnAnt(AntsAnt ant) { return ant; }
        public virtual AntsAnt OnUpdateEnemyAnt(AntsAnt ant) { return ant; }

        public virtual void OnUpdateAfter() { }
        public virtual void OnTurnInit() { }

        public virtual void OnTurnAfterStrategy(AntsLoc oldLoc, AntsLoc newLoc, DirectionType dir, TruusjeCanidateMove move) { }
        public virtual void OnTurnAfter(AntsLoc oldLoc, AntsLoc newLoc, DirectionType dir, TruusjeCanidateMove move) { }
        public virtual void OnTurnAfter() { }

        /// <summary>Returns true if the strategy can give a move, otherwise false.</summary>
        public abstract bool CanMove(AntsAnt ant, AntsLoc loc, DirectionType dir);
        /// <summary>Gets a move.</summary>
        public abstract TruusjeCanidateMove GetMove(AntsAnt ant, AntsLoc loc, DirectionType dir);
    }

Al mijn strategieën leiden van bovenstaande classe af. Ik heb er nu negen.

Ik heb een strategie HarvestFood. Die geeft alleen een move af als het een mier betreft die wat hem betreft dicht genoeg bij voedsel staat (elke ronde wordt dit op nieuw bepaald in OnTurnInit), het niet de null-move betreft (er zijn weinig strategiën bij mij die de null-move accepteren) en als er een goed kans is dat de desbetreffende ant niet wordt afgeslacht.

Mijn strategieën hebben een rangorde. In de orde loop ik met alle mieren die nog mogen zetten door de lijst. Per loop voer ik een zet uit, pas een paar kleine dingen aan en loop net zo lang totdat ze allemaal gezet hebben.

Het voordeel hiervan is dat je veel nauwkeurigere verschillende deel-problemen kan aanpakken. Als je een infuence-map gebruikt is het nogal lastig om tegelijk te bepalen dat je een vijandelijke heuvel moet gaan bestormen én iets aan je verdediging moet doen én voedsel moet oppakken, en ant2ant-battles moet besturen en ect...

Voor sommige dingen moet je nu eenmaal wat pathfinding doen, voor andere dingen werken influence-technieken beter, voor combat wil je wellicht min-max/alpha-beta inzetten, en voor weer iets anders is het ook vooral van belang dat je er niet te veel mieren voor claimt, en wil je andere randzaken meenemen in je overweging.

[edit]
Hmm, zie nu dat er een enorme bug zit in mijn static defence die ik online heb gezet. Hierdoor wordt mijn hill niet meer geleegd. Snel updaten maar

[ Voor 2% gewijzigd door Corniel op 02-12-2011 09:23 . Reden: Toevoeging over laatste update ]

[boreus]

Zo, toch maar even een account aangemaakt om me hier in te kunnen mengen. Mijn suffe collega-afstudeerders op de TU Delft zijn er maar weinig actief mee bezig.

Zelf ben ik afgestapt van het state bijhouden vanaf versie 7 (of v6 missschien). Mieren liepen in de verkeerde state te vaak langs voedsel. Nu ben ik bezig met een compleet andere aanpak en heb het geheel nog even opnieuw in C++ geschreven.

Van wat ik heb gelezen [1] was een static defence niet heel nuttig. In mijn ervaring helpt het vooral tegen niet al te sterke tegenstanders. Als je niet iedere twee of drie beurten een nieuwe mier produceert, dan doe je misschien toch al iets fout.

[1] AI challenge forum - http://forums.aichallenge.org/viewtopic.php?f=24&t=1879

[Vaan Banaan]

[kwijlmodus]
Zo, Boreus komt een even langs. Goeiendag zeg. Nummer 1 van de Nederlanders er momenteel nr 30 overall!
Ik zat vandaag je potjes te volgen en volgens mij verlies je nu in de topklasse alleen nog, omdat je ants te agressief aanvallen en daardoor wat opofferings gezind zijn.
Maar verder gefeliciteerd!
[\kwijlmodus]
Fijn, ik ben de hele avond kwijt geweest om in C stdin te kunnen debuggen uit een bestand in plaats van de console.
_{In Code::Blocks: Project -> Build Options -> Debug, tab: #defines: DEBUG}

C: Debug stdin redirect

#include <stdio.h>
int main()
{
    int c;
    #ifdef DEBUG
        freopen("c:/tmp/test.txt","r",stdin);
    #endif
    while ( (c = getchar()) != EOF )
        printf("%c", c) ;
    return 0;
}

[ Voor 39% gewijzigd door Vaan Banaan op 06-12-2011 01:21 ]

[boreus]

Bolukan schreef op maandag 28 november 2011 @ 23:12:
Zijn er ook ideeen hoe je een (gecoordineerde) fight moet aansturen. Is dat een kwestie van alle combinaties van zetten brute-forcen? En hoe beslis je dan? Iemand ideeen (hoeft niet geimplementeerd/proven) hoe je dat zou aanpakken. Welke onderdelen optimaliseer je? Wat zijn de tricky zaken?
Ik ben vooral benieuwd of er meerdere oplossingen mogelijk zijn, bijvoorbeeld a la diffusion smell, of met partiele optimalisatie (niet gecoordineerde afweging tussen ants met toch goed gedrag).

Hoewel ik er nog niet zo heel blij mee ben, dit is wat ik doe: momenteel kan ik bruteforce tot iets van 8 mieren totaal (friends+foes). Alles met meer mieren deel ik op in max. 8 mieren of 2v1 onderdelen. Het implementeren van een vooraf uitgedachte 2v1 tactiek werkte voor mij echt heel goed (zonder de bruteforce er nog bij). Verder gewoon zorgen dat je niet te veel/vroeg/onnodig 1v1 afruilt en zeker nooit 2v1 verliest.

Edit@Banaan: Klopt, de huidige afweging bij de bruteforcer kiest de opstelling waarbij mijn tegenstander potentieel het meeste kan verliezen. Hierbij wordt geen rekening gehouden met dat veel zetten gewoon niet gedaan worden door de tegenstander omdat ze slecht zijn. Op zich is deze aggressie ook wel nodig om soms door een static defence heen te kunnen. In de onderstaande match pak ik wel de laatste punten dankzij dit, terwijl runevision er al een tijdje naast staat te niksen.
http://aichallenge.org/vi...php?game=161015&user=9502

[ Voor 21% gewijzigd door boreus op 04-12-2011 21:06 ]

[Bolukan]

Ik ben heel gecharmeerd van Random sampling als vervanger van een brute-force methode.
Want of je nou 6, 8 of 9 mieren tegelijkertijd kan combineren, er zit gewoon een plafond aan.

Dirichlet distribution lijkt ingewikkeld, die beleving komt met name door de ingewikkelde wikipedia pagina, maar valt volgens mij wel mee in de praktijk.

[ Voor 17% gewijzigd door Bolukan op 06-12-2011 14:03 ]

[boreus]

Bolukan schreef op dinsdag 06 december 2011 @ 14:02:
Ik ben heel gecharmeerd van Random sampling als vervanger van een brute-force methode.
Want of je nou 6, 8 of 9 mieren tegelijkertijd kan combineren, er zit gewoon een plafond aan.

Dirichlet distribution lijkt ingewikkeld, die beleving komt met name door de ingewikkelde wikipedia pagina, maar valt volgens mij wel mee in de praktijk.

Ja ik zag ook dat a1k0n (rank: top 10) ineens zijn vecht tactiek heeft gedeeld op het forum, omg! Hij legt zo op het eerste gezicht wel redelijk precies uit hoe het geimplementeerd kan worden en verwijst hij verder voor de volledigheid naar de namen van de distributies. Ik ben met je eens dat de brute-force methode maar beperkt nuttig is.

Wat is een handige manier om bots te sharen? Op zich vind ik het wel het meest sportief om geen (volledige) code met elkaar te delen, maar vooral/alleen binaries.

[Bolukan]

We missen een tweakers-server.

[boreus]

Oke misschien werkt dit gewoon?
Dit zijn mijn submissions v1 t/m v6.
Volgens mij heeft v6 wel eens top 100 gehaald.

https://docs.google.com/o...0LTkyNjItMDczMDk4OGViYWEw

@Banaan: input redirecten (met < of >) op de console werkte niet? Weet je dat je ook de input van playgame.py kunt laten opslaan met de optie -I? Verder is voor debugging de optie -E uiteraard heel handig.

[Sjaaky]

quote: http://www.joelonsoftware.com/articles/fog0000000027.html

Old code doesn't rust, it gets better, as bugs are fixed.

Die van mij niet . Versie 1 van mijn bot zakte langzaam in de ranglijsten, maar het echte dieptepunt is dat deze nu niet eens meer compileert: http://aichallenge.org/profile.php?user=9683

Toch maar eens tijd voor een nieuwe versie maken.

[Vaan Banaan]

Hee, xathis is van de nummer 1 af.
@boreus: Ik wilde met de c_starter_package van de site inderdaad eens testen of ik de input kon steptracen. In Code::Blocks (mijn IDE voor GCC en GDB) kan je wel argumenten toevoegen, maar dat ziet hij als ehm.. argumenten. Dus '<0.bot0.input' en niet de inhoud van die file. En vervolgens vrolijk wachten bij de getchar()
Maar goed, ik ben ook helemaal niet thuis in C, het is echt een hobby project.
Gisteren weer uren bezig geweest met een "warning implicit declaration of function.." Bleek dat ik een eigen header file tussen <> had gezet in plaats van "". BRILLIANT. _{Hmm, zou die naam al bestaan?}
Wat betreft static defence: Daar heb je wel gelijk in. Hier een potje met the best of the best. 9 man en geen enkele krijgt het binnen 1000 zetten voor elkaar om een hill te razen

[boreus]

Heeft er al iemand tests gedraaid tegen mijn bots?

Goed nieuws dat er een nieuwe nr. 1 is. Die "windshield wiper" van pguilery is wel gaaf om te zien. Zelf ben ik qua vechten momenteel bezig met simulated annealing. Een andere optie waar ik over na zit te denken is een soort divide and conquer.

[Corniel]

boreus schreef op donderdag 08 december 2011 @ 11:20:
Heeft er al iemand tests gedraaid tegen mijn bots?

Ja, ik. Nog niet uitvoerig, omdat ik bij de refactoring naar versie 16 iets heel fundamenteels gemold bleek te hebben. Het heeft me een week gekost om de bug te vinden (gisteren nacht).

Ik heb een aantal tests tegen je v6 gespeeld en mijn bot is van vergelijkbare sterkte, ik denk net iets sterker. Jouw combat is daar al iets beter dan de mijne, maar ik vind meer voedsel en mijn aanval op hills is effectiever.

Wel dank voor het delen.

[ Voor 0% gewijzigd door Corniel op 08-12-2011 12:52 . Reden: typo ]

[boreus]

Heeft er trouwens iemand nagedacht over specifieke tactieken bij de multi-hill maps? Het lijkt er op (als ik kijk naar de "nieuwe" maps) dat die veel gebruikt gaan worden in de uiteindelijke competitie.

[Sjaaky]

Je kunt je ants tactisch laten spawnen. Waar je geen ants nodig hebt ga je op je eigen hill staan.
Meer fantasie heb ik niet .

[sPENKMAN]

Ik heb uit betrouwbare bron vernomen (mezelf ) dat er, als alles volgens plan loopt, zeer binnenkort een behoorlijke hoeveelheid server capaciteit bij gaat komen wat het aantal games per minuut in ieder geval zou moeten kunnen verdubbelen

We hadden op het werk nog een 3 stevige blades (2x 6C Xeon 3 Ghz met 144 GB ram) en een SAN (4U EqualLogic 6100XV) liggen die nog niet veel deden in afwachting van de start van het project. Na een positieve reactie van mijn baas en manager is er een goedkeuring gekomen de hardware tijdelijk even te doneren aan deze challenge mits het een beetje een bruikbare toevoeging is op de Amazon cloud. Ze zijn namelijk aardig ingericht op het spawnen van images die volautomatisch worden ingericht, iets wat we helaas nog niet kunnen faciliteren.

Dit komt er helaas wel op neer dat ik niet meer mag meedoen aan de challenge maar zo goed is mijn bot toch niet met een ranking van ~2500

[Corniel]

Zelf nu bezig met veel tweaken. Om een goed beeld te krijgen of het idd verbeteringen zijn actief op Fluxid begonnen. fluxid.pl.

Op basis van de score van Xathis daar en Truusje 1.15, kom ik op een ratingverschil van ongeveer 33.

Dat bekend dus dat de versie die nu online staat ongeveer op 79 zou moeten uitkomen (al lijkt dat er nog niet helemaal op ) en dat Truusje.1.07 ruim 72 gehaald zou hebben als ik die wat langer had laten staan. (ongeduldig als ik ben heb ik dat nooit gedaan).

Mocht iemand anders ook nog nuttige referentie data hebben dan hoor ik het graag. (Een stabiele score op ai challenge en op fluxid voor dezelfde versie)

[Sjaaky]

Ziet er goed uit er zit nu nog max 2uur tussen mijn partijen. Bedankt!

Wat mij de afgelopen tijd geholpen heeft met debuggen is dit kleine stukje code:

C#:

public class GameState 
{
        public void BreakWhen(int turn, bool condition)
        {
            if (Turn == turn && condition)
            {
                if (System.Diagnostics.Debugger.IsAttached)
                {
                    System.Diagnostics.Debugger.Break();
                }
            }
        }
        ..
}
//gebruik:
 GameState.BreakWhen(401, ant.Source == new Location(9, 65));

Als je in de viewer ziet dat een mier iets raars doet, dan run je de pot nogmaals in de debugger en zit je hiermee meteen op het goede punt in de partij.

[sPENKMAN]

Jup, de impact van de servers is wel duidelijk merkbaar in de aantallen games per uur. Er draaien er nu nog "maar" 12 extra waar er in ieder geval ruimte is voor nog eens 12 en potentieel daarna nog eens 6.

Even kijken hoe de boel schaalt naar mate er meer servers worden bijgezet. Ik heb zo'n vermoeden dat Janzert er nog wel een paar bij gaat schuiven zodra hij tijd heeft, heb hem helaas nog niet gesproken nadat hij de servers heeft gelanceerd

[Corniel]

Die extra servers zijn top!

Hmm, ik kwam net even achter een enorme bug:

C#:

public AntsLoc GetTile(int dr, int dc, AntsSettings settings)
{
    var r = (this.Row + dr) % settings.Rows;
    var c = (this.Col + dc) % settings.Cols;
    if (r < 0) { r += settings.Rows; }
    if (c < 0) { r += settings.Cols; }
    var loc = new AntsLoc(r, c);
    return loc;
}

Het erge is dat dit soort fouten te weinig voorkomen om direct op te vallen, maar wel heel naar gedrag veroorzaken.

[ Voor 6% gewijzigd door Corniel op 10-12-2011 20:32 ]

[Bolukan]

Corniel schreef op zaterdag 10 december 2011 @ 20:32:
Het erge is dat dit soort fouten te weinig voorkomen om direct op te vallen, maar wel heel naar gedrag veroorzaken.

Een letterlijke vorm van 'het hoekje omgaan"

[Corniel]

Bolukan schreef op zaterdag 10 december 2011 @ 21:37:
Een letterlijke vorm van 'het hoekje omgaan"

Hmm...

Werd gewoon afgestraft voor het niet schrijven van een unittest van dit vrij fundamentele stukje code.

Maar goed, we hebben nog een week: welke wijzigingen gaan we nog proberen hier?

Zelf ben ik nu bezig met het herschrijven van mijn hill-defence. Wensenlijstje is de verschillende strategieën tweaken op meerdere hills, en het verbeteren van de omschakeling tussen verspreiden (van elkaar weglopen maar niet te ver) en zo hard mogelijk richting onbekend gebied lopen.

[boreus]

Een tweak op meerdere hills heb ik ook nodig denk ik. Ik zat er nog aan te denken om een oudere versie die het goed doet daarop gewoon in te zetten zodra je in beurt 1 er achter komt of er meerdere hills zijn.

Goed werk met de extra servers spenkman!

Verder is mijn wishlist voor de komende week iets met meer combat, verdediging en aanvallen. Als de nieuwe versie met een beetje regelmaat van mijn versie 8 weet te winnen, dan ben ik wel tevreden.

[Corniel]

Hmm, Note to self: sla duidelijk betere versies op voor je gaat kloten en tweaken met nieuwe inzichten...

[boreus]

Corniel schreef op maandag 12 december 2011 @ 11:38:
Hmm, Note to self: sla duidelijk betere versies op voor je gaat kloten en tweaken met nieuwe inzichten...

Aww ja ik heb zelf ook heel lang een .jar gehad die de ass kickte van alle versies waar ik wel source code van had. Heel pijnlijk was dat. Sindsdien heb ik alles maar in een SVN gezet.

[Corniel]

boreus schreef op maandag 12 december 2011 @ 12:48:
Aww ja ik heb zelf ook heel lang een .jar gehad die de ass kickte van alle versies waar ik wel source code van had. Heel pijnlijk was dat. Sindsdien heb ik alles maar in een SVN gezet.

Nog geen tijd gehad om een SVN op te zetten, en met de resterende tijd...

[boreus]

Ik had na mijn eigen ellende in Eclipse ook wel een handige "local history" optie gevonden. Daarmee kan je ook heel veel history laten bewaren en op een handige manier terugkijken naar oudere versies. Wellicht heeft jouw IDE ook wel iets dergelijks? 't Is nu wel iets gedempte putten en verdronken kalveren helaas...

[Corniel]

boreus schreef op maandag 12 december 2011 @ 13:31:
Ik had na mijn eigen ellende in Eclipse ook wel een handige "local history" optie gevonden. Daarmee kan je ook heel veel history laten bewaren en op een handige manier terugkijken naar oudere versies. Wellicht heeft jouw IDE ook wel iets dergelijks? 't Is nu wel iets gedempte putten en verdronken kalveren helaas...

Visual Studio neemt aan dat je TFS of VSS gebruikt... Maar goed, gewoon ff kloten en dan zijn die 1,5 punten zo weer terug gevonden...

[Corniel]

Het heeft een avondje slecht humeur gekost, en de morele support van Sjaakie, maar ik heb weer een gefixte versie. Als het goed is (op fluxid in ieder geval) een punt beter.

Sjaakie zelf liet me trouwens z'n symmetrie-detector zien. Zeer indrukwekkend, al vielen de resultaten nog een beetje tegen geloof ik.

Als laatste nog bezig geweest met een ander combat mechanisme. Ik heb een mooie(re) manier gevonden om de influence-map op 1-ply te bepalen. Verder ben ik nog niet gekomen. We gaan wel zien of het luk dus.

[jeroensurft]

Gaaf, heb weekendje geknutseld aan mijn bot. Ben al best tevreden, nu kijken hoe ver ik kom. En dan wat nieuwe functies toevoegen! Jammer dat de contest redelijk snel weer sluit.

[boreus]

De thread [1] over symmetry detection heeft ook wel links naar hele gave filmpjes. Er staat ook in dat de mensen die het aan de gang dachten te krijgen er toch niet zo veel voordeel uit leken te halen. Ik kan me ook voorstellen dat je toch over het hele speelveld je mieren wilt verspreiden om voedsel te kunnen eten. Als je ook niet binnen vision range van een stukje voedsel staat, dan zal je ook wel niet de speler zijn die het gaat opeten.

Mijn eigen ding heeft nu in ieder geval geen (minder) timeouts en crashes en wint af en toe al wel een potje tegen mijn betere versies.

Ben benieuwd waar de nieuwe versie van Corniel eindigt. Daarnaast ben ik ook heel erg beniewd waar versie 2 van xathis gaat eindigen!!

[1] http://forums.aichallenge.org/viewtopic.php?f=24&t=2098

[Corniel]

boreus schreef op dinsdag 13 december 2011 @ 10:53:
De thread \[1] over symmetry detection heeft ook wel links naar hele gave filmpjes. Er staat ook in dat de mensen die het aan de gang dachten te krijgen er toch niet zo veel voordeel uit leken te halen.

Het mogelijke voordeel zit hem denk ik meer in het vroegtijdig detecteren van enemy hills, dan het spotten van voedsel. Ik ga het wellicht zelf ook proberen, maar als het geen voordeel oplevert schakel ik het gewoon direct weer uit.

[quote[Mijn eigen ding heeft nu in ieder geval geen (minder) timeouts en crashes en wint af en toe al wel een potje tegen mijn betere versies.[/quote]
Dat klinkt als vooruitgang.

Ben benieuwd waar de nieuwe versie van Corniel eindigt.

Ik ook, top-3 van Nederland zou wel heel gaaf zijn. Daarvoor moet ik nog een klein stapje maken (en zijn niet. )

Daarnaast ben ik ook heel erg beniewd waar versie 2 van xathis gaat eindigen!!

Me too. Op Fluxid was Xanthis zijn eerste plek tijdlijk tijd, maar staat ie nu 2,2 punten los. Dat zal hier waarschijnlijk ook wel ongeveer gaan gebeuren.

[ Voor 3% gewijzigd door Corniel op 13-12-2011 11:56 ]

[boreus]

Rankings op Fluxid heb ik me nooit zo mee bezig gehouden. Of is het nu zo dat veel van de bots nog regelmatig online zijn?

@Corniel: (wanneer) ga je je nieuwste versie op aichallenge.org uploaden?

Ik heb gevonden dat ze op de Universiteit Utrecht deze challenge in een vak hebben verwerkt, grappig!
http://www.cs.uu.nl/docs/vakken/b2ki/werkcollege.htm

[Corniel]

boreus schreef op dinsdag 13 december 2011 @ 14:05:
Rankings op Fluxid heb ik me nooit zo mee bezig gehouden. Of is het nu zo dat veel van de bots nog regelmatig online zijn?

Er zijn er wel een aantal online. Ik speel daar wel een regelmatig tegen mijn eigen bots (draai 3/4 versies tegelijk), maar het maakt het voor mij makkelijker om in te schatten of een aanpassing ook daadwerkelijk een verbetering is.

(wanneer) ga je je nieuwste versie op aichallenge.org uploaden?

Als ik v1.18 stabiel is kwa rating. Dat is wel bijna het geval denk ik. Ik wil ook nog wat andere zaken proberen, maar ik denk niet dat ik nog een keer tussentijds ga submitten. Sjaakie wilde ook nog een tussentijdse update doen, maar die liep te mopperen (lees niet alle veranderingen waren verbeteringen)

Ik heb gevonden dat ze op de Universiteit Utrecht deze challenge in een vak hebben verwerkt, grappig!
http://www.cs.uu.nl/docs/vakken/b2ki/werkcollege.htm

Vraag me af welk dele van deze lijst dat vak volgt.

[boreus]

Ik zit nu op de TCP server als okiobus.

Nu probeer ik iets waarbij ik de combat moves van de tegenstander probeer te voorspellen door het simpele model op het AI Challenge forum [1] te gebruiken. Weet nog niet zo goed of het werkt.

Zometeen maar even de nieuwste versie op AI challenge zetten om te zien of er geen rare problemen (crash, timeout, compile, etc..) in zitten.

Nou dat was even lastig om het compilend te krijgen
Ik zie ook wel wat matches op Fluxid waar ik toch een beetje beter nog op mijn eigen hill(s) moet letten.. Naja TODO voor later.

[ Voor 100% gewijzigd door boreus op 13-12-2011 16:26 ]

[Corniel]

boreus schreef op dinsdag 13 december 2011 @ 15:07:
Nu probeer ik iets waarbij ik de combat moves van de tegenstander probeer te voorspellen door het simpele model op het AI Challenge forum \[1] te gebruiken. Weet nog niet zo goed of het werkt (..)

Nice..

Hmm, ik kwam er achter dat het volgende op Mono niet werkt (en onder het reguliere .NET wel):

C#:

public static class Distance
{
    public const int Zero = int.MaxValue;
}

public static int[,] UpdateMinDistance(this int[,] map, AntsLoc loc, int maxdistance, MapType[,] types, int startvalue = Distance.Zero)
{
    // ...
}

Nu maar weer zoals het ooit stond met int.MaxValue als default voor startvalue. Anyway, daar gingen drie uploads voor ik het door had.

[boreus]

Wauw de toevoeging van die servers is te merken. Na een nachtje de nieuwe versie er op te hebben heeft hij al 12 keer gespeeld. Nu nog zorgen dat hij die 12 keer gewoon wint.

@Corniel: ik kan geen C#, wat betekent de [,] en de "this" in "this int[,] map"?

[Sjaaky]

[,] geeft een 2 dimensionale array aan.
'this int[,]' is alleen geldig als eerste parameter en geeft aan dat UpdateMinDistance een zogenaamde extensionmethod is. Dat wil zeggen dat je op alle 2 dimensionale arrays UpdateMinDistance aan kunt roepen alsof het een method van een 2 dimensionale array zelf is.

C#:

int [,] map;
map.UpdateMinDistance(loc, max, types);
//ipv
Util.UpdateMinDistance(map, loc, max, type);

Het is voornamelijk handig vanwege de intellisense. Die laat zien welke extensionsmethods er beschikbaar zijn voor bepaalde types. En het is ook alleen (zijn vast wel uitzondering) handig als je de source van dat type niet kunt aanpassen.

[Corniel]

Sjaaky schreef op woensdag 14 december 2011 @ 11:28:
En het is ook alleen (zijn vast wel uitzondering) handig als je de source van dat type niet kunt aanpassen.

Klopt ik ken in ieder geval één nuttige uitzondering. Soms is het nuttig om extension method op een zelf gedefinieerde interface te hebben, omdat los van hoe deze geïmplementeerd wordt de implementatie van die ene methode altijd het zelfde is (en je geen gedeelde base class wilt/kan hebben).

[ Voor 1% gewijzigd door Corniel op 14-12-2011 11:37 . Reden: style ding ]

[boreus]

Bah de resultaten van mijn nieuwste versie vallen tot nu toe tegen. Het berekenen van all-pairs shortest paths gaat ietsje stroever dan ik eerst verwachtte. Qua vechten krijg ik het ook nog even niet precies zoals ik wil.

Mijn Java versie (die ongeveer 30e stond) deed vooral een flinke BFS vanaf iedere mier. Bij het vinden van voedsel, hill of unexplored werd dit op een soort greedy manier aan de mier toegewezen. Qua combat (erg belangrijk imo) heb ik voor die versie de 2v1 scenario's met de hand uitgewerkt. Voor de andere mogelijke scenario's was het bruteforce na een opdeling in groepen van max. ca. 7 mieren. Voor het vinden van paden over grote afstanden was er nog ene opdeling in area's.

Naja de deadline is dichtbij dus het lijkt me leuk om meer te delen over strategieen. Dus vragen, opmerkingen welkom!

[Corniel]

boreus schreef op donderdag 15 december 2011 @ 20:23:
Bah de resultaten van mijn nieuwste versie vallen tot nu toe tegen (..)

Ik ken het gevoel. Ben nu met mn nieuwe combat bezig. Locale tests zijn positief, op Fluxid is het verre van een verbetering. Nog flink tweaken.

[boreus]

Corniel schreef op donderdag 15 december 2011 @ 20:37:
Ik ken het gevoel. Ben nu met mn nieuwe combat bezig. Locale tests zijn positief, op Fluxid is het verre van een verbetering. Nog flink tweaken.

Fluxid is wel gelijk een zware test imo!

[Corniel]

boreus schreef op donderdag 15 december 2011 @ 20:59:

Fluxid is wel gelijk een zware test imo!

Maar ook een goede. Ik heb van verschillende eerdere versies een betrouwbare rating. Dus ik kan zo goed testen of mijn selecte groep testruns idd representatief is, en of het een verbetering betreft.

[boreus]

boreus schreef op dinsdag 06 december 2011 @ 15:57:
https://docs.google.com/o...0LTkyNjItMDczMDk4OGViYWEw

Versie 7 en 8 staan er nu ook bij.

Nu ben ik op Fluxid aan het kijken of versie 14 het uberhaupt beter doet dan versie 8.

[Corniel]

www.corniel.nl/download/Ants/Truusje

Versie 18 en 23 ook toegevoegd.

[boreus]

Alright mijn versie 14 staat er ook op nu.
Heb maar gegokt dat Google Docs moeilijk zou doen over .exe

Ik zal eens kijken of ik nuttige dingen over Truusje kan zeggen binnenkort. Zo na 10 potjes op maze_04p_01 gedaan te hebben lijkt het er op dat food gathering niet zo'n ontzettende prioriteit is. Dan gaat het met name denk ik om plaatsen waar wel explored is, maar niet meer visible. Die plaatsen worden niet zo heel erg in de gaten gehouden. Imo meer voedsel = meer mieren, dus belangrijk.

[Corniel]

boreus schreef op vrijdag 16 december 2011 @ 10:33:

Ik zal eens kijken of ik nuttige dingen over Truusje kan zeggen binnenkort. Zo na 10 potjes op maze_04p_01 gedaan te hebben lijkt het er op dat food gathering niet zo'n ontzettende prioriteit is (..)

Ik herken wat je zegt. Ik doe niets aan het in de picture houden van de kaart. Bij de meeste mappen wordt je vrij vroeg terug gedwongen/-drongen door je tegenstanders en verspreiden mijn mieren zich automatisch prima, en loop je zo geen voedsel mis. Als er geen tegenstanders zijn, ren ik hard weg. Soms te hard, en dat kost soms voedsel, en soms je hill. Maar op het leeuwendeel van de kaarten gaat dit vrij goed. (gelukkig)

[dotcode]

Ik heb ook maar eens een bot gemaakt (peerai). Hij doet alleen nog voedsel zoeken, en andere holes bestormen. Het meest last heb ik van timeouts. Overal checks in gebouwd, maar het lijkt niet veel te helpen. Hij is in C# gemaakt, zou de GC voor de timeouts kunnen zorgen?

[Corniel]

dotcode schreef op vrijdag 16 december 2011 @ 11:31:
Het meest last heb ik van timeouts (..)

Hij is in C# gemaakt, zou de GC voor de timeouts kunnen zorgen?

Dat kan, maar lijkt me niet heel waarschijnlijk (understatement). Main tip zou toch zijn om tijdlogging toe te voegen op verschillende plekken, zodat je per turn een overzicht krijgt van waar de tijd inzit.

[boreus]

Hmm op Fluxid doet v14 het wel veel beter dan v8, maar op aichallenge.org duurt met maar lang totdat er een mooie ranking uit komt.

Corniel schreef op vrijdag 16 december 2011 @ 11:47:
[...]

Dat kan, maar lijkt me niet heel waarschijnlijk (understatement). Main tip zou toch zijn om tijdlogging toe te voegen op verschillende plekken, zodat je per turn een overzicht krijgt van waar de tijd inzit.

Dotcode: wanneer krijg je je timeouts (veel mieren?)? Test je thuis ook met een turntime van 500?

Ik output zelf iedere beurt iets:
st:0 up:15 dh:0 ba:16 sn:0 ef:0 ff:0 ex:0 mc:15 mm:16 ah:0 mr:0 sf:0 up2:0 at end of turn 162: 0/63 unmoved ants, 438 time left
st:15 up:16 dh:0 ba:0 sn:0 ef:0 ff:0 ex:0 mc:16 mm:15 ah:0 mr:0 sf:16 up2:0 at end of turn 163: 0/63 unmoved ants, 422 time left
st:16 up:15 dh:0 ba:0 sn:0 ef:0 ff:0 ex:16 mc:0 mm:16 ah:0 mr:0 sf:0 up2:0 at end of turn 164: 0/61 unmoved ants, 437 time left
st:16 up:46 dh:0 ba:0 sn:0 ef:0 ff:0 ex:0 mc:16 mm:16 ah:0 mr:0 sf:15 up2:0 at end of turn 165: 0/62 unmoved ants, 391 time left
st:16 up:94 dh:0 ba:0 sn:0 ef:0 ff:0 ex:0 mc:15 mm:16 ah:0 mr:0 sf:0 up2:109 at end of turn 166: 0/62 unmoved ants, 250 time left
st:0 up:93 dh:0 ba:0 sn:0 ef:0 ff:0 ex:0 mc:16 mm:0 ah:0 mr:16 sf:0 up2:327 at end of turn 167: 0/62 unmoved ants, 48 time left

[ Voor 71% gewijzigd door boreus op 16-12-2011 13:10 ]

[Corniel]

boreus schreef op vrijdag 16 december 2011 @ 13:05:
Hmm op Fluxid doet v14 het wel veel beter dan v8, maar op aichallenge.org duurt met maar lang totdat er een mooie ranking uit komt.

Dotcode: wanneer krijg je je timeouts (veel mieren?)? Test je thuis ook met een turntime van 500?

@Dotcode: Nog een tip, probeer het thuis ook eens 100 ms. Hoewel je dan wellicht geen goed resultaat meer krijgt is het wel fijn als alles netjes wordt afgehandeld. Ook ik heb zo m'n time management gefixt.

@Boreus: ik ken het gevoel. Btw, je v8 heb ik gespot, wat is je v14? Die heeft een andere naam toch?

[boreus]

Corniel schreef op vrijdag 16 december 2011 @ 13:38:
[...]
@Boreus: ik ken het gevoel. Btw, je v8 heb ik gespot, wat is je v14? Die heeft een andere naam toch?

http://ants.fluxid.pl/player/gogogo

Qua time-outs laat ik ook altijd een marge van 50ms over bij iedere beurt.

[ Voor 13% gewijzigd door boreus op 16-12-2011 14:20 ]

[Corniel]

WOW! ik sta nu 86e, 3e van Nederland. Dit met een bot na 17 potjes, dus logischerwijze zit er nog wat rek in. Natuurlijk zijn er nog een aantal mensen die mooie dingen op de plan hebben liggen, en een aantal die me nog voor bij gaan klimmen met hun inzending (boreus o.a.) maar voor dit moment... Roze wolk.

[Vaan Banaan]

Even voor de zekerheid: Ik heb nog tot maandagochtend 6 uur?
Eindelijk ben ik dan echt begonnen. Ik maak van elke mapsquare een A* gridje van 21x21. Ik probeer nog iets met waypoints fabrieken, maar hoe weet ik niet helemaal.
Verder wil ik een enemymap maken, wat bij het spel begint als een map 1-en. Dat is het enige veld wat enigszins een state heeft.
Bij elke beurt, worden de eigen mier als 0-en op de enenymap gezet (met viewradius2), het water als een 2.
De vijanden die ik zie, maak ik een 1. Zo heb ik dus een deel van de kaart, waarvan ik niet weet of er vijanden zijn en wat losse 1-en waar vijanden lopen.
Na elke beurt zet ik alle 1-en een pas in elke richting, zodat die uitbreidt. En dit herhaalt zo elke beurt.
Ik hoop dat ik hier iets aan heb bij de mazes of eigenlijk bij alle maps, om mieren op een strategische plek te zetten. Een doodlopend stuk waar ik ooit eens doorheen gebanjerd ben, en 0 is op de enemymap, blijft dan 'veilig', ook al ziet geen enkele mier dat stuk nog. En op een losse 1 kan ik dan wat mieren loslaten.
Op die manier wil ik voorkomen, dat mieren massaal in een hoekje tegen het water staan te bonken. Nu nog iets met eigen hill verdedigen en er was ook nog iets met vechten.
Maar goed ik heb nog 2 dagen, dus dat gaat helemaal goed komen.

[Corniel]

Vaan Banaan schreef op vrijdag 16 december 2011 @ 23:49:
Even voor de zekerheid: Ik heb nog tot maandagochtend 6 uur?

Dat heb je goed begrepen.

Eindelijk ben ik dan echt begonnen (..)

Maar goed ik heb nog 2 dagen, dus dat gaat helemaal goed komen.

Uiteraard! Ambitie is nooit verkeerd.

[dotcode]

Ik heb nu een beetje doorgetest voor de timings, maar na veel turns (400-800) krijg ik opeens een gat in de timing van +- 300ms, als het gebeurt in 1 van de eerste stappen die ik uitvoer is dat geen probeem, dan worden de andere geskipt. Maar als het aan het eind gebeurt ben ik de pineut. Het is steeds op een andere plaats . Ik denk toch dat het iets met memory te maken heeft... Dus daar ga ik eens naar kijken. Daarna even op attack focussen zodat ik geen miertjes verlies die toch niet konden winnen. En het hele veld zichtbaar maken.

BTW wat is er maandag morgen 6 uur?

[ Voor 3% gewijzigd door dotcode op 17-12-2011 11:34 ]

[sPENKMAN]

dotcode schreef op zaterdag 17 december 2011 @ 11:31:
BTW wat is er maandag morgen 6 uur?

Tot dan kan je aan je bot werken als ik me niet vergis en beginnen de finals

[boreus]

dotcode schreef op zaterdag 17 december 2011 @ 11:31:
Ik heb nu een beetje doorgetest voor de timings, maar na veel turns (400-800) krijg ik opeens een gat in de timing van +- 300ms, als het gebeurt in 1 van de eerste stappen die ik uitvoer is dat geen probeem, dan worden de andere geskipt. Maar als het aan het eind gebeurt ben ik de pineut. Het is steeds op een andere plaats . Ik denk toch dat het iets met memory te maken heeft... Dus daar ga ik eens naar kijken. Daarna even op attack focussen zodat ik geen miertjes verlies die toch niet konden winnen. En het hele veld zichtbaar maken.

BTW wat is er maandag morgen 6 uur?

In mijn code staat in bijna iedere for- of while-loop aan de bovenkant een if-no-time-left-then-return. Volgens de profiler kost me dat in de richting van 10% van de totale CPU tijd. Er is een berekening die ik die ivm de all-pairs shortest paths die gewoon over meerdere turns verspreid kan worden. Alles is beter dan een time-out krijgen in een game imo.

Gefeliciteerd Corniel met je top 100! Ik ben ook blij zelf weer in de top 100 te staan. Er moeten dit weekend nog wel een paar dingetjes gebeuren om het geheel echt een beetje te laten presteren.

[Corniel]

boreus schreef op zaterdag 17 december 2011 @ 13:25:
[...]

In mijn code staat in bijna iedere for- of while-loop aan de bovenkant een if-no-time-left-then-return

Bij mij ook. Heb nog overwogen om een tijdschatting te maken op basis van vorige ronden, maar het risico dat je dat niet goed schat is groot, en verder kost het ontwikkelen van zo'n mechanisme enorm veel tijd. En die tijd heb ik niet.

Er is een berekening die ik die ivm de all-pairs shortest paths die gewoon over meerdere turns verspreid kan worden (..)

Hier ook. Voor het berekenen van kortste paden naar vijandelijke heuvels word elke beurt een deelgebied rond elke mier geupdate. Dit geeft geen perfect kortste pad (omwegen kunnen even blijven bestaan), maar is wel heel tijd effectief. Al was het maar omdat sommige omwegen zorgen dat je van meerdere kanten bij een hill uitkomt.

Ook heb ik bij een aantal strategieën optionele post move berekeningen: Ik bereken 'snel' paden naar voedsel dat op maximaal 16 tiles away ligt. Als ik tijd overheb, kan dit oplopen tot 64 tiles.

Gefeliciteerd Corniel met je top 100! Ik ben ook blij zelf weer in de top 100 te staan (..)

Tanx. Gelukkig heb ik nog iets achter de hand. Ik heb m'n combat mechanisme opnieuw geschreven, en op Fluxid is het verschil meer dan 2,0 punt. Dus hopelijk is dat mijn ticket tot de top 100 tijdens de finale.

[ Voor 0% gewijzigd door Corniel op 17-12-2011 15:33 . Reden: lay-out foutje... ]

[dotcode]

Ik heb hem nu zo verbeterd dat hij de vorige versie in 200 opruimt en de hele kaart ziet. En alle debug statements er uitgehaald, tot nu toe nog een timeout gezien. Straks nog effe vechten goed inbouwen en daarna nog een betere hole defence. De huidige versie moet wel in de top 1000 kunnen komen.

Met mijn huidige code kan ik ook nog eens schrijven op het scherm .

Eigenlijk is het niet echt ai, maar gewoon algorithmen. Mijn ants weten niets van wat er om hen heen gebeurt, het eigenlijke zetten duur maar 10 tot 100 ms.

[ Voor 27% gewijzigd door dotcode op 17-12-2011 14:36 ]

[Corniel]

In principe m'n finale versie geupload (versie leek stabiel op fluxid). Zijn er nog nog mensen hard bezig met een ultieme laatste versie?

[dotcode]

Ik heb net wat probleempjes gefixed met als ik boven een aantal ants had ze zich terug trokken naar de hill. En een geheugen voor food dat niet meer zichtbaar is gemaakt. Daarnaast nog alleen vechten met overmacht gemaakt. Maar nog geen rennen voor je leven .

Net nog een timeout dus nog effe zoeken waar dat kan zitten. Daarna uploaden .

[Sjaaky]

Ik ben ook nog druk bezig. Helaas is fluxid zo te zien een beetje overbelast. Heel veel (bijna alle) bots hebben timeouts. Niet echt betrouwbaar dus om een verbeteringen op te baseren.

[boreus]

Ja ik ben nog wel bezig. Ik probeer de combat van v14 in v8 te stoppen. Hoewel ik niet zeker weet of hij echt beter presteert, vind ik hem er wel ietsje beter uit zien.

Het gaat wel spannend worden om in te schatten welke van alle verschillende versies het beste zal presteren in de uiteindelijke competitie. Ik heb het idee dat er veel multi-hill maps recent zijn toegevoegd aan de rotatie. Daar heb ik helaas nooit zo heel erg voor geoptimaliseerd.

[Vaan Banaan]

Ik heb zojuist de handdoek in de ring gegooid. Morgen weer werken en het wordt nu toch niks meer.
Alle deelnemers veel succes!