Esempio n. 1
0
void MekaDragon::fire()
{
    if (m_fire_timer.expired(get_attribute("fire_next"))) {
        if (m_bullet_index < m_bullets.size()) {
            if (m_dir == Right) {
                m_bullets[m_bullet_index]->fire(
                    m_x + get_attribute("attack_right"),
                    m_y + get_attribute("attack_medium"),
                    get_attribute("fire_dx"),
                    get_attribute("fire_dy"));
            }
            else if (m_dir == Left) {
                m_bullets[m_bullet_index]->fire(
                    m_x + get_attribute("attack_left"),
                    m_y + get_attribute("attack_medium"),
                    -get_attribute("fire_dx"),
                    get_attribute("fire_dy"));
            }
            m_bullet_index++;
        }
        else {
            m_bullet_index = 0;
            m_idle_timer.reset();
            set_action(Move);
            reset_attack();
        }
    }
}
Esempio n. 2
0
void MummyDragon::fire()
{
    if (m_fire_timer.expired(get_attribute("fire_next"))) {
        if (m_bullet_index < m_bullets.size()) {
            int delta_x =
                get_attribute("fire_max_dx") - get_attribute("fire_min_dx");
            int delta_y =
                get_attribute("fire_max_dy") - get_attribute("fire_min_dy");
            int fire_dx = (rand() % delta_x) + get_attribute("fire_min_dx");
            int fire_dy = (rand() % delta_y) + get_attribute("fire_min_dy");

            if (m_dir == Right) {
                m_bullets[m_bullet_index]->fire(
                    m_x + get_attribute("attack_right"),
                    m_y + get_attribute("attack_medium"),
                    fire_dx, fire_dy);
            }
            else if (m_dir == Left) {
                m_bullets[m_bullet_index]->fire(
                    m_x + get_attribute("attack_left"),
                    m_y + get_attribute("attack_medium"),
                    -fire_dx, fire_dy);
            }
            m_bullet_index++;
        }
        else {
            m_bullet_index = 0;
            set_action(Move);
            reset_attack();
        }
    }
}
Esempio n. 3
0
void Erupter::move(Map *map)
{
    Monster::move(map);

    switch(m_action) {
        case Still:
            if (m_attack_timer.check(get_attribute("attack_timer"))) {
                m_attack_timer.reset();
                int dist = get_attribute("attack_distance");
                int x = m_xref - get_front();
                int y = m_yref - get_y();
                if (x * x + y * y < dist * dist) {
                    m_attack_timer.reset();
                    fire();
                }
            }
            break;

        case MediumAttack:
            if (m_anim_timer.expired(get_attribute("treshold"))) {
                m_attack_timer.reset();
                reset_attack();
            }
            break;

        default:
            break;
    }

    // Move bullets
    std::vector<GravityBullet*> remove;

    for (std::list<GravityBullet*>::iterator it = m_bullets.begin();
         it != m_bullets.end();
         ++it) {
        GravityBullet *bullet = (*it);
        bullet->move(map);
        if (!bullet->get_moving()) {
            remove.push_back(bullet);
        }
    }

    for (int i = 0; i < remove.size(); i++) {
        GravityBullet *bullet = remove[i];
        m_bullets.remove(bullet);
        delete bullet;
    }
}
Esempio n. 4
0
void Player::player_move(Map *map)
{
    Actor::move(map);

    check_water(map);

    int input = get_input();

    const Tmx::Tileset *tileset = map->get_tileset(0);
    const Tmx::PropertySet prop = tileset->GetProperties();

    // Check if on catapult
    int catid = prop.GetNumericProperty("catapult");
    if (catid && check_below(map, 1, catid, catid) == 0) {
        if (input & PRESS_RIGHT) {
            set_vx(get_attribute("move_speed"));
        }
        else if (input & PRESS_LEFT) {
            set_vx(-get_attribute("move_speed"));
        }
        set_jump(map, true);
    }

    switch(m_action) {
        case Still:
            set_vx(0);

        case Move:
            // Check for crouch or move
            if (input & PRESS_DOWN) {
                set_action(Crouch);
            }
            else if (input & PRESS_RIGHT) {
                animate_move();
                set_action(Move);
                set_vx(get_attribute("move_speed"));
            }
            else if (input & PRESS_LEFT) {
                animate_move();
                set_action(Move);
                set_vx(-get_attribute("move_speed"));
            }
            else {
                set_action(Still);
            }

            // Check for jump
            if (input & PRESS_JUMP) {
                if (m_jump_ready && m_hit_ground) {
                    if (input & PRESS_RIGHT) {
                        set_vx(get_attribute("move_speed"));
                    }
                    else if (input & PRESS_LEFT) {
                        set_vx(-get_attribute("move_speed"));
                    }
                    set_jump(map, false);
                }
                m_jump_ready = false;
            }
            else {
                // Restore jump lock
                m_jump_ready = true;
            }

            Body::move(map);
            if (get_fall()) {
                set_action(Fall);
            }
            break;

        case Fall:
            // Check for change of direction during fall
            if (input & PRESS_RIGHT) {
                set_vx(get_attribute("move_speed"));
            }
            else if (input & PRESS_LEFT) {
                set_vx(-get_attribute("move_speed"));
            }

            Body::move(map);
            if (!get_fall()) {
                m_hit_ground = true;
                set_action(Still);
            }
            break;

        case Jump:
        case Catapult:
            Body::move(map);
            if (get_fall()) {
                set_action(Fall);
            }
            break;

        case Crouch:
            set_vx(0);
            Body::move(map);
            if (!get_fall()) {
                m_hit_ground = true;
            }

            if (!(input & PRESS_DOWN)) {
                set_action(Still);
            }
            break;

        case Hit:
            if (m_hit_timer.expired(get_attribute("hit_time"))) {
                set_vx(0);
                set_lock_direction(false);
                reset_hit();
            }
            Body::move(map);
            break;

        case HitPerish:
            animate_perish();
            set_speed(0, -get_attribute("move_speed"));
            Body::move(map);
            if (m_y < -get_image_height()) {
                set_solid(true);
                set_invisible(false);
                set_action(HitPerished);
            }
            break;

        case Attack:
        case AttackLow:
            if (animate_attack()) {
                reset_attack();
            }
            Body::move(map);
            if (!get_fall()) {
                m_hit_ground = true;
            }
            break;

        default:
            Body::move(map);
            break;
    }
}