int double_queue_init_err(double_queue_t *q, int owner, key_t key1, key_t key2, int flags1, int flags2, int(*error_f)(void*), void *error_a) {
q->owner = owner;
q->id1 = q->id2 = -1;
q->id1 = msgget(key1, flags1);
if(q->id1 == -1) {
error("Creation of message queue failed.");
return error_f(error_a);
}
q->id2 = msgget(key2, flags2);
if(q->id2 == -1) {
error("Creation of message queue failed.");
return error_f(error_a);
}
return 0;
}
static Value
_lib_char_code_at(VMState *vm, Value value)
{
Hash *args = value_to_ptr(value);
CString *string = value_to_string(hash_find(args, 1));
int index = value_to_int(hash_find(args, 2));
if (index < 0 || index >= string->length) {
error_f("Out of range when get char_at(%.*s, %d)", string->length, string->content, index);
return value_undefined();
}
return value_from_int(string->content[index]);
}
void
print_error_ovh(int priority, int instruction, int error_type, const char *message, ...) {
va_list az;
va_start(az, message);
if(i_syslog_ovh == 1)
log_error(priority, instruction, error_type, message, az);
else
error_f(instruction, error_type, message, az);
va_end(az);
return;
}
int
dprintf(int s, char *fmt, ...) {
char *buffer;
int n;
va_list va;
va_start(va, fmt);
n = vsprintf(NULL, fmt, va);
if(n > MAXLEN)
error_f(EXIT, STANDARD, "dprintf() failed: string is too long");
if((buffer = (char *)malloc((n+1) * sizeof(char))) == NULL)
error_f(EXIT, PERROR, "malloc() failed");
(void)vsnprintf(buffer, n, fmt, va);
*(buffer+n) = '\0';
va_end(va);
if(write(s, buffer, n) == -1)
n = -1;
free(buffer);
return n;
}
void errors_to_stdio(gsl_vector *solution,
double x1, double x2,
double y1, double y2)
{
double hx = (x2-x1)/64.,
hy = (y2-y1)/64.,
i,j,maxerr=0.,err;
for(i=x1; i<=x2; i+=hx)
for(j=y1; j<=y2; j+=hy)
if((err = error_f(i,j))>maxerr) maxerr = err;
printf("%d %g %f %f %e\n",N*N,intStep,
maxerr,
error_L1(error_f,x1,x2,y1,y2),
error_L2(error_f,x1,x2,y1,y2));
}
static Value
_lib_char_at(VMState *vm, Value value)
{
Hash *args = value_to_ptr(value);
CString *string = value_to_string(hash_find(args, 1));
int index = value_to_int(hash_find(args, 2));
if (index < 0 || index >= string->length) {
error_f("Out of range when get char_at(%.*s, %d)", string->length, string->content, index);
return value_undefined();
}
char buffer[2];
buffer[0] = string->content[index];
buffer[1] = 0;
return cvm_get_cstring_value(vm, buffer);
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int)
{
// Init globals from config file
Gbls::initFromConfig();
// Create window
if(D3DWindow::Create(hInstance))
{
//init space
if(SUCCEEDED(GameResources::initState())) {
ofstream error_f("client_error.log");
cerr.rdbuf(error_f.rdbuf());
GameInput input;
GameResources::input = &input;
#ifndef MYNETWORKOFF // defined in Gbls
//networking init
int c_port = DEFAULT_PORT-1;
ConfigSettings::config->getValue("network_clientPort", c_port);
NetworkClient nc(c_port);
int s_port = DEFAULT_PORT;
ConfigSettings::config->getValue("network_serverPort", s_port);
string server_ip = "127.0.0.1";
ConfigSettings::config->getValue("network_serverIP", server_ip);
try {
nc.bindToServer(server_ip, (unsigned short) s_port);
GameResources::playerNum = nc.getClientID();
} catch (runtime_error &e) {
cerr << e.what() << endl;
bool exception_occured_check_error_log = false;
assert(exception_occured_check_error_log);
}
#else
MessageBox( NULL, L"Network not enabled.\nRecompile with MYNETWORKOFF undefined to enable.", L"CRUSH.exe", MB_OK );
#endif
// Main loop
MSG msg;
//for checking fps
//DWORD startTime = timeGetTime();
//DWORD count = 0;
GameState<Entity> newGameState;
float framesRendered = 0.0f;
float updatesReceived = 0.0f;
for(;;) // "forever"
{
input.refreshState();
input.vibrateThrust(input.input.thrust);
//for checking fps
//count++;
//if(!(count%600)) {
// DWORD x = count / ((timeGetTime() - startTime)/1000.0);
// std::stringstream os;
// os << "FPS:" << x;
// string s =os.str();
// std::wstring wsTmp(s.begin(), s.end());
// MessageBox( NULL, wsTmp.c_str(), wsTmp.c_str(), MB_OK );
//}
#ifndef MYNETWORKOFF // defined in Gbls
try {
if (!GameResources::debugCamOn) {
nc.sendToServer(&(input.input));
}
} catch (runtime_error &e) {
cerr << e.what() << endl;
bool exception_occured_check_error_log = false;
assert(exception_occured_check_error_log);
}
// Get game state from network
if(nc.newStateAvailable()) {
try{
newGameState = nc.getGameState();
updatesReceived++;
} catch (runtime_error &e) {
cerr << e.what() << endl;
bool exception_occured_check_error_log = false;
assert(exception_occured_check_error_log);
}
}
#endif
framesRendered++;
Gbls::percentMissedFrames = framesRendered - updatesReceived;
// Process all pending window messages
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
GameResources::updateGameState(newGameState);
// Render
if(D3DWindow::Tick())
break;
}
}
}
D3DWindow::Destroy();
// See if there's any error messsage pending
const std::wstring& strError = D3DWindow::GetError();
if(!strError.empty())
{
MessageBox(NULL, strError.c_str(), L"Error", MB_OK | MB_ICONERROR);
}
return 0;
}
// Query - sends query and waits for result (client side)
int double_queue_query_err(
double_queue_t *q,
void * query, size_t query_length,
void ** result, size_t *result_length,
int *exit_after_signal,
long source, long destination,
int (*error_f)(void*), void *error_a) {
// Parameter checks
if(query_length > 1024 /* maksymalna długość komunikatu */) {
error("Too long message.");
return error_f(error_a);
}
// Prepare query
void * real_query = NULL;
size_t real_query_length;
char * res = NULL;
char * answer_buffer = malloc(1024+sizeof(long));
if(answer_buffer == NULL)
goto allocation_failed;
if(combine(&real_query, &real_query_length, "%l %b %l", destination, query, query_length, source) != 0)
goto allocation_failed;
// Send query
resend:
if(msgsnd(q->id1, real_query, real_query_length - sizeof(long), 0) == -1) {
if(errno == EINTR) {
log("Interrupted during waiting...");
if(*exit_after_signal) {
free(real_query);
free(answer_buffer);
return DOUBLE_QUEUE_INTERRUPTED;
} else {
goto resend;
}
}
errorp();
free(real_query);
free(answer_buffer);
return error_f(error_a);
}
free(real_query);
// Wait for result
int ret;
rerecv:
ret = msgrcv(q->id2, answer_buffer, 1024+sizeof(long) /* nie potrzebujemy adresu zwrotnego */, source, 0);
if(ret == -1 && errno == EINTR) {
log("Message receiving interrupted.");
if(*exit_after_signal) {
free(answer_buffer);
return DOUBLE_QUEUE_INTERRUPTED;
} else {
goto rerecv;
}
}
if(ret == -1 || ret == 0) {
errorp();
free(answer_buffer);
return error_f(error_a);
}
res = malloc(ret);
if(res == NULL)
goto allocation_failed;
memcpy(res, answer_buffer+sizeof(long), ret);
(*result) = res;
(*result_length) = ret;
free(answer_buffer);
return 0;
allocation_failed:
if(real_query) free(real_query);
if(answer_buffer) free(answer_buffer);
if(res) free(res);
error("Allocation failed.");
return error_f(error_a);
}
// Listen - receives query and sends result (server side)
int double_queue_listen_err(
double_queue_t *q,
int (*server)(void *, size_t, void **, size_t *, int, void*),
void *arg, int *exit_after_signal,
int destination,
int (*error_f)(void*), void *error_a) {
// Prepare buffers
void *response = NULL;
size_t response_length;
unsigned char * response_buffer = NULL;
void * query = NULL;
query = malloc(1024+2*sizeof(long) /* message + source */);
if(query == NULL) goto allocation_failed;
// Receive
int ret;
rerecv:
ret = msgrcv(q->id1, query, 1024+2*sizeof(long), destination, 0);
if(ret == -1 && errno == EINTR) {
log("Message receiving interrupted.");
if(*exit_after_signal) {
free(query);
return DOUBLE_QUEUE_INTERRUPTED;
} else {
goto rerecv;
}
}
if(ret == -1 || ret < sizeof(long)) {
error("Message received failed.");
free(query);
return error_f(error_a);
}
long source = 0;
ret -= sizeof(long);
memcpy(&source, query + ret + sizeof(long), sizeof(long));
if(server(query+sizeof(long), ret, &response, &response_length, source, arg) == -1) {
error("Server procedure failed.");
free(query);
if(response != NULL) free(response);
return error_f(error_a);
}
if(response_length > 1024) {
error("Response is too long.");
free(query);
free(response);
return error_f(error_a);
}
if(response == NULL) {
error("No response");
free(query);
free(response);
return error_f(error_a);
}
response_buffer = malloc(1024 + sizeof(long) /* address + body */);
if(response_buffer == NULL)
goto allocation_failed;
memcpy(response_buffer, &source, sizeof(long));
memcpy(response_buffer + sizeof(long), response, response_length);
resend:
if(msgsnd(q->id2, response_buffer, response_length, 0) == -1) {
if(errno == EINTR) {
log("Message sending interrupted.");
if(*exit_after_signal) {
free(query);
free(response);
free(response_buffer);
return DOUBLE_QUEUE_INTERRUPTED;
} else {
goto resend;
}
} else {
error("Sending of data failed.");
free(query);
free(response);
free(response_buffer);
return error_f(error_a);
}
}
free(response);
free(response_buffer);
free(query);
return 0;
allocation_failed:
error("Allocation failed.");
if(query) free(query);
if(response) free(response);
if(response_buffer) free(response_buffer);
return error_f(error_a);
}
