void HandleWrite() {
char* newFileName;
char logFileName[PATH_MAX];
FILE *fd;
char *buf;
struct stat s;
newFileName = NextToken();
if (!newFileName) return;
sprintf(logFileName, "%s/logs/log_of_stratagus_%d.log", GameName.c_str(), ThisPlayer->Index);
stat(logFileName, &s);
buf = (char*) malloc(s.st_size);
fd = fopen(logFileName, "rb");
fread(buf, s.st_size, 1, fd);
fclose(fd);
fd = fopen(newFileName, "wb");
if (!fd) {
SendResponseMessage("Cannot write to file.\n", 3);
free(buf);
return;
}
fwrite(buf, s.st_size, 1, fd);
fclose(fd);
free(buf);
SendResponseMessage("OK\n", 3);
}
void HandleLispGetMap() {
int i, j;
char buf[MaxMapWidth + 20];
sprintf(buf, "(\n");
SendResponseMessage(buf, 1);
for (i = 0; i < Map.Info.MapHeight; i++) {
buf[0] = '(';
for (j = 0; j < Map.Info.MapWidth; j++) {
if (Map.ForestOnMap(j, i)) {
buf[j + 1] = 'T';
} else if (Map.WaterOnMap(j, i)) {
buf[j + 1] = '^';
} else if (Map.CoastOnMap(j, i)) {
buf[j + 1] = '+';
} else if (Map.HumanWallOnMap(j, i)) {
buf[j + 1] = 'h';
} else if (Map.RockOnMap(j, i)) {
buf[j + 1] = '#';
} else if (Map.WallOnMap(j, i)) {
buf[j + 1] = 'W';
} else if (Map.OrcWallOnMap(j, i)) {
buf[j + 1] = 'c';
} else {
buf[j + 1] = '0';
}
}
sprintf(buf + Map.Info.MapWidth + 1, ")\n");
SendResponseMessage(buf, 0);
}
sprintf(buf, ")\n");
SendResponseMessage(buf, 2);
}
void FindAndGatherResource(CUnit* unit, int resourceType) {
CUnit* dest;
int x, y, result;
switch (resourceType) {
case GoldCost:
dest = UnitFindResource(unit, unit->X, unit->Y, FIND_RESOURCE_RANGE, resourceType);
if (dest != NoUnitP) {
SendCommandResource(unit, dest, 1);
// TODO: don't know what StopResourceFlag corresponds to in 2.2.4 code
// unit->StopResourceFlag = 1;
} else {
SendResponseMessage("Unable to find gold within range.\n", 3);
return;
}
break;
case WoodCost:
result = FindTerrainType(unit->Type->MovementMask, MapFieldForest, 0, FIND_RESOURCE_RANGE, unit->Player, unit->X, unit->Y, &x, &y);
if (result) {
SendCommandResourceLoc(unit, x, y, 1);
// TODO: don't know what StopResourceFlag corresponds to in 2.2.4 code
//unit->StopResourceFlag = 1;
} else {
SendResponseMessage("Unable to find wood within range.\n", 3);
return;
}
break;
default:
SendResponseMessage("Unknown resource type\n", 3);
}
SendResponseMessage("OK\n", 3);
}
// Decide proper action and perform the job.
void Action::TakeAction(){
// Do action following message type
Packet pkt;
std::string result;
std::string temp;
switch(m_GivenPkt.m_MsgType){
case AP_REGISTRATION_REQUEST:
InsertDatabase();
SendResponseMessage(AP_REGISTRATION_RESPONSE, pkt);
break;
//case AP_REGISTRATION_RESPONSE:
//break;
case AP_STATE_UPDATE_REQUEST:
UpdateDatabase();
SendResponseMessage(AP_STATE_UPDATE_RESPONSE, pkt);
break;
//case AP_STATE_UPDATE_RESPONSE:
//break;
case AP_LIST_REQUEST:
result = m_db->GetResult("select ID, IP, SSID from AP_Information;");
//Parse the result by '|' mark
//and make pkt context
while(true)
{
temp = result.substr(0,result.find('|'));
result.erase(0,result.find('|')+1);
pkt.AddValue(AP_ID, temp);
temp = result.substr(0,result.find('|'));
result.erase(0,result.find('|')+1);
pkt.AddValue(AP_IP, temp);
temp = result.substr(0,result.find('|'));
result.erase(0,result.find('|')+1);
pkt.AddValue(AP_SSID, temp);
if(result.length() < 1) break;
}
SendResponseMessage(AP_LIST_RESPONSE, pkt);
break;
default:
break;
}
}
void HandleVideo() {
char* token;
int speedup;
token = NextToken();
if (token) {
speedup = atoi(token);
if (speedup == 0)
SendResponseMessage("Bad or missing argument to Video speedup command.\n", 3);
else {
CyclesPerVideoUpdate = speedup;
SendResponseMessage("OK\n", 3);
}
}
}
void HandleRestart() {
// code from trigger.cpp StopGame().
GameResult = GameRestart;
GamePaused = true;
GameRunning = false;
SendResponseMessage("OK\n", 3);
}
void *RunThreadToCommunicationMessage(void *clientSocketAddress)
{
int clientSocket = *((int *)clientSocketAddress);
char receiveRequestMessageBuffer[BUFFERSIZE];
memset(receiveRequestMessageBuffer,'\0',BUFFERSIZE);
int receiveValue = ReceiveRequestMessage(clientSocket,receiveRequestMessageBuffer);
char requestURL[BUFFERSIZE];
char requestMethod[8];
char environmentVariable[5][1024];
int i = 0 ;
for(i = 0; i< 5;i++)
{
memset(environmentVariable[i],'\0',BUFFERSIZE);
}
memset(requestURL,'\0',BUFFERSIZE);
memset(requestMethod, '\0', 8);
//i is index of message length for bad request.
int messageLength = ParseRequestMessage(clientSocket,receiveRequestMessageBuffer, requestURL, requestMethod,environmentVariable);
printf("#2 method %s, URI %s\n",requestMethod, requestURL);
int sendMessageState = SelectSendState(requestMethod,requestURL,messageLength);//,environmentVariable);
printf("!! requestURL %s , requestMethod %s \n",requestURL,requestMethod);
////// send packetMessage
SendResponseMessage(clientSocket, sendMessageState, requestURL,environmentVariable);
if(receiveValue < BUFFERSIZE) // it tererble thing . im not want if!
{
close(clientSocket);
}
}
void HandleRandomSeed() {
char* token;
token = NextToken();
if (token) {
srand(atoi(token));
SendResponseMessage("OK\n", 3);
}
}
void HandleSpeed() {
char* token = NextToken();
if (token) {
int speedup = atoi(token);
if (speedup == 0)
SendResponseMessage("Bad or missing argument to Game Speed command.\n", 3);
else {
if (speedup == -1)
WarpSpeed = 1;
else {
WarpSpeed = 0;
EnforcedVideoSyncSpeed = speedup;
VideoSyncSpeed = EnforcedVideoSyncSpeed;
SetVideoSync();
}
SendResponseMessage("OK\n", 3);
}
}
}
void ReturnResource(CUnit* unit) {
CUnit* dest;
if (unit->CurrentResource == 0 || unit->ResourcesHeld == 0) {
SendResponseMessage("Unit has no resources to return.\n", 3);
return;
}
dest = FindDeposit(unit, unit->X, unit->Y, FIND_RESOURCE_RANGE, unit->CurrentResource);
if (dest != NoUnitP) {
SendCommandReturnGoods(unit, dest, 1);
// TODO: don't know what StopResourceFlag corresponds to in 2.2.4 code
// unit->StopResourceFlag = 1;
} else {
SendResponseMessage("Unable to find location to return resource within range.\n", 3);
return;
}
SendResponseMessage("OK\n", 3);
}
void HarvestResAtLoc(int resourceType, int x, int y) {
CUnit *unit;
CUnit *dest;
if (resourceType == GoldCost || resourceType == OilCost) {
dest = UnitFindResource(unit, x, y, FIND_RESOURCE_RANGE, resourceType);
if (dest != NoUnitP) {
SendCommandResource(unit, dest, 1);
} else {
SendResponseMessage("Unable to find resource in range.\n", 3);
return;
}
} else if (resourceType == WoodCost) {
SendCommandResourceLoc(unit, x, y, 1);
} else {
SendResponseMessage("Unknown resource type\n", 3);
return;
}
SendResponseMessage("OK\n", 3);
}
void HandleLispGetState() {
int i;
char buf[256];
int status;
char argsbuf[80];
sprintf(buf, "((\n"); // begin units list
SendResponseMessage(buf, 1);
for (i = 0; i < NumUnits; ++i) {
// Unit is dying when its action is UnitActionDie. It may still have
// hit points left as its corpse decays on the battlefield. We
// mark the hit points as 0 to indicate that the unit is dead.
//
// See unit.cpp LetUnitDie():
// unit->Orders[0]->Action = UnitActionDie;
//
int hp = Units[i]->Variable[HP_INDEX].Value;
if (Units[i]->Orders[0]->Action == UnitActionDie ||
Units[i]->Destroyed) {
hp = 0;
}
status = GetUnitStatus(Units[i], argsbuf); // UnitVisibleOnMap(Units[i], ThisPlayer)
sprintf(buf, "( %d . #s(unit player-id %d type %d loc (%d %d) hp %d r-amt %d kills %d status %d status-args (%s)))\n",
UnitNumber(Units[i]),
Units[i]->Player->Index,
GetUnitTypeNum(Units[i]->Type),
Units[i]->X,
Units[i]->Y,
hp,
Units[i]->ResourcesHeld,
Units[i]->Variable[KILL_INDEX].Value,
status,
argsbuf);
SendResponseMessage(buf, 0);
}
sprintf(buf, ") #S(global-state :gold %d :wood %d :oil %d :supply %d :demand %d))\n",
ThisPlayer->Resources[GoldCost], ThisPlayer->Resources[WoodCost], ThisPlayer->Resources[OilCost], ThisPlayer->Supply, ThisPlayer->Demand);
SendResponseMessage(buf, 2);
}
void HandleTransition() {
GamePaused = false;
char* token = NextToken();
if (token) {
unsigned num_cycles = (unsigned) atoi(token);
if (num_cycles == 0)
SendResponseMessage("Bad or missing argument to Transition command.\n", 3);
else {
GameCyclesPerTransition = num_cycles;
}
}
}
void HandleGet() {
int i;
char buf[256];
sprintf(buf, "Units: %d\n", NumUnits);
SendResponseMessage(buf, 1);
for (i = 0; i < NumUnits; ++i) {
if (Units[i]->Orders[0]->Goal) {
sprintf(buf, "Unit %d, Slot %d, Player %d: %s (%d, %d) HP: %d/%d ACTION: (%d Goal: %d (%d, %d))\n",
UnitNumber(Units[i]),
Units[i]->Slot,
Units[i]->Player->Index,
Units[i]->Type->Ident.c_str(),
Units[i]->X,
Units[i]->Y,
Units[i]->Variable[HP_INDEX].Value,
Units[i]->Stats->Variables[HP_INDEX].Value,
Units[i]->Orders[0]->Action,
UnitNumber(Units[i]->Orders[0]->Goal),
Units[i]->Orders[0]->Goal->X,
Units[i]->Orders[0]->Goal->Y);
} else {
sprintf(buf, "Unit %d, Slot %d, Player %d: %s (%d, %d) HP: %d/%d ACTION: %d\n",
UnitNumber(Units[i]),
Units[i]->Slot,
Units[i]->Player->Index,
Units[i]->Type->Ident.c_str(),
Units[i]->X,
Units[i]->Y,
Units[i]->Variable[HP_INDEX].Value,
Units[i]->Stats->Variables[HP_INDEX].Value,
Units[i]->Orders[0]->Action);
}
SendResponseMessage(buf, 0);
}
sprintf(buf, "Map Size: %dx%d\n", Map.Info.MapWidth, Map.Info.MapHeight);
SendResponseMessage(buf, 2);
}
void HandleLispGet() {
char* token = NextToken();
if (token == NULL) {
SendResponseMessage("Bad command.\n", 3);
return;
}
switch (token[0]) {
case 'G': // LISPGET GAMEINFO
case 'g':
HandleLispGetGameInfo();
break;
case 'M': // LISPGET MAP
case 'm':
HandleLispGetMap();
break;
case 'S': // LISPGET STATE
case 's':
HandleLispGetState();
break;
default:
SendResponseMessage("Unknown LISPGET argument.\n", 3);
}
}
/**
* Return game activity state: waiting, running, paused, or game over.
*/
void HandleActivity() {
char buf[32];
if (GamePaused) {
// GamePaused defined in interface.h/interface.cpp
sprintf(buf, "GAME PAUSED\n");
} else if (GameRunning) {
// GamePaused defined in interface.h/interface.cpp
sprintf(buf, "GAME RUNNING\n");
} else if (GameResult == GameNoResult) {
sprintf(buf, "GAME WAITING\n");
} else {
sprintf(buf, "GAME OVER\n"); // see results.h for results
}
SendResponseMessage(buf, 3);
}
void CheckForConnection() {
Socket newSocket = NetAcceptTCP(listeningSocket);
if (newSocket != INVALID_SOCKET) {
if (connected) {
SendResponseMessage("New connection made. Goodbye.\n", 3);
NetCloseTCP(interfaceSocket);
}
interfaceSocket = newSocket;
DebugPrint("Established socket interface connection to %d.%d.%d.%d port %d\n" _C_ NIPQUAD(ntohl(NetLastHost)) _C_ NetLastPort);
NetSetNonBlocking(interfaceSocket);
connected = true;
}
}
char HandleNewMap() {
char* token;
token = NextToken();
if (token) {
GameResult = GameRestart;
GamePaused = true;
GameRunning = false;
strcpy(CurrentMapPath, token);
fprintf(stderr, "new map is '%s'\n", CurrentMapPath);
SendResponseMessage("OK\n", 3);
return 1;
}
return 0;
}
void HandlePing() {
SendResponseMessage("PING\n", 3);
}
void HandleGetCycle() {
char buf[32];
sprintf(buf, "%ld\n", GameCycle);
SendResponseMessage(buf, 3);
}
void HandleRequest() {
char* token;
short keep_processing = 1;
int offset;
DebugPrint("Received request %s" _C_ recv_buffer);
token = FirstToken();
while (token != 0 && keep_processing) {
switch (to_request(token)) {
case ACTIVITY:
HandleActivity();
break;
case COMMAND: // COMMAND
HandleCommand();
break;
case EXIT: // EXIT
HandleQuit();
break;
case GET: // GET
HandleGet();
break;
case KILL:
HandleKill();
break;
case LISPGET: // LISPGET {STATE | GAMEINFO | MAPINFO}
HandleLispGet();
break;
case MAP: // Load new map
if (HandleNewMap()) {
LastPausedCycle = 0;
keep_processing = 0;
}
break;
case PING: // PING
HandlePing();
break;
case QUIT: // QUIT
HandleQuit();
break;
case RESTART: // RESTART / RESET
HandleRestart();
LastPausedCycle = 0;
keep_processing = 0;
break;
case SPEED: // SPEED
HandleSpeed();
break;
case TRANSITION: // TRANSITION
HandleTransition();
keep_processing = 0;
break;
case VIDEO: // VIDEO
HandleVideo();
break;
case WRITE:
HandleWrite();
break;
case CYCLE:
HandleGetCycle();
break;
case Z:
HandleRandomSeed();
break;
default:
SendResponseMessage("Unknown command.\n", 3);
}
token = NextToken();
}
// Bring pending commands to the front of recv_buffer
if (token != 0) {
offset = token + strlen(token) - temp_buffer;
temp_buffer[offset] = recv_buffer[offset];
strcpy(recv_buffer, token);
} else
memset(recv_buffer, 0, RECV_BUFFER_SIZE); // Clear the command buffer
}
void HandleCommand() {
char* token;
int unitID;
CUnit* unit;
int actionID;
int resourceType;
int x, y;
char* typeID;
CUnitType* type;
int destID;
CUnit* dest;
token = NextToken();
if (!token) return;
unitID = atoi(token);
unit = GetUnitByID(unitID);
if (!unit) {
SendResponseMessage("Unknown unit.\n", 3);
return;
}
token = NextToken();
if (!token) return;
actionID = atoi(token);
switch (actionID) {
case 0: // NOOP
// SendResponseMessage("OK\n", 3);
break;
case 1: // STOP
SendCommandStopUnit(unit);
// SendResponseMessage("OK\n", 3);
break;
case 2: // MoveTo <X> <Y>
token = NextToken();
if (token == NULL) {
SendResponseMessage("Bad arguments to Move Action.\n", 3);
return;
}
x = atoi(token);
token = NextToken();
if (token == NULL) {
SendResponseMessage("Bad arguments to Move Action.\n", 3);
return;
}
y = atoi(token);
SendCommandMove(unit, x, y, 1);
// SendResponseMessage("OK\n", 3);
break;
case 3: // Build <Type> <X> <Y>
token = NextToken();
if (token == NULL) {
SendResponseMessage("Bad arguments to Build Action.\n", 3);
return;
}
typeID = token;
type = UnitTypeByIdent(typeID);
if (type == NULL) {
SendResponseMessage("Unknown type to build.\n", 3);
return;
}
// If it's a building, train the unit.
if (unit->Type->Building)
SendCommandTrainUnit(unit, type, 1);
else // otherwise, build a building.
{
token = NextToken();
if (token == NULL) {
SendResponseMessage("Bad arguments to Build Action.\n", 3);
return;
}
x = atoi(token);
token = NextToken();
if (token == NULL) {
SendResponseMessage("Bad arguments to Build Action.\n", 3);
return;
}
y = atoi(token);
SendCommandBuildBuilding(unit, x, y, type, 1);
}
SendResponseMessage("OK\n", 3);
break;
case 4: // Attack <UnitID>
token = NextToken();
if (!token) return;
destID = atoi(token);
dest = GetUnitByID(destID);
if (!dest) {
SendResponseMessage("Unknown unit to attack.\n", 3);
return;
}
SendCommandAttack(unit, 0, 0, dest, 1);
SendResponseMessage("OK\n", 3);
break;
case 5: // Repair <UnitID>
token = NextToken();
if (!token) return;
destID = atoi(token);
dest = GetUnitByID(destID);
if (!dest) {
SendResponseMessage("Unknown unit to repair.\n", 3);
return;
}
SendCommandRepair(unit, 0, 0, dest, 1);
SendResponseMessage("OK\n", 3);
break;
case 6: // Harvest <ResourceType>
token = NextToken();
if (!token) return;
resourceType = atoi(token); // GOLD = 1, WOOD = 2
FindAndGatherResource(unit, resourceType);
break;
case 7: // Return resource
ReturnResource(unit);
break;
case 8: // Harvest unit (gold/oil) <DestUnit>
token = NextToken();
if (!token) {
SendResponseMessage("Invalid harvest argument.\n", 3);
return;
}
destID = atoi(token);
dest = GetUnitByID(destID);
if (dest == NoUnitP) {
SendResponseMessage("Invalid resource unit ID.\n", 3);
return;
}
SendCommandResource(unit, dest, 1);
SendResponseMessage("OK\n", 3);
break;
case 9: // Harvest terrain (wood) <X> <Y>
token = NextToken();
if (!token) {
SendResponseMessage("Invalid harvest argument.\n", 3);
return;
}
x = atoi(token);
token = NextToken();
if (!token) {
SendResponseMessage("Invalid harvest argument.\n", 3);
return;
}
y = atoi(token);
SendCommandResourceLoc(unit, x, y, 1);
SendResponseMessage("OK\n", 3);
break;
case 10: // Harvest location <ResourceType> <X> <Y>
token = NextToken();
if (!token) {
SendResponseMessage("Invalid harvest argument.\n", 3);
return;
}
resourceType = atoi(token); // GOLD = 1, WOOD = 2
token = NextToken();
if (!token) {
SendResponseMessage("Invalid harvest argument.\n", 3);
return;
}
x = atoi(token);
token = NextToken();
if (!token) {
SendResponseMessage("Invalid harvest argument.\n", 3);
return;
}
y = atoi(token);
HarvestResAtLoc(resourceType, x, y);
break;
default:
SendResponseMessage("Unknown command.\n", 3);
return;
}
}
void HandleLispGetGameInfo() {
char buf[256];
sprintf(buf, "#s(gameinfo player-id %d width %d length %d)\n", ThisPlayer->Index, Map.Info.MapWidth, Map.Info.MapHeight);
SendResponseMessage(buf, 3);
}
void HandleQuit() {
SendResponseMessage("BYE\n", 3);
connected = false;
NetCloseTCP(interfaceSocket);
}
