/*************************************************************************
* This function initializes the random number generator
**************************************************************************/
void InitRandom(int seed)
{
//SEED SET IN R BEFORE CALLING... ALWAYS CHECK THIS FOR DEBUGGING!
//For Debugging:
//seed = -1;
//Temp Disabled for debugging, SWITCH BACK TO PCG FOR FINAL
if (seed == -1)
{
// Seed with a fixed constant, unset for production
pcg32_srandom(42u, 54u);
}
else
{
// Seed with external entropy -- the time and some program addresses
// (which will actually be somewhat random on most modern systems).
// A better solution, entropy_getbytes, using /dev/random, is provided
// in the full library.
pcg32_srandom(seed, seed);
}
/*
if (seed == -1) {
#ifndef __VC__
srand48(7654321L);
#endif
srand(4321);
}
else {
#ifndef __VC__
srand48(seed);
#endif
srand(seed);
}
*/
}
int main(int argc, char** argv)
{
// Read command-line options
int count = atoi(argv[1]);
// use int64_t for Java convenience
int64_t initState = strtoll(argv[2], NULL, 10);
int64_t initSeq = strtoll(argv[3], NULL, 10);
int i;
// In this version of the code, we'll use the global rng, rather than a
// local one.
// You should *always* seed the RNG. The usual time to do it is the
// point in time when you create RNG (typically at the beginning of the
// program).
//
// pcg32_srandom_r takes two 64-bit constants (the initial state, and the
// rng sequence selector; rngs with different sequence selectors will
// *never* have random sequences that coincide, at all) - the code below
// shows three possible ways to do so.
pcg32_srandom((uint64_t) initState, (uint64_t) initSeq);
for (i = 0; i < count; ++i) {
printf("%d\n", (int32_t) pcg32_random());
}
return 0;
}
int main(int argc, char** argv)
{
unsigned long seeds[] = {1, 589494289, 11, 31415, 2415065787, 111111,
589494289+1000, 520326001786743721, 54553810781164123,
845796262492190295, 944310181042360313,
7, 17, 314159265, 271828182845, 0xfffffff};
int seedi = 1;
unsigned long seed;
long inc = 1;
int crush=0;
int smallcrush=1;
int i;
for(i = 1; i < argc; i++ ) {
if (0 == strcmp("--seedi", argv[i])) {
i++;
seedi = atoi(argv[i]);
} else if (0 == memcmp("--seedi=", argv[i], strlen("--seedi="))) {
seedi = atoi(&argv[i][strlen("--seedi=")]);
} else if(0 == strcmp("--smallcrush", argv[i]) ||
0 == strcmp("--smallcrush=true", argv[i])) {
smallcrush=1;
crush=0;
} else if(0 == strcmp("--crush", argv[i]) ||
0 == strcmp("--crush=true", argv[i]) ) {
smallcrush=0;
crush=1;
}
}
seed = seeds[seedi-1];
printf("seed is %lu inc is %lu\n", seed, inc);
pcg32_srandom(seed, inc);
if (smallcrush) run_smallcrush_testu01_uint("PCG-C-32");
if (crush) run_crush_testu01_uint("PCG-C-32");
return 0;
}
int main(int argc, char const * argv[]) {
const char * config_file;
int connection_numer = 0, ret, pid;
short vals[SEM_SIZE] = {1, 1};
key_t key = ftok("database.sql", KEY_ID);
key_t key_db = ftok("database.sql", KEY_DB_ID);
switch(argc) {
case 1: {
config_file = CONFIG_FILE_DEFAULT;
} break;
case 2: {
config_file = argv[1];
} break;
default: {
fprintf(stderr, "Usage: 'server.app [config_file]'.\n");
exit(EXIT_FAILURE);
}
}
pcg32_srandom(time(NULL), (intptr_t)&connection_numer);
server_sems = sem_make(key, SEM_SIZE, vals);
if(server_sems == -1) {
fprintf(stderr, "1 Can't create neccessary data to operate.\n");
exit(EXIT_FAILURE);
}
bettors = mmap(NULL, sizeof(*bettors), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
if(bettors == MAP_FAILED) {
fprintf(stderr, "2 Can't create neccessary data to operate.\n");
exit(EXIT_FAILURE);
}
clients = mmap(NULL, sizeof(*clients), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
if(clients == MAP_FAILED) {
fprintf(stderr, "3 Can't create neccessary data to operate.\n");
exit(EXIT_FAILURE);
}
winner = mmap(NULL, sizeof(*winner) * MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
if(winner == MAP_FAILED) {
fprintf(stderr, "4 Can't create neccessary data to operate.\n");
exit(EXIT_FAILURE);
}
*bettors = 0;
*clients = 0;
memset(winner, 0, sizeof(*winner) * MAX_SIZE);
if(!log_open()) {
fprintf(stderr, "Can't connect logging server.\n");
//exit(EXIT_FAILURE);
}
database = smemory_open(key_db); // TODO: define 8080
if(database == NULL) {
fprintf(stderr, "Can't reach the database.\n");
exit(EXIT_FAILURE);
}
connection = server_open(config_file);
if(connection == NULL) {
fprintf(stderr, "Can't create the main connection.\n");
exit(EXIT_FAILURE);
}
signal(SIGINT, handle_int);
signal(SIGCHLD, handle_int);
while(TRUE) {
connection_t connection_accepted;
connection_accepted = server_accept(connection);
if(connection_accepted == NULL) {
log_send(LEVEL_ERROR, "[MAIN SV] Can't connect to client.");
exit(EXIT_FAILURE); // TODO: Exit?
}
connection_numer++;
(*clients)++;
pid = fork();
if(pid == -1) {
log_send(LEVEL_ERROR, "[MAIN SV] Can't assign resources to client.");
exit(EXIT_FAILURE); // TODO: Exit?
}
if(!pid) { // Child process
// sem_lock(server_sems, 1);
// (*clients)++;
// sem_unlock(server_sems, 1);
server_ajar(connection);
log_send(LEVEL_INFO, "[CHILD SV] Disconnecting main connection.");
ret = handle(connection_accepted);
if(ret == EXIT_FAILURE) {
log_send(LEVEL_ERROR, "[CHILD SV] There was an error handling client.");
}
server_close(connection_accepted);
log_send(LEVEL_INFO, "[CHILD SV] Closed client connection.");
// sem_lock(server_sems, 1);
// (*clients)--;
// sem_unlock(server_sems, 1);
exit(ret);
}
log_send(LEVEL_INFO, "[MAIN SV] Disconnecting new connection.");
server_ajar(connection_accepted);
}
server_close(connection);
if(!db_close(database)) {
log_send(LEVEL_ERROR, "[MAIN SV] Couldn't correctly logout from database.");
}
log_close();
sem_remove(server_sems);
return 0;
}
int main(int argc, char* argv[]) {
char flags = 0;
//char* box;
uint16_t* scr; //also going to store info about whether it's '.' or '*'. 9 bit values dun exist :/ will try doing that later. It's too much butt pain inducing
char* msgbox = NULL;
int bxs = 0;
int bhs[5];
int mv[3];
struct winsize w;
ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
if(argc>1) {
//parse arggggggggggggggggggggsss
int ac;
while((ac = getopt (argc, argv, "hsb:")) != -1) {
switch(ac) {
case 'h':
; //fug you stupid standards
char* ctp = strrchr(argv[0], '/');
if(!ctp)
ctp = argv[0];
else
ctp++;
printf("%s: Generate colorful space in console.\n"
" Optional arguments:\n"
" -s\tSkip generation phase and instantly print out entire space.\n"
" -b\tPrint out floating window with text provided as argument to that option.\n", ctp);
exit(0);
break;
case 's':
flags|=1;
break;
case 'b':
if(!(flags&2)) {
int stl = strlen(optarg);
bxs = (stl > (w.ws_col/2)) ? w.ws_col/2 : stl;
msgbox = malloc((bxs+8)*6+(bxs+6)*3+6*3+5);
bxs += 6;
char* bci = msgbox;
int bcfi = bxs;
strcpy(bci, "┌");
bci+=3;
while(bcfi--) {
strcpy(bci, "─");
bci+=3;
}
strcpy(bci, "┐");
bci+=3;
*(bci++) = '\0';
strcpy(bci, "│");
bci+=3;
bcfi = bxs;
while(bcfi--) {
*(bci++) = ' ';
}
strcpy(bci, "│");
bci+=3;
*(bci++) = '\0';
strcpy(bci, "│");
bci+=3;
bcfi = 3;
while(bcfi--) {
*(bci++) = ' ';
}
strncpy(bci, optarg, bxs-6);
bci+=bxs-6;
bcfi = 3;
while(bcfi--) {
*(bci++) = ' ';
}
strcpy(bci, "│");
bci+=3;
*(bci++) = '\0';
strcpy(bci, "│");
bci+=3;
bcfi = bxs;
while(bcfi--) {
*(bci++) = ' ';
}
strcpy(bci, "│");
bci+=3;
*(bci++) = '\0';
strcpy(bci, "└");
bci+=3;
bcfi = bxs;
while(bcfi--) {
strcpy(bci, "─");
bci+=3;
}
strcpy(bci, "┘");
bci+=3;
*(bci++) = '\0';
bxs += 2;
bhs[0] = bxs*3;
bhs[1] = bxs+4;
bhs[2] = bxs+4;
bhs[3] = bxs+4;
bhs[4] = bxs*3;
//oh god that's looking so awful
}
flags|=2;
break;
case '?':
if (optopt == 'b') {
exit(0);
}
break;
}
}
}
//scr = calloc(((((w.ws_col-1)*(w.ws_row-1))*9)/16)+1, sizeof(uint16_t));
scr = calloc((w.ws_col+2)*(w.ws_row+2), sizeof(uint16_t));
signal(SIGINT, finish);
struct termios new_settings;
tcgetattr(0,&stored_settings);
new_settings = stored_settings;
new_settings.c_lflag &= ~(ECHO | ICANON);
tcsetattr(0,TCSANOW,&new_settings);
pcg32_srandom(time(NULL) ^ (intptr_t)&printf, rand());
int cnt = w.ws_row;
puts("\e[?25l");
while(--cnt) {
putchar('\n');
}
cnt = w.ws_row*w.ws_col/15;
w.ws_col++;
w.ws_row++;
int cpc[4];
while(cnt--) {
cpc[0] = (int)pcg32_boundedrand(w.ws_row);
cpc[1] = (int)pcg32_boundedrand(w.ws_col);
cpc[2] = (int)pcg32_boundedrand(216)+17;
cpc[3] = pcg32_boundedrand(10)?1:0;
*(scr+cpc[1]+cpc[0]*w.ws_col) = cpc[2]|(cpc[3]<<8);
printf("\e[%i;%iH\e[38;5;%im%c", cpc[0], cpc[1], cpc[2], cpc[3] ?'.':'*');
/** Sets an integer as random seed */
void random_seed(int seed)
{
pcg32_srandom((0x853c49e6748fea9bULL ^ seed) | 1, 0xda3e39cb94b95bdbULL);
}
