File content as of revision 56:ef9521b7ed78:

#include "Skull.h"
#include <complex>
Skull::Skull(float pos_x, float pos_y)
{
    hp = 20;
    attack = 1;
    
    _dash = false;
    _dash_counter = 0;
    
    hitbox.width = 19;
    hitbox.height = 9;
    
    sprite_size.width = 21;
    sprite_size.height = 23;
    sprite_size.offset_x = -1;
    sprite_size.offset_y = -14;
    
    _shadow.width = 19;
    _shadow.height = 5;
    _shadow.offset_x = 0;
    _shadow.offset_y = 5;
    
    position.x = pos_x;
    position.y = pos_y;
    update_prev_pos();
    
    frame.count = 0;
    frame.number = 0;
    frame.max = 2;
    face = 2;
    
    velocity = 0.2;
    _hp_drop_chance = 0;
}

void Skull::move(float player_x, float player_y, char * map, bool * doorways)
{
    if (_dash_counter < DASH_DELAY) { // Approaching Movement
        approaching_movement(player_x, player_y);
    } else if (_dash_counter < DASH_DELAY + 28){ // Dashing movement; const 28 = 4(velocity_index_increment_delay) * 7 (length of the velocity_pattern)
        dash_movement();
    } else {
        _dash_counter = 0;
        velocity = 0.2;
    }
    undo_move_x(entity_to_map_collision_test(position.x, prev_pos.y, map, doorways));
    undo_move_y(entity_to_map_collision_test(prev_pos.x, position.y, map, doorways));
    
    _dash_counter++;
    increment_frames();
}

void Skull::approaching_movement(float player_x, float player_y)
{
    _dash = false;
    std::complex<double> pos_diff(player_x - position.x, player_y - position.y);     // defining difference in position as a vector for simplicity, similar to Headless
    position.x += velocity * pos_diff.real() / std::abs(pos_diff);
    position.y += velocity * pos_diff.imag() / std::abs(pos_diff);
    // Setting Face
    if (abs(pos_diff.real()) > abs(pos_diff.imag())) {
        if (pos_diff.real() > 0) {
            face = 1;
        } else {
            face = 3;
        }
    } else {
        if (pos_diff.imag() > 0) {
            face = 2;
        } else {
            face = 0;
        }
    }
}

void Skull::dash_movement() // Changes velocity over time using the velocity pattern
{
    _dash = true;
    velocity = skull_velocity_pattern[(int)((_dash_counter - DASH_DELAY)/4)];
    if (face == 0){
        position.y -= velocity;
    } else if (face == 1){
        position.x += velocity;
    } else if (face == 2){
        position.y += velocity;
    } else if (face == 3){
        position.x -= velocity;
    }
}

void Skull::draw(N5110 &lcd)
{
    update_offsets();
    lcd.drawSpriteTransparent(position.x+_shadow.offset_x,
                              position.y+_shadow.offset_y,
                              _shadow.height,
                              _shadow.width,
                              (char *)skull_shadow_sprite[frame.number]);
    lcd.drawSpriteTransparent(position.x+sprite_size.offset_x,
                              position.y+sprite_size.offset_y,
                              sprite_size.height,
                              sprite_size.width,
                              (char *)skull_sprite[face][_dash]);
}

void Skull::take_damage(int damage)
{
    hp -= 1;
}

// Methods

void Skull::increment_frames()
{
    if (frame.number < frame.max) {
        frame.count++;
    } else {
        frame.count = 0;
    }
    frame.number = (frame.count/20) % frame.max;
}

void Skull::update_offsets()    // Animates the shadows by offsetting the skull from the shadow periodically
{
    if (frame.number == 0) {
        sprite_size.offset_y = -14;
    } else if (frame.number == 1) {
        sprite_size.offset_y = -15;
    }
}