const int PairCollisionFilter::runIrr() {
device->run();
driver->beginScene();
scene_manager->drawAll();
gui_env->drawAll();
hkVector4 new_pos = movingBox->getPosition();
scene::IMeshSceneNode* g_box = (scene::IMeshSceneNode*) scene_manager->getSceneNodeFromId(1);
g_box->setPosition(core::vector3df(new_pos(0), new_pos(1), new_pos(2)));
//reset moving box position
if(receiver.IsKeyDown(EKEY_CODE::KEY_KEY_R)) {
movingBox->setPosition(hkVector4(0.f, 7.f, 0.f));
}
//press space to make flying moving box
if(receiver.IsKeyDown(EKEY_CODE::KEY_SPACE)) {
movingBox->setLinearVelocity(hkVector4(0.f, 3.f, 0.f));
}
driver->endScene();
return 0;
}
void ViewObject::draw(){
GraphicsManager &graphics_manager = GraphicsManager::getInstance();
string temp_str;
if(getBorder() == true){
temp_str = " " + getViewString() + " " + intToString(value) + " ";
} else {
temp_str = getViewString() + " " + intToString(value);
}
//Draw centered at position
Position pos = viewToWorld(getPosition());
graphics_manager.drawString(pos, temp_str, CENTER_JUSTIFIED, getColor());
//Draw box around display
if (getBorder() == true){
int boxLength = strlen(getViewString().c_str()) + 4;
int boxHeight = 3;
int boxOffset = boxLength/2;
bool odd = false;
if (boxLength % 2){
odd = true;
}
for (int i = 0; i < boxLength; i++){
Position new_pos(pos.getX() + i - boxOffset, pos.getY()-1);
graphics_manager.drawCh(new_pos, '-', getColor());
}
//Bottom
for (int i = 0; i < boxLength; i++){
Position new_pos(pos.getX() + i - boxOffset, pos.getY()+1);
graphics_manager.drawCh(new_pos, '-', getColor());
}
//Left
Position left_pos(pos.getX()-boxOffset-1, pos.getY());
graphics_manager.drawCh(left_pos, '|', getColor());
//Right
if (!odd){
Position right_pos(pos.getX()+boxOffset, pos.getY());
graphics_manager.drawCh(right_pos, '|', getColor());
} else {
Position right_pos(pos.getX()+boxOffset+1, pos.getY());
graphics_manager.drawCh(right_pos, '|', getColor());
}
}
}
void
register_changed_room (int room)
{
if (has_room_changed (room)) return;
changed_room =
add_to_array (&room, 1, changed_room, &changed_room_nmemb,
changed_room_nmemb, sizeof (room));
qsort (changed_room, changed_room_nmemb, sizeof (room), (m_comparison_fn_t) cint);
struct pos p;
new_pos (&p, &global_level, room, -1, -1);
p.floor = 0;
for (p.place = 0; p.place < PLACES; p.place++)
register_changed_pos (&p, -1);
p.place = 0;
for (p.floor = 1; p.floor < FLOORS; p.floor++)
register_changed_pos (&p, -1);
p.place = 9;
for (p.floor = 1; p.floor < FLOORS; p.floor++)
register_changed_pos (&p, -1);
}
void CameraHandler::RotateCamera(Vector3df pivot, CameraID id, qreal x, qreal y)
{
if (id_to_cam_entity_.contains(id))
{
Scene::Entity *cam_entity = id_to_cam_entity_[id];
OgreRenderer::EC_OgreCamera *ec_camera = cam_entity->GetComponent<OgreRenderer::EC_OgreCamera>().get();
OgreRenderer::EC_OgrePlaceable *cam_ec_placable = cam_entity->GetComponent<OgreRenderer::EC_OgrePlaceable>().get();
if (!ec_camera || !cam_ec_placable)
return;
Ogre::Camera* cam = ec_camera->GetCamera();
Vector3df pos = cam_ec_placable->GetPosition();
Vector3df dir(pos-pivot);
Quaternion quat(-x,cam_ec_placable->GetLocalYAxis());
quat *= Quaternion(-y, cam_ec_placable->GetLocalXAxis());
dir = quat * dir;
Vector3df new_pos(pivot+dir);
cam_ec_placable->SetPosition(new_pos);
cam_ec_placable->LookAt(pivot);
last_dir_=pivot - cam_ec_placable->GetPosition();
}
}
/// Returns to coordinate of the node around this node
/// (Directions 1-8 (incl), 0 = no change)
MapPoint TradeGraph::GetNodeAround(const MapPoint pos, const unsigned char dir) const
{
Point<int> cpos = Point<int>(pos.x, pos.y);
Point<int> new_pos(cpos);
switch(dir)
{
case 1: new_pos = Point<int>(cpos.x-1, cpos.y); break;
case 2: new_pos = Point<int>(cpos.x-1, cpos.y-1); break;
case 3: new_pos = Point<int>(cpos.x, cpos.y-1); break;
case 4: new_pos = Point<int>(cpos.x+1, cpos.y-1); break;
case 5: new_pos = Point<int>(cpos.x+1, cpos.y); break;
case 6: new_pos = Point<int>(cpos.x+1, cpos.y+1); break;
case 7: new_pos = Point<int>(cpos.x, cpos.y+1); break;
case 8: new_pos = Point<int>(cpos.x-1, cpos.y+1); break;
default: break;
}
// Consider map borders
if(new_pos.x < 0) new_pos.x += size.x;
if(new_pos.x >= size.x) new_pos.x -= size.x;
if(new_pos.y < 0) new_pos.y += size.y;
if(new_pos.y >= size.y) new_pos.y -= size.y;
return MapPoint(new_pos.x, new_pos.y);
}
static void printDistanceMatrix(MknnKmeansAlgorithm *kmeans) {
MknnDataset *dataset = mknn_kmeans_getDataset(kmeans);
MknnDistance *distance = mknn_kmeans_getDistance(kmeans);
int64_t n = mknn_dataset_getNumObjects(dataset);
std::vector<double> matrix(n * n);
mknn_fillDistanceMatrix(dataset, distance, matrix.data(), 8);
std::vector<int> limits_clusters;
showMatrixToScreen("distances", matrix, n, limits_clusters);
int64_t *assign = mknn_kmeans_getAssignations(kmeans, false);
int64_t nc = mknn_kmeans_getNumCentroids(kmeans);
std::vector<int> new_pos(n * n);
int cont = 0;
for (int j = 0; j < nc; j++) {
limits_clusters.push_back(cont);
for (int i = 0; i < n; i++) {
if (assign[i] == j)
new_pos[cont++] = i;
}
}
my::assert::equalInt("n", cont, n);
std::vector<double> matrix2(n * n);
for (int row = 0; row < n; row++) {
for (int col = 0; col < n; col++) {
matrix2[row * n + col] = matrix[new_pos[row] * n + new_pos[col]];
}
}
showMatrixToScreen("distances2", matrix2, n, limits_clusters);
}
// Move up or down.
void Hero::move(int dy) {
df::Vector new_pos(getPosition().getX(), getPosition().getY() + dy);
// If stays on screen, allow move.
if ((new_pos.getY() >= 0) &&
(new_pos.getY() < DM.getVertical()))
WM.moveObject(this, new_pos);
}
void
generate_stars_for_cell (int x, int y)
{
struct pos p; new_pos (&p, &global_level, mr.cell[x][y].room, -1, -1);
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++)
generate_stars_for_pos (&p);
}
void
generate_stars_for_room (int room)
{
struct pos p; new_pos (&p, &global_level, room, -1, -1);
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++)
generate_stars_for_pos (&p);
}
void ZLightingCoursor::OnSetFrame(int frame)
{
QPointF current_pos = pos();
int dx = ((double)(m_DestPoint.x()-current_pos.x()))/((double)frame);
int dy = ((double)(m_DestPoint.y()-current_pos.y()))/((double)frame);
QPointF new_pos(current_pos.x()+dx, current_pos.y()+dy);
setPos(new_pos);
}
//! [0]
Window::Window(QString filename):run_animation(false),m_animation_number(0),anim_time(0.0)
{
scene = new GraphSceneJM(filename,this);
graph_view = new GraphViewJM(scene);
m_shotbutton = new QPushButton("Shot", this);
m_saveposbutton = new QPushButton("Save Pos", this);
m_newposbutton = new QPushButton("New Pos", this);
m_newposname_edit = new QLineEdit(this);
m_delposbutton = new QPushButton("Delete this position", this);
m_gotoposbutton = new QPushButton("Goto Pos:", this);
m_pos_list = new QComboBox(this);
m_destpos_list = new QComboBox(this);
m_animfile_label = new QLabel("Save as:",this);
m_animfile_edit = new QLineEdit(this);
m_writefilebutton = new QPushButton("Write File", this);
QGridLayout *mainLayout = new QGridLayout;
mainLayout->addWidget(graph_view,1,1,10,2);
mainLayout->addWidget(m_shotbutton,1,3,1,2);
mainLayout->addWidget(m_saveposbutton,2,3,1,2);
mainLayout->addWidget(m_pos_list,3,3,1,2);
mainLayout->addWidget(m_delposbutton,4,3,1,2);
mainLayout->addWidget(m_newposbutton,5,3,1,1);
mainLayout->addWidget(m_newposname_edit,5,4,1,1);
mainLayout->addWidget(m_gotoposbutton,6,3,1,1);
mainLayout->addWidget(m_destpos_list,6,4,1,1);
mainLayout->addWidget(m_animfile_label,7,3,1,1);
mainLayout->addWidget(m_animfile_edit,7,4,1,1);
mainLayout->addWidget(m_writefilebutton,8,3,1,2);
setLayout(mainLayout);
setWindowTitle(tr("QAnimDrawer"));
QObject::connect(m_shotbutton, SIGNAL(clicked()), graph_view, SLOT(ask_shot()));
QObject::connect(m_saveposbutton, SIGNAL(clicked()), this, SLOT(save_pos()));
QObject::connect(m_delposbutton, SIGNAL(clicked()), this, SLOT(del_pos()));
QObject::connect(m_gotoposbutton, SIGNAL(clicked()), this, SLOT(goto_pos()));
QObject::connect(m_newposbutton, SIGNAL(clicked()), this, SLOT(new_pos()));
QObject::connect(m_pos_list, SIGNAL(currentIndexChanged(int)), this, SLOT(change_pos(int)));
QObject::connect(m_writefilebutton, SIGNAL(clicked()), this, SLOT(write_file()));
scene->draw_skel();
update_pos_list();
timer=new QTimer(this);
QObject::connect(timer, SIGNAL(timeout()), this, SLOT(timer_timeout()));
}
// Move up or down.
void Hero::move(int dy) {
df::GraphicsManager &graphics_manager = df::GraphicsManager::getInstance();
df::WorldManager &world_manager = df::WorldManager::getInstance();
df::Position new_pos(getPosition().getX(), getPosition().getY() + dy);
// If stays on screen, allow move.
if ((new_pos.getY() >= 0) &&
(new_pos.getY() < graphics_manager.getVertical()))
world_manager.moveObject(this, new_pos);
}
void Pony::mouseMoveEvent(QMouseEvent* event)
{
if (dragging) {
x_pos = event->globalPos().x();
y_pos = event->globalPos().y();
QPoint new_pos(event->globalPos().x()-current_behavior->x_center,event->globalPos().y()-current_behavior->y_center);
move(new_pos);
event->accept();
}
}
bool update_map(rm_localization::UpdateMap::Request &req,
rm_localization::UpdateMap::Response &res) {
boost::mutex::scoped_lock lock(closest_keyframe_update_mutex);
Eigen::Vector3f intrinsics;
memcpy(intrinsics.data(), req.intrinsics.data(), 3 * sizeof(float));
bool update_intrinsics = intrinsics[0] != 0.0f;
if (update_intrinsics) {
ROS_INFO("Updated camera intrinsics");
this->intrinsics = intrinsics;
ROS_INFO_STREAM("New intrinsics" << std::endl << this->intrinsics);
}
for (size_t i = 0; i < req.idx.size(); i++) {
Eigen::Quaternionf orientation;
Eigen::Vector3f position, intrinsics;
memcpy(orientation.coeffs().data(),
req.transform[i].unit_quaternion.data(), 4 * sizeof(float));
memcpy(position.data(), req.transform[i].position.data(),
3 * sizeof(float));
Sophus::SE3f new_pos(orientation, position);
if (req.idx[i] == closest_keyframe_idx) {
//closest_keyframe_update_mutex.lock();
camera_position = new_pos
* keyframes[req.idx[i]]->get_pos().inverse()
* camera_position;
keyframes[req.idx[i]]->get_pos() = new_pos;
//if (update_intrinsics) {
// keyframes[req.idx[i]]->get_intrinsics() = intrinsics;
//}
//closest_keyframe_update_mutex.unlock();
} else {
keyframes[req.idx[i]]->get_pos() = new_pos;
//if (update_intrinsics) {
// keyframes[req.idx[i]]->get_intrinsics() = intrinsics;
//}
}
}
return true;
}
void GameInstSet::update_instance_for_step(InstanceState* state,
GameInst* inst) {
if (inst->destroyed)
return;
if (true || inst->solid) {
Pos last_pos(inst->last_x, inst->last_y), new_pos(inst->x, inst->y);
LANARTS_ASSERT(within_bounds_check(last_pos));
LANARTS_ASSERT(within_bounds_check(new_pos));
__update_collision_position(state, last_pos, new_pos);
}
inst->last_x = inst->x, inst->last_y = inst->y;
}
static int
do_op_up(struct form_state *fs, struct line_info *line, int current, int utf8)
{
int old_state;
if (current == -1) return 0;
if (!(current - !!fs->state_cell)) return 1;
if (!utf8) {
fs->state -= line[current].start - line[current-1].start;
int_upper_bound(&fs->state, line[current-1].end);
return 0;
}
old_state = fs->state;
if (fs->state_cell) {
int len = utf8_ptr2cells(fs->value + line[current - 1].start,
fs->value + fs->state_cell);
new_pos(fs, line, current - 2, len + line[current - 1].last_char_width);
} else {
int len = utf8_ptr2cells(fs->value + line[current].start,
fs->value + fs->state);
new_pos(fs, line, current - 1, len);
}
if (old_state != fs->state ) {
if (fs->state_cell && fs->state == line[current - 1].start) {
unsigned char *new_value;
new_value = utf8_prevchar(fs->value + fs->state, 1, fs->value);
fs->state_cell = new_value - fs->value;
} else
fs->state_cell = 0;
}
return 0;
}
void MainGraphicsView::mouseMove(int m_x, int m_y) {
if( this->single_left_mouse_down ) {
// only if the left mouse is down, and this isn't a multitouch event (otherwise single_left_mouse_down should be set to false)
//qDebug(" lmb");
if( this->has_last_mouse ) {
//qDebug(" has last mouse");
/*QPointF old_pos = this->mapToScene(this->last_mouse_x, this->last_mouse_y);
QPointF new_pos = this->mapToScene(event->x(), event->y());*/
//qDebug("%d, %d -> %d, %d", last_mouse_x, last_mouse_y, m_x, m_y);
QPointF old_pos(this->last_mouse_x, this->last_mouse_y);
QPointF new_pos(m_x, m_y);
QPointF diff = old_pos - new_pos; // n.b., scene scrolls in opposite direction to mouse movement
// drag - we do this ourselves rather than using drag mode QGraphicsView::ScrollHandDrag, to avoid conflict with multitouch
QPointF centre = this->getCenter();
QPoint centre_pixels = this->mapFromScene(centre);
centre_pixels.setX( centre_pixels.x() + diff.x() );
centre_pixels.setY( centre_pixels.y() + diff.y() );
centre = this->mapToScene(centre_pixels);
//this->centerOn(centre);
// have problems on Android with Qt 5.3 if we try to call centerOn() directly from an event callback (the screen doesn't update during the touch operation)
this->has_new_center_on = true;
this->new_center_on = centre;
//qDebug(" post centre on: %f, %f", new_center_on.x(), new_center_on.y());
// need to check against drag_tol_c, otherwise simply clicking can cause us to move with kinetic motion (at least on Android)
if( fabs(diff.x()) > drag_tol_c || fabs(diff.y()) > drag_tol_c ) {
int time_ms = game_g->getElapsedMS() - last_mouse_ms; // we don't use getElapsedFrameMS(), as we don't know how many times mouseMove() may have been called per frame
if( time_ms > 0 ) {
diff /= (float)time_ms;
this->has_kinetic_scroll = true;
this->kinetic_scroll_dir.set(diff.x(), diff.y());
this->kinetic_scroll_speed = this->kinetic_scroll_dir.magnitude();
this->kinetic_scroll_dir /= this->kinetic_scroll_speed;
this->kinetic_scroll_speed = std::min(this->kinetic_scroll_speed, 1.0f);
//qDebug(" speed: %f", this->kinetic_scroll_speed);
}
}
else {
this->has_kinetic_scroll = false;
}
//qDebug(" has last mouse done");
}
else {
this->has_kinetic_scroll = false;
}
this->has_last_mouse = true;
this->last_mouse_x = m_x;
this->last_mouse_y = m_y;
this->last_mouse_ms = game_g->getElapsedMS();
}
}
float CVT::move_sites_GPU()
{
float max_offset = 0;
/*
for (int i = 0; i < cells.size(); i++)
{
cells[i].site.x += 1;
cells[i].site.y += 1;
if (cells[i].site.x >= input_image.size().height) cells[i].site.x = 0;
if (cells[i].site.y >= input_image.size().width) cells[i].site.y = 0;
}*/
float total = 0;
cv::Point2d new_pos(0, 0);
/*
if (cell.coverage.empty()) std::cout << "! Error: cell.coverage " << cell.site << " size = " << cell.coverage.size() << std::endl;
//Generate virtual high resolution image;
cv::Size res(img.size().width * subpixels, img.size().height * subpixels);
cv::Mat resizedImg(res.width, res.height, CV_LOAD_IMAGE_GRAYSCALE);
cv::resize(img, resizedImg, res, 0, 0, CV_INTER_LINEAR);
//compute weighted average
float total = 0;
cv::Point2d new_pos(0, 0);
for (auto& c : cell.coverage)
{
float d = color2dist(resizedImg, c);
new_pos.x += d*c.x;
new_pos.y += d*c.y;
total += d;
}
//normalize
new_pos.x /= total;
new_pos.y /= total;
//Redirect output site to the position in original image
new_pos.x /= subpixels;
new_pos.y /= subpixels;
//update
float dist = fabs(new_pos.x - cell.site.x/subpixels) + fabs(new_pos.y - cell.site.y/subpixels); //manhattan dist
cell.site = new_pos;
//done
return dist;
*/
return max_offset;
}
void mod_node_impl::push_pos(node_position const& pos)
{
node_pos new_pos(pos);
uint16_t eq_comp = ct_none;
if (!pos_hist_.empty())
eq_comp = eq_components(pos_hist_.back().pos, new_pos, true);
pos_hist_.push_back(node_pos_stamp(new_pos, eq_comp));
if (pos_hist_.size() > hist_len_)
pos_hist_.pop_front();
}
void
draw_animated_foreground (ALLEGRO_BITMAP *bitmap, int room)
{
room_view = room;
struct pos p; new_pos (&p, &global_level, room, -1, -1);
/* loose_floor_fall_debug (); */
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++) {
draw_falling_loose_floor (bitmap, &p, em, vm);
}
draw_anims (bitmap, em, vm);
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++) {
draw_potion (bitmap, &p, em, vm);
if (is_sword (&p)) draw_sword (bitmap, &p, vm);
}
/* editor graphics */
switch (edit) {
case EDIT_GUARD:
case EDIT_GUARD_SELECT:
case EDIT_GUARD_SKILL:
case EDIT_SKILL_LEGACY_TEMPLATES:
case EDIT_GUARD_TYPE:
case EDIT_GUARD_STYLE:
case EDIT_GUARD_SKILL_ATTACK:
case EDIT_GUARD_SKILL_COUNTER_ATTACK:
case EDIT_GUARD_SKILL_DEFENSE:
case EDIT_GUARD_SKILL_COUNTER_DEFENSE:
case EDIT_GUARD_SKILL_ADVANCE:
case EDIT_GUARD_SKILL_RETURN:
case EDIT_GUARD_SKILL_REFRACTION:
case EDIT_GUARD_SKILL_EXTRA_LIFE:
case EDIT_GUARD_LIVES:
draw_start_guards (bitmap, vm);
break;
case EDIT_KID:
draw_start_kid (bitmap, vm);
break;
default: break;
}
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++)
draw_box (bitmap, &p, vm);
}
// Move up or down.
void Hero::move(int dy) {
// See if time to move.
if (move_countdown > 0)
return;
move_countdown = move_slowdown;
// If stays on window, allow move.
df::Position new_pos(getPosition().getX(), getPosition().getY() + dy);
df::WorldManager &world_manager = df::WorldManager::getInstance();
if ((new_pos.getY() > 3) &&
(new_pos.getY() < world_manager.getBoundary().getVertical()-1))
world_manager.moveObject(this, new_pos);
}
int pathfinding(char ***map, t_pos dst, t_pos pos, char c)
{
char tmp;
if (pos.x == dst.x && pos.y == dst.y)
return (1);
else if (pos.x < 0 || pos.y < 0)
return (0);
else if ((*map)[pos.y][pos.x] == 'X' || (*map)[pos.y][pos.x] == c)
return (0);
tmp = (*map)[pos.y][pos.x];
(*map)[pos.y][pos.x] = c;
if (pathfinding(map, dst, new_pos(pos.x, pos.y + 1), c))
return (1);
if (pathfinding(map, dst, new_pos(pos.x + 1, pos.y), c))
return (1);
if (pathfinding(map, dst, new_pos(pos.x, pos.y - 1), c))
return (1);
if (pathfinding(map, dst, new_pos(pos.x - 1, pos.y), c))
return (1);
(*map)[pos.y][pos.x] = tmp;
return (0);
}
void SpritePropertyImpl::Translate(float x, float y)
{
if (!m_spr) {
return;
}
sm::vec2 new_pos(x, y);
std::vector<SprPtr> sprs;
sprs.push_back(m_spr);
EditAddRecordSJ::Instance()->Add(std::make_shared<TranslateSpriteAOP>(sprs, new_pos - m_spr->GetPosition()));
m_spr->SetPosition(new_pos);
}
struct pos *
pos_gen (struct coord *c, struct pos *p, int dx, int dy)
{
int floor, place;
if (c->x >= dx) place = (c->x - dx) / PLACE_WIDTH;
else if (0 <= c->x && c->x < dx) place = -1;
else place = -(((dx - c->x - 1) / PLACE_WIDTH) + 1);
if (c->y >= dy) floor = (c->y - dy) / PLACE_HEIGHT;
else if (0 <= c->y && c->y < dy) floor = -1;
else floor = -(((dy - c->y - 1) / PLACE_HEIGHT) + 1);
return new_pos (p, c->l, c->room, floor, place);
}
// Move up or down.
void EnemyTank::move(int dx) {
// See if time to move.
if (move_countdown > 0)
return;
//Reset countdown
move_countdown = move_slowdown;
// If stays on window, allow move.
df::Position new_pos(getPosition().getX() + dx, getPosition().getY());
df::WorldManager &world_manager = df::WorldManager::getInstance();
if ((new_pos.getX() > world_manager.getView().getCorner().getX()) &&
(new_pos.getX() < world_manager.getView().getCorner().getX() + world_manager.getView().getHorizontal()))
world_manager.moveObject(this, new_pos);
}
void
draw_room (ALLEGRO_BITMAP *bitmap, int room,
enum em em, enum vm vm)
{
struct pos p; new_pos (&p, &global_level, room, -1, -1);
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++) {
draw_conbg (bitmap, &p, em, vm);
free_stars (&p);
}
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place <= PLACES; p.place++)
draw_confg (bitmap, &p, em, vm);
}
POS2D RRG::_steer( POS2D pos_a, POS2D pos_b ) {
POS2D new_pos( pos_a[0], pos_a[1] );
double delta[2];
delta[0] = pos_a[0] - pos_b[0];
delta[1] = pos_a[1] - pos_b[1];
double delta_len = sqrt(delta[0]*delta[0]+delta[1]*delta[1]);
if (delta_len > _segment_length) {
double scale = _segment_length / delta_len;
delta[0] = delta[0] * scale;
delta[1] = delta[1] * scale;
new_pos.setX( pos_b[0]+delta[0] );
new_pos.setY( pos_b[1]+delta[1] );
}
return new_pos;
}
void
draw_animated_background (ALLEGRO_BITMAP *bitmap, int room)
{
room_view = room;
struct pos p; new_pos (&p, &global_level, room, -1, -1);
for (p.floor = FLOORS; p.floor >= 0; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++)
draw_no_floor_selection (bitmap, &p);
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++) {
if (con (&p)->fg == WALL) continue;
draw_fire (bitmap, &p, vm);
draw_balcony_stars (bitmap, &p, vm);
}
}
// move the enemy with the given deltas
void Enemy::move(int dx, int dy) {
// See if time to move.
if (move_countdown > 0){
move_countdown--;
return;
}
// reset countdown
move_countdown = move_slowdown;
// If stays on window, allow move.
df::Position new_pos(getPosition().getX() + dx, getPosition().getY() + dy);
df::WorldManager &world_manager = df::WorldManager::getInstance();
// If stays on window, allow move.
if ((new_pos.getY() > 0) &&
(new_pos.getY() < world_manager.getBoundary().getVertical())){
world_manager.moveObject(this, new_pos);
}
}
struct pos *
get_new_rel_pos (struct pos *old_src, struct pos *old_dest,
struct pos *new_src, struct pos *new_dest)
{
struct pos nold_src; npos (old_src, &nold_src);
struct pos nold_dest; npos (old_dest, &nold_dest);
struct pos nnew_src; npos (new_src, &nnew_src);
pos2room (&nold_dest, nold_src.room, &nold_dest);
if (nold_dest.room != nold_src.room)
return invalid_pos (new_dest);
new_pos (new_dest, nnew_src.l, nnew_src.room,
nnew_src.floor + (nold_dest.floor - nold_src.floor),
nnew_src.place + (nold_dest.place - nold_src.place));
return npos (new_dest, new_dest);
}
