int main() {
init();
// Execute loop forever (or until game ends)
while(true) {
//Gets the newest map. Every int will have a value of EMPTY, ME, OPPONENT, TAKEN_BY_ME, or TAKEN_BY_OPPONENT.
std::vector< std::vector<int> > m = getMap();
int myLocX, myLocY, opLocX, opLocY;
for(int y = 0; y < 16; y++) {
for(int x = 0; x < 16; x++) {
if(m[y][x] == ME) {
myLocX = x;
myLocY = y;
}
else if(m[y][x] == OPPONENT) {
opLocX = x;
opLocY = y;
}
}
}
//Sample - logs where each player is.
dbg::logln("Me: " + std::to_string(myLocX) + ' ' + std::to_string(myLocY) + "; Opponent: " + std::to_string(opLocX) + ' ' + std::to_string(opLocY));
//Figure out what direction to go in.
//Send NORTH, EAST, SOUTH, or WEST
sendMove(WEST);
}
}
void childPlayParent()
{
//Child does dumbplay
//Child does not check for winning
int columnPlayed = smartPlay(CHILD_PIECE);
//Notify parent of column played
sendMove(sendID,columnPlayed);
}
void parentPlayChild(int childIndex)
{
//Set the child board as the active board
activeBoard = &parentBoardsArray[childIndex];
//smart and dumb play return column played unless game is won
//If won, game over is called, handle form there
//Otherwise notify child of parent play
int columnPlayed = dumbPlay(PARENT_PIECE);
//Notify child of column played
sendMove(sendIDs[childIndex],columnPlayed);
}
/************************************************************************************
*
* ***********************************************************************************/
IPState ScopeDome::MoveAbs(double az)
{
LOGF_DEBUG("MoveAbs (%f)", az);
targetAz = az;
double azDiff = az - DomeAbsPosN[0].value;
LOGF_DEBUG("azDiff = %f", azDiff);
// Make relative (-180 - 180) regardless if it passes az 0
if (azDiff > 180)
{
azDiff -= 360;
}
if (azDiff < -180)
{
azDiff += 360;
}
LOGF_DEBUG("azDiff rel = %f", azDiff);
refineMove = true;
return sendMove(azDiff);
}
void multiPlayer() {
int myMove;
int oppMove = 0;
int connect = 0;
// Find other players
while(!connect) {
connect = findPlayer();
}
// NOTE: Need to build something to determine who goes first
// Compare Xbee ID's perhaps?
// Begin game
while(!game.gameOver && connect) {
if(game.turn) {
// Pick Move
myMove = pickMove();
// Send Move
sendMove(myMove);
// Receive new score after opponent takes damage
game.oppScore = recieveScore();
} else {
// Receive player move and take damage
game.myScore = attack(recieveMove(), game.myScore);
// Send new score
sendScore(game.myScore);
}
// Check game status
game.gameOver = gameStatus();
!game.turn;
}
if (!connect) {
printBSOD();
} else {
printResults();
}
}
Board::Board(MainWindow* mWnd)
{
for(int i = 0; i < BOARD_SIZE; ++i)
{
for(int j = 0; j < BOARD_SIZE; ++j)
{
if((i+j)%2 != 0)
addItem(new CheckableField(j, i, this));
else
addItem(new UncheckableField(j, i));
items().front()->setPos(i*PIECE_SIZE, j*PIECE_SIZE);
fields[j][i] = dynamic_cast<Field*>(items().front());
}
}
for(int i = 0; i < BOARD_SIZE; ++i)
{
for(int j = 0; j < BOARD_SIZE; ++j)
{
if((i+j)%2 != 0 && j != 3 && j != 4)
{
Piece* newPiece = new Piece(j > 4 ? Piece::WHITE : Piece::BLACK, this);
newPiece->setParentItem(fields[j][i]);
}
}
}
checkedPiece = NULL;
gamerColor = Piece::BLACK;
blockMoves();
gamerColor = Piece::WHITE;
blockMoves();
connect(this, SIGNAL(whiteInc(bool)), mWnd, SLOT(whitePointsInc(bool)));
connect(this, SIGNAL(blackInc(bool)), mWnd, SLOT(blackPointsInc(bool)));
connect(this, SIGNAL(move(QString)), mWnd, SLOT(sendMove(QString)));
}
int main(int argc, char *argv[]) {
int ret; //fuer getopt funktion
char player = '3';
char gameId[15];
char *confDateiName = malloc(256);
strcpy(confDateiName, "client.conf");
pid_t pid;
//Config-Datei einlesen und struct betanken
log_printf(LOG_DEBUG,"Using config-file %s\n",confDateiName);
configstruct = get_config(confDateiName);
log_printf(LOG_PRINTF,"\n");
//11-stellige Game-Id aus Kommandozeile auslesen
if (argc < 2) {
printf("Keine Game-Id angegeben!\n");
help();
exit(EXIT_FAILURE);
}
strcpy(gameId,argv[1]);
if(strlen(gameId) != 11) {
printf("Game-Id muss 11-stellig sein!\n");
help();
exit(EXIT_FAILURE);
}
//optional gewunschte Spielernummer, config Dateiname oder log Level einlesen
while ((ret=getopt(argc, argv, "p:c:l:")) != -1) {
switch (ret) {
case 'p':
player = optarg[0];
if (player!='0' && player != '1') {
printf("Es gibt nur 2 Spieler! 0 oder 1 eingeben!\n");
help();
exit(EXIT_FAILURE);
}
break;
case 'c':
strcpy(confDateiName, optarg);
break;
case 'l':
configstruct.loglevel = atoi(optarg);
break;
default:
help();
exit(EXIT_FAILURE);
}
}
//Shared-Memory erstellen
//shmSegment() um die ID zu erstellen -> vor fork()
int shmid = shmSegment(sizeof(struct shmInfos));
//shmAnbinden(shmid); um es an den Prozess zu binden
shmPtr = shmAnbinden(shmid);
//shm automatisch entfernen, wenn alle prozesse detached sind
shmDelete(shmid);
//Pipe anlegen
int pipe_fd[2];
if(pipe(pipe_fd)<0){
log_printf(LOG_ERROR,"Fehler bei Pipe anlegen");
};
// zweiten Prozess erstellen.
// Connector ist der Kindprozess
// Thinker der Elternprozess
switch (pid = fork ()) {
case -1:
log_printf (LOG_ERROR,"Fehler bei fork()\n");
break;
case 0: // Connector
shmPtr->pid1=pid;
char *getText;
//Verbindung mit Server herstellen
netConnect(configstruct.port, configstruct.hostname);
while (1) {
getText = netReadLine();
if (strncmp(getText, "+ MNM ",6) == 0) {
//+ MNM Gameserver v1.0 accepting connections
sendVersion();
} else if (strncmp(getText, "+ Clie",6) == 0) {
//+ Client version accepted - please send Game-ID to join
sendGameId(gameId);
} else if (strncmp(getText, "+ PLAY",6) == 0) {
//+ PLAYING Quarto
parseGamekind(getText, shmPtr);
sendPlayer(player, shmPtr);
} else if (strncmp(getText, "+ ENDP",6) == 0) {
//+ ENDPLAYERS
//noop
} else if (strncmp(getText, "+ MOVE",6) == 0) {
//+ MOVE 3000
parseMovetimeout(getText, shmPtr);
} else if (strncmp(getText, "+ NEXT",6) == 0) {
//+ NEXT 7
parseNext(getText, shmPtr);
} else if (strncmp(getText, "+ FIEL",6) == 0) {
//+ FIELD 4,4
parseField(getText);
} else if (strncmp(getText, "+ ENDF",6) == 0) {
//+ ENDFIELD
if (shmPtr->gameover != 1) {
sendThinking();
}
} else if (strncmp(getText, "+ OKTH",6) == 0) {
//Hier Zug erhalten und per sendMove(stein, naechsterstein) senden
if(ueberwacheFd(pipe_fd,getText)==1){
log_printf(LOG_DEBUG,"Gandalf hat gesprochen und wurde vor dem ertrinken gerettet!\n");
sendMove(getText);
}
else{
log_printf(LOG_PRINTF,"Gandalf ist ersoffen\n");
}
} else if (strncmp(getText, "+ WAIT",6) == 0) {
//+ WAIT
sendOkwait();
} else if (strncmp(getText, "+ GAME",6) == 0) {
//+ GAMEOVER [[ hh Spielernummer des Gewinners ii hh Spielername des Gewinners ii ]]
shmPtr->gameover = 1;
parseGameover(getText);
} else if (strncmp(getText, "+ QUIT",6) == 0) {
//+ QUIT
netDisconnect();
break;
} else if (strncmp(getText, "-",1) == 0) {
//Well, f**k.
//aufraeumen + signal an parent schicken, damit der sich beendet
netDisconnect();
free(confDateiName);
kill(getppid(),SIGCHLD);
break;
}
}
break;
default: // Thinker
shmPtr->pid0=pid;
//wenn das Signal kommt, dass er denken soll
signal(SIGUSR1, signalHandler);
//wenn das Signal vom Kind kommt, dass er sich beenden soll (wegen Fehler)
signal(SIGCHLD, endHandler);
while (1){
// Auf Signal warten
pause();
log_printf(LOG_DEBUG,"thinker hat fertig gedacht\n");
// In die Pipe schreiben
pipe_write(pipe_fd);
}
if (wait (NULL) != pid) {
log_printf(LOG_ERROR,"Fehler beim Warten auf den Kindprozess\n");
return EXIT_FAILURE;
}
break;
}
return 0;
}
// Processes the commands entered directly in the server, not the chat messages
void Widget::sendCmdLine()
{
if (!enableGameServer)
{
logMessage(QObject::tr("This is not a game server, commands are disabled"));
return;
}
QString str = ui->cmdLine->text();
if (str == "clear")
{
ui->log->clear();
return;
}
else if (str == "stop")
{
delete this;
return;
}
else if (str == "listTcpPlayers")
{
for (int i=0; i<tcpPlayers.size(); i++)
{
Player* p = tcpPlayers[i];
logMessage(p->name+" "+p->IP+":"+QString().setNum(p->port));
}
return;
}
else if (str.startsWith("setPeer"))
{
if (udpPlayers.size() == 1)
{
cmdPeer = udpPlayers[0];
QString peerName = cmdPeer->IP + " " + QString().setNum(cmdPeer->port);
logMessage(QObject::tr("UDP: Peer set to %1").arg(peerName));
return;
}
str = str.right(str.size()-8);
QStringList args = str.split(':');
bool ok;
if (args.size() != 2)
{
if (args.size() != 1)
{
logMessage(QObject::tr("UDP: setPeer takes a pony id or ip:port combination"));
return;
}
quint16 id = args[0].toUInt(&ok);
if (!ok)
{
logMessage(QObject::tr("UDP: setPeer takes a pony id as argument"));
return;
}
for (int i=0; i<udpPlayers.size();i++)
{
if (udpPlayers[i]->pony.id == id)
{
cmdPeer = Player::findPlayer(udpPlayers,udpPlayers[i]->IP, udpPlayers[i]->port);
logMessage(QObject::tr("UDP: Peer set to %1").arg(udpPlayers[i]->pony.name));
return;
}
}
logMessage(QObject::tr("UDP: Peer not found (id %1)").arg(args[0]));
return;
}
quint16 port = args[1].toUInt(&ok);
if (!ok)
{
logMessage(QObject::tr("UDP: setPeer takes a port as argument"));
return;
}
cmdPeer = Player::findPlayer(udpPlayers,args[0], port);
if (cmdPeer->IP!="")
logMessage(QObject::tr("UDP: Peer set to %1").arg(str));
else
logMessage(QObject::tr("UDP: Peer not found (%1)").arg(str));
return;
}
else if (str.startsWith("listPeers"))
{
if (str.size()<=10)
{
for (int i=0; i<win.udpPlayers.size();i++)
win.logMessage(QString().setNum(win.udpPlayers[i]->pony.id)
+" ("+QString().setNum(win.udpPlayers[i]->pony.netviewId)+")"
+" "+win.udpPlayers[i]->pony.name
+" "+win.udpPlayers[i]->IP
+":"+QString().setNum(win.udpPlayers[i]->port)
+" "+QString().setNum((int)timestampNow()-win.udpPlayers[i]->lastPingTime)+"s");
return;
}
str = str.right(str.size()-10);
Scene* scene = findScene(str);
if (scene->name.isEmpty())
win.logMessage(QObject::tr("Can't find scene"));
else
for (int i=0; i<scene->players.size();i++)
win.logMessage(win.udpPlayers[i]->IP
+":"+QString().setNum(win.udpPlayers[i]->port)
+" "+QString().setNum((int)timestampNow()-win.udpPlayers[i]->lastPingTime)+"s");
return;
}
else if (str.startsWith("listVortexes"))
{
for (int i=0; i<scenes.size(); i++)
{
win.logMessage("Scene "+scenes[i].name);
for (int j=0; j<scenes[i].vortexes.size(); j++)
win.logMessage("Vortex "+QString().setNum(scenes[i].vortexes[j].id)
+" to "+scenes[i].vortexes[j].destName+" "
+QString().setNum(scenes[i].vortexes[j].destPos.x)+" "
+QString().setNum(scenes[i].vortexes[j].destPos.y)+" "
+QString().setNum(scenes[i].vortexes[j].destPos.z));
}
return;
}
else if (str.startsWith("sync"))
{
win.logMessage(QObject::tr("UDP: Syncing manually"));
sync.doSync();
return;
}
// DEBUG global commands from now on
else if (str==("dbgStressLoad"))
{
// Send all the players to the GemMines at the same time
for (int i=0; i<udpPlayers.size(); i++)
sendLoadSceneRPC(udpPlayers[i], "GemMines");
return;
}
else if (str.startsWith("dbgStressLoad"))
{
str = str.mid(14);
// Send all the players to the given scene at the same time
for (int i=0; i<udpPlayers.size(); i++)
sendLoadSceneRPC(udpPlayers[i], str);
return;
}
else if (str.startsWith("tele"))
{
str = str.right(str.size()-5);
QStringList args = str.split(' ');
if (args.size() != 2)
{
logStatusMessage(QObject::tr("Error: Usage is tele ponyIdToMove destinationPonyId"));
return;
}
bool ok;
bool ok1;
bool ok2 = false;
quint16 sourceID = args[0].toUInt(&ok);
quint16 destID = args[1].toUInt(&ok1);
Player* sourcePeer;
if (!ok && !ok1)
{
logStatusMessage(QObject::tr("Error: Usage is tele ponyIdToMove destinationPonyId"));
return;
}
for (int i=0; i<udpPlayers.size();i++)
{
if (udpPlayers[i]->pony.id == sourceID)
{
sourcePeer = udpPlayers[i];
ok2 = true;
break;
}
}
if (!ok2)
{
logStatusMessage(QObject::tr("Error: Source peer does not exist!"));
return;
}
for (int i=0; i<udpPlayers.size();i++)
{
if (udpPlayers[i]->pony.id == destID)
{
logMessage(QObject::tr("UDP: Teleported %1 to %2").arg(sourcePeer->pony.name,udpPlayers[i]->pony.name));
if (udpPlayers[i]->pony.sceneName.toLower() != sourcePeer->pony.sceneName.toLower())
sendLoadSceneRPC(sourcePeer, udpPlayers[i]->pony.sceneName, udpPlayers[i]->pony.pos);
else
sendMove(sourcePeer, udpPlayers[i]->pony.pos.x, udpPlayers[i]->pony.pos.y, udpPlayers[i]->pony.pos.z);
return;
}
}
logMessage(QObject::tr("Error: Destination peer does not exist!"));
}
if (cmdPeer->IP=="")
{
logMessage(QObject::tr("Select a peer first with setPeer/listPeers"));
return;
}
else // Refresh peer info
{
cmdPeer = Player::findPlayer(udpPlayers,cmdPeer->IP, cmdPeer->port);
if (cmdPeer->IP=="")
{
logMessage(QObject::tr("UDP: Peer not found"));
return;
}
}
// User commands from now on (requires setPeer)
if (str.startsWith("disconnect"))
{
logMessage(QObject::tr("UDP: Disconnecting"));
sendMessage(cmdPeer,MsgDisconnect, "Connection closed by the server admin");
Player::disconnectPlayerCleanup(cmdPeer); // Save game and remove the player
}
else if (str.startsWith("load"))
{
str = str.mid(5);
sendLoadSceneRPC(cmdPeer, str);
}
else if (str.startsWith("getPos"))
{
logMessage(QObject::tr("Pos : ","Short for position") + QString().setNum(cmdPeer->pony.pos.x)
+ " " + QString().setNum(cmdPeer->pony.pos.y)
+ " " + QString().setNum(cmdPeer->pony.pos.z));
}
else if (str.startsWith("getRot"))
{
logMessage(QObject::tr("Rot : x=","Short for rotation") + QString().setNum(cmdPeer->pony.rot.x)
+ ", y=" + QString().setNum(cmdPeer->pony.rot.y)
+ ", z=" + QString().setNum(cmdPeer->pony.rot.z)
+ ", w=" + QString().setNum(cmdPeer->pony.rot.w));
}
else if (str.startsWith("getPonyData"))
{
logMessage("ponyData : "+cmdPeer->pony.ponyData.toBase64());
}
else if (str.startsWith("sendPonies"))
{
sendPonies(cmdPeer);
}
else if (str.startsWith("sendUtils3"))
{
logMessage(QObject::tr("UDP: Sending Utils3 request"));
QByteArray data(1,3);
sendMessage(cmdPeer,MsgUserReliableOrdered6,data);
}
else if (str.startsWith("setPlayerId"))
{
str = str.right(str.size()-12);
QByteArray data(3,4);
bool ok;
unsigned id = str.toUInt(&ok);
if (ok)
{
logMessage(QObject::tr("UDP: Sending setPlayerId request"));
data[1]=(quint8)(id&0xFF);
data[2]=(quint8)((id >> 8)&0xFF);
sendMessage(cmdPeer,MsgUserReliableOrdered6,data);
}
else
/************************************************************************************
*
* ***********************************************************************************/
IPState ScopeDome::MoveRel(double azDiff)
{
refineMove = false;
return sendMove(azDiff);
}
