switch (state){

    case states.seek:
        #region Seek

        charge_cooldown_counter = max(0, charge_cooldown_counter - 1 * global.move_mod);
        additional_debug_info = string(charge_cooldown_counter)

        SetTarget(oTracker);

        //set state to charge if tracker is within charge distance
        var in_range = collision_circle(x, y, charge_radius, oTracker, false, true)
        if  (in_range) && (charge_cooldown_counter <= 0){
            bonus_hp = hp_start/2;
            state = states.charge;
            break;

        }

        avoid_angle = 0;
        target_dir = point_direction(x, y, target_x, target_y)

        with (oBigEnemy){
            if (id != other.id){
                if (point_distance(x, y, other.x, other.y) < other.avoid_distance){
                    if (other.avoid_angle != 0) {break;}
                    other.avoid_angle = choose(-45, 45);
                }
            }
            //else other.avoid_angle = 0;
        }

        var delta = angle_difference(target_dir, direction);

        direction += (sign(delta) * turn_rate + avoid_angle) + (sin((get_timer()+wobble_offset)/100000)*10);

        Move();

        if (target_x >= x) image_xscale = 1*size;
        else image_xscale = -1*size;
        if (target_y >= y) image_index = 0;
        else image_index = 1;

        break;
        #endregion


    case states.charge:
        #region Charge

        //SetTarget(oTracker);
        CreateAlert();

        charge_counter += 1* global.move_mod;
        if(bonus_hp <= 0){
            charge_cooldown_counter = charge_cooldown/2;
            charge_counter = 0;

            instance_destroy(my_alert);
            my_alert = noone;

            state = states.seek;

            break;
        }

        if (charge_counter >= charge_time){

            charge_cooldown_counter = charge_cooldown;
            charge_counter = 0;
            additional_debug_info = string(charge_cooldown_counter);
            target_angle = point_direction(x, y, target_x, target_y)


            instance_destroy(my_alert);
            my_alert = noone;

            start_charge_x = x;
            start_charge_y = y;

            state = states.attack;
            break;

        }
        //reduce offset
        if(abs(offset_x)>0) offset_x = Approach(offset_x, 0, knockback_recovery * global.move_mod);
        if(abs(offset_y)>0) offset_y = Approach(offset_y, 0, knockback_recovery * global.move_mod);

        break;
        #endregion

    case states.attack:
        #region Attack

        var dist_charged = point_distance(x, y, start_charge_x, start_charge_y);

        move_x = lengthdir_x(charge_spd, target_angle);
        move_y = lengthdir_y(charge_spd, target_angle);

        x += (move_x + offset_x)*global.move_mod;
        y += (move_y + offset_y)*global.move_mod;
        depth = -1*y

        if(abs(offset_x)>0) offset_x = Approach(offset_x, 0, knockback_recovery * global.move_mod);
        if(abs(offset_y)>0) offset_y = Approach(offset_y, 0, knockback_recovery * global.move_mod);

        if (dist_charged > charge_distance || bonus_hp <= 0){
            //keep some momentum
            bonus_hp = 0;

            offset_x += lengthdir_x(charge_spd, target_angle);
            offset_y += lengthdir_y(charge_spd, target_angle);

            state = states.seek;

        }

        #endregion
        break;
}