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();
}
