예제 #1
0
/**
 * \brief Check if the collision is with a player.
 * \param that The other item of the collision.
 * \param info Some informations about the collision.
 */
void ptb::honeypot::collision_check_and_apply
( bear::engine::base_item& that, bear::universe::collision_info& info )
{
  player_proxy p(&that);

  if ( p != NULL )
    {
      if ( !m_given )
        {
          create_decoration();
          m_given = true;
          level_variables::set_honeypots_found
            ( get_level(),
              level_variables::get_honeypots_found(get_level()) + 1 );
          level_variables::set_honeypot_found( get_level(), m_id, true);

          if ( level_variables::get_honeypots_found(get_level()) % 5 == 0 )
            {
              give_life(1);
              give_life(2);
            }

	  on_found(p.get_index());
	  send_notification(p.get_index());

          kill();
        }
      else
        default_collision(info);
    }
  else
    default_collision(info);
} // honeypot::collision_check_and_apply()
static void
debugger_run_handler (IdeRunManager *run_manager,
                      IdeRunner     *runner,
                      gpointer       user_data)
{
  IdeDebuggerEditorAddin *self = user_data;
  IdeDebugManager *debug_manager;
  IdeContext *context;
  g_autoptr(GError) error = NULL;

  IDE_ENTRY;

  g_assert (IDE_IS_RUN_MANAGER (run_manager));
  g_assert (IDE_IS_RUNNER (runner));
  g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self));

  /*
   * Get the currently configured debugger and attach it to our runner.
   * It might need to prepend arguments like `gdb', `pdb', `mdb', etc.
   */
  context = ide_object_get_context (IDE_OBJECT (run_manager));
  debug_manager = ide_debug_manager_from_context (context);

  if (!ide_debug_manager_start (debug_manager, runner, &error))
    send_notification (self,
                       _("Failed to start the debugger"),
                       error->message,
                       "computer-fail-symbolic",
                       TRUE);

  IDE_EXIT;
}
예제 #3
0
파일: mesh_gatt.c 프로젝트: AlexDM0/bluenet
void resume_notifications() {

	waiting_notification_t* notification = nb_peek();

	if (send_notification(notification) == NRF_SUCCESS) {

#ifdef PRINT_MESH_VERBOSE
		LOGd("notification done");
#endif

		nb_pop();

		if (nb_empty()) {
			notifactionsPending = false;

#ifdef PRINT_MESH_VERBOSE
			LOGd("no more notifications pending");
#endif

		} else {

#ifdef PRINT_MESH_VERBOSE
			LOGd("continue with next pending notification");
#endif

			resume_notifications();
		}

	}

}
예제 #4
0
파일: Volume.cpp 프로젝트: luciang/haiku
// SendNotification
int
Volume::SendNotification(port_id port, int32 token, uint32 what, int32 op,
	nspace_id nsida, nspace_id nsidb, vnode_id vnida, vnode_id vnidb,
	vnode_id vnidc, const char *name)
{
PRINT(("Volume::SendNotification(%ld, %ld, 0x%lx, 0x%lx, %ld, %ld, %lld, %lld, %lld, \"%s\")\n", port, token, what, op, nsida, nsidb, vnida, vnidb, vnidc, name));
	return send_notification(port, token, what, op, nsida, nsidb, vnida,
		vnidb, vnidc, name);
}
예제 #5
0
void
send_notification_nbr(struct nbr *nbr, uint32_t status_code, uint32_t msg_id,
    uint16_t msg_type)
{
	log_debug("%s: lsr-id %s, status %s", __func__, inet_ntoa(nbr->id),
	     status_code_name(status_code));

	send_notification(status_code, nbr->tcp, msg_id, msg_type);
	nbr_fsm(nbr, NBR_EVT_PDU_SENT);
}
예제 #6
0
/* Clientlib */
int ts3plugin_onTextMessageEvent(uint64 serverConnectionHandlerID, anyID targetMode, anyID toID, anyID fromID, const char* fromName, const char* fromUniqueIdentifier, const char* message, int ffIgnored) {
    printf("PLUGIN: onTextMessageEvent %llu %d %d %s %s %d\n", (long long unsigned int)serverConnectionHandlerID, targetMode, fromID, fromName, message, ffIgnored);

	/* Friend/Foe manager has ignored the message, so ignore here as well. */
	if(ffIgnored) {
		return 0; /* Client will ignore the message anyways, so return value here doesn't matter */
	}

	send_notification(serverConnectionHandlerID, fromName, message);
    return 0;  /* 0 = handle normally, 1 = client will ignore the text message */
}
예제 #7
0
void
send_notification_nbr(struct nbr *nbr, u_int32_t status, u_int32_t msgid,
    u_int32_t type)
{
	struct ibuf	*buf;

	if (nbr->iface->passive)
		return;

	buf = send_notification(status, nbr->iface, msgid, type);
	evbuf_enqueue(&nbr->wbuf, buf);
}
예제 #8
0
  void service::send_notification(json_rpc_notification notification)
  {
    lock_guard lock(mutex_);

    for ( auto& ptr : connections_ )
    {
      auto connection = ptr.lock();

      if ( connection )
      {
        connection->send_notification(notification);
      }
    }
  }
예제 #9
0
/*
for reporting a sample that satisfies the reporting criteria and resetting the state machine
*/
int report_sample(sample s)
{
    if(send_notification(s)){  // sends current_sample if observing is on
        last_band = band(s); // limits state machine
        high_step = s + LWM2M_step; // reset floating band upper limit defined by step
        low_step = s - LWM2M_step; // reset floating band lower limit defined by step
        pmin_timer.detach();
        pmin_exceeded = false; // state machine to inhibit reporting at intervals < pmin
        pmin_timer.attach(&on_pmin, LWM2M_pmin);
        pmax_timer.detach();
        pmax_timer.attach(&on_pmax, LWM2M_pmax);
        return 1;
    }
    else return 0;
}
예제 #10
0
/**
 * The Notification timer looks for unsent notifications and sends them.
 *  - because not all events should wait until the notifications for them are sent
 * @param ticks - the current time
 * @param param - pointer to the domain_list
 */
void notification_timer(unsigned int ticks, void* param)
{
	r_notification *n;
	lock_get(notification_list->lock);
	while(notification_list->head){
		n = notification_list->head;
		notification_list->head = n->next;
		if (n->next) n->next->prev=0;
		else notification_list->tail=n->next;
		lock_release(notification_list->lock);			
		
		send_notification(n);
		free_r_notification(n);
		lock_get(notification_list->lock);
	}	
	lock_release(notification_list->lock);				
}
/**
 * \brief The hideout is discovered.
 * \param index Index of player that discovers hideout. 
 */
void ptb::hideout_bonus_item::discover(unsigned int index)
{
  bool bonus(false);

  if ( !game_variables::get_hideout_state(m_id) )
    {
      game_variables::set_hideout_state( m_id, true);
      bonus = true;
    }

  bear::engine::var_map vars;
  bear::engine::game::get_instance().get_game_variables
    ( vars, PTB_PERSISTENT_PREFIX +
      game_variables::get_main_level_name() + "/hideout/.*");
  
  bear::engine::var_map::iterator<bool>::type it;
  std::string prefix
    (PTB_PERSISTENT_PREFIX + game_variables::get_main_level_name()
     + "/hideout/");
  
  unsigned int found = 0;
  for ( it=vars.begin<bool>();
	(it!=vars.end<bool>()); ++it )
    {
      std::string var(it->first);
      std::string c1;
      c1 = var.erase(0, prefix.size());
      
      if ( game_variables::get_hideout_state(c1) )
	found++;
      else
	bonus = false;
    }

  if ( bonus )
    level_variables::all_hideouts_found(get_level());

  send_notification(index,found,vars.size());

  kill();
} // hideout_bonus_item::discover()
예제 #12
0
파일: tray.c 프로젝트: azuring/eyerest
void on_status (
        OrgZlbruceEyerestBasic *object,
        guint arg_time_remain,
        const gchar *arg_state)
{
    time_t time_remain = arg_time_remain;
    static gchar time_str[PATH_MAX];
    struct tm* tm = localtime(&time_remain);
    int len = 0;
    if(tm == NULL)
    {
        len = g_snprintf(time_str, sizeof(time_str), "%lu", (unsigned long)time);
    }
    else
    {
        len = strftime(time_str, sizeof(time_str), "%M:%S", tm);
    }

    //g_printf("time_str = %s, state = %s\n", time_str, arg_state);

    gtk_menu_item_set_label(GTK_MENU_ITEM(menu_item_state), time_str);
    gtk_status_icon_set_tooltip_text (tray_icon, time_str);

    if(arg_time_remain < 60)
    {
        if(!g_notified)
        {
            send_notification(time_str, arg_time_remain);
        }
    }
    else
    {
        g_notified = FALSE;
        if(g_notify_id != 0)
        {
            close_notification();
        }
    }
}
예제 #13
0
파일: mesh_gatt.c 프로젝트: AlexDM0/bluenet
void value_set_handler(void* p_event_data, uint16_t event_size) {

//	LOGd("value_set_handler");

//	waiting_notification_t* notification = (waiting_notification_t*) p_event_data;
	waiting_notification_t* notification = nb_peek();

//	printArray(notification, sizeof(waiting_notification_t));

	uint32_t err_code = send_notification(notification);
	if (err_code == BLE_ERROR_NO_TX_BUFFERS) {

#ifdef PRINT_MESH_VERBOSE
		LOGd("adding pending notification");
#endif

		notifactionsPending = true;
	} else {
//		LOGd("popping notification");
		nb_pop();
	}

}
예제 #14
0
int ts3plugin_onClientPokeEvent(uint64 serverConnectionHandlerID, anyID fromClientID, const char* pokerName, const char* pokerUniqueIdentity, const char* message, int ffIgnored) {
    anyID myID;

    printf("PLUGIN onClientPokeEvent: %llu %d %s %s %d\n", (long long unsigned int)serverConnectionHandlerID, fromClientID, pokerName, message, ffIgnored);

	/* Check if the Friend/Foe manager has already blocked this poke */
	if(ffIgnored) {
		return 0;  /* Client will block anyways, doesn't matter what we return */
	}

    /* Example code: Send text message back to poking client */
    if(ts3Functions.getClientID(serverConnectionHandlerID, &myID) != ERROR_ok) {  /* Get own client ID */
        ts3Functions.logMessage("Error querying own client id", LogLevel_ERROR, "Plugin", serverConnectionHandlerID);
        return 0;
    }
    if(fromClientID != myID) {  /* Don't reply when source is own client */
        if(ts3Functions.requestSendPrivateTextMsg(serverConnectionHandlerID, "Received your poke!", fromClientID, NULL) != ERROR_ok) {
            ts3Functions.logMessage("Error requesting send text message", LogLevel_ERROR, "Plugin", serverConnectionHandlerID);
        }
    }
	send_notification(serverConnectionHandlerID, pokerName, message);

    return 0;  /* 0 = handle normally, 1 = client will ignore the poke */
}
예제 #15
0
/**
 * Envoie un message de failure vers le socket précisé, avec des détails ou non.
 */
static void send_failure(const int socket, const char *param)
{
  send_notification(socket, RET_ERR, param);
}
예제 #16
0
/**
 * Envoie un message okas vers le socket précisé, avec des détails ou non.
 */
static void send_ok(const int socket, const char *param)
{
  send_notification(socket, RET_OK, param);
}
예제 #17
0
파일: jsonrpc-c.c 프로젝트: CoRfr/jsonrpc-c
int jrpc_ClientSendNotification(jrpc_ClientRef_t client, const char * method, cJSON * params) {
    return send_notification(client->connection, method, params);
}
예제 #18
0
void process()
{
    while (1)
    {
        char menu = get_menu();

        switch (menu)
        {
            case 'm': // menu
            case 'M':
                break;

            case 'q': // quit
            case 'Q':
                printf("quit..!!\n");
                return;

            case 's': // start server
            case 'S':
                start_listening_server();
                break;

            case 't': // send request
            case 'T':
                send_request_all();
                break;

            case 'c': // start client
            case 'C':
                start_discovery_server();
                break;

            case 'r': // send request
            case 'R':
                send_request();
                break;

            case 'b': // send notification
            case 'B':
                send_notification();
                break;

            case 'n': // select network
            case 'N':
                select_network();
                break;

            case 'x': // unselect network
            case 'X':
                unselect_network();
                break;

            case 'h': // handle request response
            case 'H':
                handle_request_response();
                break;

            case 'w':
            case 'W':
                g_received = 0;
                start_discovery_server();
                send_secure_request();
                while (g_received == 0)
                {
                    sleep(1);
                    handle_request_response();
                }
                break;

            case 'z':
            case 'Z':
                start_listening_server();
                while (1)
                {
                    sleep(1);
                    handle_request_response();
                }
                break;

            case 'g': // get network information
            case 'G':
                get_network_info();
                break;

            default:
                printf("not supported menu!!\n");
                break;
        }
    }
}