Beispiel #1
0
void CommandProcessor::customEvent(QEvent* e) {
  if (e->type() == 10000) {
    // EngineEvent
    return ;

  }
  else if (e->type() == 10001) {
    MClientEvent* me = static_cast<MClientEvent*>(e);
    
    if(me->dataTypes().contains("XMLAll")) {
      emit parseMudOutput(me->payload()->toString(),
			  me->dataTypes());

    } else if (me->dataTypes().contains("UserInput")) {
      emit parseUserInput(me->payload()->toString());

    } else if (me->dataTypes().contains("SocketConnected")) {
      emit socketOpen(true);

    } else if (me->dataTypes().contains("SocketDisconnected")) {
      emit socketOpen(false);

    } else if (me->dataTypes().contains("UnlockProcessor")) {
      qDebug() << "* got UNLOCK message";
      _task->_semaphore.release();

    }
  }
}
int main(int argc, char *argv[]){
	sleepy = argc != 1? 0 : 1;//So that if a machine is playing, sleeps can be removed
	struct timespec delayTime;//
	delayTime.tv_sec = 0;//These three lines create something that nanosleep can use to sleep. Details can be changed to change sleep time
	delayTime.tv_nsec = 500*1000*1000;//Starting at 500,000,000 nanoseconds (0.5s). Can be reassigned.
	puts("This is an in-development version. The treasure and traps are always visible.");
	char dungeon[DUNGEON_X][DUNGEON_Y];
	uint8_t playerPos[2] = {1, 1};//Starting position for the player
	uint8_t playing = 1; //So we don't instantly exit
	uint8_t monsterPos[2] = {2, 2}; //Starting monster position - randomisation incoming
	uint8_t awake = 0; //The monster starts invisible. This doubles as 'is the monster active?'
	uint8_t trapPos[2][2] = {{1, 2}, {3, 5}}; //Two traps to wake the monster - will be randomised
	uint8_t treasurePos[2] = {2, 1}; //The treasure was once in the same place as the monster. Randomisation will need to ensure that this is never the case
	setUpDungeon(&dungeon, playerPos, trapPos, monsterPos, treasurePos);//Because setUpDungeon takes a pointer, and a bunch of positions to tell it where stuff goes
	//validateDungeon(&dungeon);//As does validateDungeon. Commented because reasons
	if (sleepy) nanosleep(&delayTime, NULL);//Wait a moment
	while(playing){//If you're not playing anymore, the game really ought to end
		system("clear");//We are now officially *NIX specific
		uint8_t isValidCommand = 0;//So that if the input is invalid, it can be ignored and retried without redrawing
		uint8_t ignoreNext = 0;//For invalid strings, helps prevent ignorance of next valid input
		int8_t parseReturn;
		setUpDungeon(&dungeon, playerPos, trapPos, monsterPos, treasurePos);//Because setUpDungeon takes a pointer to a char[][]
										    //and a bunch of positions so that all things are in their rightful places
		drawDungeon(&dungeon, playerPos, trapPos, monsterPos, awake, treasurePos);//drawDungeon must know all things' positions
		printPrompt(&dungeon, awake, playerPos, trapPos, monsterPos, treasurePos);
		char text[3];//Command char, \n and \0
		while(!isValidCommand){
			fgets(text, 3, stdin);//Technically, this reads a file. stdin is a file, though. Uses a pointer, the number of characters you want and file
			if((text[1] == '\n' && text[2] == '\0') || text[1] == '\0'){//If the only input characters are the command, \n and EOF, or the command is \nEOF
									//in the event that the previous command was invalid and of the correct length type.
									//Rejects strings terminated with ^D but no \n, and glitches out, but that's not the kind of thing
				if(ignoreNext || text[0] == '\n'){	//any normal person would be inputting, anyway. Machines will learn what constitutes valid, too
					ignoreNext = 0;
				}
				else{
					parseReturn = parseUserInput(&dungeon, text[0], &playerPos, &awake, &trapPos);
					isValidCommand = parseReturn == 1? 1 : 0;
				}
			}
			else{
				if(!ignoreNext){
				puts("Invalid command.");
				ignoreNext = 1;
				if (sleepy) nanosleep(&delayTime, NULL);
				}
			}
		}
		if (sleepy) nanosleep(&delayTime, NULL);
		doMonsterMove(&dungeon, playerPos, &monsterPos, &playing);
	}
	return 0;
}
Beispiel #3
0
int main(int argc, char *args)
{
	struct termios newTermio;
	struct termios storedTermio;
	bool running = true;
	char choice[8] = {0};
	int count = 0;
	
	tcgetattr(0,&storedTermio);
	memcpy(&newTermio,&storedTermio,sizeof(struct termios));
	
	// Disable canonical mode, and set buffer size to 0 byte(s)
	newTermio.c_lflag &= (~ICANON);
	newTermio.c_lflag &= (~ECHO);
	newTermio.c_cc[VTIME] = 0;
	newTermio.c_cc[VMIN] = 1;
	tcsetattr(0,TCSANOW,&newTermio);

	printf("\nOpenJAUS Node Manager Version %s (%s)\n\n", OJ_NODE_MANAGER_VERSION, __DATE__); 

	FileLoader *configData = new FileLoader("nodeManager.conf");
	MyHandler *handler = new MyHandler();

	nm = new NodeManager(configData, handler);
	printHelpMenu();
	
	while(running)
	{
		bzero(choice, 8);
		count = read(0, &choice, 8);
		//printf("%d %d %d %d %d %d %d %d %d\n", count, choice[0], choice[1], choice[2], choice[3], choice[4], choice[5], choice[6], choice[7]);
		if(count == 1 && choice[0] == 27) // ESC
		{
			running = false;
		}
		else if(count == 1)
		{
			parseUserInput(choice[0]);
		}
	}

	tcsetattr(0, TCSANOW, &storedTermio);
	return 0;
}
Beispiel #4
0
void Game::run() {

	/*TODO:The timer should be an object, Game::run should not call
	 * sdl functions directly
	 */

	LCVAR_Event gameEvent;
	gameEvent.type = NOTHING;
	int startTicks = 0;

	//TODO: Clean this up, do not hardcode
	turn = WHITE;

	bool gameEnd = false;
	short errorCode = 0;

	//TODO: Don't hardcode these settings
	engine->init(32, 600, 600, ".", errorCode);

	handleErrors(errorCode);

	drawEverything();
	refreshScreen();

	while (!gameEnd){

		getEvent(gameEvent);

		if(gameEvent.type == QUIT){

			gameEnd = true;

		}else if (gameEvent.type == MOVE){
			parseUserInput(gameEvent);
		}

		drawEverything();
		refreshScreen();

		gameEvent.type = NOTHING;

	}

}
void QgsAdvancedDigitizingDockWidget::lockConstraint( bool activate /* default true */ )
{
  CadConstraint *constraint = objectToConstraint( sender() );
  if ( !constraint )
  {
    return;
  }

  if ( activate )
  {
    QString textValue = constraint->lineEdit()->text();
    if ( !textValue.isEmpty() )
    {
      bool ok;
      double value = parseUserInput( textValue, ok );
      if ( ok )
      {
        constraint->setValue( value );
      }
      else
      {
        activate = false;
      }
    }
    else
    {
      activate = false;
    }
  }
  constraint->setLockMode( activate ? CadConstraint::HardLock : CadConstraint::NoLock );

  if ( activate )
  {
    // deactivate perpendicular/parallel if angle has been activated
    if ( constraint == mAngleConstraint.get() )
    {
      lockAdditionalConstraint( NoConstraint );
    }

    // run a fake map mouse event to update the paint item
    emit pointChanged( mCadPointList.value( 0 ) );
  }
}
void QgsAdvancedDigitizingDockWidget::updateConstraintValue( CadConstraint *constraint, const QString &textValue, bool convertExpression )
{
  if ( !constraint || textValue.isEmpty() )
  {
    return;
  }

  if ( constraint->lockMode() == CadConstraint::NoLock )
    return;

  bool ok;
  double value = parseUserInput( textValue, ok );
  if ( !ok )
    return;

  constraint->setValue( value, convertExpression );
  // run a fake map mouse event to update the paint item
  emit pointChanged( mCadPointList.value( 0 ) );
}
/**
 * Application entry point. Configures the peripherals and starts the echo 
 * server.
 * 
 * For a description of parameters, please refer to the file description.
 * 
 * \return 0 if successful, -1 in case of any error.
 */
int	main(int argc, char *argv[])
{
	/* The client parameters specified by the user. */
	static ClientParams clientParams;
	/* The client statistics. */
	static ClientStats clientStats;

	/* The socket for sending/receiving the echo. */
	int echoSocket;
	/* Address of the echo server. */
	struct sockaddr_in echoServer;
	/* Address received by the echo client. */
	struct sockaddr_in echoClient;
	/* Length of the address received by echo client. */
	uint32_t clientLength = sizeof(struct sockaddr_in);

	/* Time stamp before sending the echo request. */
	struct timeval timeBeforeSend;
	/* Time stamp after receiving the echo response. */
	struct timeval timeAfterReceive;

	/* ID of the current fork. */
	uint32_t forkNr = 0;
	/* Macro for logging debug messages to the console. */
#define LOGMSG(format,args...) printf("[%d] " format "\n", forkNr, ##args)

	printBanner();
	
	/* Parse program options. */
	if (!parseUserInput(argc, argv, &clientParams))
	{
		printUsage();
		return -1;
	}
	if (clientParams.showHelp)
	{
		printUsage();
		return 0;
	}
	if (clientParams.showLicense)
	{
		printLicense();
		return 0;
	}

	/* Create the requested number of forks. */
	if (clientParams.numForks)
	{
		pid_t pid;
		do
		{
			if ((pid = fork()) == 0)
			{
				break;
			}
			forkNr++;
			clientParams.numForks--;
		}
		while (clientParams.numForks);
	}

	/* Create the echo request and response buffers. */
	uint8_t *echoRequest;
	uint8_t *echoResponse = malloc(clientParams.echoLength);
	if (!echoResponse)
	{
		LOGMSG("*** Error allocating echo response buffer.");
		return -1;
	}

	/* Create the UDP socket. */
	echoSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (echoSocket < 0)
	{
		LOGMSG("*** Error creating echo socket.");
		return -1;
	}

	/* Create the echo server address. */
	memset(&echoServer, 0, sizeof(echoServer));
	echoServer.sin_family      = AF_INET;
	echoServer.sin_addr.s_addr = clientParams.serverAddr;
	echoServer.sin_port        = htons(7);

	/* Prepare the stats. */
	clientStats.numErrors   = 0;
	clientStats.maxTime     = 0;
	clientStats.minTime     = 0xFFFFFFFF;
	clientStats.averageTime = 0;
	clientStats.elapsedTime = malloc(sizeof(uint32_t) * clientParams.numIterations);
	if (!clientStats.elapsedTime)
	{
		LOGMSG("*** Error allocating memory.");
		return -1;
	}

	/* Loop through the number of selected iterations. */
	uint32_t iter; for (iter = 0; iter < clientParams.numIterations; iter++)
	{
		LOGMSG("Iteration %d/%d.", iter + 1, clientParams.numIterations);

		/* Prepare the echo request message. */
		echoRequest = getEchoRequest(clientParams.echoLength);
		clientStats.elapsedTime[iter] = 0;

		/* Send the data to the echo server. */
		LOGMSG("Sending %d characters to %s...",
				clientParams.echoLength, clientParams.serverAddrString);

		gettimeofday(&timeBeforeSend, NULL);

		int32_t requestLength = sendto(echoSocket, echoRequest,
				clientParams.echoLength, 0, (struct sockaddr *)&echoServer,
				sizeof(echoServer));

		if (requestLength != clientParams.echoLength)
		{
			LOGMSG("*** Error sending echo request.");
			clientStats.numErrors++;
			continue;
		}

		/* Set timeout for echo reception. */
		if (sigsetjmp(receiveTimeout, 1))
		{
			LOGMSG("*** Timeout while waiting for echo.");
			clientStats.numErrors++;
			continue;
		}

		signal(SIGALRM, receiveTimeoutHandler);
		alarm(ECHO_RECEIVE_TIMEOUT);

		/* Wait for the echo response. */
		int32_t responseLength = recvfrom(echoSocket, echoResponse,
				clientParams.echoLength, 0,	(struct sockaddr *)&echoClient,
				&clientLength);

		/* Clear the timeout alarm and remember the time. */
		alarm(0);
		signal(SIGALRM, SIG_DFL);
		gettimeofday(&timeAfterReceive, NULL);

		/* Check the echo response. */
		if (responseLength == -1)
		{
			LOGMSG("*** Echo receive error: %s", strerror(errno));
			continue;
		}
		if (responseLength != clientParams.echoLength)
		{
			LOGMSG("*** Echo size mismatch: received %d bytes, expected %d.",
					responseLength, clientParams.echoLength);
			clientStats.numErrors++;
			continue;
		}
		if (echoServer.sin_addr.s_addr != echoClient.sin_addr.s_addr)
		{
			LOGMSG("*** Received unexpected echo from %s, expected %s.",
					inet_ntoa(echoClient.sin_addr), inet_ntoa(echoServer.sin_addr));
			clientStats.numErrors++;
			continue;
		}
		if (memcmp(echoRequest, echoResponse, responseLength) != 0)
		{
			LOGMSG("*** Echo data mismatch.");
			clientStats.numErrors++;
			continue;
		}

		/* Remember the echo duration. */
		clientStats.elapsedTime[iter] = getElapsedTime(&timeBeforeSend,
				&timeAfterReceive);
		LOGMSG("Received echo after %u milliseconds.",
				clientStats.elapsedTime[iter]);

		/* Calculate the statistics. */
		clientStats.averageTime += clientStats.elapsedTime[iter];
		if (clientStats.elapsedTime[iter] > clientStats.maxTime)
		{
			clientStats.maxTime = clientStats.elapsedTime[iter];
		}
		if (clientStats.elapsedTime[iter] < clientStats.minTime)
		{
			clientStats.minTime = clientStats.elapsedTime[iter];
		}
	}

	/* Calculate the statistics. */
	if (clientParams.numIterations > clientStats.numErrors)
	{
		clientStats.averageTime = clientStats.averageTime /
				(clientParams.numIterations - clientStats.numErrors);
	}
	else
	{
		clientStats.averageTime = clientStats.maxTime;
	}

	/* Print the statistics. */
	printf("\n");
	LOGMSG("Finished with %d errors.", clientStats.numErrors);
	LOGMSG("Echo length = %d bytes: Avg = %d ms, Min = %d ms, Max = %d ms.",
			clientParams.echoLength, clientStats.averageTime, clientStats.minTime,
			clientStats.maxTime);
	printf("\n");

	return 0;
}
Beispiel #8
0
/**
 * Main function
 *
 */
int main(int argc, char* argv[])
{
    int i, j, cmdargv_len;
    int rc = 0;
    int pipeExists = 0;

    char *formattedInput = NULL;
    char *userInput = NULL;
    char **cmdargv = NULL ;

    char *cdCmd = NULL;
    char *pipeCmd = NULL;

    if((userInput = malloc(sizeof(char)*MAX_CMD_LEN)) == NULL)
        ERROR("Failed malloc\n");

    cmdargv_len = sizeof(char*) * MAX_CMD_ARGS;
    if((cmdargv = (char**) malloc(cmdargv_len)) == NULL) {
        ERROR("Failed malloc\n");
    } else {
        memset(cmdargv, '\0', sizeof(char*) * MAX_CMD_ARGS);
    }

    registerSignalHandler();

    while(1)
    {
        printf("_dash > ");
        got_sigint = false;
        if (fgets(userInput, MAX_CMD_LEN, stdin) == NULL) {
            if (got_sigint) {
              printf("\n");
              continue;
            } else {
              // Ctrl+D
              return 0;
            }
        }


        // TODO: Sanitize user input! We're currently hoping the user is a
        // benelovent, sweet human being. HA!

        if( (formattedInput = malloc(sizeof(userInput))) == NULL )
            ERROR("Failed malloc\n");
        removeNewLine(userInput, formattedInput);

        // See if user wants out.
        if((strcmp("quit", formattedInput) == 0) ||
           (strcmp("exit", formattedInput) == 0) ||
           (strcmp("q", formattedInput) == 0))
        {
            printf("Quitting!\n");
            goto cleanup;
        }

        // Check to see if user wants to change working directories
        if( (cdCmd = strstr(formattedInput, "cd ")) != NULL )
        {
            if(changeDir(cdCmd) != 0)
                ERROR("cd failed.");

            free(cdCmd);

            // No need to fork/exec, can just move on.
            continue;
        }

        // Check to see if user wants to pipe commands
        if( (pipeCmd = strstr(formattedInput, "|")) != NULL )
        {
            pipeExists = 1;

            // Don't need to free pipeCmd bc freeing formattedInput will take
            // care of that for us.
            //free(pipeCmd);
        }

        parseUserInput(formattedInput, cmdargv);

        for(j=0; cmdargv[j] != NULL; j++)
            printf("%d: cmdargv[%d]: %s\n", __LINE__, j, cmdargv[j]);

        rc = execute_fork(cmdargv, pipeExists);
        ASSERT( rc != 0 );

        pipeExists = 0;
    }

/* Cleanup! */
cleanup:
    free(formattedInput);
    free(userInput);
    if (cmdargv) {
        for (i = 0; i < MAX_CMD_ARGS; i++) {
            free(cmdargv[i]); /* free(NULL) is ok with glibc */
        }
    }
    free(cmdargv);

    printf("All finished.\n");

    return 0;
}
Beispiel #9
0
int main(int argc, char *args)
{
	// Console parameters
	HANDLE handleStdin;
    INPUT_RECORD inputEvents[128];
	DWORD eventCount;

	// Control parameter
	bool running = true;
	int i = 0;

	printf("\nOpenJAUS Node Manager Version %s (%s)\n\n", OJ_NODE_MANAGER_VERSION, __DATE__); 

	// Setup the console window's input handle
	handleStdin = GetStdHandle(STD_INPUT_HANDLE); 

	MyHandler *handler = new MyHandler();
	FileLoader *configData = new FileLoader("nodeManager.conf");

	nm = new NodeManager(configData, handler);

	printHelpMenu();

	while(running)
	{
		// See how many events are waiting for us, this prevents blocking if none
		GetNumberOfConsoleInputEvents(handleStdin, &eventCount);
		
		if(eventCount > 0)
		{
			// Check for user input here
			ReadConsoleInput( 
					handleStdin,		// input buffer handle 
					inputEvents,		// buffer to read into 
					128,				// size of read buffer 
					&eventCount);		// number of records read 
		}
 
	    // Parse console input events 
        for (i = 0; i < (int) eventCount; i++) 
        {
            switch(inputEvents[i].EventType) 
            { 
				case KEY_EVENT: // keyboard input 
					if(inputEvents[i].Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)
					{
						running = false;
					}
					else if(inputEvents[i].Event.KeyEvent.bKeyDown)
					{
						parseUserInput(inputEvents[i].Event.KeyEvent.uChar.AsciiChar);
					}
					break;
				
				default:
					break;
			}
		}

		Sleep((DWORD)(0.2*1e3));
	}
	return 0;
}
Beispiel #10
0
char getUserInput()
{
	char retVal = FALSE;
	int choice;
#if defined(WIN32)
	int i = 0;
#endif

	if(verbose)
	{
	#if defined(WIN32)
    INPUT_RECORD inputEvents[128];
	DWORD eventCount;

		// See how many events are waiting for us, this prevents blocking if none
		GetNumberOfConsoleInputEvents(handleStdin, &eventCount);

		if(eventCount > 0)
		{
			// Check for user input here
			ReadConsoleInput(
					handleStdin,		// input buffer handle
					inputEvents,		// buffer to read into
					128,				// size of read buffer
					&eventCount);		// number of records read
		}

	    // Parse console input events
        for (i = 0; i < (int) eventCount; i++)
        {
            switch(inputEvents[i].EventType)
            {
				case KEY_EVENT: // keyboard input
					parseUserInput(inputEvents[i].Event.KeyEvent.uChar.AsciiChar);
					retVal = TRUE;
					break;

				default:
					break;
			}
		}
	#elif defined(__linux) || defined(linux) || defined(__linux__) || defined(__APPLE__)
		choice = getc(stdin);
		if(choice > -1)
		{
			parseUserInput(choice);
			retVal = TRUE;
		}
	#endif
	}
	else
	{
		choice = getch(); // Get the key that the user has selected
		updateScreen(keyboardLock, choice);
		if(choice > -1)
		{
			parseUserInput(choice);
			retVal = TRUE;
		}
	}

	return retVal;
}