void Molotov::on_std_turn_player_hold_ignited() { --fuse_turns_; if (fuse_turns_ <= 0) { msg_log::add("The Molotov Cocktail explodes in my hand!"); map::player->active_explosive = nullptr; map::player->update_clr(); const Pos player_pos = map::player->pos; Snd snd("I hear an explosion!", Sfx_id::explosion_molotov, Ignore_msg_if_origin_seen::yes, player_pos, nullptr, Snd_vol::high, Alerts_mon::yes); snd_emit::emit_snd(snd); explosion::run(player_pos, Expl_type::apply_prop, Expl_src::misc, Emit_expl_snd::no, 0, new Prop_burning(Prop_turns::std)); delete this; } }
/** * @fn static BOOL rcv_snd(void) * @brief Receive a data and send a data */ L1CODE static BOOL rcv_snd(void) { if ( mnTxCount <= 0 && mnRxCount <= 1 ) { /* transfer end */ /* CS disable */ if( mpCurConfig->mnCS >= 0 ) *pSPI0_FLG &= ~( 1 << ( mpCurConfig->mnCS ) ); /* SPI disable */ *pSPI0_CTL = 0; ssync(); /* Get rest of one rx message, if there is. */ get_rx(); /* Complete! */ mpCurConfig = 0; return FALSE; } else { /* transfer continue */ /* Send tx */ snd(); if (!get_rx() ) { /* get dummy data for trigger */ volatile UH dummy = *pSPI0_RDBR; } return TRUE; } }
/*! Sends gt highway command to com.nokia.services.hsapplication.IHomeScreenClient service. \a functionSignature function name, \a widgetDescriptor parsed widget descriptor. */ void HsWidgetInstallerSender::widgetChanged(QString functionSignature, HsWidgetComponentDescriptor &widgetDescriptor) { QVariantHash widgetDescriptorHash; widgetDescriptorHash["uri"] = widgetDescriptor.uri(); widgetDescriptorHash["title"] = widgetDescriptor.title(); widgetDescriptorHash["description"] = widgetDescriptor.description(); widgetDescriptorHash["iconUri"] = widgetDescriptor.iconUri(); widgetDescriptorHash["hidden"] = widgetDescriptor.hidden(); widgetDescriptorHash["serviceXml"] = widgetDescriptor.serviceXml(); widgetDescriptorHash["version"] = widgetDescriptor.version(); widgetDescriptorHash["installationPath"] = widgetDescriptor.installationPath(); widgetDescriptorHash["Hs::translationFilename"] = widgetDescriptor.translationFilename(); XQServiceRequest snd(INTERFACE_NAME, functionSignature, true); XQRequestInfo requestInfo = snd.info(); requestInfo.setBackground(true); snd.setInfo(requestInfo); snd << widgetDescriptorHash; bool res=snd.send(); if (!res) { qDebug() << "error send: " << snd.latestError(); } }
void tex_alloc(const char *name, device_memory& mem, InterpolationType interpolation, ExtensionType extension) { VLOG(1) << "Texture allocate: " << name << ", " << string_human_readable_number(mem.memory_size()) << " bytes. (" << string_human_readable_size(mem.memory_size()) << ")"; thread_scoped_lock lock(rpc_lock); mem.device_pointer = ++mem_counter; RPCSend snd(socket, &error_func, "tex_alloc"); string name_string(name); snd.add(name_string); snd.add(mem); snd.add(interpolation); snd.add(extension); snd.write(); snd.write_buffer((void*)mem.data_pointer, mem.memory_size()); }
void task_release_tile(RenderTile& tile) { thread_scoped_lock acquire_lock(acquire_mutex); if(tile.buffer) tile.buffer = ptr_imap[tile.buffer]; if(tile.rng_state) tile.rng_state = ptr_imap[tile.rng_state]; { thread_scoped_lock lock(rpc_lock); RPCSend snd(socket, &error_func, "release_tile"); snd.add(tile); snd.write(); lock.unlock(); } do { if(blocked_waiting) listen_step(); /* todo: avoid busy wait loop */ thread_scoped_lock lock(rpc_lock); if(!acquire_queue.empty()) { AcquireEntry entry = acquire_queue.front(); acquire_queue.pop_front(); if(entry.name == "release_tile") { lock.unlock(); break; } else { cout << "Error: unexpected release RPC receive call \"" + entry.name + "\"\n"; } } } while(acquire_queue.empty() && !stop); }
/* note that the lock must be already acquired upon entry. * This is necessary because the caller often peeks at * the header and delegates control to here when it doesn't * specifically handle the current RPC. * The lock must be unlocked before returning */ void process(RPCReceive& rcv, thread_scoped_lock &lock) { if(rcv.name == "mem_alloc") { MemoryType type; network_device_memory mem; device_ptr client_pointer; rcv.read(mem); rcv.read(type); lock.unlock(); client_pointer = mem.device_pointer; /* create a memory buffer for the device buffer */ size_t data_size = mem.memory_size(); DataVector &data_v = data_vector_insert(client_pointer, data_size); if(data_size) mem.data_pointer = (device_ptr)&(data_v[0]); else mem.data_pointer = 0; /* perform the allocation on the actual device */ device->mem_alloc(mem, type); /* store a mapping to/from client_pointer and real device pointer */ pointer_mapping_insert(client_pointer, mem.device_pointer); } else if(rcv.name == "mem_copy_to") { network_device_memory mem; rcv.read(mem); lock.unlock(); device_ptr client_pointer = mem.device_pointer; DataVector &data_v = data_vector_find(client_pointer); size_t data_size = mem.memory_size(); /* get pointer to memory buffer for device buffer */ mem.data_pointer = (device_ptr)&data_v[0]; /* copy data from network into memory buffer */ rcv.read_buffer((uint8_t*)mem.data_pointer, data_size); /* translate the client pointer to a real device pointer */ mem.device_pointer = device_ptr_from_client_pointer(client_pointer); /* copy the data from the memory buffer to the device buffer */ device->mem_copy_to(mem); } else if(rcv.name == "mem_copy_from") { network_device_memory mem; int y, w, h, elem; rcv.read(mem); rcv.read(y); rcv.read(w); rcv.read(h); rcv.read(elem); device_ptr client_pointer = mem.device_pointer; mem.device_pointer = device_ptr_from_client_pointer(client_pointer); DataVector &data_v = data_vector_find(client_pointer); mem.data_pointer = (device_ptr)&(data_v[0]); device->mem_copy_from(mem, y, w, h, elem); size_t data_size = mem.memory_size(); RPCSend snd(socket, &error_func, "mem_copy_from"); snd.write(); snd.write_buffer((uint8_t*)mem.data_pointer, data_size); lock.unlock(); } else if(rcv.name == "mem_zero") { network_device_memory mem; rcv.read(mem); lock.unlock(); device_ptr client_pointer = mem.device_pointer; mem.device_pointer = device_ptr_from_client_pointer(client_pointer); DataVector &data_v = data_vector_find(client_pointer); mem.data_pointer = (device_ptr)&(data_v[0]); device->mem_zero(mem); } else if(rcv.name == "mem_free") { network_device_memory mem; device_ptr client_pointer; rcv.read(mem); lock.unlock(); client_pointer = mem.device_pointer; mem.device_pointer = device_ptr_from_client_pointer_erase(client_pointer); device->mem_free(mem); } else if(rcv.name == "const_copy_to") { string name_string; size_t size; rcv.read(name_string); rcv.read(size); vector<char> host_vector(size); rcv.read_buffer(&host_vector[0], size); lock.unlock(); device->const_copy_to(name_string.c_str(), &host_vector[0], size); } else if(rcv.name == "tex_alloc") { network_device_memory mem; string name; InterpolationType interpolation; bool periodic; device_ptr client_pointer; rcv.read(name); rcv.read(mem); rcv.read(interpolation); rcv.read(periodic); lock.unlock(); client_pointer = mem.device_pointer; size_t data_size = mem.memory_size(); DataVector &data_v = data_vector_insert(client_pointer, data_size); if(data_size) mem.data_pointer = (device_ptr)&(data_v[0]); else mem.data_pointer = 0; rcv.read_buffer((uint8_t*)mem.data_pointer, data_size); device->tex_alloc(name.c_str(), mem, interpolation, periodic); pointer_mapping_insert(client_pointer, mem.device_pointer); } else if(rcv.name == "tex_free") { network_device_memory mem; device_ptr client_pointer; rcv.read(mem); lock.unlock(); client_pointer = mem.device_pointer; mem.device_pointer = device_ptr_from_client_pointer_erase(client_pointer); device->tex_free(mem); } else if(rcv.name == "load_kernels") { bool experimental; rcv.read(experimental); bool result; result = device->load_kernels(experimental); RPCSend snd(socket, &error_func, "load_kernels"); snd.add(result); snd.write(); lock.unlock(); } else if(rcv.name == "task_add") { DeviceTask task; rcv.read(task); lock.unlock(); if(task.buffer) task.buffer = device_ptr_from_client_pointer(task.buffer); if(task.rgba_half) task.rgba_half = device_ptr_from_client_pointer(task.rgba_half); if(task.rgba_byte) task.rgba_byte = device_ptr_from_client_pointer(task.rgba_byte); if(task.shader_input) task.shader_input = device_ptr_from_client_pointer(task.shader_input); if(task.shader_output) task.shader_output = device_ptr_from_client_pointer(task.shader_output); task.acquire_tile = function_bind(&DeviceServer::task_acquire_tile, this, _1, _2); task.release_tile = function_bind(&DeviceServer::task_release_tile, this, _1); task.update_progress_sample = function_bind(&DeviceServer::task_update_progress_sample, this); task.update_tile_sample = function_bind(&DeviceServer::task_update_tile_sample, this, _1); task.get_cancel = function_bind(&DeviceServer::task_get_cancel, this); device->task_add(task); } else if(rcv.name == "task_wait") { lock.unlock(); blocked_waiting = true; device->task_wait(); blocked_waiting = false; lock.lock(); RPCSend snd(socket, &error_func, "task_wait_done"); snd.write(); lock.unlock(); } else if(rcv.name == "task_cancel") { lock.unlock(); device->task_cancel(); } else if(rcv.name == "acquire_tile") { AcquireEntry entry; entry.name = rcv.name; rcv.read(entry.tile); acquire_queue.push_back(entry); lock.unlock(); } else if(rcv.name == "acquire_tile_none") { AcquireEntry entry; entry.name = rcv.name; acquire_queue.push_back(entry); lock.unlock(); } else if(rcv.name == "release_tile") { AcquireEntry entry; entry.name = rcv.name; acquire_queue.push_back(entry); lock.unlock(); } else { cout << "Error: unexpected RPC receive call \"" + rcv.name + "\"\n"; lock.unlock(); } }
void task_cancel() { thread_scoped_lock lock(rpc_lock); RPCSend snd(socket, &error_func, "task_cancel"); snd.write(); }
void task_wait() { thread_scoped_lock lock(rpc_lock); RPCSend snd(socket, &error_func, "task_wait"); snd.write(); lock.unlock(); TileList the_tiles; /* todo: run this threaded for connecting to multiple clients */ for(;;) { if(error_func.have_error()) break; RenderTile tile; lock.lock(); RPCReceive rcv(socket, &error_func); if(rcv.name == "acquire_tile") { lock.unlock(); /* todo: watch out for recursive calls! */ if(the_task.acquire_tile(this, tile)) { /* write return as bool */ the_tiles.push_back(tile); lock.lock(); RPCSend snd(socket, &error_func, "acquire_tile"); snd.add(tile); snd.write(); lock.unlock(); } else { lock.lock(); RPCSend snd(socket, &error_func, "acquire_tile_none"); snd.write(); lock.unlock(); } } else if(rcv.name == "release_tile") { rcv.read(tile); lock.unlock(); TileList::iterator it = tile_list_find(the_tiles, tile); if (it != the_tiles.end()) { tile.buffers = it->buffers; the_tiles.erase(it); } assert(tile.buffers != NULL); the_task.release_tile(tile); lock.lock(); RPCSend snd(socket, &error_func, "release_tile"); snd.write(); lock.unlock(); } else if(rcv.name == "task_wait_done") { lock.unlock(); break; } else lock.unlock(); } }
void throw_item(Actor& actor_throwing, const Pos& tgt_cell, Item& item_thrown) { Throw_att_data data(actor_throwing, item_thrown, tgt_cell, actor_throwing.pos); const Actor_size aim_lvl = data.intended_aim_lvl; vector<Pos> path; line_calc::calc_new_line(actor_throwing.pos, tgt_cell, false, THROW_RANGE_LMT, false, path); const auto& item_thrown_data = item_thrown.get_data(); const string item_name_a = item_thrown.get_name(Item_ref_type::a); if (&actor_throwing == map::player) { msg_log::clear(); msg_log::add("I throw " + item_name_a + "."); } else { const Pos& p = path.front(); if (map::cells[p.x][p.y].is_seen_by_player) { msg_log::add(actor_throwing.get_name_the() + " throws " + item_name_a + "."); } } render::draw_map_and_interface(true); int blocked_in_element = -1; bool is_actor_hit = false; const char glyph = item_thrown.get_glyph(); const Clr clr = item_thrown.get_clr(); int chance_to_destroy_item = 0; Pos cur_pos(-1, -1); for (size_t i = 1; i < path.size(); ++i) { render::draw_map_and_interface(false); cur_pos.set(path[i]); Actor* const actor_here = utils::get_actor_at_pos(cur_pos); if (actor_here) { if (cur_pos == tgt_cell || actor_here->get_data().actor_size >= Actor_size::humanoid) { data = Throw_att_data(actor_throwing, item_thrown, tgt_cell, cur_pos, aim_lvl); if (data.attack_result >= success_small && !data.is_ethereal_defender_missed) { if (map::cells[cur_pos.x][cur_pos.y].is_seen_by_player) { render::draw_glyph('*', Panel::map, cur_pos, clr_red_lgt); render::update_screen(); sdl_wrapper::sleep(config::get_delay_projectile_draw() * 4); } const Clr hit_message_clr = actor_here == map::player ? clr_msg_bad : clr_msg_good; const bool CAN_SEE_ACTOR = map::player->can_see_actor(*actor_here, nullptr); string defender_name = CAN_SEE_ACTOR ? actor_here->get_name_the() : "It"; msg_log::add(defender_name + " is hit.", hit_message_clr); actor_here->hit(data.dmg, Dmg_type::physical); is_actor_hit = true; //If throwing a potion on an actor, let it make stuff happen... if (item_thrown_data.type == Item_type::potion) { static_cast<Potion*>(&item_thrown)->collide(cur_pos, actor_here); delete &item_thrown; game_time::tick(); return; } blocked_in_element = i; chance_to_destroy_item = 25; break; } } } if (map::cells[cur_pos.x][cur_pos.y].is_seen_by_player) { render::draw_glyph(glyph, Panel::map, cur_pos, clr); render::update_screen(); sdl_wrapper::sleep(config::get_delay_projectile_draw()); } const auto* feature_here = map::cells[cur_pos.x][cur_pos.y].rigid; if (!feature_here->is_projectile_passable()) { blocked_in_element = item_thrown_data.type == Item_type::potion ? i : i - 1; break; } if (cur_pos == tgt_cell && data.intended_aim_lvl == Actor_size::floor) { blocked_in_element = i; break; } } //If potion, collide it on the landscape if (item_thrown_data.type == Item_type::potion) { if (blocked_in_element >= 0) { static_cast<Potion*>(&item_thrown)->collide(path[blocked_in_element], nullptr); delete &item_thrown; game_time::tick(); return; } } if (rnd::percent() < chance_to_destroy_item) { delete &item_thrown; } else { const int DROP_ELEMENT = blocked_in_element == -1 ? path.size() - 1 : blocked_in_element; const Pos drop_pos = path[DROP_ELEMENT]; const Matl matl_at_drop_pos = map::cells[drop_pos.x][drop_pos.y].rigid->get_matl(); bool is_noisy = false; switch (matl_at_drop_pos) { case Matl::empty: is_noisy = false; break; case Matl::stone: is_noisy = true; break; case Matl::metal: is_noisy = true; break; case Matl::plant: is_noisy = false; break; case Matl::wood: is_noisy = true; break; case Matl::cloth: is_noisy = false; break; case Matl::fluid: is_noisy = false; break; } if (is_noisy) { const Alerts_mon alerts = &actor_throwing == map::player ? Alerts_mon::yes : Alerts_mon::no; if (!is_actor_hit) { Snd snd(item_thrown_data.land_on_hard_snd_msg, item_thrown_data.land_on_hard_sfx, Ignore_msg_if_origin_seen::yes, drop_pos, nullptr, Snd_vol::low, alerts); snd_emit::emit_snd(snd); } } item_drop::drop_item_on_map(drop_pos, item_thrown); } render::draw_map_and_interface(); game_time::tick(); }
~NetworkDevice() { RPCSend snd(socket, "stop"); snd.write(); }
void stepNetwork(void) { int i, k, pi, pi2, nbytes, newfd; char remoteIP[INET6_ADDRSTRLEN]; struct sockaddr_storage remoteaddr; socklen_t addrlen; struct timeval tv; if(getDeathMessage(sendbuf)) { for(k = 0; k < conf.maxPlayers; ++k) { if(connection[k].socket && !connection[k].bot) { snd(connection[k].socket, "\r\n"); snd(connection[k].socket, sendbuf); snd(connection[k].socket, "\r\n> "); } } } tv.tv_sec = 0; tv.tv_usec = 1; readfds = master; if(select(fdmax + 1, &readfds, NULL, NULL, &tv) == -1) { print_error("select"); exit(5); } for(i = 0; i <= fdmax; ++i) { if(FD_ISSET(i, &readfds)) { if(i == listener) { addrlen = sizeof remoteaddr; newfd = accept(listener, (struct sockaddr *)&remoteaddr, &addrlen); if(newfd == -1) { print_error("accept"); } else { getnameinfo((struct sockaddr *)&remoteaddr, addrlen, remoteIP, sizeof remoteIP, NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV); for(k = 0; k < conf.maxPlayers; ++k) { if(connection[k].socket == 0) { connection[k].socket = newfd; playerJoin(k); updateName(k, "Anonymous"); allSendPlayerPos(k); break; } } if(k == conf.maxPlayers) { close(newfd); printf("new connection from %s on socket %d refused: max connections\n", remoteIP, newfd); } else { FD_SET(newfd, &master); if(newfd > fdmax) { fdmax = newfd; } printf("new connection from %s on socket %d accepted\n", remoteIP, newfd); snd(newfd, WELCOME); } } } else { if((nbytes = recv(i, buf, sizeof buf, 0)) <= 0) { if(nbytes == 0) { printf("socket %d hung up\n", i); } else { print_error("recv"); } for(k = 0; k < conf.maxPlayers; ++k) { if(connection[k].socket == i) { disconnectPlayer(k); allSendPlayerLeave(k); break; } } close(i); FD_CLR(i, &master); } else { pi = -1; for(k = 0; k < conf.maxPlayers; ++k) { if(connection[k].socket == i) { pi = k; break; } } for(k = 0; k < nbytes && pi >= 0; ++k) { unsigned char c = buf[k]; if(c != '\r' && c != '\n') { if(isprint(c) && connection[pi].msgbufindex < 128 - 2) { connection[pi].msgbuf[connection[pi].msgbufindex++] = c; } } else { if(connection[pi].msgbufindex == 0) { continue; } connection[pi].msgbuf[connection[pi].msgbufindex] = '\0'; connection[pi].msgbuf[connection[pi].msgbufindex + 1] = '\0'; connection[pi].msgbufindex = 0; if(connection[pi].echo) { snd(i, connection[pi].msgbuf); snd(i, "\r\n"); } if(!overdrive)printf("%16s (%d): \"%s\"\n", getPlayer(pi)->name, pi, connection[pi].msgbuf); switch(connection[pi].msgbuf[0]) { case 'n': { updateName(pi, connection[pi].msgbuf + 2); break; } case 'v': { updateVelocity(pi, atof(connection[pi].msgbuf + 2)); break; } case 'z': { updateZoom(atof(connection[pi].msgbuf + 2)); break; } case 'c': { clearTraces(pi); break; } case 'o': { overdrive = !overdrive; break; } case 'b': { connection[pi].bot = !connection[pi].bot; if(connection[pi].bot) { sendOwnId(i, pi); for(pi2 = 0; pi2 < conf.maxPlayers; ++pi2) { if(connection[pi2].socket) { sendPlayerPos(i, pi2); } } } break; } case 'f': { toggleFps(); break; } case 'i': { if(strcmp("init", connection[pi].msgbuf) == 0) { reinitialize(); } break; } case 'x': { if(strcmp("xit", connection[pi].msgbuf) == 0) { exit(0); } break; } case 'e': { connection[pi].echo = !connection[pi].echo; break; } case 'q': { disconnectPlayer(pi); allSendPlayerLeave(pi); break; } case 'r': { validateOld(pi); break; } default: { updateAngle(pi, atof(connection[pi].msgbuf)); break; } } if(connection[pi].socket && !connection[pi].bot) { snd(i, "> "); } } } } } } } for(k = 0; k < conf.maxPlayers; ++k) { if(getPlayer(k)->active && getPlayer(k)->timeoutcnt > 2) { disconnectPlayer(k); allSendPlayerLeave(k); } } }
int main(int argc, char *argv[]) { const char *file; bool loop = false; int gain = 100; int pan = 0; while (1) { int c; int option_index = 0; static struct option long_options[] = { {"loop", no_argument, 0, 'l'}, {"gain", required_argument, 0, 'g'}, {"pan", required_argument, 0, 'p'}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "lgp:", long_options, &option_index); if (c == -1) break; switch (c) { case 'l': loop = true; break; case 'g': gain = atoi(optarg); break; case 'p': pan = atoi(optarg); break; default: usage(); return 1; } } if (optind < argc) { file = argv[optind]; } else { usage(); return 1; } // test if file exists int fd = open(file, O_RDONLY); if (fd < 0) { fprintf(stderr, "Can't open file %s\n", file); return 1; } close(fd); signal(SIGINT, keyb_int); BFileGameSound snd(file, loop); status_t err; err = snd.InitCheck(); if (err < B_OK) { fprintf(stderr, "Init failed, error 0x%08lx (%s)\n", err, strerror(err)); return 1; } err = snd.SetGain(gain / 100.0); if (err < B_OK) { fprintf(stderr, "Setting gain failed, error 0x%08lx (%s)\n", err, strerror(err)); return 1; } err = snd.SetPan(pan / 100.0); if (err < B_OK) { fprintf(stderr, "Setting pan failed, error 0x%08lx (%s)\n", err, strerror(err)); return 1; } err = snd.Preload(); if (err < B_OK) { fprintf(stderr, "Preload failed, error 0x%08lx (%s)\n", err, strerror(err)); return 1; } err = snd.StartPlaying(); if (err < B_OK) { fprintf(stderr, "Start playing failed, error 0x%08lx (%s)\n", err, strerror(err)); return 1; } while (snd.IsPlaying() && !interrupted) snooze(50000); err = snd.StopPlaying(); if (err < B_OK) { fprintf(stderr, "Stop playing failed, error 0x%08lx (%s)\n", err, strerror(err)); return 1; } return 0; }
int main(int argc, char* argv[]) { g_pApp = new FZApp(); g_pApp->InitInstance(SCREEN_WIDTH, SCREEN_HEIGHT); int fontIndex = g_pApp->m_renderer->addFont("Assets/Arial.ttf", 20); int font2 = g_pApp->m_renderer->addFont("Assets/HARNGTON.TTF", 30); Resource snd("Assets/guitar.wav"); g_pApp->m_resMan->getHandle(&snd); float xPos = 0; float speed = 100.0f; double circBuffer[120]; int index = 0; double delta = 0; double lastFrame = 0; bool running = true; Texture2D tex1; tex1.load("Assets/thing.png", false); Texture2D tex2; tex2.load("Assets/thing2.png", false); std::wstring text = L"The quick brown fox jumped over the lazy dog."; float x = 0; float y = 0; int sx = 0; int sy = 0; int sw = 128; int sh = 128; int w = 256; int h = 256; while (running) { if (glfwGetKey(GLFW_KEY_ESC) || !glfwGetWindowParam(GLFW_OPENED)) { running = false; } x+= 90.f * delta; y += 1.f * delta; h = 256*sinf(y); w = 256*cosf(y); g_pApp->m_renderer->clear(0.4f, 0.3f, 0.8f); g_pApp->m_renderer->beginBatch(); g_pApp->m_renderer->draw(tex1, 512, 384, w, h, sx, sy, sw, sh, Color::White, 0.1f, x); g_pApp->m_renderer->draw(tex2, 64 + abs(768*sinf(y)), 200, 200, 200, Color::Green, 0.1f, x); g_pApp->m_renderer->drawString(fontIndex, text, (int)(1024/2 - g_pApp->m_renderer->stringSize(fontIndex, text)/2.f), 400, Color::Red); g_pApp->m_renderer->drawString(font2, text, (int)(1024/2 - g_pApp->m_renderer->stringSize(font2, text)/2.f), 200, Color::Yellow); g_pApp->m_renderer->endBatch(); glfwSwapBuffers(); double curTime = glfwGetTime(); delta = curTime - lastFrame; lastFrame = curTime; circBuffer[index] = delta; ++index; if (index > 119) { double avg = 0; for (int i = 0; i < 120; ++i) { avg += circBuffer[i]; } avg /= 120; index = 0; //std::cout << 1 / avg << std::endl; } } delete g_pApp; return 0; }
void ui_result (global_t * gp) { int p, i; int iy[4]; char buf[1024]; int n = 0; if (flag_pause && !auto_play && !BUILD4) { wait4key (); } if (!point) make_point (); if (BUILD4) wrap_widgets (); snd (audioplay_yaku ()); flag_not_needredraw = 0; point_clear (); memcpy (hora_global, gp, sizeof (global_t)); hora_reset (); for (p = 0; p < 4; p++) { if (result[p].flag == 0) { continue; } n++; } for (p = 0; p < 4; p++) { if (result[p].flag == 0) { continue; } if (result[p].flag != RESULT_RYUKYOKU && (result[p].who != -1)) { hora_set (hora_global, result[p].who); } else { hora_set (hora_global, -1); } result_cvt_to_int (result + p, iy); pmcontainer_print (point_results, pm_result_name[result[p].flag]); for (i = 0; i < 4; i++) { integer_t color; pmcontainer_print (point_home[i], pm_home_names[i]); print_yakupoint (point_home_point[i], result[p].points[i]); widget_configure (point_home_user[i], resource_text, player[pplayer[i]].name); color = point_color (result[p].points[i]); widget_configure (point_home_user[i], resource_textfont, MEDIUMJP); widget_configure (point_home_user[i], resource_textcolor, color); { extern integer_t *tblpos; color = point_bgcolor (result[p].points[i]); widget_model_change (name_frame[tblpos[i]], color, white, white, white); } } if (result[p].fu) { widget_configure (point_fubase, resource_invisible, 0); print_yakupoint (point_fu, result[p].fu); print_yakupoint (point_fan, result[p].fan); } else { widget_configure (point_fubase, resource_invisible, 1); } #define yaku_idx(idx) \ if (!point_yaku[idx]) { goto YAKUEND; } { integer_t idx = 0; for (i = 0; i < Y_MAX; i++) { if (Y_GET (iy, i)) { char buf[128]; int len, n; yaku_idx (idx); strcpy (buf, result_str[i]); len = strlen (buf); if (buf[len - 1] == ')' && buf[len - 3] == '(') { buf[len - 3] = buf[len - 1] = 0; n = buf[len - 2] - '0'; print_yakupoint (point_yaku_point[idx], n); } else { widget_configure (point_yaku_point[idx], resource_text, ""); } widget_configure (point_yaku[idx], resource_text, buf); idx++; } } if (result[p].dora) { yaku_idx (idx); widget_configure (point_yaku[idx], resource_text, dora_str); print_yakupoint (point_yaku_point[idx], result[p].dora); idx++; } if (result[p].uradora) { yaku_idx (idx); widget_configure (point_yaku[idx], resource_text, uradora_str); print_yakupoint (point_yaku_point[idx], result[p].uradora); idx++; } if (result[p].akadora) { yaku_idx (idx); widget_configure (point_yaku[idx], resource_text, akadora_str); print_yakupoint (point_yaku_point[idx], result[p].akadora); idx++; } for (; idx < 30; idx++) { if (!point_yaku[idx]) { continue; } widget_configure (point_yaku[idx], resource_text, ""); widget_configure (point_yaku_point[idx], resource_text, ""); } } YAKUEND: draw_hora (); { extern widget_t board; if (!BUILD4) { widget_unmap (board); } widget_map (point); widget_display (point); widget_flush (point); { for (i = 0; i < 4; i++) { widget_display (name_frame[i]); widget_flush (name_frame[i]); } } if (!auto_play) wait_key (); hora_reset (); } } linepos_clear (); for (i = 0; i < 4; i++) { widget_model_change (name_frame[i], get_basiccolorpixel (), white, white, white); } if (!BUILD4) { widget_unmap (point); } else { unwrap_widgets (); } board_reset (); board_redraw (1); if (logfile) log_play (gp, logfile); }
void Thrower::throwItem(Actor& actorThrowing, const Pos& targetCell, Item& itemThrown) { MissileAttackData* data = new MissileAttackData( actorThrowing, itemThrown, targetCell, actorThrowing.pos, eng); const ActorSize aimLevel = data->intendedAimLevel; vector<Pos> path; eng.lineCalc->calcNewLine(actorThrowing.pos, targetCell, false, THROWING_RANGE_LIMIT, false, path); const ItemData& itemThrownData = itemThrown.getData(); const string itemName_a = eng.itemDataHandler->getItemRef(itemThrown, ItemRefType::a, true); if(&actorThrowing == eng.player) { eng.log->clearLog(); eng.log->addMsg("I throw " + itemName_a + "."); } else { const Pos& p = path.front(); if(eng.map->cells[p.x][p.y].isSeenByPlayer) { eng.log->addMsg( actorThrowing.getNameThe() + " throws " + itemName_a + "."); } } Renderer::drawMapAndInterface(true); int blockedInElement = -1; bool isActorHit = false; const char glyph = itemThrown.getGlyph(); const SDL_Color clr = itemThrown.getClr(); int chanceToDestroyItem = 0; Pos curPos(-1, -1); for(unsigned int i = 1; i < path.size(); i++) { Renderer::drawMapAndInterface(false); curPos.set(path.at(i)); Actor* const actorHere = Utils::getActorAtPos(curPos, eng); if(actorHere != NULL) { if( curPos == targetCell || actorHere->getData().actorSize >= actorSize_humanoid) { delete data; data = new MissileAttackData(actorThrowing, itemThrown, targetCell, curPos, eng, aimLevel); if( data->attackResult >= successSmall && data->isEtherealDefenderMissed == false) { if(eng.map->cells[curPos.x][curPos.y].isSeenByPlayer) { Renderer::drawGlyph('*', Panel::map, curPos, clrRedLgt); Renderer::updateScreen(); SdlWrapper::sleep(Config::getDelayProjectileDraw() * 4); } const SDL_Color hitMessageClr = actorHere == eng.player ? clrMsgBad : clrMsgGood; const bool CAN_SEE_ACTOR = eng.player->isSeeingActor(*actorHere, NULL); string defenderName = CAN_SEE_ACTOR ? actorHere->getNameThe() : "It"; eng.log->addMsg(defenderName + " is hit.", hitMessageClr); actorHere->hit(data->dmg, DmgType::physical, true); isActorHit = true; //If throwing a potion on an actor, let it make stuff happen... if(itemThrownData.isPotion) { dynamic_cast<Potion*>(&itemThrown)->collide(curPos, actorHere); delete &itemThrown; delete data; eng.gameTime->actorDidAct(); return; } blockedInElement = i; chanceToDestroyItem = 25; break; } } } if(eng.map->cells[curPos.x][curPos.y].isSeenByPlayer) { Renderer::drawGlyph(glyph, Panel::map, curPos, clr); Renderer::updateScreen(); SdlWrapper::sleep(Config::getDelayProjectileDraw()); } const Feature* featureHere = eng.map->cells[curPos.x][curPos.y].featureStatic; if(featureHere->isProjectilePassable() == false) { blockedInElement = itemThrownData.isPotion ? i : i - 1; break; } if(curPos == targetCell) { blockedInElement = i; break; } } //If potion, collide it on the landscape if(itemThrownData.isPotion) { if(blockedInElement >= 0) { dynamic_cast<Potion*>(&itemThrown)->collide( path.at(blockedInElement), NULL); delete &itemThrown; delete data; eng.gameTime->actorDidAct(); return; } } if(Rnd::percentile() < chanceToDestroyItem) { delete &itemThrown; } else { const int DROP_ELEMENT = blockedInElement == -1 ? path.size() - 1 : blockedInElement; const Pos dropPos = path.at(DROP_ELEMENT); const MaterialType materialAtDropPos = eng.map->cells[dropPos.x][dropPos.y].featureStatic->getMaterialType(); if(materialAtDropPos == materialType_hard) { const AlertsMonsters alertsMonsters = &actorThrowing == eng.player ? AlertsMonsters::yes : AlertsMonsters::no; if(isActorHit == false) { Snd snd(itemThrownData.landOnHardSurfaceSoundMsg, itemThrownData.landOnHardSurfaceSfx, IgnoreMsgIfOriginSeen::yes, dropPos, NULL, SndVol::low, alertsMonsters); SndEmit::emitSnd(snd, eng); } } eng.itemDrop->dropItemOnMap(dropPos, itemThrown); } delete data; Renderer::drawMapAndInterface(); eng.gameTime->actorDidAct(); }
Sender RedmineClient::getSender() { Sender snd(_url, net); return snd; }
int main(int argc, char *argv[]) { int opt= 0; static struct option long_options[] = { {"snd", no_argument, 0, 's' }, {"rcv", no_argument, 0, 'r' }, {"mac", no_argument, 0, 'm' }, {"all", no_argument, 0, 'a' }, {"ph", required_argument, 0, 'p' }, {0, 0, 0, 0 } }; int long_index =0; while ((opt = getopt_long(argc, argv,"srmap:", long_options, &long_index )) != -1) { switch (opt) { case 's' : //send statistics if(snd("s")==-1) { std::cout<<"Error: msg not send"<<std::endl; return -1; } if(rcv()==-1) { std::cout<<"Error: msg not recived"<<std::endl; return -1; } break; case 'r' : //recive statistics if(snd("r")==-1) { std::cout<<"Error: msg not send"<<std::endl; return -1; } if(rcv()==-1) { std::cout<<"Error: msg not recived"<<std::endl; return -1; } break; case 'm' : //Macaddress statistics if(snd("m")==-1) { std::cout<<"Error: msg not send"<<std::endl; return -1; } if(rcv()==-1) { std::cout<<"Error: msg not recived"<<std::endl; return -1; } break; case 'a' : //all ports if(snd("a")==-1) { std::cout<<"Error: msg not send"<<std::endl; return -1; } if(rcv()==-1) { std::cout<<"Error: msg not recived"<<std::endl; return -1; } break; case 'p' : //given port if(snd(optarg)==-1) { std::cout<<"Error: msg not send"<<std::endl; return -1; } if(rcv()==-1) { std::cout<<"Error: msg not recived"<<std::endl; return -1; } break; default: print_usage(); exit(EXIT_FAILURE); } } return 0; }
~NetworkDevice() { RPCSend snd(socket, &error_func, "stop"); snd.write(); }
void task_cancel() { RPCSend snd(socket, "task_cancel"); snd.write(); }
Spell_effect_noticed Spell::cast(Actor* const caster, const bool IS_INTRINSIC) const { TRACE_FUNC_BEGIN; assert(caster); if (caster->prop_handler().allow_cast_spell(Verbosity::verbose)) { if (caster->is_player()) { TRACE << "Player casting spell" << std::endl; const Shock_src shock_src = IS_INTRINSIC ? Shock_src::cast_intr_spell : Shock_src::use_strange_item; const int SHOCK_VALUE = IS_INTRINSIC ? shock_lvl_intr_cast() : 10; map::player->incr_shock(SHOCK_VALUE, shock_src); Snd snd("", Sfx_id::spell_generic, Ignore_msg_if_origin_seen::yes, caster->pos, caster, Snd_vol::low, Alerts_mon::yes); snd_emit::emit_snd(snd); } else //Caster is monster { TRACE << "Monster casting spell" << std::endl; Mon* const mon = static_cast<Mon*>(caster); const bool IS_MON_SEEN = map::player->can_see_actor(*mon); std::string spell_str = mon->data().spell_cast_msg; if (!spell_str.empty()) { std::string mon_name = ""; if (IS_MON_SEEN) { mon_name = mon->name_the(); } else //Cannot see monster { mon_name = mon->data().is_humanoid ? "Someone" : "Something"; } spell_str = mon_name + " " + spell_str; } Snd snd(spell_str, Sfx_id::END, Ignore_msg_if_origin_seen::no, caster->pos, caster, Snd_vol::low, Alerts_mon::no); snd_emit::emit_snd(snd); mon->spell_cool_down_cur_ = mon->data().spell_cooldown_turns; } if (IS_INTRINSIC) { const Range cost = spi_cost(false, caster); caster->hit_spi(rnd::range(cost), Verbosity::silent); } Spell_effect_noticed is_noticed = Spell_effect_noticed::no; if (caster->is_alive()) { is_noticed = cast_impl(caster); } game_time::tick(); TRACE_FUNC_END; return is_noticed; } TRACE_FUNC_END; return Spell_effect_noticed::no; }
void process(RPCReceive& rcv) { // fprintf(stderr, "receive process %s\n", rcv.name.c_str()); if(rcv.name == "mem_alloc") { MemoryType type; network_device_memory mem; device_ptr remote_pointer; rcv.read(mem); rcv.read(type); /* todo: CPU needs mem.data_pointer */ remote_pointer = mem.device_pointer; mem_data[remote_pointer] = vector<uint8_t>(); mem_data[remote_pointer].resize(mem.memory_size()); if(mem.memory_size()) mem.data_pointer = (device_ptr)&(mem_data[remote_pointer][0]); else mem.data_pointer = 0; device->mem_alloc(mem, type); ptr_map[remote_pointer] = mem.device_pointer; ptr_imap[mem.device_pointer] = remote_pointer; } else if(rcv.name == "mem_copy_to") { network_device_memory mem; rcv.read(mem); device_ptr remote_pointer = mem.device_pointer; mem.data_pointer = (device_ptr)&(mem_data[remote_pointer][0]); rcv.read_buffer((uint8_t*)mem.data_pointer, mem.memory_size()); mem.device_pointer = ptr_map[remote_pointer]; device->mem_copy_to(mem); } else if(rcv.name == "mem_copy_from") { network_device_memory mem; int y, w, h, elem; rcv.read(mem); rcv.read(y); rcv.read(w); rcv.read(h); rcv.read(elem); device_ptr remote_pointer = mem.device_pointer; mem.device_pointer = ptr_map[remote_pointer]; mem.data_pointer = (device_ptr)&(mem_data[remote_pointer][0]); device->mem_copy_from(mem, y, w, h, elem); RPCSend snd(socket); snd.write(); snd.write_buffer((uint8_t*)mem.data_pointer, mem.memory_size()); } else if(rcv.name == "mem_zero") { network_device_memory mem; rcv.read(mem); device_ptr remote_pointer = mem.device_pointer; mem.device_pointer = ptr_map[mem.device_pointer]; mem.data_pointer = (device_ptr)&(mem_data[remote_pointer][0]); device->mem_zero(mem); } else if(rcv.name == "mem_free") { network_device_memory mem; device_ptr remote_pointer; rcv.read(mem); remote_pointer = mem.device_pointer; mem.device_pointer = ptr_map[mem.device_pointer]; ptr_map.erase(remote_pointer); ptr_imap.erase(mem.device_pointer); mem_data.erase(remote_pointer); device->mem_free(mem); } else if(rcv.name == "const_copy_to") { string name_string; size_t size; rcv.read(name_string); rcv.read(size); vector<char> host_vector(size); rcv.read_buffer(&host_vector[0], size); device->const_copy_to(name_string.c_str(), &host_vector[0], size); } else if(rcv.name == "tex_alloc") { network_device_memory mem; string name; bool interpolation; bool periodic; device_ptr remote_pointer; rcv.read(name); rcv.read(mem); rcv.read(interpolation); rcv.read(periodic); remote_pointer = mem.device_pointer; mem_data[remote_pointer] = vector<uint8_t>(); mem_data[remote_pointer].resize(mem.memory_size()); if(mem.memory_size()) mem.data_pointer = (device_ptr)&(mem_data[remote_pointer][0]); else mem.data_pointer = 0; rcv.read_buffer((uint8_t*)mem.data_pointer, mem.memory_size()); device->tex_alloc(name.c_str(), mem, interpolation, periodic); ptr_map[remote_pointer] = mem.device_pointer; ptr_imap[mem.device_pointer] = remote_pointer; } else if(rcv.name == "tex_free") { network_device_memory mem; device_ptr remote_pointer; rcv.read(mem); remote_pointer = mem.device_pointer; mem.device_pointer = ptr_map[mem.device_pointer]; ptr_map.erase(remote_pointer); ptr_map.erase(mem.device_pointer); mem_data.erase(remote_pointer); device->tex_free(mem); } else if(rcv.name == "task_add") { DeviceTask task; rcv.read(task); if(task.buffer) task.buffer = ptr_map[task.buffer]; if(task.rgba_byte) task.rgba_byte = ptr_map[task.rgba_byte]; if(task.rgba_half) task.rgba_half = ptr_map[task.rgba_half]; if(task.shader_input) task.shader_input = ptr_map[task.shader_input]; if(task.shader_output) task.shader_output = ptr_map[task.shader_output]; task.acquire_tile = function_bind(&DeviceServer::task_acquire_tile, this, _1, _2); task.release_tile = function_bind(&DeviceServer::task_release_tile, this, _1); task.update_progress_sample = function_bind(&DeviceServer::task_update_progress_sample, this); task.update_tile_sample = function_bind(&DeviceServer::task_update_tile_sample, this, _1); task.get_cancel = function_bind(&DeviceServer::task_get_cancel, this); device->task_add(task); } else if(rcv.name == "task_wait") { device->task_wait(); RPCSend snd(socket, "task_wait_done"); snd.write(); } else if(rcv.name == "task_cancel") { device->task_cancel(); } }
// step P step2(P ai, P game) { P map; P game2; P lambdaman; int vitality; P lambdaman2; P lambdalocation; int lambdax; int lambday; P lambdaman3; int lambdadirection; P lambdaman4; int lambdalive; int lambdascore; int ghostlength; P game3; P ghosts; P tempghost; int ghostvitality; P ghostlocation; int ghosty; int ghostx; int ghostdirection; int ghostdist; int ghostdist2; int ghostpoint; P fruits; int uppoint; int rightpoint; int downpoint; int leftpoint; int maxpoint; int retdirection; int ghostmul; int fruittime; P farpoint; turn = turn + 1; uppoint = 0; rightpoint = 0; downpoint = 0; leftpoint = 0; maxpoint = 0 - 99999999; retdirection = 0; map = fst(game); gmap = map; //list_to_tree(game); game2 = snd(game); lambdaman = fst(game2); game3 = snd(game2); ghosts = fst(game3); fruits = snd(game3); fruitbonus = 0; fruittime = toi(fruits); if(fruittime > 0){ fruitbonus = 1000; } else{} //debug(fruittime); vitality = toi(fst(lambdaman)); lambdaman2 = snd(lambdaman); lambdalocation = fst(lambdaman2); lambdax = toi(fst(lambdalocation)); lambday = toi(snd(lambdalocation)); lambdaman3 = snd(lambdaman2); lambdadirection = toi(fst(lambdaman3)); lambdaman4 = snd(lambdaman3); lambdalive = toi(fst(lambdaman4)); lambdascore = toi(snd(lambdaman4)); uppoint = dfs(lambday - 1, lambdax, 10, 0) * 10; rightpoint = dfs(lambday, lambdax + 1, 10, 1) * 10; downpoint = dfs(lambday + 1, lambdax, 10, 2) * 10; leftpoint = dfs(lambday, lambdax - 1, 10, 3) * 10; if(getNumber(lambday - 1,lambdax, map) == 0){ uppoint = 0 - 99999999; } else{} if(getNumber(lambday,lambdax + 1, map) == 0){ rightpoint = 0 - 99999999; } else{} if(getNumber(lambday + 1,lambdax, map) == 0){ downpoint = 0 - 99999999; } else{} if(getNumber(lambday,lambdax - 1, map) == 0){ leftpoint = 0 - 99999999; } else{} //farpoint = P(0,0); //farpoint = getfarpoint(0, 0, map, lambday, lambdax); //uppoint = uppoint + toi(fst(farpoint)); //rightpoint = rightpoint - toi(snd(farpoint)); //downpoint = downpoint - toi(fst(farpoint)); //leftpoint = leftpoint + toi(snd(farpoint)); //ghostlength = 2 + mod(turn / 5, 13); ghostlength = 4; if(mod(myrand(), 30) == 0){ randomv = mod(myrand(), 7); } if(randomv == 0){ uppoint = uppoint + 1000; } else{} if(randomv == 1){ rightpoint = rightpoint + 1000; } else{} if(randomv == 2){ downpoint = downpoint + 1000; } else{} if(randomv == 3){ leftpoint = leftpoint + 1000; } else{} while(1 - atom(ghosts)){ tempghost = fst(ghosts); ghosts = snd(ghosts); ghostvitality = toi(fst(tempghost)); tempghost = snd(tempghost); ghostlocation = fst(tempghost); ghostx = toi(fst(ghostlocation)); ghosty = toi(snd(ghostlocation)); ghostdirection = toi(snd(tempghost)); ghostdist = abs(lambdax - ghostx) + abs(lambday - ghosty); if(ghostdist < (vitality / 127 - 3) * 2){ if(ghostvitality == 2){ ghostmul = 0; } else{ ghostmul = -1; } } else{ ghostmul = 1; } if(ghostdist < ghostlength){ ghostpoint = 1000000 * ghostlength / pow2(ghostdist) * ghostmul; } else{ ghostpoint = 0; } uppoint = uppoint - ghostpoint * sign(lambday - ghosty); rightpoint = rightpoint + ghostpoint * sign(lambdax - ghostx); downpoint = downpoint + ghostpoint * sign(lambday - ghosty); leftpoint = leftpoint - ghostpoint * sign(lambdax - ghostx); } if(maxpoint < uppoint){ retdirection = 0; maxpoint = uppoint; } else{} if(maxpoint < rightpoint){ retdirection = 1; maxpoint = rightpoint; } else{} if(maxpoint < downpoint){ retdirection = 2; maxpoint = downpoint; } else{} if(maxpoint < leftpoint){ retdirection = 3; maxpoint = leftpoint; } else{} return P(P(retdirection, 0), retdirection); }
Point::Point(const Point& p){ fst() = p.fst(); snd() = p.snd(); }