bool mp_linear_step_object(const double x, const double y, const double stepsize, const int object, const bool solid_only) { enigma::object_collisions* const inst = ((enigma::object_collisions*)enigma::instance_event_iterator->inst); if (fequal(inst->x, x) && fequal(inst->y, y)) return true; inst->direction = atan2(inst->y - y, x - inst->x)*(180/M_PI); if (hypot(x - inst->x, y - inst->y) <= stepsize) { if (solid_only ? (place_free(x, y)) : (!place_meeting(x, y, object))) { inst->x = x; inst->y = y; return true; } return false; } double xstep, ystep; xstep = cos(inst->direction*M_PI/180)*stepsize; ystep = -sin(inst->direction*M_PI/180)*stepsize; if (solid_only ? (place_free(inst->x + xstep, inst->y + ystep)) : (!place_meeting(inst->x + xstep, inst->y + ystep, object))) { inst->x += xstep; inst->y += ystep; return true; } return false; }
static void add_file_chooser_response (GtkDialog *widget, GtkResponseType response, gpointer user_data) { Place *place; GPtrArray *new_values; if (response != GTK_RESPONSE_OK) { gtk_widget_destroy (GTK_WIDGET (widget)); return; } place = g_slice_new0 (Place); place->location = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (widget)); place->settings_key = TRACKER_KEY_RECURSIVE_DIRECTORIES; place->display_name = g_file_get_basename (place->location); new_values = place_get_new_settings_values (place, FALSE); g_settings_set_strv (tracker_preferences, place->settings_key, (const gchar **) new_values->pdata); g_ptr_array_unref (new_values); gtk_widget_destroy (GTK_WIDGET (widget)); place_free (place); }
void create_up_stairs(dungeon_t* src, branch_t* to_branch, dungeon_t* to_dungeon, stairs_t* to_stairs) { int stairs_x, stairs_y; do { stairs_x = random(1, src->width - 1); stairs_y = random(1, src->height - 1); } while (!place_free(src, stairs_x, stairs_y) || stairs_at(src, stairs_x, stairs_y) || (get_tile_at(src, stairs_x, stairs_y)->properties & TILE_PROP_NO_SPAWN)); to_stairs->to = src; to_stairs->warp_x = stairs_x; to_stairs->warp_y = stairs_y; stairs_t* up = new stairs_t; up->to = to_dungeon; up->to_branch = to_branch->name; up->x = stairs_x; up->y = stairs_y; up->warp_x = to_stairs->x; up->warp_y = to_stairs->y; set_tile_at(src, stairs_x, stairs_y, TILES[TILE_STAIRS_UP]); src->stairs[src->num_stairs] = up; src->num_stairs++; }
static void clear(struct mwServicePlace *srvc) { if(srvc->handler && srvc->handler->clear) srvc->handler->clear(srvc); while(srvc->places) place_free(srvc->places->data); }
void creature_t::blink() { std::vector<coord_t> valid_coords; for (int y = pos.y - FOV_RADIUS; y <= pos.y + FOV_RADIUS; y++) { for (int x = pos.x - FOV_RADIUS; x <= pos.x + FOV_RADIUS; x++) { if (sees(x, y) && place_free(current_dungeon, x, y, this)) { valid_coords.push_back(coord_t {x, y}); } } } if (valid_coords.size()) { std::random_shuffle(valid_coords.begin(), valid_coords.end()); if (identity == IDENT_PLAYER) { append_msg_log("You feel a wrenching sensation!"); } cloud_create_translocation_effect(pos.x, pos.y); coord_t target = valid_coords.front(); pos = target; if (identity != IDENT_PLAYER) { if (player.sees(this)) { append_msg_log("%s blinks!", capitalize(get_full_name()).c_str()); } else { append_msg_log("%s suddenly disappears!", capitalize(get_full_name()).c_str()); } } } else { if (identity == IDENT_PLAYER) { append_msg_log("You shudder for a moment."); } else if (player.sees(this)) { append_msg_log("%s shudders for a moment.", capitalize(get_full_name()).c_str()); } } }
bool mp_linear_path_object(int path, const double x, const double y, const double stepsize, const int object, const bool solid_only) { enigma::object_collisions* const inst = ((enigma::object_collisions*)enigma::instance_event_iterator->inst); double pathpx = inst->x, pathpy = inst->y, pathpdir = atan2(pathpy - y, x - pathpx)*(180/M_PI); path_clear_points(path); path_add_point(path, pathpx, pathpy, 100); if (fequal(pathpx, x) && fequal(pathpy, y)) return true; double xstep, ystep; bool pathfound; const double max_dist = hypot(x - pathpx, y - pathpy); while (path_get_length(path) < max_dist) { pathfound = false; if (hypot(x - pathpx, y - pathpy) <= stepsize) { if (solid_only ? (place_free(x, y)) : (!place_meeting(x, y, object))) { path_add_point(path, x, y, 100); return true; } return false; } xstep = cos(pathpdir*M_PI/180)*stepsize; ystep = -sin(pathpdir*M_PI/180)*stepsize; if (solid_only ? (place_free(pathpx + xstep, pathpy + ystep)) : (!place_meeting(pathpx + xstep, pathpy + ystep, object))) { pathpx += xstep; pathpy += ystep; path_add_point(path, pathpx, pathpy, 100); pathfound = true; } if (!pathfound) return false; } return false; }
int mwPlace_destroy(struct mwPlace *p, guint32 code) { int ret = 0; place_state(p, mwPlace_CLOSING); if(p->channel) { ret = mwChannel_destroy(p->channel, code, NULL); p->channel = NULL; } place_free(p); return ret; }
void FireBall::onStep() { switch (dir) { case UPLEFT: y -= sp; x -= sp; break; case DOWNRIGHT: y += sp; x += sp; break; case DOWNLEFT: y += sp; x -= sp; break; case UPRIGHT: y -= sp; x += sp; break; } ((SpriteMap*) graphic)->playAnim("shake"); if (!place_free(x, y)) instance_destroy(); depth = y; };
void creature_t::split_creature() { std::vector<coord_t> valid_coords; for (int y = pos.y - 1; y <= pos.y + 1; y++) { for (int x = pos.x - 1; x <= pos.x + 1; x++) { if (place_free(current_dungeon, x, y, this)) { valid_coords.push_back(coord_t { x, y }); } } } if (valid_coords.size()) { std::random_shuffle(valid_coords.begin(), valid_coords.end()); coord_t pos = valid_coords.front(); if (player.sees(this)) { append_msg_log("%s multiplies!", capitalize(get_full_name()).c_str()); } creature_t* new_creature = create_creature_by_name(name); new_creature->hp = hp; new_creature->challenge_rating = 0; // Award no exp for multiplied creature. add_creature_to_dungeon(current_dungeon, new_creature, pos.x, pos.y); } else { if (player.sees(this)) { append_msg_log("%s jiggles.", capitalize(get_full_name()).c_str()); } } }
void create_empty_stairs(dungeon_t* src, const std::string& to_branch) { int src_x, src_y; do { src_x = random(1, src->width - 1); src_y = random(1, src->height - 1); } while (!place_free(src, src_x, src_y) || stairs_at(src, src_x, src_y) || (get_tile_at(src, src_x, src_y)->properties & TILE_PROP_NO_SPAWN)); stairs_t* down = new stairs_t; down->to = nullptr; down->to_branch = to_branch; down->x = src_x; down->y = src_y; down->warp_x = -1; down->warp_y = -1; set_tile_at(src, src_x, src_y, TILES[TILE_STAIRS_DOWN]); src->stairs[src->num_stairs] = down; src->num_stairs++; }
void creature_t::teleport() { // TODO: Controlled teleport. if (identity != IDENT_PLAYER) { if (player.sees(this)) { MAKE_CAPITAL(prefix, prefix, 8); append_msg_log("%s %s teleports away.", prefix, name); } } int x, y; do { x = random(0, current_dungeon->width - 1); y = random(0, current_dungeon->height - 1); } while (!place_free(current_dungeon, x, y, this)); cloud_create_translocation_effect(pos.x, pos.y); pos.x = x; pos.y = y; }
static GList * get_places_list (void) { GList *list, *l; GHashTable *places; Place *place, *old_place; GList *places_list; places = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal, NULL, (GDestroyNotify) place_free); /* add home */ place = g_slice_new0 (Place); place->location = g_file_new_for_path (g_get_home_dir ()); place->place_type = PLACE_XDG; place->display_name = g_strdup (_("Home")); g_hash_table_insert (places, place->location, place); /* first, load the XDG dirs */ list = get_xdg_dirs (); for (l = list; l != NULL; l = l->next) { place = l->data; g_hash_table_insert (places, place->location, place); } g_list_free (list); /* then, insert all the tracker locations that are not XDG dirs */ list = get_tracker_locations (); for (l = list; l != NULL; l = l->next) { place = l->data; old_place = g_hash_table_lookup (places, place->location); if (old_place == NULL) g_hash_table_insert (places, place->location, place); else place_free (place); } g_list_free (list); /* finally, load bookmarks, and possibly update attributes */ list = get_bookmarks (); for (l = list; l != NULL; l = l->next) { place = l->data; old_place = g_hash_table_lookup (places, place->location); if (old_place == NULL) { g_hash_table_insert (places, place->location, place); } else { g_free (old_place->display_name); old_place->display_name = g_strdup (place->display_name); if (old_place->place_type == PLACE_OTHER) old_place->place_type = PLACE_BOOKMARKS; place_free (place); } } g_list_free (list); places_list = g_hash_table_get_values (places); g_hash_table_steal_all (places); g_hash_table_unref (places); return places_list; }
bool mp_potential_step_object(const double x, const double y, const double stepsize, const int object, const bool solid_only) { enigma::object_collisions* const inst = ((enigma::object_collisions*)enigma::instance_event_iterator->inst); if (fequal(inst->x, x) && fequal(inst->y, y)) return true; double dir, xstep, ystep, goaldir; goaldir = atan2(inst->y - y, x - inst->x)*(180/M_PI); dir = (goaldir + 360) %(variant) 360; //direct goal direction if (abs((dir - inst->direction + 540) %(variant) 360 - 180) <= mp_potential::maxrot) { if (hypot(x - inst->x, y - inst->y) <= stepsize) { if (solid_only ? (place_free(x, y)) : (!place_meeting(x, y, object))) { inst->direction = dir; inst->x = x; inst->y = y; return true; } if (mp_potential::onspot) { inst->direction += min(mp_potential::maxrot, max(-mp_potential::maxrot, (goaldir - inst->direction + 540) %(variant) 360 - 180)); } return false; } xstep = cos(dir*M_PI/180)*stepsize; ystep = -sin(dir*M_PI/180)*stepsize; if (solid_only ? (place_free(inst->x + mp_potential::ahead*xstep, y + mp_potential::ahead*ystep) && place_free(inst->x + xstep,inst->y + ystep)) : (!place_meeting(inst->x + mp_potential::ahead*xstep, y + mp_potential::ahead*ystep, object) && !place_meeting(inst->x + xstep, inst->y + ystep, object))) { inst->direction = dir; inst->x += xstep; inst->y += ystep; return true; } } //alternate either side of the goal direction full circle for (int i = mp_potential::rotstep; i < 180; i += mp_potential::rotstep) { dir = (goaldir - i + 360) %(variant) 360; if (abs((dir - inst->direction + 540) %(variant) 360 - 180) <= mp_potential::maxrot) { xstep = cos(dir*M_PI/180)*stepsize; ystep = -sin(dir*M_PI/180)*stepsize; if (solid_only ? (place_free(inst->x + mp_potential::ahead*xstep, y + mp_potential::ahead*ystep) && place_free(inst->x + xstep,inst->y + ystep)) : (!place_meeting(inst->x + mp_potential::ahead*xstep, y + mp_potential::ahead*ystep, object) && !place_meeting(inst->x + xstep, inst->y + ystep, object))) { inst->direction = dir; inst->x += xstep; inst->y += ystep; return true; } } dir = (goaldir + i + 360) %(variant) 360; if (abs((dir - inst->direction + 540) %(variant) 360 - 180) <= mp_potential::maxrot) { xstep = cos(dir*M_PI/180)*stepsize; ystep = -sin(dir*M_PI/180)*stepsize; if (solid_only ? (place_free(inst->x + mp_potential::ahead*xstep, inst->y + mp_potential::ahead*ystep) && place_free(inst->x + xstep, inst->y + ystep)) : (!place_meeting(inst->x + mp_potential::ahead*xstep, inst->y + mp_potential::ahead*ystep, object) && !place_meeting(inst->x + xstep, inst->y + ystep, object))) { inst->direction = dir; inst->x += xstep; inst->y += ystep; return true; } } } if (mp_potential::onspot) { inst->direction += min(mp_potential::maxrot, max(-mp_potential::maxrot, (goaldir - inst->direction + 540) %(variant) 360 - 180)); } return false; }
bool mp_potential_path_object(int path, const double x, const double y, const double stepsize, double factor, const int object, const bool solid_only) { enigma::object_collisions* const inst = ((enigma::object_collisions*)enigma::instance_event_iterator->inst); double pathpx = inst->x, pathpy = inst->y, pathpdir = inst->direction; path_clear_points(path); path_add_point(path, pathpx, pathpy, 100); if (fequal(pathpx, x) && fequal(pathpy, y)) return true; if (factor < 1) return false; double dir, xstep, ystep, goaldir; bool pathfound; const double max_dist = factor*hypot(x - pathpx, y - pathpy); while (path_get_length(path) < max_dist) { goaldir = atan2(pathpy - y, x - pathpx)*(180/M_PI); pathfound = false; //direct goal direction dir = (goaldir + 360) %(variant) 360; if (abs((dir - pathpdir + 540) %(variant) 360 - 180) <= mp_potential::maxrot) { if (hypot(x - pathpx, y - pathpy) <= stepsize) { if (solid_only ? (place_free(x, y)) : (!place_meeting(x, y, object))) { path_add_point(path, x, y, 100); return true; } return false; } xstep = cos(dir*M_PI/180)*stepsize; ystep = -sin(dir*M_PI/180)*stepsize; if (solid_only ? (place_free(pathpx + mp_potential::ahead*xstep, pathpy + mp_potential::ahead*ystep) && place_free(pathpx + xstep, pathpy + ystep)) : (!place_meeting(pathpx + mp_potential::ahead*xstep, pathpy + mp_potential::ahead*ystep, object) && !place_meeting(pathpx + xstep, pathpy + ystep, object))) { pathpdir = dir; pathpx += xstep; pathpy += ystep; path_add_point(path, pathpx, pathpy, 100); pathfound = true; } } if (!pathfound) { //alternate either side of the goal direction full circle for (int i = mp_potential::rotstep; i < 180; i += mp_potential::rotstep) { dir = (goaldir - i + 360) %(variant) 360; if (abs((dir - pathpdir + 540) %(variant) 360 - 180) <= mp_potential::maxrot) { xstep = cos(dir*M_PI/180)*stepsize; ystep = -sin(dir*M_PI/180)*stepsize; if (solid_only ? (place_free(pathpx + mp_potential::ahead*xstep, pathpy + mp_potential::ahead*ystep) && place_free(pathpx + xstep, pathpy + ystep)) : (!place_meeting(pathpx + mp_potential::ahead*xstep, pathpy + mp_potential::ahead*ystep, object) && !place_meeting(pathpx + xstep, pathpy + ystep, object))) { pathpdir = dir; pathpx += xstep; pathpy += ystep; path_add_point(path, pathpx, pathpy, 100); pathfound = true; break; } } dir = (goaldir + i + 360) %(variant) 360; if (abs((dir - pathpdir + 540) %(variant) 360 - 180) <= mp_potential::maxrot) { xstep = cos(dir*M_PI/180)*stepsize; ystep = -sin(dir*M_PI/180)*stepsize; if (solid_only ? (place_free(pathpx + mp_potential::ahead*xstep, pathpy + mp_potential::ahead*ystep) && place_free(pathpx + xstep, pathpy + ystep)) : (!place_meeting(pathpx + mp_potential::ahead*xstep, pathpy + mp_potential::ahead*ystep, object) && !place_meeting(pathpx + xstep, pathpy + ystep, object))) { pathpdir = dir; pathpx += xstep; pathpy += ystep; path_add_point(path, pathpx, pathpy, 100); pathfound = true; break; } } } if (!pathfound) return false; } } return false; }
void _take_stairs(stairs_t* stairs) { dungeon_t* prev_dungeon = current_dungeon; TRACE("take_stairs: stairs->to_branch=%s", stairs->to_branch.c_str()); // Arrive from town to infinite dungeon: clear infinite dungeon. if (stairs->to && stairs->to_branch == BRANCH_INFINITE_DUNGEON && current_branch->name != BRANCH_INFINITE_DUNGEON) { stairs->to = nullptr; branch_t* inf_branch = find_branch(stairs->to_branch); for (dungeon_t* dungeon : inf_branch->dungeons) { destroy_dungeon(dungeon); } inf_branch->dungeons.clear(); } // Generate the next dungeon if needed. if (stairs->to == nullptr && stairs->to_branch == current_branch->name) { dungeon_t* next_level = generate_next_level(current_branch); create_up_stairs(next_level, current_branch, prev_dungeon, stairs); } else if (stairs->to == nullptr) { // Stairs to a new branch. branch_t* prev_branch = current_branch; current_branch = create_branch(stairs->to_branch); dungeon_t* next_level = current_branch->dungeons.front(); // Check if the level has stairs that lead back to the branch already. bool has_stairs = false; for (int i = 0; i < next_level->num_stairs; i++) { if (next_level->stairs[i]->to_branch == prev_branch->name) has_stairs = true; } if (!has_stairs) create_up_stairs(next_level, prev_branch, prev_dungeon, stairs); else stairs->to = next_level; } dungeon_t* dst = stairs->to; current_dungeon = dst; current_branch = find_branch(stairs->to_branch); player.pos.x = stairs->warp_x; player.pos.y = stairs->warp_y; // Do not follow player to the world map. if (current_branch->name != "World") { std::vector<coord_t> free_coords; for (int y = player.pos.y - 1; y <= player.pos.y + 1; y++) for (int x = player.pos.x - 1; x <= player.pos.x + 1; x++) if (place_free(current_dungeon, x, y)) free_coords.push_back( coord_t { x, y} ); std::vector<creature_t*> following_creatures; for (int y = stairs->y - 1; y <= stairs->y + 1; y++) { for (int x = stairs->x - 1; x <= stairs->x + 1; x++) { creature_t* creature = get_creature_at(prev_dungeon, x, y); if (creature && following_creatures.size() < free_coords.size()) { following_creatures.push_back(creature); remove_creature_no_destroy(prev_dungeon, creature); } } } for (size_t i = 0; i < following_creatures.size(); i++) { add_creature_to_dungeon(current_dungeon, following_creatures[i], free_coords[i].x, free_coords[i].y); } if (following_creatures.size() == 1) append_msg_log("%s follows you.", capitalize(following_creatures.front()->get_full_name()).c_str()); else if (following_creatures.size() > 1) append_msg_log("Some creatures follow you."); } clear_action_list(); append_action_list(&player); }
void _select_direction() { const std::string move_keys = "lkjhyubn12346789"; int state = statestack_top(); char key = io::getchar(); if (char_in(key, move_keys)) { if (state == STATE_CLOSE_DOOR) { int x, y; x = player.pos.x; y = player.pos.y; compute_xy_by_direction(direction_from_key(key), &x, &y); tile_t* tile = get_tile_at(current_dungeon, x, y); if (tile->id == TILE_DOOR_OPEN) { if (place_free(current_dungeon, x, y) && count_items_at(current_dungeon, x, y) == 0) { close_door(current_dungeon, &player, x, y); player.ap -= player.speed; } else { append_msg_log("The door is blocked!"); } } else if (tile->id == TILE_DOOR_CLOSED) { append_msg_log("That door is already closed."); } else { append_msg_log("There is no door there!"); } statestack_pop(); } else if (state == STATE_CHAT) { int x = player.pos.x; int y = player.pos.y; compute_xy_by_direction(direction_from_key(key), &x, &y); creature_t* creature = get_creature_at(current_dungeon, x, y); if (creature) { chat(creature); } else { append_msg_log("There is no one there to talk to!"); } statestack_pop(); } return; } if (key == '\x1B') { append_msg_log("Nevermind."); statestack_pop(); } }