int main(int argc, const char * argv[])
{
/*
* Main function, this is what the OS calls when the
* program execution is requested (and on some systems
* after the signature is verified and a sandbox is set
* up). This sets everything up for the game to be playable.
* After everything is set up, it forwards its args to the
* game function and all is good.
*/
//if (streamlib_version != GLOBAL_STREAMLIB_VERSION)
if (!check_version_compadible()) //better method
{
cout << "Error! Streamlib error" << endl;
exit(-1);
}
resizeterm(181, 48);
environment_init(env);
long seed = time(0);
/* BEGIN DEVELOPER MODE CHECK */
if (argc > 1)
{
if (strcmp(argv[1], "developer-mode") == 0)
{
env.developer_mode = true;
devsettings();
if (argc > 2)
{
seed = atol(argv[2]);
}
}
else
{
seed = atol(argv[1]);
}
}
/* END DEVELOPER MODE CHECK */
//clear();
int selection = -1;
while (selection == -1)
selection = displaylauncher(seed);
extern int playernum;
extern char * hostname;
//env.allow_refresh = false;
if (selection == 1)
{
//nothing here... idk why i added this
}
if (selection == 2)
{
env.music = false;
}
if (selection == 1 || selection == 2)
{
int difficulty_selection = 1; //patch for difficulty selections
//while (difficulty_selection < 1 || difficulty_selection > 2)
{
selectdifficulty();
/*cout << "Please select a difficulty:" << endl
<< "1. Normal (1x damage and strength)" << endl
<< "2. Hard (2x damage and strength)" << endl
<< "--> Hard also has around 2.5x more enemies" << endl;
cin >> difficulty_selection;*/
}
env.difficulty = (character::difficulty)(difficulty_selection);
}
if (selection == 3)
{
multiplayer = true;
cout << "Which player are you? (1/2) ";
int player;
cin >> player;
playernum = player;
strcpy(hostname, "localhost");
}
//void main(int argc, char ** argv) {
void TaskKermit(void *pvParameters) // Operate the Kermit Server
{
(void) pvParameters;
int status, rx_len, i, x;
char c;
UCHAR *inbuf;
short r_slot;
parity = P_PARITY; /* Set this to desired parity */
status = X_OK; /* Initial kermit status */
xargc = argc;
xargv = argv;
xname = argv[0];
while (--xargc > 0) { /* Loop through command-line words */
xargv++;
if (**xargv == '-') { /* Have dash */
c = *(*xargv+1); /* Get the option letter */
x = doarg(c); /* Go handle the option */
if (x < 0) doexit(FAILURE);
} else { /* No dash where expected */
fatal("Malformed command-line option: '",*xargv,"'");
}
}
if (!action) /* Nothing to do, give usage message */
usage();
#ifdef DEBUG
debug(DB_LOG,"SIMULATED ERROR RATE:",0,errorrate);
if (errorrate) srand(seed); /* Init random error generator */
#endif /* DEBUG */
/* THE REAL STUFF IS FROM HERE DOWN */
xSerialPrintf_P(PSTR("\r\nFree Heap Size: %u"),xPortGetMinimumEverFreeHeapSize() ); // needs heap_1.c, heap_2.c or heap_4.c
xSerialPrintf_P(PSTR("\r\nKermit HighWater: %u\r\n"), uxTaskGetStackHighWaterMark(NULL));
spiBegin(SDCard); // initialise the SPI bus for Kermit Server SD Card use.
spiSelect (SDCard);
if (!devopen("dummy")) /* Open the communication device */
doexit(FAILURE);
if (!devsettings("dummy")) /* Perform any needed settings */
doexit(FAILURE);
if (db) /* Open debug log if requested */
debug(DB_OPN,"debug.log",0,0);
debug(DB_MSG,"Initializing...",0,0);
/* Fill in parameters for this run */
k.xfermode = xmode; /* Text/binary automatic/manual */
k.remote = remote; /* Remote vs local */
k.binary = ftype; /* 0 = text, 1 = binary */
k.parity = parity; /* Communications parity */
k.bct = (check == 5) ? 3 : check; /* Block check type */
k.ikeep = keep; /* Keep incompletely received files */
k.filelist = cmlist; /* List of files to send (if any) */
k.cancel = 0; /* Not cancelled yet */
/* Fill in the i/o pointers */
k.zinbuf = i_buf; /* File input buffer */
k.zinlen = IBUFLEN; /* File input buffer length */
k.zincnt = 0; /* File input buffer position */
k.obuf = o_buf; /* File output buffer */
k.obuflen = OBUFLEN; /* File output buffer length */
k.obufpos = 0; /* File output buffer position */
/* Fill in function pointers */
k.rxd = readpkt; /* for reading packets */
k.txd = tx_data; /* for sending packets */
k.ixd = inchk; /* for checking connection */
k.openf = openfile; /* for opening files */
k.finfo = fileinfo; /* for getting file info */
k.readf = readfile; /* for reading files */
k.writef = writefile; /* for writing to output file */
k.closef = closefile; /* for closing files */
#ifdef DEBUG
k.dbf = db ? dodebug : 0; /* for debugging */
#else
k.dbf = 0;
#endif /* DEBUG */
/* Force Type 3 Block Check (16-bit CRC) on all packets, or not */
k.bctf = (check == 5) ? 1 : 0;
/* Initialize Kermit protocol */
status = kermit(K_INIT, &k, 0, 0, "", &r);
#ifdef DEBUG
debug(DB_LOG,"init status:",0,status);
debug(DB_LOG,"version:",k.version,0);
#endif /* DEBUG */
if (status == X_ERROR)
doexit(FAILURE);
if (action == A_SEND)
status = kermit(K_SEND, &k, 0, 0, "", &r);
/*
Now we read a packet ourselves and call Kermit with it. Normally, Kermit
would read its own packets, but in the embedded context, the device must be
free to do other things while waiting for a packet to arrive. So the real
control program might dispatch to other types of tasks, of which Kermit is
only one. But in order to read a packet into Kermit's internal buffer, we
have to ask for a buffer address and slot number.
To interrupt a transfer in progress, set k.cancel to I_FILE to interrupt
only the current file, or to I_GROUP to cancel the current file and all
remaining files. To cancel the whole operation in such a way that the
both Kermits return an error status, call Kermit with K_ERROR.
*/
while (status != X_DONE) {
/*
Here we block waiting for a packet to come in (unless readpkt times out).
Another possibility would be to call inchk() to see if any bytes are waiting
to be read, and if not, go do something else for a while, then come back
here and check again.
*/
inbuf = getrslot(&k,&r_slot); /* Allocate a window slot */
rx_len = k.rxd(&k,inbuf,P_PKTLEN); /* Try to read a packet */
debug(DB_PKT,"main packet",&(k.ipktbuf[0][r_slot]),rx_len);
/*
For simplicity, kermit() ACKs the packet immediately after verifying it was
received correctly. If, afterwards, the control program fails to handle the
data correctly (e.g. can't open file, can't write data, can't close file),
then it tells Kermit to send an Error packet next time through the loop.
*/
if (rx_len < 1) { /* No data was read */
freerslot(&k,r_slot); /* So free the window slot */
if (rx_len < 0) /* If there was a fatal error */
doexit(FAILURE); /* give up */
/* This would be another place to dispatch to another task */
/* while waiting for a Kermit packet to show up. */
}
/* Handle the input */
switch (status = kermit(K_RUN, &k, r_slot, rx_len, "", &r)) {
case X_OK:
#ifdef DEBUG
/*
This shows how, after each packet, you get the protocol state, file name,
date, size, and bytes transferred so far. These can be used in a
file-transfer progress display, log, etc.
*/
debug(DB_LOG,"NAME",r.filename ? (char *)r.filename : "(NULL)",0);
debug(DB_LOG,"DATE",r.filedate ? (char *)r.filedate : "(NULL)",0);
debug(DB_LOG,"SIZE",0,r.filesize);
debug(DB_LOG,"STATE",0,r.status);
debug(DB_LOG,"SOFAR",0,r.sofar);
#endif /* DEBUG */
/* Maybe do other brief tasks here... */
continue; /* Keep looping */
case X_DONE:
break; /* Finished */
case X_ERROR:
doexit(FAILURE); /* Failed */
break;
}
}
doexit(SUCCESS);
}
