Contest #2: Space Invaders

volkard

Gewonnen. Wo ist der nächste Wettbewerb?

class PicardWarpTunnelFighter : public SpaceShip
{
public:
	PicardWarpTunnelFighter(size_t x, size_t y)
		: SpaceShip(x, y)
	{ }

	void computeNextMove(SpaceField &field) {
        /*
        struct MyAstroids{
            vector<Point> astroidsPosition;
            size_t difficulty;
        };
        struct MySpaceField{
            char spaceField[20][20];
            SpaceShip *spaceShip;
            MyAstroids astroids;
            Point lastShipPosition;
        };
        reinterpret_cast<MySpaceField&>(field).astroids.astroidsPosition.clear();
        */

	    while(field.isAstroidHere(getPosition()))
            field.moveAstroidsForward();
	}
};

edit: Mist, die Enterprise war schneller.

Es ist eine Weile her, dass ich einen Space-Invaders-Automaten gesehen habe, aber ich kann mich nicht daran erinnern, dass es darin Asteroiden gegeben hätte.

Man konnte allerdings durch den eigenen Schild nach oben schießen, wie mir Futurama beigebracht hat.

Natürlich zaehlen campers und volkards Schiffe nicht, da sie gezielt meine Implementierung ausnutzen. Vielleicht sollte ich somit dazu erwaehnen, dass man selbst nur moveR/L/U/D benutzen und sich die ganzen Informationen über field und somit die Positionen der Astroiden beschaffen darf.

Shade Of Mine

KasF schrieb:

Natürlich zaehlen campers und volkards Schiffe nicht, da sie gezielt meine Implementierung ausnutzen. Vielleicht sollte ich somit dazu erwaehnen, dass man selbst nur moveR/L/U/D benutzen und sich die ganzen Informationen über field und somit die Positionen der Astroiden beschaffen darf.

Oder vielleicht sollte der Code nicht so leicht abusebar sein.

bmario

Hinweis am Rande, ein Lichtjahr (light year) ist keine Zeiteinheit

*Edit: Wenn man der computeNextMove() das SpaceField als const -Referenz übergibt, ist immerhin Volkard's Hack dahin. Dann sollte aber besser SpaceField::isAstroidHere() auch const sein.

volkard

KasF schrieb:

Natürlich zaehlen campers und volkards Schiffe nicht, da sie gezielt meine Implementierung ausnutzen.

Natürlich...
Warptunneln ist doch was ganz normales.

Shade Of Mine schrieb:

Oder vielleicht sollte der Code nicht so leicht abusebar sein.

Solange ich das hier nicht an einen Kunden verkaufen, kann es mir herzlichst egal sein!

bmario schrieb:

Hinweis am Rande, ein Lichtjahr (light year) ist keine Zeiteinheit

Es dient auch hier der Entfernung, die das Raumschiff im Astroidenfeld schon zurückgelegt hat

bmario schrieb:

*Edit: Wenn man der computeNextMove() das SpaceField als const -Referenz übergibt, ist immerhin Volkard's Hack dahin. Dann sollte aber besser SpaceField::isAstroidHere() auch const sein.

Ja das stimmt. Aber waehrend des Programmierens kam irgendwann der Punkt, wo ich mir selbst gesagt habe: "Ach, ist doch egal. Es geht hier nur um den Spaß und ich bin gerade zu Faul, um es sauber zu machen" ...

Entweder du machst es sauber, oder du musst Lösungen zulassen, die die Implementierung ausnutzen

Das ist das einzig Kluge, sonst ist schwammig, was man darf und was nicht. Und statt dafür Regeln wie "man darf nur diese Methoden aufrufen" zu formulieren, kann man den Code gleich entsprechend gestalten. Worauf ich hingegen keine Rücksicht nehmen würde, sind tatsächliche Hacks mit U.B., const_cast, #define private public etc.

volkard

edit: Nagut, dann schreibe ich nicht, wie ich es machen würde. Kann ja nicht wissen, daß man das offensichtliche nicht sagen darf. Wobei ich eher denke, daß KasF kaum darüber nachgedacht hat, wie eine gute Lösung aussehen würde.

Rhombicosidodecahedron

class ReallyOutsideTheBox: public SpaceShip
{
public:
	ReallyOutsideTheBox(size_t x, size_t y)
		: SpaceShip(20 + 1, 20 + 1) // könnte sich noch ein wenig ändern.
	{
	}

	void computeNextMove(SpaceField &field)
	{
		static long i = 0;
		i++;
		if(i == MAX_LONG - 3 ) // -3 Sicherheitsabstand und mir reicht der fünfte Platz :)
			destroy();  //ungetestet aber ungefähr so sollte es sein :)
	}
};

Mal eine "Böse" Frage:
Wenn ich anstatt x und y konstante Werte > 19 nehme, dann wird ja irgendwo Speicher ein Byte mit einem 'S' überschrieben (typischer Buffer Overflow), aber gibt es nach der Klasse SpaceField einen definierten Bereich, der "problemlos" überschrieben / gelesen werden kann (d.h. nicht abstützt, aber Spieler außerhalb des Spielfeldes)? Sozusagen der "Subraum", um bei StarTrek zu bleiben.

Kleines Codeupdate für die Heulsusen unter uns.

Ich find das auch schade, dass ihr da so pedantisch wart. Statt da zu kritisieren oder euch lustig drüber zu machen, könntet ihr den Quelltext ja auch 100% perfekt refaktorisieren und als Beispiel für perfektes C++ den kommenden Jahrhunderten und Jahrtausenden übergeben als Mahnmal des menschlichen Intellekts!

volkard schrieb:

...

Du bist doch echt der tollste beschde und coolste Typ in diesem Forum und weißt auch echt alles besser als wir alle zusammen. Statt den Leuten lieber ihren Spaß zu lassen, musst du es ihnen kaputt machen, da du bei dieser für dich primitiven Aufgabe ja selbst kein Spaß hast und somit den anderen auch nicht das Vergnügen gönnen willst. Ich disqualifiziere dich jetzt schonmal. Ist immerhin mein Spiel und ich suche mir eben nun mal meine Mitspieler selbst aus ...

@Decimad: Leider ist dieses Verhalten ein Problem in diesem Forum und genau dieses Verhalten ist auch das Abbild des Informatikers in unserer Gesellschaft. Schade, wo ich doch auch auch ganz nette, normale und soziale Informatiker kenne ...

Aber genug Off-Topic

volkard

Taktik: Auf der Grundlinie bleiben. Asteroiden verglühen dann automatisch vor dem Aufprall.

void computeNextMove(const SpaceField &field)
            {
                if(getPosition().y<field.getSizeY())
                    moveDown();
            }

Überlebt beliebig lange.
Vermutlich Programmierfehler.

volkard

Taktik: Loch suchen und reinfahren.

class TomParisShuttle : public SpaceShip
{
    public:
            Point findSpace(const SpaceField &field)
            {
                for(size_t y=field.getSizeY()-1;y>=1;--y)
                    for(size_t x=0;x<field.getSizeX();++x)
                        if(!field.isAstroidHere(Point(x,y)))
                           return Point(x,y);
                return Point(3,3);
            }
            void computeNextMove(const SpaceField &field)
            {
                Point space=findSpace(field);
                while(getPosition().y<space.y)
                    moveDown();
                while(getPosition().y>space.y)
                    moveUp();
                while(getPosition().x>space.x)
                    moveLeft();
                while(getPosition().x<space.x)
                    moveRight();
            }
};

Überlebt extrem lange.
Vermutlich Regelfehler.

volkard schrieb:

Vermutlich Programmierfehler.

Behoben. Danke.

volkard schrieb:

Vermutlich Regelfehler.

Behoben. Danke.

Du bist echt unglaublich. Wieso kannst du mich nicht ganz normal - wie ein Erwachsener - schon in deinem ersten Post auf meine ganzen Fehler aufmerksam machen und zur Qualitaet dieses Threads beitragen. Wieso nicht!? Ehrlich, sags mir. Wieso musst du dich dermaßen arrogant profilieren? ... Ich weiß echt nicht, wie oft ich dich schon bzgl dieses kindische Verhalten hier im Forum angesprochen habe. Traurig

camper

volkard schrieb:

Taktik: Loch suchen und reinfahren.

Das war auch die erste Lösung, die mir eingefallen ist. Eine Variante, die auch mit kaltem Kaffee funktioniert war mir dann aber lieber

volkard

KasF schrieb:

...

Der Unterschied ist nur, ob ich es gleich sage, oder ob ich warte, bis Du soweit bist, es aufzunehmen. Das sehe ich auch oft, gerade hier im Forum, daß eine Aussage auf der ersten Seite partout nicht zur Kenntnis genommen wird, aber dieselbe Aussage auf Seite 7 wird vom Threadersteller (nachdem er sich ein paar Seiten lang mit dem Problem beschäftigt hat) als "die Lösung" gefeiert.

Warum macht ihr nicht mal einen Contest bei dem man etwas mit mehr Taktik machen kann? Z.B. ein Feld auf dem Energie und Punkte Items leigen. Man kann dann einen Roboter über das Feld steuern und jede Bewegung kostet Energie, das Schauen, was z.B. in einer Reihe vor einem liegt kostet auch Energie. Außerdem könnte man auch zwei Roboter gegeneinander antreten lassen und die Roboter können Bomben legen und zünden. Wer in einem Zeitraum am meisten Punkte einsammelt oder den anderen zerstört, gewinnt. Die Rechenzeit für einen Roboter sollte auch begrenzt sein, wenn sie gegeneinander spielen.