From 4f032479507641dacc772624c4a6b56a664fb249 Mon Sep 17 00:00:00 2001 From: Daniel Axtens Date: Fri, 10 Sep 2010 14:48:48 +0800 Subject: [PATCH] applied TPG's patch, fixed wash --- src/link/C/agents/c_angel.c | 86 ++++++----- src/link/C/agents/c_lucifer.c | 138 ++++++++--------- src/link/C/agents/c_streetfighter.c | 134 +++++++++-------- src/link/C/agents/c_wash.c | 177 ++++++++++++++++++++++ src/link/C/c_link.c | 217 ++++++++++++++------------- src/link/C/c_link.h | 224 +++++++++++++++------------- 6 files changed, 590 insertions(+), 386 deletions(-) mode change 100644 => 100755 src/link/C/agents/c_angel.c mode change 100644 => 100755 src/link/C/agents/c_lucifer.c mode change 100644 => 100755 src/link/C/agents/c_streetfighter.c create mode 100644 src/link/C/agents/c_wash.c mode change 100644 => 100755 src/link/C/c_link.c mode change 100644 => 100755 src/link/C/c_link.h diff --git a/src/link/C/agents/c_angel.c b/src/link/C/agents/c_angel.c old mode 100644 new mode 100755 index 62e2147..d11b551 --- a/src/link/C/agents/c_angel.c +++ b/src/link/C/agents/c_angel.c @@ -1,41 +1,45 @@ -/* - * c_angel.c - * c-link-lib - * - * Created by Daniel Axtens on 20/04/10. - * Licensed under an MIT-style license: see the LICENSE file for details. - * - */ - -#include - -/* Implement the angel bot, which always tells the truth - and expects others to do the same */ - -ATTACKTYPE Attack( char * foe_name ) { - ATTACKTYPE attack; - - attack.realAttack = RandomAttack(); /* Chooses randomly from Rock, Paper, Scissors */ - attack.promisedAttack = attack.realAttack; /* Tells the truth for its bluff */ - - return attack; -} - -ITEMTYPE Defend( char * foeName, ITEMTYPE foePromisedAttack ) { - return foePromisedAttack; /* Trusts them to be going for a tie */ -} - -/* You need to define a results function, even if it isn't used - (otherwise the linker will complain) */ -void Results( char * foeName, int isInstigatedByYou, RESULTTYPE winner, - ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, - int pointDelta ) { - - return; /* Ignore whatever just happened. */ -} - -/* same for Cleanup() */ - -void Cleanup() { - return; -} \ No newline at end of file +/* + * c_angel.c + * c-link-lib + * + * Created by Daniel Axtens on 20/04/10. + * Licensed under an MIT-style license: see the LICENSE file for details. + * + */ + +#include + +void * Initialise( char * me ) { + return NULL; +} + +/* Implement the angel bot, which always tells the truth + and expects others to do the same */ + +ATTACKTYPE Attack( void * this, char * foe_name ) { + ATTACKTYPE attack; + + attack.realAttack = RandomAttack(); /* Chooses randomly from Rock, Paper, Scissors */ + attack.promisedAttack = attack.realAttack; /* Tells the truth for its bluff */ + + return attack; +} + +ITEMTYPE Defend( void * this, char * foeName, ITEMTYPE foePromisedAttack ) { + return foePromisedAttack; /* Trusts them to be going for a tie */ +} + +/* You need to define a results function, even if it isn't used + (otherwise the linker will complain) */ +void Results( void * this, char * foeName, int isInstigatedByYou, RESULTTYPE winner, + ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, + int pointDelta ) { + + return; /* Ignore whatever just happened. */ +} + +/* same for Cleanup() */ + +void Cleanup( void * this ) { + return; +} diff --git a/src/link/C/agents/c_lucifer.c b/src/link/C/agents/c_lucifer.c old mode 100644 new mode 100755 index f497366..8325840 --- a/src/link/C/agents/c_lucifer.c +++ b/src/link/C/agents/c_lucifer.c @@ -1,67 +1,71 @@ -/* - * c_lucifer.c - * c-link-lib - * - * Created by Daniel Axtens on 20/04/10. - * Licensed under an MIT-style license: see the LICENSE file for details. - * - */ - - -#include - -/* Implement the lucifer bot, which always lies expecting people to be good - and always goes for the kill */ - -ATTACKTYPE Attack( char * foe_name ) { - ATTACKTYPE attack; - - attack.realAttack = RandomAttack(); - - /* Here we choose the thing that will hurt them if they go for a tie */ - switch (attack.realAttack) { - case rock: - attack.promisedAttack = scissors; - break; - case paper: - attack.promisedAttack = rock; - break; - default: /* attack = scissors */ - attack.promisedAttack = paper; - break; - } - - return attack; -} - -/* Here we trust that they are telling the truth. And we try to kill them. */ -ITEMTYPE Defend( char * foeName, ITEMTYPE foePromisedAttack ) { - ITEMTYPE defence; - switch (foePromisedAttack) { - case rock: - defence = paper; - break; - case paper: - defence = scissors; - break; - default: - defence = rock; - break; - } - return defence; -} - -/* You need to define a results function, even if it isn't used - (otherwise the linker will complain) */ -void Results( char * foeName, int isInstigatedByYou, RESULTTYPE winner, - ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, - int pointDelta ) { - - return; /* Ignore whatever just happened. */ -} - -/* same for Cleanup() */ - -void Cleanup() { - return; -} \ No newline at end of file +/* + * c_lucifer.c + * c-link-lib + * + * Created by Daniel Axtens on 20/04/10. + * Licensed under an MIT-style license: see the LICENSE file for details. + * + */ + + +#include + +/* Implement the lucifer bot, which always lies expecting people to be good + and always goes for the kill */ + +void * Initialise( char * myName ) { + return NULL; +} + +ATTACKTYPE Attack( void * this, char * foe_name ) { + ATTACKTYPE attack; + + attack.realAttack = RandomAttack(); + + /* Here we choose the thing that will hurt them if they go for a tie */ + switch (attack.realAttack) { + case rock: + attack.promisedAttack = scissors; + break; + case paper: + attack.promisedAttack = rock; + break; + default: /* attack = scissors */ + attack.promisedAttack = paper; + break; + } + + return attack; +} + +/* Here we trust that they are telling the truth. And we try to kill them. */ +ITEMTYPE Defend( void * this, char * foeName, ITEMTYPE foePromisedAttack ) { + ITEMTYPE defence; + switch (foePromisedAttack) { + case rock: + defence = paper; + break; + case paper: + defence = scissors; + break; + default: + defence = rock; + break; + } + return defence; +} + +/* You need to define a results function, even if it isn't used + (otherwise the linker will complain) */ +void Results( void * this, char * foeName, int isInstigatedByYou, RESULTTYPE winner, + ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, + int pointDelta ) { + + return; /* Ignore whatever just happened. */ +} + +/* same for Cleanup() */ + +void Cleanup( void * this ) { + return; +} diff --git a/src/link/C/agents/c_streetfighter.c b/src/link/C/agents/c_streetfighter.c old mode 100644 new mode 100755 index 39a8cda..3ddf697 --- a/src/link/C/agents/c_streetfighter.c +++ b/src/link/C/agents/c_streetfighter.c @@ -1,65 +1,69 @@ -/* - * c_streetfighter.c - * c-link-lib - * - * Created by Daniel Axtens on 20/04/10. - * Licensed under an MIT-style license: see the LICENSE file for details. - * - */ - - -#include - -/* Implement the streetfighter bot, which thinks everyone has it in for him. */ - -ATTACKTYPE Attack( char * foe_name ) { - ATTACKTYPE attack; - - attack.realAttack = RandomAttack(); - - /* Here we choose the thing that will hurt them if they go for the kill */ - switch (attack.realAttack) { - case rock: - attack.promisedAttack = paper; - break; - case paper: - attack.promisedAttack = scissors; - break; - default: /* attack = scissors */ - attack.promisedAttack = rock; - break; - } - return attack; -} - -/* Here we assume they are lying, trying to kill us. And we try to kill them. */ -ITEMTYPE Defend( char * foeName, ITEMTYPE foePromisedAttack ) { - ITEMTYPE defence; - switch (foePromisedAttack) { - case rock: - defence = scissors; - break; - case paper: - defence = rock; - break; - default: - defence = paper; - break; - } - return defence; -} - -/* You need to define a results function, even if it isn't used - (otherwise the linker will complain) */ -void Results( char * foeName, int isInstigatedByYou, RESULTTYPE winner, - ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, - int pointDelta ) { - - return; /* Ignore whatever just happened. */ -} - -/* same for Cleanup() */ - -void Cleanup() { - return; -} +/* + * c_streetfighter.c + * c-link-lib + * + * Created by Daniel Axtens on 20/04/10. + * Licensed under an MIT-style license: see the LICENSE file for details. + * + */ + + +#include + +/* Implement the streetfighter bot, which thinks everyone has it in for him. */ + +void * Initialise( char * myName ) { + return NULL; +} + +ATTACKTYPE Attack( void * this, char * foe_name ) { + ATTACKTYPE attack; + + attack.realAttack = RandomAttack(); + + /* Here we choose the thing that will hurt them if they go for the kill */ + switch (attack.realAttack) { + case rock: + attack.promisedAttack = paper; + break; + case paper: + attack.promisedAttack = scissors; + break; + default: /* attack = scissors */ + attack.promisedAttack = rock; + break; + } + return attack; +} + +/* Here we assume they are lying, trying to kill us. And we try to kill them. */ +ITEMTYPE Defend( void * this, char * foeName, ITEMTYPE foePromisedAttack ) { + ITEMTYPE defence; + switch (foePromisedAttack) { + case rock: + defence = scissors; + break; + case paper: + defence = rock; + break; + default: + defence = paper; + break; + } + return defence; +} + +/* You need to define a results function, even if it isn't used + (otherwise the linker will complain) */ +void Results( void * this, char * foeName, int isInstigatedByYou, RESULTTYPE winner, + ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, + int pointDelta ) { + + return; /* Ignore whatever just happened. */ +} + +/* same for Cleanup() */ + +void Cleanup( void * this ) { + return; +} diff --git a/src/link/C/agents/c_wash.c b/src/link/C/agents/c_wash.c new file mode 100644 index 0000000..9ca4a41 --- /dev/null +++ b/src/link/C/agents/c_wash.c @@ -0,0 +1,177 @@ +/* + * c_frechie.c + * c-link-lib + * + * Created by Daniel Axtens on 22/04/10. + * Licensed under an MIT-style license: see the LICENSE file for details. + * + */ + +#include +#include +#include + +/* Implement the wash agent, that is by default nice but will + permanently turn against any agent that betrays it. + This is trickier in C than in any other language, for a number of reasons: + - there's no classes in C, so we can't just write a generic learning agent + and subclass it. + - your agent has no idea how many agents it's going to battle, or how many + battles it is going to fight, so you've got to do dynamic memory allocation. + (anyone who tries to read the source of the supervisor to find out is liable + to have their program break unexpectedly) + */ + +/* To simplify things, we just look at whether we have lost to a particular agent. + Unlike in the Python version, we don't keep a generic list + This is also done in a inefficient (O(bot-cout)) way. + Implementing a faster version is left as an exercise to the DSA student. */ + +/* Our guess at the number of agents I'm going to fight in my lifetime + (note that this is only a guess, not an upper limit. Do *not* take it as + gospel on the number of agents you're going to see. */ +#define NUMBEROFAGENTSGUESS 100 + +/* data for each instance of my agent */ +typedef struct { + /* The name of the n-th foe who has beaten us */ + char (*defeatingFoes)[MAXFOENAMELEN]; + + /* The length of the array, and how far we are along it */ + size_t foesLen; + unsigned int foesCount; +} wash_data; + + +/* an internal function - have I lost to a given foe? */ +int haveLostTo( wash_data * me, char * foeName ) { + + int foe; + + /* check every foe we know to have defeated us */ + for (foe=0; foefoesCount; foe++) { + if (strncmp( me->defeatingFoes[foe], foeName, MAXFOENAMELEN) == 0) { + //debugmsg( "%d\thaveLostTo( %s ) -> Yes\n", me, foeName ); + return 1; + } + } + + /* this foe not found */ + return 0; +} + +/* set up myself */ +void * Initialise( char * myName ) { + wash_data * me = malloc( sizeof( wash_data ) ); + + me->defeatingFoes = calloc( NUMBEROFAGENTSGUESS, sizeof( MAXFOENAMELEN*sizeof(char) ) ); + me->foesLen = NUMBEROFAGENTSGUESS; + me->foesCount = 0; + + return (void *) me; +} + +/* Attack */ +ATTACKTYPE Attack( void * this, char * foeName ) { + wash_data * me = (wash_data *)this; + + ATTACKTYPE attack; + + attack.realAttack = RandomAttack(); + + /* have I lost to this foe? */ + if ( haveLostTo(me, foeName) ) { + /* Assume they are lying */ + switch (attack.realAttack) { + case rock: + attack.promisedAttack = scissors; + break; + case paper: + attack.promisedAttack = rock; + break; + default: /* attack = scissors */ + attack.promisedAttack = paper; + break; + } + } else { + /* be nice! */ + attack.promisedAttack = attack.realAttack; + } + + + return attack; +} + +/* defend */ +ITEMTYPE Defend( void * this, char * foeName, ITEMTYPE foePromisedAttack ) { + wash_data * me = (wash_data *)this; + + ITEMTYPE defence; + + if (haveLostTo(me, foeName)) { + /* They've screwed us in the past, assume they're lying and go for the + kill. */ + switch (foePromisedAttack) { + case rock: + defence = scissors; + break; + case paper: + defence = rock; + break; + default: + defence = paper; + break; + } + } else { + /* be nice! */ + defence = foePromisedAttack; + } + + return defence; +} + +/* This is so much less fun in C */ +void Results( void * this, char * foeName, int isInstigatedByYou, + RESULTTYPE winner, ITEMTYPE attItem, ITEMTYPE defItem, + ITEMTYPE bluffItem, int pointDelta ) { + + wash_data * me = (wash_data *)this; + + int foe; + + /* figure out if we lost, which is the only thing we care about + if we didn't, move on. */ + if ((winner == tie) || + (winner==attacker && isInstigatedByYou) || + (winner==defender && !isInstigatedByYou) ) return; + + //fprintf( stderr, "%d\tsaving loss from %s\n", me, foeName ); + + /* if we've already lost the foe, don't store again */ + for (foe=0; foefoesCount; foe++) { + if (strncmp( me->defeatingFoes[foe], foeName, MAXFOENAMELEN ) == 0) { + /* we've found it! */ + return; + } + } + + /* we haven't found the foe. add it, expanding the array if needed */ + if (me->foesCount==me->foesLen) { + /* double the array size. This should error check, but doesn't */ + me->defeatingFoes = realloc( me->defeatingFoes, + me->foesLen*2*sizeof( MAXFOENAMELEN*sizeof(char) ) ); + me->foesLen *= 2; + } + + strncpy( me->defeatingFoes[me->foesCount], foeName, MAXFOENAMELEN ); + me->foesCount++; + + return; +} + +/* Cleanup */ +void Cleanup( void * this ) { + wash_data * me = (wash_data *) this; + free(me->defeatingFoes); + free(me); +} \ No newline at end of file diff --git a/src/link/C/c_link.c b/src/link/C/c_link.c old mode 100644 new mode 100755 index fdb1ffc..39dda6b --- a/src/link/C/c_link.c +++ b/src/link/C/c_link.c @@ -1,107 +1,110 @@ -/* - * c_link.c - * c-link-lib - * - * Created by Daniel Axtens on 19/04/10. - * Licensed under an MIT-style license: see the LICENSE file for details. - * - */ - -#include "c_link.h" -#include -#include -#include -#include - -/* You don't need to read this file. - All you have to do is implement the bot functions defined in - This file sets up the I/O for you, as well as some utility functions and tables. - */ - -char ITEMNAMES[3][MAXITEMLEN] = {"Rock", "Paper", "Scissors"}; - -/* rock-rock rock-paper rock-scissors - paper-rock paper-paper paper-scissors - scissors-rock scissors-paper scissors-scissors */ - -RESULTTYPE RESULTOF[3][3] = { { tie, defender, attacker }, - { attacker, tie, defender }, - { defender, attacker, tie } }; - - -ITEMTYPE RandomAttack() { - return (ITEMTYPE)rand()%3; -} - -ITEMTYPE stringToItem( char * str ) { - if (strcasecmp( str, "Rock" ) == 0) return rock; - if (strcasecmp( str, "Paper" ) == 0) return paper; - if (strcasecmp( str, "Scissors" ) == 0) return scissors; - /* If we reach this point, we've got real problems. */ - fprintf( stderr, "Attempt to convert invalid string \"%s\" into an ITEMTYPE! Aborting.\n", str ); - exit(EXIT_FAILURE); - return -1; -} - - -RESULTTYPE stringToResult( char * str ) { - if (strcasecmp( str, "Attacker" ) == 0) return attacker; - if (strcasecmp( str, "Defender" ) == 0) return defender; - if (strcasecmp( str, "Tie" ) == 0) return tie; - /* If we reach this point, we've got real problems. */ - fprintf( stderr, "Attempt to convert invalid string \"%s\" into an ITEMTYPE! Aborting.\n", str ); - exit(EXIT_FAILURE); - return -1; -} - -int main( int argc, char * argv[] ) { - srand( time( NULL ) ); - - char command[MAXCOMMANDLEN]; - char foeName[MAXFOENAMELEN]; - char attItem[MAXITEMLEN], defItem[MAXITEMLEN], bluffItem[MAXITEMLEN]; - char didYouInstigate[MAXBOOLLEN]; - char winner[MAXRESULTLEN]; - int pointChange; - - ATTACKTYPE attack; - ITEMTYPE defence; - - /* generate a random id for this bot. Hopefully it's unique - I can't use the UUID, because python doesn't pass it to me! */ - me = rand(); - - - scanf( "%s", command ); - - while (strcasecmp("BYE",command) != 0) { - - if (strcasecmp("ATTACK", command) == 0) { - scanf( "%s", foeName ); - attack = Attack( foeName ); - printf("ATTACKING %s %s\n", ITEMNAMES[attack.realAttack], ITEMNAMES[attack.promisedAttack]); - - } else if (strcasecmp("DEFEND", command) == 0) { - scanf( "%s %s", foeName, bluffItem ); - defence = Defend(foeName, stringToItem(bluffItem)); - printf("DEFENDING %s\n", ITEMNAMES[defence]); - - } else if (strcasecmp("RESULTS", command) == 0) { - /* (foeName, isInstigatedByYou, winner, attItem, defItem, bluffItem, pointDelta) */ - scanf( "%s %s %s %s %s %s %d", foeName, didYouInstigate, winner, attItem, defItem, bluffItem, &pointChange ); - Results(foeName, (strcasecmp("True",didYouInstigate)==0), stringToResult(winner), - stringToItem(attItem), stringToItem(defItem), stringToItem(bluffItem), pointChange); - printf("OK\n"); - } - - fflush(stdout); - fflush(stderr); - - // read the next command! - scanf( "%s", command ); - } - - Cleanup(); - - return 0; -} \ No newline at end of file +/* + * c_link.c + * c-link-lib + * + * Created by Daniel Axtens on 19/04/10. + * Licensed under an MIT-style license: see the LICENSE file for details. + * + */ + +#include "c_link.h" +#include +#include +#include +#include + +/* You don't need to read this file. + All you have to do is implement the bot functions defined in + This file sets up the I/O for you, as well as some utility functions and tables. + */ + +char ITEMNAMES[3][MAXITEMLEN] = {"Rock", "Paper", "Scissors"}; + +/* rock-rock rock-paper rock-scissors + paper-rock paper-paper paper-scissors + scissors-rock scissors-paper scissors-scissors */ + +RESULTTYPE RESULTOF[3][3] = { { tie, defender, attacker }, + { attacker, tie, defender }, + { defender, attacker, tie } }; + +ITEMTYPE RandomAttack() { + return (ITEMTYPE)rand()%3; +} + +ITEMTYPE stringToItem( char * str ) { + if (strcasecmp( str, "Rock" ) == 0) return rock; + if (strcasecmp( str, "Paper" ) == 0) return paper; + if (strcasecmp( str, "Scissors" ) == 0) return scissors; + /* If we reach this point, we've got real problems. */ + fprintf( stderr, "Attempt to convert invalid string \"%s\" into an ITEMTYPE! Aborting.\n", str ); + exit(EXIT_FAILURE); + return -1; +} + + +RESULTTYPE stringToResult( char * str ) { + if (strcasecmp( str, "Attacker" ) == 0) return attacker; + if (strcasecmp( str, "Defender" ) == 0) return defender; + if (strcasecmp( str, "Tie" ) == 0) return tie; + /* If we reach this point, we've got real problems. */ + fprintf( stderr, "Attempt to convert invalid string \"%s\" into an ITEMTYPE! Aborting.\n", str ); + exit(EXIT_FAILURE); + return -1; +} + +int main( int argc, char * argv[] ) { + srand( time( NULL ) ); + + char command[MAXCOMMANDLEN]; + char foeName[MAXFOENAMELEN]; + char attItem[MAXITEMLEN], defItem[MAXITEMLEN], bluffItem[MAXITEMLEN]; + char didYouInstigate[MAXBOOLLEN]; + char winner[MAXRESULTLEN]; + int pointChange; + void *thisInstance; + + ATTACKTYPE attack; + ITEMTYPE defence; + + /* generate a random id for this bot. Hopefully it's unique + I can't use the UUID, because python doesn't pass it to me! */ + me = rand(); + + // TODO: Get the UUID passed by python + // Currently, just pass an empty string to the initialise function + thisInstance = Initialise( "" ); + + scanf( "%s", command ); + + while (strcasecmp("BYE",command) != 0) { + + if (strcasecmp("ATTACK", command) == 0) { + scanf( "%s", foeName ); + attack = Attack( thisInstance, foeName ); + printf("ATTACKING %s %s\n", ITEMNAMES[attack.realAttack], ITEMNAMES[attack.promisedAttack]); + + } else if (strcasecmp("DEFEND", command) == 0) { + scanf( "%s %s", foeName, bluffItem ); + defence = Defend(thisInstance, foeName, stringToItem(bluffItem)); + printf("DEFENDING %s\n", ITEMNAMES[defence]); + + } else if (strcasecmp("RESULTS", command) == 0) { + /* (foeName, isInstigatedByYou, winner, attItem, defItem, bluffItem, pointDelta) */ + scanf( "%s %s %s %s %s %s %d", foeName, didYouInstigate, winner, attItem, defItem, bluffItem, &pointChange ); + Results(thisInstance, foeName, (strcasecmp("True",didYouInstigate)==0), stringToResult(winner), + stringToItem(attItem), stringToItem(defItem), stringToItem(bluffItem), pointChange); + printf("OK\n"); + } + + fflush(stdout); + fflush(stderr); + + // read the next command! + scanf( "%s", command ); + } + + Cleanup(thisInstance); + + return 0; +} diff --git a/src/link/C/c_link.h b/src/link/C/c_link.h old mode 100644 new mode 100755 index c3bd87c..5953acb --- a/src/link/C/c_link.h +++ b/src/link/C/c_link.h @@ -1,106 +1,118 @@ -/* - * c_link.h - * c-link-lib - * - * Created by Daniel Axtens on 19/04/10. - * Licensed under an MIT-style license: see the LICENSE file for details. - * - */ - -#include - -#define MAXCOMMANDLEN 15 -#define MAXFOENAMELEN 50 -#define MAXITEMLEN 10 -#define MAXRESULTLEN 10 -#define MAXBOOLLEN 6 - -/********** Type definitions **********/ - -/* The type of item used in an attack or defence */ -typedef enum {rock, paper, scissors} ITEMTYPE; - -/* A result of a battle, in terms of who won */ -typedef enum {attacker, defender, tie} RESULTTYPE; - - -/* An attack, consisting of the real attack and the attack promised */ -typedef struct { - ITEMTYPE realAttack; - ITEMTYPE promisedAttack; -} ATTACKTYPE; - - -/********** Utility Function definitions **********/ -/* These are implemented in c-link.c, and automagically linked in */ - -/* prints a debug message. Same arguments as printf(). - (you can't use printf because it is used to talk between - the agent and supervisor) - */ - -#define debugmsg(x...) fprintf(stderr, x) - -/* A (hopefully) unique identifier for this particular instance of your agent, - to help with debugging */ -int me; - - -/* Returns a random item */ - -ITEMTYPE RandomAttack(); - -/* A useful translation table - eg debugmsg( "I use %s.\n", ITEMNAMES[rock] ); */ - -extern char ITEMNAMES[3][MAXITEMLEN]; - -/* Another useful table - who's the victor given an - attacker with first item vs defender with the second item? */ -extern RESULTTYPE RESULTOF[3][3]; - -/********** Bot Function definitions **********/ -/* You need to provide implementations for these to create a bot */ - -/* Defend( foeName : string - the name of your foe; - foePromisedAttack : ITEMTYPE - the item your foe promised to use - ) : ITEMTYPE - the item you wish to use to defend; - - Called when your agent needs to defend itself. - - */ -ITEMTYPE Defend( char * foeName, ITEMTYPE foePromisedAttack ); - - -/* Attack( foeName : string - the name of your foe - ) : ATTACKTYPE - the real and promised attack you wish to use - - Called when your agent needs to attack another agent. - - */ -ATTACKTYPE Attack( char * foeName ); - - -/* Results( foeName : string - the name of your foe; - isInstigatedByYou : 0=you defended/1=you attacked; - winner : RESULTTYPE - who won - attItem : ITEMTYPE - the item used to attack; - defItem : ITEMTYPE - the item used to defend; - bluffItem : ITEMTYPE - the item that was promised - pointDelta : integer - how your points were affected. - ); - - Called after your agent battles another agent, to tell you how the battle goes. - - */ -void Results( char * foeName, int isInstigatedByYou, RESULTTYPE winner, - ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, - int pointDelta ); - -/* Cleanup(); - - Called when your agent is no longer needed, either due to the round ending - or due to your agent being eliminated. - - */ -void Cleanup(); \ No newline at end of file +/* + * c_link.h + * c-link-lib + * + * Created by Daniel Axtens on 19/04/10. + * Licensed under an MIT-style license: see the LICENSE file for details. + * + */ + +#include + +#define MAXCOMMANDLEN 15 +#define MAXFOENAMELEN 50 +#define MAXITEMLEN 10 +#define MAXRESULTLEN 10 +#define MAXBOOLLEN 6 + +/********** Type definitions **********/ + +/* The type of item used in an attack or defence */ +typedef enum {rock, paper, scissors} ITEMTYPE; + +/* A result of a battle, in terms of who won */ +typedef enum {attacker, defender, tie} RESULTTYPE; + + +/* An attack, consisting of the real attack and the attack promised */ +typedef struct { + ITEMTYPE realAttack; + ITEMTYPE promisedAttack; +} ATTACKTYPE; + + +/********** Utility Function definitions **********/ +/* These are implemented in c-link.c, and automagically linked in */ + +/* prints a debug message. Same arguments as printf(). + (you can't use printf because it is used to talk between + the agent and supervisor) + */ + +#define debugmsg(x...) fprintf(stderr, x) + +/* A (hopefully) unique identifier for this particular instance of your agent, + to help with debugging */ +int me; + + +/* Returns a random item */ + +ITEMTYPE RandomAttack(); + +/* A useful translation table + eg debugmsg( "I use %s.\n", ITEMNAMES[rock] ); */ + +extern char ITEMNAMES[3][MAXITEMLEN]; + +/* Another useful table - who's the victor given an + attacker with first item vs defender with the second item? */ +extern RESULTTYPE RESULTOF[3][3]; + +/********** Bot Function definitions **********/ +/* You need to provide implementations for these to create a bot */ + +/* Initialise( yourName : string - name of this instance (you) + ) : void * - A data pointer to represent this instance + + Called to create a new instance of this agent + + */ +void *Initialise( char * yourName ); + +/* Defend( this : pointer - value returned from Initialise(); + foeName : string - the name of your foe; + foePromisedAttack : ITEMTYPE - the item your foe promised to use + ) : ITEMTYPE - the item you wish to use to defend; + + Called when your agent needs to defend itself. + + */ +ITEMTYPE Defend( void * this, char * foeName, ITEMTYPE foePromisedAttack ); + + +/* Attack( this: pointer - value returned from Initialise(); + foeName : string - the name of your foe + ) : ATTACKTYPE - the real and promised attack you wish to use + + Called when your agent needs to attack another agent. + + */ +ATTACKTYPE Attack( void * this, char * foeName ); + + +/* Results( this : pointer - value returned from Initialise(); + foeName : string - the name of your foe; + isInstigatedByYou : 0=you defended/1=you attacked; + winner : RESULTTYPE - who won + attItem : ITEMTYPE - the item used to attack; + defItem : ITEMTYPE - the item used to defend; + bluffItem : ITEMTYPE - the item that was promised + pointDelta : integer - how your points were affected. + ); + + Called after your agent battles another agent, to tell you how the battle goes. + + */ +void Results( void * this, char * foeName, int isInstigatedByYou, RESULTTYPE winner, + ITEMTYPE attItem, ITEMTYPE defItem, ITEMTYPE bluffItem, + int pointDelta ); + +/* Cleanup( this: pointer - value returned from Initialise() + ); + + Called when your agent is no longer needed, either due to the round ending + or due to your agent being eliminated. + + */ +void Cleanup( void * this ); -- 2.20.1