Esempio n. 1
0
 //==============================================================================
 Time getLastMouseDownTime() const noexcept
 {
     return Time (mouseDowns[0].time);
 }
Esempio n. 2
0
 /// division operator
 Time Time::operator/ (double div) const
 {
   return Time(this->totalDays()/div);
 }
Esempio n. 3
0
void TurretDataComponent::updateAutoCooldown(float secondsToAdd) {
	int milisecondsToAdd = secondsToAdd*1000;
	nextAutoFireTime = Time();
	nextAutoFireTime.addMiliTime(milisecondsToAdd);
}
Esempio n. 4
0
void ReqLogin::ChooseMode()
{
  TheResearchCalendar::Instance()->Clear();

  GameMode gm = AMJU_MODE_NO_GAME;
  bool doCogTests = false;

  PXml research = m_xml.getChildNode(5);
  if (SafeStrCmp(research.getName(), "research"))
  {
    // Schedule - for calendar
    PXml p = research.getChildNode(4);
    if (SafeStrCmp(p.getName(), "dates"))
    {
      Time today(Time::Now());
      today.RoundDown(TimePeriod(ONE_DAY_IN_SECONDS));

      // Bunch of dates - add to TheResearchCal
      int numDates = p.nChildNode();
      for (int i = 0; i < numDates; i++)
      {
        PXml date = p.getChildNode(i);
        if (SafeStrCmp(date.getName(), "date"))
        {
          if (SafeStrCmp(date.getChildNode(0).getName(), "timestamp") &&
              SafeStrCmp(date.getChildNode(1).getName(), "cogtest") &&
              SafeStrCmp(date.getChildNode(2).getName(), "play"))
          {
            std::string dateStr = date.getChildNode(0).getText();
            bool cogtest = SafeStrCmp(date.getChildNode(1).getText(), "1"); 
            bool play = SafeStrCmp(date.getChildNode(2).getText(), "1"); 

            Time t(dateStr);
            t.RoundDown(TimePeriod(ONE_DAY_IN_SECONDS));
            if (t == today)
            {
              // Cog tests already done today ?
              Results results = TheCogTestResults::Instance()->GetResultsForDate(Time::Now());
              if (results.empty())
              {
                doCogTests = cogtest;
              }
              else
              {
                doCogTests = false;
                std::cout << "Test results for today are here already.\n";
              }

              if (play)
              { 
                gm = AMJU_MODE_MULTI;
              }
              if (doCogTests && !play)
              {
                // Create dummy target for heart count, etc
                CreateDummyLocalPlayer();
              }
            }
            TheResearchCalendar::Instance()->AddResearchDate(ResearchDate(Time(dateStr), cogtest, play));   
          }
          else
          {
            std::cout << "Login: unexpected format for session dates.\n";
            Assert(0);
          }
        }
      }
    }
    else
    {
      std::cout << "Login: found research element but no schedule.\n";
    }
  }
  else
  {
    std::cout << "No research element in login.pl response?!?\n";
    Assert(0);
  }

  // Now we can look up today on the calendar to get game mode flags.

  ResetLocalPlayerFuelCount();

  SetGameMode(gm); // TODO handle edit mode - send extra flag to login.pl ??

  SetDoCogTests(doCogTests); // mode, in GameMode

  TheGSCalendar::Instance()->SetPrevState(TheGSToday::Instance());
  TheGSThanks::Instance()->SetPrevState(TheGSToday::Instance());
  TheGame::Instance()->SetCurrentState(TheGSThanks::Instance());
  TheGSMain::Instance()->ResetHud();
}
void prompt_code(){
	Putc(COM1, 96);					// GO command for trains
	Create(PR_TIMER, timer_code);
	int dfa_tid = Create(PR_DFA, dfa_code);
	int train_tid = Create(PR_TRAIN_COMMANDER, train_commander_code);
	int switch_tid = Create(PR_SWITCH, switch_code);
	Create(PR_SENSOR, sensor_code);
	
	char input, state;
	char buff[9];
	train_server_request tsr;
	
	int node_index = 0;
	
	while (1){
		input = Getc(COM2);
		if (input == 'q'){
			Putc(COM1, 97);							// Stop command for trains
			Putc(COM2, input);						// ECHO
			Printf(COM2, " ");Printf(COM2, " ");Printf(COM2, " ");
			// send signal to calibration server to print calibration data and halt the system.
			// Send(WhoIs("CALIBRATIONSERVER"), &input, sizeof(char), &input, sizeof(char));
			
			SHUTDOWN();								// CALL SHUTDOWN SYSCALL to shutdown the program
		}
		else if (input == '/'){
			Debug("[Time: %d     ]", Time());
			continue;
		}
		Send(dfa_tid, &input, sizeof(char), &buff, 9*sizeof(char));
		state = buff[0];
		switch (state){
			case DFA_FULL:
				Printf(COM2, "\033[s\033[%d;%dHPrompt is full!                    \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				break;
			case DFA_INVALID:
				Printf(COM2, "\033[%d;%dHInvalid input!!!                         \033[%d;%dH", CMD_OUT_ROW, CMD_OUT_COL, CMD_ROW, CMD_COL);
				Printf(COM2, "\033[%d;%dH\033[s                     \033[u", CMD_ROW, CMD_COL);
				break;
			case DFA_OK:
				Putc(COM2, input);			// ECHO
				break;
			case DFA_BACKSPACE:
				Printf(COM2, "%c %c", input, input);		// Echo
				break;
			case DFA_NO_BACKSPACE:
				Printf(COM2, "\033[s\033[%d;%dH                                          \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				break;
			case DFA_TR_SP:
				Printf(COM2, "\033[s\033[%d;%dHSetting speed of tr#%d to %d...           \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], buff[1]);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				// Send command to the train task to set speed of the train
				Send(train_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_TR_SP_AT_NODE:
				Printf(COM2, "\033[s\033[%d;%dHSetting speed of tr#%d to %d at node %s...\033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], buff[1], (buff+3));
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				tsr.type = TRAIN_TYPE_SPEED_AT_NODE;
				tsr.data.speed_request.speed = buff[1];
				tsr.data.speed_request.tr_num = buff[2];
				strncpy(tsr.data.speed_request.node_name, buff+3, 6);
				Send(WhoIs("TRAINSERVER"), &tsr, sizeof(train_server_request), &input, sizeof(char));
				
				break;
			case DFA_TR_RV:
				Printf(COM2, "\033[s\033[%d;%dHReversing tr#%d...                        \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2]);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[1] = 15;
				Send(train_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW:
				Printf(COM2, "\033[s\033[%d;%dHThrowing sw#%d to %c...                   \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], buff[1]);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_STOP_AT:
				Printf(COM2, "\033[s\033[%d;%dHStopping train %d at %s                   \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], (buff+3));
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				// Send appropriate command to train server to stop the train at the appropriate location
				tsr.type = TRAIN_TYPE_SPEED_AT_NODE;
				tsr.data.speed_request.speed = buff[1];
				tsr.data.speed_request.tr_num = buff[2];
				strncpy(tsr.data.speed_request.node_name, buff+3, 6);
				Send(WhoIs("TRAINSERVER"), &tsr, sizeof(train_server_request), &input, sizeof(char));
				break;
			case DFA_GO_TO:
				tsr.type = TRAIN_TYPE_GO_TO_NODE;
				tsr.data.speed_request.tr_num = buff[2];
				strncpy(tsr.data.speed_request.node_name, buff+3, 6);
				Send(WhoIs("TRAINSERVER"), &tsr, sizeof(train_server_request), &node_index, sizeof(int));
				if(node_index != -1) {
					Printf(COM2, "\033[s\033[%d;%dHMoving train %d to %s                    \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], (buff+3));
					Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				}
				else {
					Printf(COM2, "\033[s\033[%d;%dHInvalid node name                        \033[u", CMD_OUT_ROW, CMD_OUT_COL);
					Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				}
				break;
			case DFA_SW_ALL_C:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to C (curve)...     \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_ALL_C;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_ALL_S:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to S (straight)...  \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_ALL_S;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_SMALL_LOOP1:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to small loop 1...  \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_SMALL_LOOP1;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_SMALL_LOOP2:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to small loop 2...  \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_SMALL_LOOP2;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_MEDIUM_LOOP:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to medium loop...   \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_MEDIUM_LOOP;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_LARGE_LOOP:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to large loop...    \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_LARGE_LOOP;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_EXTRA_LARGE_LOOP:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to extra large loop \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_EXTRA_LARGE_LOOP;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));
				break;
			case DFA_SW_DEFAULT:
				Printf(COM2, "\033[s\033[%d;%dHInitializing switches to default state... \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				buff[2] = SWICTH_DEFAULT;
				Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));break;
				break;
			default:
				Printf(COM2, "\033[s\033[%d;%dHDFA PROBLEM!!!                           \033[u", CMD_OUT_ROW, CMD_OUT_COL);
				Printf(COM2, "\033[%d;%dH\033[s                    \033[u", CMD_ROW, CMD_COL);
				break;
		}
	}
	
	Warning(0,"Unexpected return from Exit() at prompt_code\n\r");
	Exit();
	Warning(0,"Unexpected return from Exit() at prompt_code\n\r");
}
Esempio n. 6
0
int main(int argc, char** argv) {

  if (argc != 3) {
    fprintf(stderr, "usage: %s i2c-dev i2c-slave-number\n", argv[0]);
    exit(1);
  }

  const char* bus = argv[1];
  char* err;
  int dev = strtol(argv[2], &err, 10);
  if(!*argv[2] || *err) {
    fprintf(stderr, "usage: %s <i2c-dev> <i2c-slave-number>\n", argv[0]);
    fprintf(stderr, "       i2c-slave-number must be a number\n");
    exit(1);
  }

  WebServiceFSM wsfsm{"http://localhost:8080/"};

  RealProtocolFSM pfsm;
  pfsm.init(bus, dev);

  joystickInit();
  uint8_t id = 0;

  // ProtocolState old_state = pfsm.state;

  while(true) {
    js_state state;
    joystickState(&state);

    wsfsm.update();
    pfsm.update();

    /* DEBUGGING
    if(pfsm.state != old_state) {
      fprintf(stderr, "PFSM: %s => %s\n", ProtocolStateStr[old_state], ProtocolStateStr[pfsm.state]);
      old_state = pfsm.state;
    }
    */
      Message msg;

    // can we send another message?
    if(pfsm.state == IDLE) {
      double speed_value = 0.0;
      double angle_value = 0.0;

      if(Time() - lastJoystickUpdate() < TimeLength::inSeconds(1)) {

        speed_value = (static_cast<double>(state.axis[1])) * (33.0 / 32767.0);
        angle_value = (static_cast<double>(state.axis[0])) * (-30.0 / 32767.0);

        // deadzones
        if(speed_value > -5 && speed_value < 5) {
          speed_value = 0;
        }
        if(angle_value > -2 && angle_value < 2) {
          angle_value = 0;
        }
      } else if (wsfsm.command_available) {
        speed_value = wsfsm.command.speed * 33.0;
        angle_value = std::max(-30.0, std::min(30.0, wsfsm.command.angle*-1.0));
        wsfsm.command_completed = true;
      }
      int8_t speed_ival = static_cast<int8_t>(speed_value);
      int8_t angle_ival = static_cast<int8_t>(angle_value);
      //printf("speed = %f, %d  angle = %f, %d\n", speed_value, speed_ival, angle_value, angle_ival);

      messageSignedInit(&msg, COMMAND_SET_MOTION, speed_ival, angle_ival, id++);

      pfsm.send(&msg);

    }


    if(pfsm.state == SENDING_FAILED || pfsm.state == ACKING_FAILED) {
      // don't care for now
      fprintf(stderr, "ignorning error\n");
      pfsm.clearError();
      messageSignedInit(&msg, COMMAND_SET_MOTION, speed_ival, angle_ival, id++);
      pfsm.send(&msg);
      // webservice: will be implemented in wsfsm.cpp later
    }

    if(pfsm.state == ACK_COMPLETE) {
      pfsm.acknowledgeAck();
    }

    // sleep off any delay the protocol is waiting for because we have
    // nothing better to do right now - imp. b/c running on battery
    TimeLength delay = pfsm.delayRemaining();
    if(delay > TimeLength::inSeconds(0)) {
      usleep(delay.microseconds());
    }
  }

  return (EXIT_SUCCESS);
}
Esempio n. 7
0
time_t CTimer::RetryTime(void)
{
    return Time() +
        (m_ReasonableRefreshDelay>0?m_ReasonableRefreshDelay:24*60*60);
    /* 24 hours */
}
Esempio n. 8
0
void ComplexStatsWin::refresh()
{
	Time f; // from
	Time t; // to
	
	switch ( (En_stats_interval)((int)interval.GetData()) )
	{
		case siDay:
			{
				Date d = day_date.GetData();
				f = ToTime(d);
				t = Time(d.year, d.month, d.day, 23, 59, 59);
				break;
			}
		case siMonth:
			{
				Date from = FirstDayOfMonth(month_date.GetData());
				Date to = LastDayOfMonth(month_date.GetData());
				f = Time(from.year, from.month, from.day, 0, 0, 0);
				t = Time(to.year, to.month, to.day, 23, 59, 59);
				break;
			}
		case siDateRange:
			{
				Date from = date_from.GetData();
				Date to = date_to.GetData();
				f = Time(from.year, from.month, from.day, 0, 0, 0);
				t = Time(to.year, to.month, to.day, 23, 59, 59);
			}
	};
	
	//record count
	SQL & Select(SqlCountRows()).From(RECORD).Where(REC_DATE >= f && REC_DATE <= t);
	if (SQL.Fetch())
		record_count.SetText(~AsString(SQL[0]));
	
	//income
	SQL & Select(SqlSum(ITEM_PRICE))
		.From(RECORD_ITEM)
		.InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD))
		.Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t)
	;
	if (SQL.Fetch())
	{
		String s = ConvertMoney().Format(SQL[0]);
		income.SetText(~s);
	}
	
	//income from invoices only
	SQL & Select(SqlSum(ITEM_PRICE))
		.From(RECORD_ITEM)
		.InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD))
		.Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t && NotNull(INVOICE_ID.Of(RECORD)))
	;
	if (SQL.Fetch())
	{
		String s = ConvertMoney().Format(SQL[0]);
		income_inv.SetText(~s);
	}
	
	//income without invoices
	SQL & Select(SqlSum(ITEM_PRICE))
		.From(RECORD_ITEM)
		.InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD))
		.Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t && IsNull(INVOICE_ID.Of(RECORD)))
	;
	if (SQL.Fetch())
	{
		String s = ConvertMoney().Format(SQL[0]);
		income_noinv.SetText(~s);
	}
	
	//products
	products.Clear();
	SQL & Select(NAME.Of(LOV_PRODUCT), Count(LOV_PRODUCT))
		.From(RECORD_ITEM)
		.InnerJoin(LOV_PRODUCT).On(PROD_ID.Of(RECORD_ITEM) == ID.Of(LOV_PRODUCT))
		.InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD))
		.Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t)
		.GroupBy(NAME.Of(LOV_PRODUCT))
		.OrderBy(Descending(Count(LOV_PRODUCT)))
	;
	while(SQL.Fetch())
		products.Add(SQL);
	
	//clients
	unsigned c = 0;
	clients.Clear();
	SQL & Select(NAME.Of(LOV_TITLE), FIRST_NAME.Of(CLIENT), LAST_NAME.Of(CLIENT))
		.From(RECORD)
		.InnerJoin(PATIENT).On(PATIENT_ID.Of(RECORD) == ID.Of(PATIENT))
		.InnerJoin(CLIENT).On(CLIENT_ID.Of(PATIENT) == ID.Of(CLIENT))
		.LeftJoin(LOV_TITLE).On(TITLE_ID.Of(CLIENT) == ID.Of(LOV_TITLE))
		.Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t)
		.OrderBy(REC_DATE.Of(RECORD))
	;
	while(SQL.Fetch() && ++c)
		clients.Add(SQL);
	client_count.SetText(AsString(c));
}
Esempio n. 9
0
Time GetUtcTime() {
	SYSTEMTIME st;
	GetSystemTime(&st);
	return Time(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
}
void
nest::SimulationManager::update_()
{
  // to store done values of the different threads
  std::vector< bool > done;
  bool done_all = true;
  delay old_to_step;
  exit_on_user_signal_ = false;

  std::vector< lockPTR< WrappedThreadException > > exceptions_raised(
    kernel().vp_manager.get_num_threads() );
  bool exception_raised = false; // none raised on any thread

// parallel section begins
#pragma omp parallel
  {
    const int thrd = kernel().vp_manager.get_thread_id();

    do
    {
      if ( print_time_ )
      {
        gettimeofday( &t_slice_begin_, NULL );
      }

      if ( kernel().sp_manager.is_structural_plasticity_enabled()
        && ( clock_.get_steps() + from_step_ )
            % kernel().sp_manager.get_structural_plasticity_update_interval()
          == 0 )
      {
        for ( std::vector< Node* >::const_iterator i =
                kernel().node_manager.get_nodes_on_thread( thrd ).begin();
              i != kernel().node_manager.get_nodes_on_thread( thrd ).end();
              ++i )
        {
          ( *i )->update_synaptic_elements(
            Time( Time::step( clock_.get_steps() + from_step_ ) ).get_ms() );
        }
#pragma omp barrier
#pragma omp single
        {
          kernel().sp_manager.update_structural_plasticity();
        }
        // Remove 10% of the vacant elements
        for ( std::vector< Node* >::const_iterator i =
                kernel().node_manager.get_nodes_on_thread( thrd ).begin();
              i != kernel().node_manager.get_nodes_on_thread( thrd ).end();
              ++i )
        {
          ( *i )->decay_synaptic_elements_vacant();
        }
      }


      if ( from_step_ == 0 ) // deliver only at beginning of slice
      {
        kernel().event_delivery_manager.deliver_events( thrd );
#ifdef HAVE_MUSIC
// advance the time of music by one step (min_delay * h) must
// be done after deliver_events_() since it calls
// music_event_out_proxy::handle(), which hands the spikes over to
// MUSIC *before* MUSIC time is advanced

// wait until all threads are done -> synchronize
#pragma omp barrier
// the following block is executed by the master thread only
// the other threads are enforced to wait at the end of the block
#pragma omp master
        {
          // advance the time of music by one step (min_delay * h) must
          // be done after deliver_events_() since it calls
          // music_event_out_proxy::handle(), which hands the spikes over to
          // MUSIC *before* MUSIC time is advanced
          if ( slice_ > 0 )
          {
            kernel().music_manager.advance_music_time();
          }

          // the following could be made thread-safe
          kernel().music_manager.update_music_event_handlers(
            clock_, from_step_, to_step_ );
        }
// end of master section, all threads have to synchronize at this point
#pragma omp barrier
#endif
      }

      // preliminary update of nodes that use waveform relaxtion
      if ( kernel().node_manager.wfr_is_used() )
      {
#pragma omp single
        {
          // if the end of the simulation is in the middle
          // of a min_delay_ step, we need to make a complete
          // step in the wfr_update and only do
          // the partial step in the final update
          // needs to be done in omp single since to_step_ is a scheduler
          // variable
          old_to_step = to_step_;
          if ( to_step_ < kernel().connection_manager.get_min_delay() )
          {
            to_step_ = kernel().connection_manager.get_min_delay();
          }
        }

        bool max_iterations_reached = true;
        const std::vector< Node* >& thread_local_wfr_nodes =
          kernel().node_manager.get_wfr_nodes_on_thread( thrd );
        for ( long n = 0; n < wfr_max_iterations_; ++n )
        {
          bool done_p = true;

          // this loop may be empty for those threads
          // that do not have any nodes requiring wfr_update
          for ( std::vector< Node* >::const_iterator i =
                  thread_local_wfr_nodes.begin();
                i != thread_local_wfr_nodes.end();
                ++i )
          {
            done_p = wfr_update_( *i ) && done_p;
          }

// add done value of thread p to done vector
#pragma omp critical
          done.push_back( done_p );
// parallel section ends, wait until all threads are done -> synchronize
#pragma omp barrier

// the following block is executed by a single thread
// the other threads wait at the end of the block
#pragma omp single
          {
            // set done_all
            for ( size_t i = 0; i < done.size(); i++ )
            {
              done_all = done[ i ] && done_all;
            }

            // gather SecondaryEvents (e.g. GapJunctionEvents)
            kernel().event_delivery_manager.gather_events( done_all );

            // reset done and done_all
            //(needs to be in the single threaded part)
            done_all = true;
            done.clear();
          }

          // deliver SecondaryEvents generated during wfr_update
          // returns the done value over all threads
          done_p = kernel().event_delivery_manager.deliver_events( thrd );

          if ( done_p )
          {
            max_iterations_reached = false;
            break;
          }
        } // of for (wfr_max_iterations) ...

#pragma omp single
        {
          to_step_ = old_to_step;
          if ( max_iterations_reached )
          {
            std::string msg = String::compose(
              "Maximum number of iterations reached at interval %1-%2 ms",
              clock_.get_ms(),
              clock_.get_ms() + to_step_ * Time::get_resolution().get_ms() );
            LOG( M_WARNING, "SimulationManager::wfr_update", msg );
          }
        }

      } // of if(wfr_is_used)
      // end of preliminary update

      const std::vector< Node* >& thread_local_nodes =
        kernel().node_manager.get_nodes_on_thread( thrd );
      for (
        std::vector< Node* >::const_iterator node = thread_local_nodes.begin();
        node != thread_local_nodes.end();
        ++node )
      {
        // We update in a parallel region. Therefore, we need to catch
        // exceptions here and then handle them after the parallel region.
        try
        {
          if ( not( *node )->is_frozen() )
          {
            ( *node )->update( clock_, from_step_, to_step_ );
          }
        }
        catch ( std::exception& e )
        {
          // so throw the exception after parallel region
          exceptions_raised.at( thrd ) = lockPTR< WrappedThreadException >(
            new WrappedThreadException( e ) );
        }
      }

// parallel section ends, wait until all threads are done -> synchronize
#pragma omp barrier

// the following block is executed by the master thread only
// the other threads are enforced to wait at the end of the block
#pragma omp master
      {
        // check if any thread in parallel section raised an exception
        for ( index thrd = 0; thrd < kernel().vp_manager.get_num_threads();
              ++thrd )
        {
          if ( exceptions_raised.at( thrd ).valid() )
          {
            exception_raised = true;
            break;
          }
        }

        // gather only at end of slice
        if ( to_step_ == kernel().connection_manager.get_min_delay() )
        {
          kernel().event_delivery_manager.gather_events( true );
        }

        advance_time_();

        if ( SLIsignalflag != 0 )
        {
          LOG( M_INFO,
            "SimulationManager::update",
            "Simulation exiting on user signal." );
          exit_on_user_signal_ = true;
        }

        if ( print_time_ )
        {
          gettimeofday( &t_slice_end_, NULL );
          print_progress_();
        }
      }
// end of master section, all threads have to synchronize at this point
#pragma omp barrier

    } while (
      to_do_ > 0 and not exit_on_user_signal_ and not exception_raised );

    // End of the slice, we update the number of synaptic elements
    for ( std::vector< Node* >::const_iterator i =
            kernel().node_manager.get_nodes_on_thread( thrd ).begin();
          i != kernel().node_manager.get_nodes_on_thread( thrd ).end();
          ++i )
    {
      ( *i )->update_synaptic_elements(
        Time( Time::step( clock_.get_steps() + to_step_ ) ).get_ms() );
    }

  } // end of #pragma parallel omp

  // check if any exceptions have been raised
  for ( index thrd = 0; thrd < kernel().vp_manager.get_num_threads(); ++thrd )
  {
    if ( exceptions_raised.at( thrd ).valid() )
    {
      simulating_ = false; // must mark this here, see #311
      inconsistent_state_ = true;
      throw WrappedThreadException( *( exceptions_raised.at( thrd ) ) );
    }
  }
}
Esempio n. 11
0
bool PlayerCreationManager::createCharacter(ClientCreateCharacterCallback* callback) {
	TemplateManager* templateManager = TemplateManager::instance();

	ZoneClientSession* client = callback->getClient();

	if (client->getCharacterCount(zoneServer.get()->getGalaxyID()) >= 10) {
		ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are limited to 10 characters per galaxy.", 0x0);
		client->sendMessage(errMsg);

		return false;
	}

	PlayerManager* playerManager = zoneServer.get()->getPlayerManager();

	SkillManager* skillManager = SkillManager::instance();

	//Get all the data and validate it.
	UnicodeString characterName;
	callback->getCharacterName(characterName);

	//TODO: Replace this at some point?
	if (!playerManager->checkPlayerName(callback))
		return false;

	String raceFile;
	callback->getRaceFile(raceFile);

	uint32 serverObjectCRC = raceFile.hashCode();

	PlayerCreatureTemplate* playerTemplate =
			dynamic_cast<PlayerCreatureTemplate*>(templateManager->getTemplate(
					serverObjectCRC));

	if (playerTemplate == NULL) {
		error("Unknown player template selected: " + raceFile);
		return false;
	}

	String fileName = playerTemplate->getTemplateFileName();
	String clientTemplate = templateManager->getTemplateFile(
			playerTemplate->getClientObjectCRC());

	RacialCreationData* raceData = racialCreationData.get(fileName);

	if (raceData == NULL)
		raceData = racialCreationData.get(0); //Just get the first race, since they tried to create a race that doesn't exist.

	String profession, customization, hairTemplate, hairCustomization;
	callback->getSkill(profession);

	if (profession.contains("jedi"))
		profession = "crafting_artisan";

	callback->getCustomizationString(customization);
	callback->getHairObject(hairTemplate);
	callback->getHairCustomization(hairCustomization);

	float height = callback->getHeight();
	height = MAX(MIN(height, playerTemplate->getMaxScale()),
			playerTemplate->getMinScale());

	//validate biography
	UnicodeString bio;
	callback->getBiography(bio);

	bool doTutorial = callback->getTutorialFlag();
	//bool doTutorial = false;

	ManagedReference<CreatureObject*> playerCreature =
			zoneServer.get()->createObject(
					serverObjectCRC, 2).castTo<CreatureObject*>();

	if (playerCreature == NULL) {
		error("Could not create player with template: " + raceFile);
		return false;
	}

	Locker playerLocker(playerCreature);

	playerCreature->createChildObjects();
	playerCreature->setHeight(height);
	playerCreature->setCustomObjectName(characterName, false); //TODO: Validate with Name Manager.

	client->setPlayer(playerCreature);
	playerCreature->setClient(client);

	// Set starting cash and starting bank
	playerCreature->setCashCredits(startingCash, false);
	playerCreature->setBankCredits(startingBank, false);

	ManagedReference<PlayerObject*> ghost = playerCreature->getPlayerObject();

	if (ghost != NULL) {
		//Set skillpoints before adding any skills.
		ghost->setSkillPoints(skillPoints);
		ghost->setStarterProfession(profession);
	}

	addCustomization(playerCreature, customization,
			playerTemplate->getAppearanceFilename());
	addHair(playerCreature, hairTemplate, hairCustomization);
	if (!doTutorial) {
		addProfessionStartingItems(playerCreature, profession, clientTemplate,
				false);
		addStartingItems(playerCreature, clientTemplate, false);
		addRacialMods(playerCreature, fileName,
				playerTemplate->getStartingSkills(),
				playerTemplate->getStartingItems(), false);
	} else {
		addProfessionStartingItems(playerCreature, profession, clientTemplate,
				true);
		addStartingItems(playerCreature, clientTemplate, true);
		addRacialMods(playerCreature, fileName,
				playerTemplate->getStartingSkills(),
				playerTemplate->getStartingItems(), true);
	}

	// Set starting cash and starting bank
	playerCreature->setCashCredits(startingCash, false);
	playerCreature->setBankCredits(startingBank, false);

	if (ghost != NULL) {

		ghost->setAccountID(client->getAccountID());

		if (!freeGodMode) {
			try {
				uint32 accID = client->getAccountID();

				ManagedReference<Account*> playerAccount = playerManager->getAccount(accID);

				if (playerAccount == NULL) {
					playerCreature->destroyPlayerCreatureFromDatabase(true);
					return false;
				}

				int accountPermissionLevel = playerAccount->getAdminLevel();
				String accountName = playerAccount->getUsername();

				if(accountPermissionLevel > 0 && (accountPermissionLevel == 9 || accountPermissionLevel == 10 || accountPermissionLevel == 12 || accountPermissionLevel == 15)) {
					playerManager->updatePermissionLevel(playerCreature, accountPermissionLevel);

					/*
					Reference<ShipControlDevice*> shipControlDevice = zoneServer->createObject(STRING_HASHCODE("object/intangible/ship/sorosuub_space_yacht_pcd.iff"), 1).castTo<ShipControlDevice*>();
					//ShipObject* ship = (ShipObject*) server->createObject(STRING_HASHCODE("object/ship/player/player_sorosuub_space_yacht.iff"), 1);
					Reference<ShipObject*> ship = zoneServer->createObject(STRING_HASHCODE("object/ship/player/player_basic_tiefighter.iff"), 1).castTo<ShipObject*>();

					shipControlDevice->setControlledObject(ship);

					if (!shipControlDevice->transferObject(ship, 4))
						info("Adding of ship to device failed");

					ManagedReference<SceneObject*> datapad = playerCreature->getSlottedObject("datapad");

					if (datapad != NULL) {
						if (!datapad->transferObject(shipControlDevice, -1)) {
							shipControlDevice->destroyObjectFromDatabase(true);
						}
					} else {
						shipControlDevice->destroyObjectFromDatabase(true);
						error("could not get datapad from player");
					}
					*/
				}

				if (accountPermissionLevel < 9) {
					try {
						StringBuffer query;
						//query << "SELECT UNIX_TIMESTAMP(creation_date) FROM characters c WHERE galaxy_id = " << zoneServer.get()->getGalaxyID() << " AND account_id = " << client->getAccountID() << " ORDER BY creation_date desc;";
						uint32 galaxyId = zoneServer.get()->getGalaxyID();
						uint32 accountId = client->getAccountID();
						query << "(SELECT UNIX_TIMESTAMP(c.creation_date) as t FROM characters as c WHERE c.account_id = " << accountId << " AND c.galaxy_id = " << galaxyId << " ORDER BY c.creation_date DESC) UNION (SELECT UNIX_TIMESTAMP(d.creation_date) FROM deleted_characters as d WHERE d.account_id = " << accountId << " AND d.galaxy_id = " << galaxyId << " ORDER BY d.creation_date DESC) ORDER BY t DESC LIMIT 1";

						Reference<ResultSet*> res = ServerDatabase::instance()->executeQuery(query);

						if (res != NULL && res->next()) {
							uint32 sec = res->getUnsignedInt(0);

							Time timeVal(sec);

							if (timeVal.miliDifference() < 3600000) {
								ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are only permitted to create one character per hour. Repeat attempts prior to 1 hour elapsing will reset the timer.", 0x0);
								client->sendMessage(errMsg);

								playerCreature->destroyPlayerCreatureFromDatabase(true);
								return false;
							}
							//timeVal.se
						}
					} catch (DatabaseException& e) {
						error(e.getMessage());
					}

					Locker locker(&charCountMutex);

					if (lastCreatedCharacter.containsKey(accID)) {
						Time lastCreatedTime = lastCreatedCharacter.get(accID);

						if (lastCreatedTime.miliDifference() < 3600000) {
							ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are only permitted to create one character per hour. Repeat attempts prior to 1 hour elapsing will reset the timer.", 0x0);
							client->sendMessage(errMsg);

							playerCreature->destroyPlayerCreatureFromDatabase(true);
							return false;
						} else {
							lastCreatedTime.updateToCurrentTime();

							lastCreatedCharacter.put(accID, lastCreatedTime);
						}
					} else {
						lastCreatedCharacter.put(accID, Time());
					}
				}

			} catch (Exception& e) {
				error(e.getMessage());
			}
		} else {
			playerManager->updatePermissionLevel(playerCreature, PermissionLevelList::instance()->getLevelNumber("admin"));
		}

		if (doTutorial)
			playerManager->createTutorialBuilding(playerCreature);
		else
			playerManager->createSkippedTutorialBuilding(playerCreature);

		ValidatedPosition* lastValidatedPosition =
				ghost->getLastValidatedPosition();
		lastValidatedPosition->update(playerCreature);

		ghost->setBiography(bio);

		ghost->setLanguageID(playerTemplate->getDefaultLanguage());
	}

	ClientCreateCharacterSuccess* msg = new ClientCreateCharacterSuccess(
			playerCreature->getObjectID());
	playerCreature->sendMessage(msg);

	ChatManager* chatManager = zoneServer.get()->getChatManager();
	chatManager->addPlayer(playerCreature);

	String firstName = playerCreature->getFirstName();
	String lastName = playerCreature->getLastName();
	int raceID = playerTemplate->getRace();

	try {
		StringBuffer query;
		query
				<< "INSERT INTO `characters_dirty` (`character_oid`, `account_id`, `galaxy_id`, `firstname`, `surname`, `race`, `gender`, `template`)"
				<< " VALUES (" << playerCreature->getObjectID() << ","
				<< client->getAccountID() << "," << zoneServer.get()->getGalaxyID()
				<< "," << "'" << firstName.escapeString() << "','"
				<< lastName.escapeString() << "'," << raceID << "," << 0 << ",'"
				<< raceFile.escapeString() << "')";

		ServerDatabase::instance()->executeStatement(query);
	} catch (DatabaseException& e) {
		error(e.getMessage());
	}

	playerManager->addPlayer(playerCreature);

	// Copy claimed veteran rewards from player's alt character
	uint32 accID = client->getAccountID();
	ManagedReference<Account*> playerAccount = playerManager->getAccount(accID);
	if (playerAccount != NULL && ghost != NULL) {

		// Find the first alt character
		ManagedReference<CreatureObject*> altPlayer = NULL;
		CharacterList* characters = playerAccount->getCharacterList();
		for(int i = 0; i < characters->size(); ++i) {
			CharacterListEntry* entry = &characters->get(i);
			if(entry->getGalaxyID() == zoneServer.get()->getGalaxyID() &&
		       entry->getFirstName() != playerCreature->getFirstName() ) {

				altPlayer = playerManager->getPlayer(entry->getFirstName());
				if( altPlayer != NULL ){
					break;
				}
			}
		}

		// Record the rewards if alt player was found
		if( altPlayer != NULL && altPlayer->getPlayerObject() != NULL){

			Locker alocker( altPlayer );
			for( int i = 0; i < playerManager->getNumVeteranRewardMilestones(); i++ ){
				int milestone = playerManager->getVeteranRewardMilestone(i);
				String claimedReward = altPlayer->getPlayerObject()->getChosenVeteranReward(milestone);
				if( !claimedReward.isEmpty() ){
					ghost->addChosenVeteranReward(milestone,claimedReward);
				}
			}
		}
	}

	client->addCharacter(playerCreature->getObjectID(), zoneServer.get()->getGalaxyID());

	JediManager::instance()->onPlayerCreated(playerCreature);

	chatManager->sendMail("system", "@newbie_tutorial/newbie_mail:welcome_subject", "@newbie_tutorial/newbie_mail:welcome_body", playerCreature->getFirstName());

	//Join auction chat room
	ghost->addChatRoom(chatManager->getAuctionRoom()->getRoomID());

	ManagedReference<SuiMessageBox*> box = new SuiMessageBox(playerCreature, SuiWindowType::NONE);
	box->setPromptTitle("PLEASE NOTE");
	box->setPromptText("You are limited to creating one character per hour. Attempting to create another character or deleting your character before the 1 hour timer expires will reset the timer.");

	ghost->addSuiBox(box);
	playerCreature->sendMessage(box->generateMessage());

	return true;
}
Esempio n. 12
0
bool CSubprocess::PSExtract(CSubprocess::PInfoArray &arPinfo)
{
  bool rc=false;
  arPinfo.clear();
  // If Windows NT:
  switch(GetPlatform()) {
  case VER_PLATFORM_WIN32_NT:
    if(hInstLib1) {
      
      // Get procedure addresses.
      static BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * ) = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))GetProcAddress( hInstLib1, "EnumProcesses" ) ;
      if( lpfEnumProcesses) {
        
        if(hInstLib2) {
          
          static DWORD (WINAPI *lpfNtQueryInformationProcess)( HANDLE, int, void *, DWORD, LPDWORD ) =
            (DWORD(WINAPI *)(HANDLE, int, void *, DWORD, LPDWORD)) GetProcAddress( hInstLib2,"NtQueryInformationProcess" ) ;
          
          if(lpfNtQueryInformationProcess){
            DWORD dwMaxPids=256;
            DWORD dwPidSize;
            DWORD *arPids = NULL ;
            do {
              delete [] arPids;
              arPids=new DWORD[dwMaxPids];
            } while(lpfEnumProcesses(arPids, dwMaxPids, &dwPidSize) && dwPidSize/sizeof(DWORD)==dwMaxPids) ;
            
            if(dwPidSize/sizeof(DWORD)<dwMaxPids){
              rc=true;
              for( DWORD dwIndex = 0 ; dwIndex < dwPidSize/sizeof(DWORD); dwIndex++ ) {
                // Regardless of OpenProcess success or failure, we
                // still call the enum func with the ProcID.
                DWORD pid=arPids[dwIndex];
                HANDLE hProcess=::OpenProcess( PROCESS_QUERY_INFORMATION, FALSE, pid ); 
                if (hProcess ) {
                  struct {
                    DWORD ExitStatus; // receives process termination status
                    DWORD PebBaseAddress; // receives process environment block address
                    DWORD AffinityMask; // receives process affinity mask
                    DWORD BasePriority; // receives process priority class
                    ULONG UniqueProcessId; // receives process identifier
                    ULONG InheritedFromUniqueProcessId; // receives parent process identifier
                  } pbi;
                  memset( &pbi, 0, sizeof(pbi)); 
                  DWORD retLen; 
                  __int64 ftCreation,ftExit,ftKernel,ftUser;
                  if(lpfNtQueryInformationProcess(hProcess, 0 /*ProcessBasicInformation*/, &pbi, sizeof(pbi), &retLen)>=0 &&
                    TRUE==::GetProcessTimes (hProcess,(FILETIME *)&ftCreation,(FILETIME *)&ftExit,(FILETIME *)&ftKernel,(FILETIME *)&ftUser)){
                    // The second test is important.  It excludes orphaned processes who appear to have been adopted by virtue of a new
                    // process having been created with the same ID as their original parent.
                    PInfo p;
                    p.PID=pid;
                    p.PPID=pbi.InheritedFromUniqueProcessId;
                    p.tCreation=ftCreation;
                    p.tCpu=Time((ftKernel+ftUser)/10000);
                    arPinfo.push_back(p);
                  }
                  
                  CloseHandle(hProcess); 

                }
              }
            }
            delete [] arPids;
          }          
        }
      }      
    }
    break;
  case VER_PLATFORM_WIN32_WINDOWS:
    
    if( hInstLib1) {
      
      static HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD)=
        (HANDLE(WINAPI *)(DWORD,DWORD))GetProcAddress( hInstLib1,"CreateToolhelp32Snapshot" ) ;
      static BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32)=
        (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( hInstLib1, "Process32First" ) ;
      static BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32)=
        (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( hInstLib1, "Process32Next" ) ;
      if( lpfProcess32Next && lpfProcess32First && lpfCreateToolhelp32Snapshot) {
        
        // Get a handle to a Toolhelp snapshot of the systems
        // processes.
        HANDLE hSnapShot = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) ;
        if(INVALID_HANDLE_VALUE != hSnapShot) {
          // Get the first process' information.
          PROCESSENTRY32 procentry;
          procentry.dwSize = sizeof(PROCESSENTRY32) ;
          if(lpfProcess32First( hSnapShot, &procentry )){
            rc=true;
            do {
              PInfo p;
              p.PID=procentry.th32ProcessID;
              p.PPID=procentry.th32ParentProcessID;
              arPinfo.push_back(p);
            } while(lpfProcess32Next( hSnapShot, &procentry ));
          }
          CloseHandle(hSnapShot);
        }
      }
    }
    break;
  default:
    break;
  }    

  SetParents(arPinfo);

  if(!rc){
    ERROR(_T("Couldn't get process information!\n"));
  }
  return rc;
}
Esempio n. 13
0
void MouseInputSource::handleWheel (ComponentPeer* const peer, const Point<int>& positionWithinPeer, const int64 time, const float x, const float y)
{
    pimpl->handleWheel (peer, positionWithinPeer, Time (time), x, y);
}
Esempio n. 14
0
void MouseInputSource::handleEvent (ComponentPeer* peer, const Point<int>& positionWithinPeer, const int64 time, const ModifierKeys& mods)
{
    pimpl->handleEvent (peer, positionWithinPeer, Time (time), mods.withOnlyMouseButtons());
}
Esempio n. 15
0
// Static
Time Time::fromMicroseconds(Int64 microSeconds){
	return Time(microSeconds);	
};
Esempio n. 16
0
Time GetSysTime() {
	return Time(time(NULL));
}
		Time BgfxClock::GetElapsedTime()
		{
			const double Freq = double( bx::getHPFrequency() );
			const double ToMs = 1000.0 / Freq;
			return Time( bx::getHPCounter() * ToMs * 0.001f );
		}
Esempio n. 18
0
int64 GetUTCSeconds(Time tm)
{
	return tm - Time(1970, 1, 1) + GetLeapSeconds(tm);
}
Esempio n. 19
0
void CTimer::Start(void)
{
    m_TimerLock.Lock();
    m_StartTime = Time();
}
Esempio n. 20
0
Time TimeFromUTC(int64 seconds)
{
	Time tm = Time(1970, 1, 1) + seconds;
	return tm - GetLeapSeconds(tm);
}
void SchedulesTabController::addRule(model::ScheduleRuleset & scheduleRuleset)
{
  model::ScheduleRule rule(scheduleRuleset);

  rule.daySchedule().addValue(Time(1,0),defaultStartingValue(rule.daySchedule()));
}
Esempio n. 22
0
Time EXP_FUNC systemTime()
{
	return Time(time(NULL));
}
Esempio n. 23
0
static void trainSetSpeed(const int speed, const int stopTime, const int delayer, Driver* me) {
  char msg[4];
  msg[1] = (char)me->trainNum;

  if (me->lastSensorActualTime > 0) {
    // a/d related stuff
    int newSpeed = speed >=0 ? speed : 0;
    int now = Time(me->timeserver) * 10;
    if (me->speed == newSpeed) {
      // do nothing
    }
    else if (me->speed == 0) {
      // accelerating from 0
      int v0 = getVelocity(me);
      int v1 = me->v[newSpeed][ACCELERATE];
      int t0 = now + 8; // compensate for time it takes to send to train
      int t1 = now + 8 + me->a[newSpeed];
      poly_init(&me->adPoly, t0, t1, v0, v1);
      me->isAding = 1;
      me->lastReportDist = 0;
      me->adEndTime = t1;
    } else if (newSpeed == 0) {
      // decelerating to 0
      int v0 = getVelocity(me);
      int v1 = me->v[newSpeed][DECELERATE];
      int t0 = now + 8; // compensate for time it takes to send to train
      int t1 = now + 8 + getStoppingTime(me);
      poly_init(&me->adPoly, t0, t1, v0, v1);
      me->isAding = 1;
      me->lastReportDist = 0;
      me->adEndTime = t1;
    }
  }

  TrainDebug(me, "Train Setting Speed %d", speed);

  if (speed >= 0) {
    if (delayer) {
      TrainDebug(me, "Reversing speed.------- %d", speed);
      msg[0] = 0xf;
      msg[1] = (char)me->trainNum;
      msg[2] = (char)speed;
      msg[3] = (char)me->trainNum;
      Putstr(me->com1, msg, 4);

      //TrainDebug(me, "Next Sensor: %d %d", me->nextSensorIsTerminal, me->lastSensorIsTerminal);
      // Update prediction
      if (me->nextSensorIsTerminal) {
        me->nextSensorBox = me->nextSensorBox == EX ? EN : EX;

        //TrainDebug(me, "LAst Sensor: %d ", me->lastSensorVal);
      } else {
        int action = me->nextSensorVal%2 == 1 ? 1 : -1;
        me->nextSensorVal = me->nextSensorVal + action;
      }
      if (me->lastSensorIsTerminal) {
        me->lastSensorBox = me->lastSensorBox == EX ? EN : EX;
      } else {
        int action = me->lastSensorVal%2 == 1 ? 1 : -1;
        me->lastSensorVal = me->lastSensorVal + action;
      }

      float distTemp = me->distanceFromLastSensor;
      me->distanceFromLastSensor = me->distanceToNextSensor;
      me->distanceToNextSensor = distTemp;

      char valTemp = me->nextSensorVal;
      me->nextSensorVal = me->lastSensorVal;
      me->lastSensorVal = valTemp;

      char boxTemp = me->nextSensorBox;
      me->nextSensorBox = me->lastSensorBox;
      me->lastSensorBox = boxTemp;

      if (me->nextSensorIsTerminal || me->lastSensorIsTerminal){
        char isTemp = me->nextSensorIsTerminal;
        me->nextSensorIsTerminal = me->lastSensorIsTerminal;
        me->lastSensorIsTerminal = isTemp;
      }
      // Reserve the track above train and future (covers case of init)

      // Update prediction
      updatePrediction(me);
      int reserveStatus = reserveMoreTrack(me, 0, me->d[speed][ACCELERATE][MAX_VAL]); // moving
      if (reserveStatus == RESERVE_FAIL) {
        reroute(me);
      }
    } else {
      //TrainDebug(me, "Set speed. %d %d", speed, me->trainNum);
      msg[0] = (char)speed;
      Putstr(me->com1, msg, 2);
      if (speed == 0) {
        int delayTime = stopTime + 500;
        Reply(me->stopDelayer, (char*)&delayTime, 4);
      }
    }
    if (speed > me->speed) {
      me->speedDir = ACCELERATE;
    } else if (speed < me->speed) {
      me->speedDir = DECELERATE;
    }
    me->speed = speed;
  } else {
    //TrainDebug(me, "Reverse... %d ", me->speed);
    DriverMsg delayMsg;
    delayMsg.type = SET_SPEED;
    delayMsg.timestamp = stopTime + 500;
    if (me->speedAfterReverse == -1) {
      delayMsg.data2 = (signed char)me->speed;
    } else {
      delayMsg.data2 = (signed char)me->speedAfterReverse;
    }
    //TrainDebug(me, "Using delayer: %d for %d", me->delayer, stopTime);

    Reply(me->delayer, (char*)&delayMsg, sizeof(DriverMsg));

    msg[0] = 0;
    msg[1] = (char)me->trainNum;

    Putstr(me->com1, msg, 2);
    me->speed = 0;
    me->speedDir = DECELERATE;
  }
}
Esempio n. 24
0
    /** \fn content(po::variables_map const& vm)
        \brief Execute the NEST synapse Miniapp.
        \param vm encapsulate the command line and all needed informations
     */
    void model_content(po::variables_map const& vm)
    {
        PoorMansAllocator poormansallocpool;
        double dt = vm["dt"].as<double>();
        int iterations = vm["iterations"].as<int>();
        const int num_connections = vm["nConnections"].as<int>();
        const int num_detectors = vm["nDetectors"].as<int>();
        bool with_connector = vm.count("connector") > 0;
        bool with_manager = vm.count("manager") > 0;

        //will turn into ptr to base class if more synapse are implemented
        tsodyks2* syn;
        ConnectorBase* conn = NULL;

        //preallocate vector for results
        std::vector<spikedetector> detectors(num_detectors);
        std::vector<targetindex> detectors_targetindex(num_detectors);

        // register spike detectors

        connectionmanager* cn = NULL;

        for(unsigned int i=0; i < num_detectors; ++i) {
            detectors[i].set_lid(i);    //give nodes a local id
            //scheduler stores pointers to the spike detectors
            detectors_targetindex[i] = scheduler::add_node(&detectors[i]);  //add them to the scheduler
        }

        if (vm["model"].as<std::string>() == "tsodyks2") {
            const double delay = vm["delay"].as<double>();
            const double weight = vm["weight"].as<double>();
            const double U = vm["U"].as<double>();
            const double u = vm["u"].as<double>();
            const double x = vm["x"].as<double>();
            const double tau_rec = vm["tau_rec"].as<double>();
            const double tau_fac = vm["tau_fac"].as<double>();
            const bool pool = vm["pool"].as<bool>();
            if(pool){
                poormansallocpool.states = pool;
            }
            if ( with_manager ) {
                //build connection manager
                cn = new connectionmanager(vm);
                build_connections_from_neuron(detectors_targetindex, *cn, vm);
            }
            else if ( with_connector ) {
                //build connector
                for(unsigned int i=0; i < num_connections; ++i) {
                    //TODO permute parameters
                    tsodyks2 synapse(delay, weight, U, u, x, tau_rec, tau_fac, detectors_targetindex[i%num_detectors]);
                    conn = add_connection(conn, synapse); //use static function from connectionmanager
                }
            }
            else {
                syn = new tsodyks2(delay, weight, U, u, x, tau_rec, tau_fac, detectors_targetindex[0]);
            }
        }
        /* else if () .. further synapse models*/
        else {
            throw std::invalid_argument("connection model implementation missing");
        }
        //create a few events
        std::vector< spikeevent > events(iterations);
        for (unsigned int i=0; i<iterations; i++) {
            Time t(i*10.0);
            events[i].set_stamp( t ); // in Network::send< SpikeEvent >
            events[i].set_sender( NULL ); // in Network::send< SpikeEvent >
            //events[i]->set_sender_gid( sgid ); // Network::send_local
        }

        boost::chrono::system_clock::duration delay;

        if ( with_manager ) {
            if (cn==NULL) {
                throw std::runtime_error("connectionmanager pointer is not valid");
            }
            const int t = vm["thread"].as<int>(); // thead_num
            const int min_delay=vm["min_delay"].as<int>();
            const int nSpikes = vm["nSpikes"].as<int>();
            const int simtime = iterations * min_delay;
            const int ngroups = vm["nGroups"].as<int>();
            const int rank = vm["rank"].as<int>();
            const int size = vm["size"].as<int>();
            const int ncells = vm["nNeurons"].as<int>();
            //environment::event_generator generator(nSpikes, simtime, ngroups, rank, size, ncells);
            environment::event_generator generator(ngroups);
            double mean = static_cast<double>(simtime) / static_cast<double>(nSpikes);
            double lambda = 1.0 / static_cast<double>(mean * size);
            environment::generate_poisson_events(generator.begin(),
                             simtime, ngroups, rank, size, ncells, lambda);

            const unsigned int stats_generated_spikes = generator.get_size(t);
            int sim_time = 0;
            spikeevent se;
            boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
            for (unsigned int i=0; i<iterations; i++) {
                sim_time+=min_delay;
                while(generator.compare_top_lte(t, sim_time)) {
                    environment::gen_event g = generator.pop(t);
                    index nid = g.first;
                    se.set_stamp( Time(g.second) ); // in Network::send< SpikeEvent >
                    se.set_sender_gid( nid ); // in Network::send< SpikeEvent >

                    cn->send(t, nid, se); //send spike
                }
            }
            delay = boost::chrono::system_clock::now() - start;
            std::cout << "Connection manager simulated" << std::endl;
            std::cout << "Statistics:" << std::endl;
            std::cout << "\tgenerated spikes: " << stats_generated_spikes << std::endl;
            int recvSpikes=0;
            for (unsigned int i=0; i<detectors.size(); i++)
                recvSpikes+=detectors[i].spikes.size();
            std::cout << "\trecv spikes: " << recvSpikes << std::endl;

            std::cout << "\tEvents left:" << std::endl;
            while (!generator.empty(t)) {
                environment::gen_event g = generator.pop(t);
                std::cout << "Event " << g.first << " " << g.second << std::endl;
            }

            delete cn;
        }
        else if ( with_connector ) {
            if (conn==NULL) {
                throw std::runtime_error("connector pointer is not valid");
            }
            boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
            for (unsigned int i=0; i<iterations; i++) {
                conn->send(events[i]); //send spike
            }
            delay = boost::chrono::system_clock::now() - start;

            std::cout << "Connector simulated with " << num_connections << " connections" << std::endl;
        }
        else {
            if (!syn) {
                throw std::runtime_error("connection pointer is not valid");
            }
            double t_lastspike = 0.0;
            boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
            for (unsigned int i=0; i<iterations; i++) {
                syn->send(events[i], t_lastspike); //send spike
                t_lastspike += dt;
            }
            delay = boost::chrono::system_clock::now() - start;
            std::cout << "Single connection simulated" << std::endl;
            delete syn;
        }

        std::cout << "Duration: " << delay << std::endl;
        std::cout << "Last weight " << detectors[0].spikes.back().get_weight() << std::endl;
    }
Esempio n. 25
0
 /// multiplication operator
 Time Time::operator* (double mult) const
 {
   return Time(this->totalDays()*mult);
 }
Esempio n. 26
0
// Static
Time Time::fromSeconds(float seconds){
	return Time((Int64)(seconds * 1000000.f));
};
Esempio n. 27
0
 /// get current time of day
 Time Time::currentTime()
 {
   posix_time::ptime now = posix_time::second_clock::local_time();
   return Time(now.time_of_day());
 }
Esempio n. 28
0
// Build a Time object from an amount of miliseconds
Time Time::fromMiliSeconds(Int64 miliSeconds){
	return Time((Int64)(miliSeconds * 10000.f));
};
Esempio n. 29
0
BOOL
MFCArrangeView::OnDrop(
			COleDataObject* object,
			DROPEFFECT dropEffect,
			CPoint point 
		)
{
	cerr << "MFCArrangeView::on drop"<<endl;
	point += GetScrollPosition();
	switch (dragon.type) {
		case QuaDrop::FILES:
		case QuaDrop::AUDIOFILES:
		case QuaDrop::MIDIFILES: {
			Time	at_time;
			short	at_channel;
			Pix2Time(point.x, at_time);
			at_channel = Pix2Channel(point.y);
			std::cerr << "file drop " << at_channel << " chan " << at_time.StringValue() << endl;
			//			int		bar, barbeat, beattick;
//			at_time.GetBBQValue(bar, barbeat, beattick);
//			fprintf(stderr, "drag files is dropped: on point %d %d, channel %d, ticks %d t %d:%d.%d\n", point.x, point.y, at_channel, at_time.ticks, bar, barbeat, beattick);
			short	i;
			bool	drop_sample_file=false;
			bool	drop_midi_file=false;
			bool	drop_qua_file=false;
			for (i=0; ((unsigned)i)<dragon.data.filePathList->size(); i++) {
				string	mime_t = Qua::identifyFile(dragon.data.filePathList->at(i));
				if (mime_t.size() > 0) {
					std::cout << "drop " << dragon.data.filePathList->at(i) << ", " << mime_t << endl;
					if (mime_t == "audio/x-midi") {
						drop_midi_file = true;
						break;
					} else if (mime_t == "audio/x-wav" ||
								mime_t == "audio/x-raw" ||
								mime_t == "audio/x-aiff") {
						drop_sample_file = true;
						break;
					} else if (mime_t == "audio/x-quascript") {
						drop_qua_file = true;
						break;
					}
				} else {
//					fprintf(stderr, "dragged file %d unidentifiable\n", i);
				}
			}
			if (i == dragon.count) { // didn't find something useable in the drop
				return FALSE;
			}
			if (drop_sample_file) {
				StabEnt *s = quaLink->CreateSample("", *dragon.data.filePathList);
				quaLink->CreateInstance(s, at_channel, at_time, Time());
			} else if (drop_midi_file) {
				;
			} else if (drop_qua_file) {
				;
			} else {
				return FALSE;
			}
			return TRUE;
		}

		case QuaDrop::VSTPLUGIN: 
		case QuaDrop::VOICE: 
		case QuaDrop::SAMPLE: 
		case QuaDrop::SCHEDULABLE: {
			Time	at_time;
			short	at_channel;
			Pix2Time(point.x, at_time);
			at_channel = Pix2Channel(point.y);
			cerr << "schedulable drop " << at_channel << " chan " << at_time.StringValue() << endl;
//			int		bar, barbeat, beattick;
//			at_time.GetBBQValue(bar, barbeat, beattick);
//			fprintf(stderr, "drop schedulable %s: on point %d %d, channel %d, ticks %d t %d:%d.%d\n", dragon.data.symbol->name, point.x, point.y, at_channel, at_time.ticks, bar, barbeat, beattick);

			quaLink->CreateInstance(dragon.data.symbol, at_channel, at_time, Time::zero);
			return TRUE;
		}
			
		case QuaDrop::INSTANCE: {
			Time	at_time;
			short	at_channel;
			Pix2Time(point.x, at_time);
			at_channel = Pix2Channel(point.y);
			std::cerr << "instance drop " << at_channel << " chan " << at_time.StringValue() << endl;
			//			int		bar, barbeat, beattick;
//			at_time.GetBBQValue(bar, barbeat, beattick);
//			fprintf(stderr, "drop instance %s: on point %d %d, channel %d, ticks %d t %d:%d.%d\n", dragon.data.symbol->name, point.x, point.y, at_channel, at_time.ticks, bar, barbeat, beattick);
			Instance *i = dragon.data.symbol->InstanceValue();
			if (i != nullptr) {
				quaLink->MoveInstance(dragon.data.symbol, at_channel, at_time, i->duration);
			} else {
				std::cout << "oops bad drop ... expected an instance" << endl;
			}
			return TRUE;
		}
		case QuaDrop::APPLICATION:
		case QuaDrop::PORT:
		case QuaDrop::BUILTIN:
		case QuaDrop::TEMPLATE:
			switch (dropEffect) {
				case DROPEFFECT_COPY:
					fprintf(stderr, "left click drag: on drop copy %d %d\n", point.x, point.y);
					break;
				case DROPEFFECT_MOVE:
					fprintf(stderr, "left click drag: on drop move %d %d\n", point.x, point.y);
					break;
				case DROPEFFECT_LINK:
					fprintf(stderr, "left click drag: on drop link %d %d\n", point.x, point.y);
					break;
			}
			break;
	}
	return FALSE;
}
Esempio n. 30
0
void notify_ADMINX(Connection *xConn,PCStr(admin),PCStr(what),PCStr(body))
{   FILE *tmp;
    FILE *bt;
    Connection ConnBuff,*Conn = &ConnBuff;
    CStr(head,1024);
    CStr(me,128);
    CStr(date,128);
    CStr(load,128);
    CStr(cwd,1024);
    CStr(uname,128);
    int now;
    const char *bugbox = "*****@*****.**";
    CStr(msgid,1024);
    CStr(buf,1024);

    if( strncasecmp(what,"sig",3) != 0 )
        if( strncasecmp(what,"failed",6) != 0 )
            if( strncasecmp(what,"modified",8) != 0 )
                if( strncasecmp(what,"approved",8) != 0 )
                    if( strncasecmp(what,"detected",8) != 0 )
                        if( strncasecmp(what,"[",1) != 0 ) /* abort in child process */
                            return;

    if( admin == NULL || *admin == 0 )
        admin = getADMIN1();

    now = time(NULL);
    if( xConn )
        *Conn = *xConn;
    else	bzero(Conn,sizeof(Connection));
    tmp = TMPFILE("NOTIFY");

    head[0] = 0;
    if( gethostname(me,sizeof(me)) != 0 )
        strcpy(me,"?");
    sprintf(msgid,"%d.%d.%d@%s",getpid(),itime(0),getuid(),me);

    StrftimeLocal(AVStr(date),sizeof(date),TIMEFORM_RFC822,now,0);
    Xsprintf(TVStr(head),"Subject: DeleGate-Report: %s\r\n",what);
    Xsprintf(TVStr(head),"From: [%d]@%s\r\n",getuid(),me);
    Xsprintf(TVStr(head),"To: %s (DeleGate ADMIN)\r\n",admin);
    Xsprintf(TVStr(head),"Reply-To: %s\r\n",bugbox);
    Xsprintf(TVStr(head),"Date: %s\r\n",date);
    Xsprintf(TVStr(head),"Message-Id: <%s>\r\n",msgid);
    Xsprintf(TVStr(head),"Content-Type: text/plain\r\n");
    fprintf(tmp,"%s\r\n",head);
    fprintf(tmp,"PLEASE FORWARD THIS MESSAGE TO <%s>.\r\n",bugbox);
    fprintf(tmp,"IT WILL BE HELPFUL FOR DEBUGGING.\r\n");
    fprintf(tmp,"\r\n");
    fprintf(tmp,"%s",head);
    fprintf(tmp,"Event: %s\r\n",what);
    Uname(AVStr(uname));
    fprintf(tmp,"Version: %s (%s)\r\n",DELEGATE_verdate(),uname);
    fprintf(tmp,"Host: %s\r\n",me);
    fprintf(tmp,"Owner: uid=%d/%d, gid=%d/%d\r\n",
            geteuid(),getuid(),getegid(),getgid());
    StrftimeLocal(AVStr(date),sizeof(date),TIMEFORM_RFC822,START_TIME,0);
    fprintf(tmp,"Started: %s\r\n",date);
    fprintf(tmp,"Pid: %d\r\n",getpid());
    cwd[0] = 0;
    IGNRETS getcwd(cwd,sizeof(cwd));
    fprintf(tmp,"Cwd: %s\r\n",cwd);
    strfLoadStat(AVStr(load),sizeof(load),"%L (%l)",now);
    fprintf(tmp,"Load: %s\r\n",load);
    fprintf(tmp,"Stack: %X %d/%d\r\n",p2i(STACK_PEAK),ll2i(STACK_BASE-STACK_PEAK),
            STACK_SIZE);
    fprintf(tmp,"\r\n");

    if( iamServer() ) {
    } else {
        fprintf(tmp,"Client-Proto: %s\r\n",CLNT_PROTO);
        fprintf(tmp,"Client-Host: %s:%d\r\n",Client_Addr(buf),Client_Port);
        if( TeleportHost[0] )
            fprintf(tmp,"Rident-Host: %s:%d..%s:%d\r\n",TelesockHost,TelesockPort,
                    TeleportAddr,TeleportPort);
        fprintf(tmp,"\r\n");
    }
    fprintf(tmp,"%s\r\n",body);

    /*
    	if( strncasecmp(what,"sig",3) == 0 || *what == '[' ){
    */
    if( strncasecmp(what,"sig",3) == 0
            || strncasecmp(what,"failed",6) == 0
            || *what == '[' ) {
        fprintf(tmp,"--iLog--begin\r\n");
        iLOGdump1(tmp,0);
        fprintf(tmp,"--iLog--end\r\n");

        fprintf(tmp,"\r\n");
        fprintf(tmp,"--AbortLog--begin\r\n");
        putAbortLog(tmp);
        fprintf(tmp,"--AbortLog--end\r\n");
    }

    if( strncasecmp(what,"sig",3) == 0 ) {
        int btout[2];
        double Start = Time();
        int rcc;

        fprintf(tmp,"\r\n");
        fprintf(tmp,"--BackTrace--begin\r\n");
        fflush(tmp);

        if( pipe(btout) == 0 ) {
            setNonblockingIO(btout[1],1);
            bt = fdopen(btout[1],"w");
            putBackTrace(bt);
            fclose(bt);
            bt = fdopen(btout[0],"r");
            rcc = file_copyTimeout(bt,tmp,NULL,128*1024,NULL,15);
            fclose(bt);
            sv1log("BatckTrace: %dB / %.1fs\n",rcc,Time()-Start);
        } else {
            bt = TMPFILE("BackTrace");
            putBackTrace(bt);
            fseek(bt,0,0);
            copyfile1(bt,tmp);
            fclose(bt);
        }
        fprintf(tmp,"\r\n");
        fprintf(tmp,"--BackTrace--end\r\n");
    }

    fflush(tmp);
    fseek(tmp,0,0);
    if( curLogFp() ) {
        CStr(line,1024);
        while( fgets(line,sizeof(line),tmp) != NULL )
            fprintf(curLogFp(),"--ABORT-- %s",line);
        fseek(tmp,0,0);
    }
    Conn->co_mask = (CONN_NOPROXY | CONN_NOMASTER);
    sendmail1(Conn,admin,admin,tmp,NULL);
    fclose(tmp);
}