परिणाम सामने हैं, प्रतियोगिता समाप्त हो गई है।
विजेता अर्शजी का एविलबोट है जिसमें 14 जीत के साथ नियो-बॉट 13 जीत और सेंट्रेबोट और लास्टस्टैंड 11 जीत के साथ प्रत्येक है।
फाइनल रन से स्कोर
Results:
java Rifter: 9 match wins (45 total bout wins)
java EvadeBot: 10 match wins (44 total bout wins)
java EvilBot: 14 match wins (59 total bout wins)
java LastStand: 11 match wins (43 total bout wins)
java UltraBot: 9 match wins (40 total bout wins)
python ReadyAimShoot.py: 8 match wins (36 total bout wins)
./SpiralBot: 0 match wins (1 total bout wins)
python DodgingTurret.py: 8 match wins (43 total bout wins)
ruby1.9 TroubleAndStrafe.rb: 8 match wins (41 total bout wins)
./RandomBot: 1 match wins (6 total bout wins)
python StraightShooter.py: 8 match wins (41 total bout wins)
python mineminemine.py: 3 match wins (14 total bout wins)
./CamperBot: 5 match wins (20 total bout wins)
python3.3 CunningPlanBot.py: 3 match wins (15 total bout wins)
node CentreBot.js: 11 match wins (44 total bout wins)
node Neo-Bot.js: 13 match wins (59 total bout wins)
python NinjaPy.py: 3 match wins (19 total bout wins)
यह एक पहाड़ी चुनौती है। उद्देश्य एक बॉट लिखना है जो किसी भी अन्य की तुलना में अन्य बॉट्स को अधिक हरा देगा।
खेल
बॉट्स सभी को एक-दूसरे के खिलाफ 10x10 अखाड़े में एक समय में 2 के खिलाफ खड़ा किया जाएगा, जिसमें प्रतिद्वंद्वी की ऊर्जा को 10 से घटाकर 0 करने से पहले अपनी खुद की ऊर्जा को 0 तक कम करने का काम होगा।
प्रत्येक मैच में 5 मुकाबले होंगे। मैच का विजेता सबसे अधिक मुकाबलों का विजेता होता है। मैच जीत और बाउट जीत की कुल संख्या को नियंत्रण कार्यक्रम द्वारा संग्रहीत किया जाएगा और प्रतियोगिता के समग्र विजेता को निर्धारित करने के लिए उपयोग किया जाएगा। विजेता बड़े हरे रंग की टिक और जनता की प्रशंसा प्राप्त करता है।
प्रत्येक बाउट कई राउंड में आगे बढ़ेगा। प्रत्येक दौर की शुरुआत में अखाड़े की वर्तमान स्थिति प्रत्येक बॉट को दी जाएगी और बॉट इसके बाद एक कमांड के साथ जवाब देगा कि वह आगे क्या करना चाहता है। एक बार दोनों कमांड को कंट्रोल प्रोग्राम द्वारा प्राप्त कर लिया गया है और दोनों कमांड को एक ही समय में निष्पादित किया जाता है और नए राज्य को प्रतिबिंबित करने के लिए अखाड़ा और बॉट एनर्जी के स्तर को अपडेट किया जाता है। यदि खेल को जारी रखने के लिए दोनों बॉट में अभी भी पर्याप्त ऊर्जा है तो गेम अगले दौर में होगा। बाउट प्रति 1000 राउंड की एक सीमा होगी, यह सुनिश्चित करने के लिए कि कोई भी बॉटल हमेशा के लिए नहीं चलती है, और इस स्थिति में कि यह सीमा विजेता तक पहुंच जाएगी सबसे अधिक ऊर्जा के साथ बॉट होगा। यदि दोनों बॉट्स में समान ऊर्जा होती है तो बाउट ड्रॉ होता है और न ही बॉट को जीत के लिए एक बिंदु मिलेगा (यह ऐसा होगा जैसे कि वे हार गए हों)।
हथियार
प्रत्येक बॉट के पास कई हथियार होंगे:
- कवच-भेदी गोलियां। ये एक बार में 3 वर्गों की यात्रा करते हैं और 1 ऊर्जा बिंदु को नुकसान पहुंचाते हैं।
- मिसाइलों। ये एक समय में 2 चौकों की यात्रा करते हैं और प्रभाव के बिंदु पर 3 ऊर्जा बिंदुओं को नुकसान पहुंचाते हैं, और तुरंत सभी वर्गों में क्षति का 1 बिंदु।
- बारूदी सुरंगों। ये तुरंत बॉट के आसपास के चौकों में से एक में गिरा दिए जाते हैं और आगे बढ़ने पर 2 ऊर्जा बिंदुओं को नुकसान पहुंचाते हैं, और तुरंत आसपास के किसी एक वर्ग में खड़े किसी भी चीज को नुकसान के 1 ऊर्जा बिंदु।
- इलेक्ट्रो-मैग्नेटिक पल्स। दोनों बॉट्स मूवमेंट सर्किट को 2 मोड़ों के लिए खराबी के कारण, जिसका अर्थ है कि वे स्थानांतरित नहीं कर सकते हैं। वे, हालांकि, अभी भी हथियार तैनात कर सकते हैं (हाँ मुझे पता है कि यह यथार्थवादी नहीं है, लेकिन यह एक खेल है। यह वास्तविक जीवन नहीं माना जाता है)। संपादित करें: प्रत्येक ईएमपी तैनाती बॉट का एक ऊर्जा बिंदु खर्च करेगी जो इसका उपयोग करती है।
बुलेट / मिसाइल केवल बॉट, या दीवारों के साथ प्रभाव डाल सकते हैं। वे किसी भी ऐसे बॉट को मारेंगे, जो किसी भी ऐसे वर्ग में है, जिससे वे गुजरते हैं। एक बार जब वे कुछ हिट करते हैं तो वे गायब हो जाते हैं।
सभी मामलों immediately surrounding squaresमें 8 वर्गों का मतलब है कि बॉट अपने अगले कदम - मूर पड़ोस पर जा सकता है।
आज्ञा
0कुछ मत करो।N,NE,E,SE,S,SW,W,NWसभी दिशा आदेशों कर रहे हैं और दिए गए दिशा में बॉट एक वर्ग ले जाएँ। यदि बॉट उस दिशा में जाने में असमर्थ है क्योंकि चौराहे पर एक दीवार या कोई अन्य बॉट है, तो बॉट वहीं रहता है। एक वर्ग में जाना जिसमें पहले से ही एक बुलेट या मिसाइल सुरक्षित है क्योंकि बुलेट / मिसाइल को उस वर्ग से बाहर जाने के पहले से ही माना जाएगा।Bएक अंतरिक्ष द्वारा पीछा किया जाता है और फिर एक दिशा निर्देश उस दिशा में एक कवच भेदी गोली चलाता है।Mएक स्थान और उसके बाद एक दिशा निर्देश उस दिशा में एक मिसाइल फायर करता है।Lएक स्थान और उसके बाद दिशा निर्देशों में से एक बॉट के बगल में उस वर्ग पर एक भूमि की खान को गिराता है। यदि वर्ग पहले से ही दीवार या बॉट द्वारा कब्जा कर लिया गया है, तो कमांड को अनदेखा किया जाता है। यदि एक बारूदी सुरंग को दूसरे बारूदी सुरंग पर गिराया जाता है, तो यह विस्फोट कर देती है। यह बॉट को ड्रोपिंग करने वाले नुकसान पहुंचाएगा, और मूल बारूदी सुरंग की सीमा के भीतर किसी भी अन्य बॉट को नुकसान पहुंचाएगा।Pईएमपी फायर करता है।
चूँकि प्रति राउंड केवल एक कमांड दिया जा सकता है, एक बोट केवल एक हथियार को स्थानांतरित या आग / तैनात कर सकता है, एक ही समय में दोनों नहीं।
आदेशों का आदेश
या तो बॉट की आवाजाही हमेशा पहले आएगी, और सभी आंदोलनों को दो बार प्रयास किया जाएगा कि एक और बॉट रास्ते में हो लेकिन रास्ते से बाहर जा रहा है।
उदाहरण
- बॉट 1 स्थानांतरित करने की कोशिश करता है
Eलेकिन बॉट 2 पहले से ही उस वर्ग में है - नियंत्रण कार्यक्रम बॉट 2 पर आगे बढ़ता है।
- बॉट 2 स्थानांतरित करने की कोशिश करता है
Sऔर सफल होता है क्योंकि कुछ भी रास्ते में नहीं है। - बोट 1 को अपनी चाल में दूसरा प्रयास करने का मौका मिलता है। इस बार यह सफल हुआ और बॉट 1 आगे बढ़ा
E।
एक बार जब बॉट्स ने कोई ऐसी हरकत की है जिसे वे करना चाहते हैं, तो हथियारों को निकाल दिया जाएगा और सभी प्रोजेक्टाइल (नए और पहले फायर किए गए) अपने पूर्वनिर्धारित संख्याओं को स्थानांतरित कर देंगे।
अखाड़ा
प्रत्येक दौर की शुरुआत में बॉट कार्यक्रम की एकमात्र कमांड लाइन तर्क के रूप में खेल की वर्तमान स्थिति प्राप्त करेगा:
X.....LLL.
..........
..........
..........
M.........
..........
..........
..........
..........
...B.....Y
Y 10
X 7
B 3 9 W
M 0 4 S
L 6 0
B 3 9 S
L 7 0
L 8 0
अखाड़ा पहले 10 वर्णों की 10 पंक्तियों से मिलकर आता है। यह दीवारों से घिरा हुआ है जिन्हें नहीं दिखाया गया है। पात्रों के अर्थ इस प्रकार हैं:
.एक खाली वर्ग का प्रतिनिधित्व करता हैYआपके बॉट का प्रतिनिधित्व करता है।Xप्रतिद्वंद्वी बॉट का प्रतिनिधित्व करता है।Lएक बारूदी सुरंग का प्रतिनिधित्व करता है।Bउड़ान में एक गोली का प्रतिनिधित्व करता है।Mउड़ान में एक मिसाइल का प्रतिनिधित्व करता है।
इसके बाद बॉट की शेष ऊर्जा, प्रति पंक्ति एक बॉट होती है। केवल एक स्थान अपने ऊर्जा स्तर से बॉट पहचानकर्ता को अलग करेगा। अखाड़े में, Yअपने बॉट का Xप्रतिनिधित्व करता है और अपने प्रतिद्वंद्वी का प्रतिनिधित्व करता है। अंत में प्रोजेक्टाइल और बारूदी सुरंगों, उनकी स्थिति और (यदि उपयुक्त हो) शीर्षकों की एक सूची आती है, फिर से प्रति पंक्ति एक।
नियंत्रण कार्यक्रम
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define NUMBOTS 2
#define BOUTSPERMATCH 5
#define ROUNDSPERBOUT 1000
#define MAXFILENAMESIZE 100
#define MAXWEAPONS 100
#define DISPLAYBOUTS true
typedef struct
{
int x, y, energy;
char cmd[5];
} Bot;
int getxmove(char cmd[5]);
int getymove(char cmd[5]);
int newposinbounds(int oldx, int oldy, int dx, int dy);
int directhit(Bot bot, int landmine[2]);
int landminecollision(int landmine1[2], int landmine2[2]);
int inshrapnelrange(Bot bot, int landmine[2]);
int directiontoint(char direction[5], char directions[8][3]);
void deployweapons(Bot *bot, Bot *enemy, int bullets[MAXWEAPONS][3], int missiles[MAXWEAPONS][3], int landmines[MAXWEAPONS][2], char directions[8][3]);
void cleararena(char arena[10][11]);
int main()
{
FILE *fp;
Bot b1, b2;
int bot1, bot2, bot1bouts, bot2bouts;
int bout, round, loop, totalprojectiles, dx, dy;
char bots[NUMBOTS][MAXFILENAMESIZE]=
{
"./donowt ",
"php -f huggybot.php "
};
char directions[8][3]={"N", "NE", "E", "SE", "S", "SW", "W", "NW"};
char openstring[5000], argumentstring[4000], bot1string[6], bot2string[6];
int matcheswon[NUMBOTS],boutswon[NUMBOTS];
int missiles[MAXWEAPONS][3];
int bullets[MAXWEAPONS][3];
int landmines[MAXWEAPONS][2];
int paralyzedturnsremaining=0;
bool bot1moved;
char arena[10][11];
char projectiles[300][10];
for(loop=0;loop<NUMBOTS;loop++)
{
matcheswon[loop]=0;
boutswon[loop]=0;
}
srand(time(NULL));
for(bot1=0;bot1<NUMBOTS-1;bot1++)
{
for(bot2=bot1+1;bot2<NUMBOTS;bot2++)
{
bot1bouts=bot2bouts=0;
printf("%s vs %s ",bots[bot1],bots[bot2]);
for(bout=0;bout<BOUTSPERMATCH;bout++)
{
printf("%d ",bout);
//setup the arena for the bout
b1.x=1;b1.y=1;
b2.x=9;
//b1.y=rand()%10;
b2.y=rand()%10;
b1.energy=b2.energy=10;
//clear the previous stuff
memset(missiles, -1, sizeof(missiles));
memset(bullets, -1, sizeof(bullets));
memset(landmines, -1, sizeof(landmines));
for(round=0;round<ROUNDSPERBOUT;round++)
{
//draw the arena based on current state
cleararena(arena);
totalprojectiles=0;
for(loop=0;loop<MAXWEAPONS;loop++)
{
if(bullets[loop][0]!= -1)
{
arena[bullets[loop][1]][bullets[loop][0]]='B';
sprintf(projectiles[totalprojectiles], "%c %d %d %s\n", 'B', bullets[loop][0], bullets[loop][1], directions[bullets[loop][2]]);
totalprojectiles+=1;
}
if(missiles[loop][0]!= -1)
{
arena[missiles[loop][1]][missiles[loop][0]]='M';
sprintf(projectiles[totalprojectiles], "%c %d %d %s\n", 'M', missiles[loop][0], missiles[loop][1], directions[missiles[loop][2]]);
totalprojectiles+=1;
}
if(landmines[loop][0]!= -1)
{
arena[landmines[loop][1]][landmines[loop][0]]='L';
sprintf(projectiles[totalprojectiles], "%c %d %d\n", 'L', landmines[loop][0], landmines[loop][1]);
totalprojectiles+=1;
}
}
//send the arena to both bots to get the commands
// create bot1's input
arena[b1.y][b1.x]='Y';
arena[b2.y][b2.x]='X';
sprintf(bot1string, "Y %d\n", b1.energy);
sprintf(bot2string, "X %d\n", b2.energy);
strcpy(argumentstring, "'");
strncat(argumentstring, *arena, 10*11);
strcat(argumentstring, bot1string);
strcat(argumentstring, bot2string);
for(loop=0;loop<totalprojectiles;loop++)
{
strcat(argumentstring, projectiles[loop]);
}
strcat(argumentstring, "'");
sprintf(openstring, "%s %s", bots[bot1], argumentstring);
// send it and get the command back
fp=popen(openstring, "r");
fgets(b1.cmd, 5, fp);
fflush(NULL);
pclose(fp);
// create bot2's input
arena[b2.y][b2.x]='Y';
arena[b1.y][b1.x]='X';
sprintf(bot2string, "Y %d\n", b2.energy);
sprintf(bot1string, "X %d\n", b1.energy);
strcpy(argumentstring, "'");
strncat(argumentstring, *arena, 10*11);
strcat(argumentstring, bot2string);
strcat(argumentstring, bot1string);
for(loop=0;loop<totalprojectiles;loop++)
{
strcat(argumentstring, projectiles[loop]);
}
strcat(argumentstring, "'");
sprintf(openstring, "%s %s", bots[bot2], argumentstring);
// send it and get the command back
fp=popen(openstring, "r");
fgets(b2.cmd, 5, fp);
fflush(NULL);
pclose(fp);
if(DISPLAYBOUTS)
{
arena[b1.y][b1.x]='A';
arena[b2.y][b2.x]='B';
printf("\033c");
printf("Round: %d\n", round);
printf("%s", arena);
sprintf(bot1string, "A %d\n", b1.energy);
sprintf(bot2string, "B %d\n", b2.energy);
printf("%s%s", bot1string, bot2string);
}
//do bot movement phase
if(paralyzedturnsremaining==0)
{
// move bot 1 first
bot1moved=false;
dx=dy=0;
dx=getxmove(b1.cmd);
dy=getymove(b1.cmd);
if(newposinbounds(b1.x, b1.y, dx, dy))
{
if(!(b1.x+dx==b2.x) || !(b1.y+dy==b2.y))
{
bot1moved=true;
b1.x=b1.x+dx;
b1.y=b1.y+dy;
}
}
// move bot 2 next
dx=dy=0;
dx=getxmove(b2.cmd);
dy=getymove(b2.cmd);
if(newposinbounds(b2.x, b2.y, dx, dy))
{
if(!(b2.x+dx==b1.x) || !(b2.y+dy==b1.y))
{
b2.x=b2.x+dx;
b2.y=b2.y+dy;
}
}
if(!bot1moved) // if bot2 was in the way first time, try again
{
dx=dy=0;
dx=getxmove(b1.cmd);
dy=getymove(b1.cmd);
if(newposinbounds(b1.x, b1.y, dx, dy))
{
if(!(b1.x+dx==b2.x) || !(b1.y+dy==b2.y))
{
b1.x=b1.x+dx;
b1.y=b1.y+dy;
}
}
}
//check for landmine hits
for(loop=0;loop<MAXWEAPONS;loop++)
{
if(landmines[loop][0]!= -1)
{
if(directhit(b1, landmines[loop]))
{
b1.energy-=2;
if(inshrapnelrange(b2, landmines[loop]))
{
b2.energy-=1;
}
landmines[loop][0]= -1;
landmines[loop][1]= -1;
}
if(directhit(b2, landmines[loop]))
{
b2.energy-=2;
if(inshrapnelrange(b1, landmines[loop]))
{
b1.energy-=1;
}
landmines[loop][0]= -1;
landmines[loop][1]= -1;
}
}
}
}
else
{
paralyzedturnsremaining-=1;
}
//do weapons firing phase
if(strcmp(b1.cmd, "P")==0)
{
paralyzedturnsremaining=2;
b1.energy--;
}
else if(strcmp(b2.cmd, "P")==0)
{
paralyzedturnsremaining=2;
b2.energy--;
}
deployweapons(&b1, &b2, bullets, missiles, landmines, directions);
deployweapons(&b2, &b1, bullets, missiles, landmines, directions);
//do weapons movement phase
int moves;
for(loop=0;loop<MAXWEAPONS;loop++)
{
dx=dy=0;
if(bullets[loop][0]!= -1)
{
dx=getxmove(directions[bullets[loop][2]]);
dy=getymove(directions[bullets[loop][2]]);
for(moves=0;moves<3;moves++)
{
if(newposinbounds(bullets[loop][0], bullets[loop][1], dx, dy))
{
bullets[loop][0]+=dx;
bullets[loop][1]+=dy;
if(directhit(b1, bullets[loop]))
{
b1.energy-=1;
bullets[loop][0]= -1;
bullets[loop][1]= -1;
bullets[loop][2]= -1;
}
if(directhit(b2, bullets[loop]))
{
b2.energy-=1;
bullets[loop][0]= -1;
bullets[loop][1]= -1;
bullets[loop][2]= -1;
}
}
else
{
bullets[loop][0]= -1;
bullets[loop][1]= -1;
bullets[loop][2]= -1;
dx=dy=0;
}
}
}
};
for(loop=0;loop<MAXWEAPONS;loop++)
{
dx=dy=0;
if(missiles[loop][0]!= -1)
{
dx=getxmove(directions[missiles[loop][2]]);
dy=getymove(directions[missiles[loop][2]]);
for(moves=0;moves<2;moves++)
{
if(newposinbounds(missiles[loop][0], missiles[loop][1], dx, dy))
{
missiles[loop][0]+=dx;
missiles[loop][1]+=dy;
if(directhit(b1, missiles[loop]))
{
b1.energy-=3;
if(inshrapnelrange(b2, missiles[loop]))
{
b2.energy-=1;
}
missiles[loop][0]= -1;
missiles[loop][1]= -1;
missiles[loop][2]= -1;
}
if(directhit(b2, missiles[loop]))
{
b2.energy-=3;
if(inshrapnelrange(b1, missiles[loop]))
{
b1.energy-=1;
}
missiles[loop][0]= -1;
missiles[loop][1]= -1;
missiles[loop][2]= -1;
}
}
else
{
if(inshrapnelrange(b1, missiles[loop]))
{
b1.energy-=1;
}
if(inshrapnelrange(b2, missiles[loop]))
{
b2.energy-=1;
}
missiles[loop][0]= -1;
missiles[loop][1]= -1;
missiles[loop][2]= -1;
dx=dy=0;
}
}
}
}
//check if there's a winner
if(b1.energy<1 || b2.energy<1)
{
round=ROUNDSPERBOUT;
}
}
// who has won the bout
if(b1.energy<b2.energy)
{
bot2bouts+=1;
boutswon[bot2]+=1;
}
else if(b2.energy<b1.energy)
{
bot1bouts+=1;
boutswon[bot1]+=1;
}
}
if(bot1bouts>bot2bouts)
{
matcheswon[bot1]+=1;
}
else if(bot2bouts>bot1bouts)
{
matcheswon[bot2]+=1;
}
printf("\n");
}
}
// output final scores
printf("\nResults:\n");
printf("Bot\t\t\tMatches\tBouts\n");
for(loop=0;loop<NUMBOTS;loop++)
{
printf("%s\t%d\t%d\n", bots[loop], matcheswon[loop], boutswon[loop]);
}
}
int getxmove(char cmd[5])
{
int dx=0;
if(strcmp(cmd, "NE")==0)
dx= 1;
else if(strcmp(cmd, "E")==0)
dx= 1;
else if(strcmp(cmd, "SE")==0)
dx= 1;
else if(strcmp(cmd, "SW")==0)
dx= -1;
else if(strcmp(cmd, "W")==0)
dx= -1;
else if(strcmp(cmd, "NW")==0)
dx= -1;
return dx;
}
int getymove(char cmd[5])
{
int dy=0;
if(strcmp(cmd, "N")==0)
dy= -1;
else if(strcmp(cmd, "NE")==0)
dy= -1;
else if(strcmp(cmd, "SE")==0)
dy= 1;
else if(strcmp(cmd, "S")==0)
dy= 1;
else if(strcmp(cmd, "SW")==0)
dy= 1;
else if(strcmp(cmd, "NW")==0)
dy= -1;
return dy;
}
int newposinbounds(int oldx, int oldy, int dx, int dy)
{
return (oldx+dx>=0 && oldx+dx<10 && oldy+dy>=0 && oldy+dy<10);
}
int directhit(Bot bot, int landmine[2])
{
return (bot.x==landmine[0] && bot.y==landmine[1]);
}
int landminecollision(int landmine1[2], int landmine2[2])
{
return ((landmine1[1]==landmine2[1]) && abs(landmine1[0]==landmine2[0]));
}
int inshrapnelrange(Bot bot, int landmine[2])
{
return (abs(bot.x-landmine[0])<2 && abs(bot.y-landmine[1])<2);
}
int directiontoint(char direction[5], char directions[8][3])
{
int loop,returnval=8;
for(loop=0;loop<8;loop++)
{
if(strcmp(directions[loop], direction)==0)
returnval=loop;
}
return returnval;
}
void deployweapons(Bot *bot, Bot *enemy, int bullets[MAXWEAPONS][3], int missiles[MAXWEAPONS][3], int landmines[MAXWEAPONS][2], char directions[8][3])
{
int loop;
if(strlen(bot->cmd)>2)
{
if(bot->cmd[0]=='B')
{
int weaponslot=0;
while(bullets[weaponslot][0]!= -1)
weaponslot+=1;
bullets[weaponslot][0]=bot->x;
bullets[weaponslot][1]=bot->y;
bullets[weaponslot][2]=directiontoint(bot->cmd+2, directions);
if(bullets[weaponslot][2]>7)
{
// direction wasn't recognized so clear the weapon
bullets[weaponslot][0]= -1;
bullets[weaponslot][1]= -1;
bullets[weaponslot][2]= -1;
}
}
if(bot->cmd[0]=='M')
{
int weaponslot=0;
while(missiles[weaponslot][0]!= -1)
weaponslot+=1;
missiles[weaponslot][0]=bot->x;
missiles[weaponslot][1]=bot->y;
missiles[weaponslot][2]=directiontoint(bot->cmd+2, directions);
if(missiles[weaponslot][2]>7)
{
// direction wasn't recognized so clear the weapon
missiles[weaponslot][0]= -1;
missiles[weaponslot][1]= -1;
missiles[weaponslot][2]= -1;
}
}
if(bot->cmd[0]=='L')
{
int weaponslot=0;
while(landmines[weaponslot][0]!= -1)
weaponslot+=1;
if(newposinbounds(bot->x, bot->y, getxmove(bot->cmd+2), getymove(bot->cmd+2)))
{
landmines[weaponslot][0]=bot->x+getxmove(bot->cmd+2);
landmines[weaponslot][1]=bot->y+getymove(bot->cmd+2);
//check for landmine hits
for(loop=0;loop<MAXWEAPONS;loop++)
{
if(landmines[loop][0]!= -1)
{
if(landminecollision(landmines[weaponslot], landmines[loop]) && weaponslot!=loop)
{
if(inshrapnelrange(*bot, landmines[loop]))
{
bot->energy-=1;
}
if(inshrapnelrange(*enemy, landmines[loop]))
{
enemy->energy-=1;
}
landmines[loop][0]= -1;
landmines[loop][1]= -1;
landmines[weaponslot][0]= -1;
landmines[weaponslot][1]= -1;
}
}
}
}
}
}
}
void cleararena(char arena[10][11])
{
int loop;
memset(arena, '.', 110);
for(loop=0;loop<10;loop++)
{
arena[loop][10]='\n';
}
}
नियंत्रण कार्यक्रम आपके बॉट को कमांड लाइन से कॉल करेगा। इस कारण से, प्रोग्राम जिन्हें कमांड लाइन से नहीं बुलाया जा सकता है उन्हें अमान्य माना जाएगा । मैं उन लोगों से माफी मांगता हूं जिनकी पसंद की भाषा उस तरह से काम नहीं करती है, लेकिन प्रत्येक मैच को मैन्युअल रूप से करना अव्यावहारिक होगा।
intx13 ने कुछ बगफिक्स के साथ नियंत्रण कार्यक्रम का अधिक मजबूत संस्करण लिखा है, जिसे आप यहां पा सकते हैं ।
नियंत्रण कार्यक्रम में सुधार या बग-सुधार के सुझाव स्वागत योग्य हैं।
टेस्ट बॉट
स्कोरिंग रन में कोई भी टेस्ट बॉट शामिल नहीं होगा। वे सिर्फ परीक्षण के उद्देश्य के लिए हैं।
डडली डोनट (C)
int main(int argc, char *argv)
{
printf("0");
}
स्थिति की परवाह किए बिना कुछ भी नहीं करता है। ज्यादा जीत की उम्मीद नहीं थी।
HuggyBot (PHP)
<?php
$arena=$argv[1];
list($meX, $meY)=findMe($arena);
list($oppX, $oppY)=findOpp($arena);
if($meY<$oppY)
{
if($meX<$oppX)
echo "SE";
elseif($meX==$oppX)
echo "S";
else
echo "SW";
}
elseif($meY==$oppY)
{
if($meX<$oppX)
echo "E";
else
echo "W";
}
else
{
if($meX<$oppX)
echo "NE";
elseif($meX==$oppX)
echo "N";
else
echo "NW";
}
function findMe($arena)
{
return find("Y", explode("\n", $arena));
}
function findOpp($arena)
{
return find("X", explode("\n", $arena));
}
function find($char, $array)
{
$x=0;
$y=0;
for($loop=0;$loop<10;$loop++)
{
if(strpos($array[$loop], $char)!==FALSE)
{
$x=strpos($array[$loop], $char);
$y=$loop;
}
}
return array($x, $y);
}
?>
प्रतिद्वंद्वी के ठीक बगल में आने की कोशिश करता है। बारूदी सुरंगों की वजह से यह उनके लिए नहीं दिखता है। जब यह अपने लक्ष्य को प्राप्त कर लेता है तो प्रतिद्वंद्वी के लिए मिसाइलों की कम प्रभावी रणनीति बनाता है।
परिणाम
24 मार्च 2014 को 23:59 के बाद अंतिम स्कोरिंग रन किया जाएगा । मैं नियमित रूप से टेस्ट रन चलाऊंगा ताकि प्रवेशक देख सकें कि उनके बॉट मौजूदा विपक्ष के खिलाफ कैसे ढेर हो रहे हैं।
प्रविष्टियां
प्रविष्टियों में आपके बॉट का स्रोत और कमांड लाइन तर्क शामिल होना चाहिए, जिसे मुझे इसे चलाने के लिए उपयोग करना होगा। आप जितनी चाहें उतनी विभिन्न प्रविष्टियाँ पोस्ट करने के लिए स्वागत करते हैं, लेकिन प्रत्येक उत्तर में केवल एक बॉट होना चाहिए ।
जरूरी
ऐसा लगता है कि कुछ प्रविष्टियाँ रनों के बीच कुछ स्थिति को बनाए रखने के लिए डिस्क पर लिखना चाहती हैं। डिस्क पर लिखने के संबंध में ये नए नियम हैं।
- आप अपने स्वयं के बॉट के स्रोत को संशोधित कर सकते हैं। किसी भी अन्य बॉट को संशोधित करना धोखा है और परिणामी बॉट को अयोग्य घोषित किया जाएगा।
- आप राज्य को संग्रहीत करने के उद्देश्य से बनाई गई फ़ाइल को लिख सकते हैं। यह फ़ाइल उस निर्देशिका की उपनिर्देशिका में संग्रहीत होनी चाहिए जहाँ आपका बॉट स्थित है। उपनिर्देशिका नाम दिया जाएगा
state। फाइलसिस्टम के किसी अन्य भाग (अपने स्वयं के स्रोत के अलावा) को लिखना बंद है।