Pvp priest attempt #1

var blacklist = ['chin', 'Arcuz', 'Sieghart', 'Spadar', 'jane1', 'SixSix', 'Choko', "Glass"];

var clock = 0, lastability = 0, target;
setInterval(function()
    {
    drawstuff(get_targeted_monster());
    },10);
function drawstuff(target)
{
    clear_drawings();
    draw_circle(character.real_x,character.real_y,character.range,.5,0xF00F);
    if (target)
        draw_circle(target.real_x,target.real_y,G.monsters[target.mtype].range,.5,0xFF0000);
}
function SeekAndDestroy() {
        var lowest_health = lowest_health_partymember();
    //If we have a target to heal, heal them. Otherwise attack a target.
    if (lowest_health.health < 0.75) {
        if (distance_to_point(lowest_health.real_x, lowest_health.real_y) < character.range) {
            heal(lowest_health);
        }
        else {
            move_to_target(lowest_health);
        }
    }

    if(character.hp<character.max_hp-200) parent.use('hp')
    if(character.mp<character.max_mp-300) parent.use('mp')
    clock = Date.now();

    if ( clock < parent.next_attack.getTime() ) return;

    // Search for characters to attack first (PVP)

    for ( var playername of blacklist ) {

            target = get_player(playername);

            if ( !target ) continue;

            if ( target.type != "character" || target.rip || !target.hp ) continue;

            set_message("Attacking "+target.name);

            if ( !in_attack_range(target) ) {

                move(

                    character.real_x+(target.real_x-character.real_x),

                    character.real_y+(target.real_y-character.real_y)

                    );

            } else if ( target && target.hp && !target.dead ) {

                Ability();

                parent.player_attack.call(target);

                last_attack = clock;

            }

            parent.ctarget= target;



            //Use a potion

            return; // No need to continue.

    }



    // Monster attack as a fallback

    target = get_nearest_monster({min_xp:50,max_att:character.attack});

    if ( !target ) return;

    set_message("Hunting "+target.name);

    if ( !in_attack_range(target) ) {

        move(

            character.real_x+(target.real_x-character.real_x),

            character.real_y+(target.real_y-character.real_y)

            );

    } else if ( target && target.hp && !target.dead ) {

        Ability();

        parent.monster_attack.call(target);

        last_attack = clock;

    }
// Use a potion



    parent.ctarget = target;

    shift(41,'goldbooster');

    loot();

    shift(41,'xpbooster');



}

setInterval(function(){SeekAndDestroy()},350); // Timer every .35 sec



function Ability() {

    if ( clock < lastability + 15000 ) return;

    lastability = clock;

    switch ( character.ctype ) {

        case "warrior":

    parent.socket.emit("ability",{name:"charge"});

    if ( parent.ctarget ) parent.socket.emit("ability",{name:"taunt",id:parent.ctarget.id});

            return true;

        case "rogue":

            parent.socket.emit("ability",{name:"invis"});

            return true;

    }

    if ( !parent.ctarget ) return false;

    switch ( character.ctype ) {

        case "mage":

            parent.socket.emit("ability",{name:"burst",id:parent.ctarget.id});

            return true;

        case "priest":

            parent.socket.emit("ability",{name:"curse",id:parent.ctarget.id});

            return true;

        case "ranger":

            parent.socket.emit("ability",{name:"supershot",id:parent.ctarget.id});

            return true;

    }

    return false;

}

function NextTarget() {

    var min_xp = 50;

    var max_attack = character.attack * 0.75;

    for( id in parent.entities ) { // Search only in range first

        var current = parent.entities[id];

        if ( !current || current.type != "monster" || current.dead ) continue;

        if ( current.xp<min_xp || current.attack>=max_attack ) continue;

        var c_dist = parent.distance(character,current);

        if ( c_dist <= character.range ) return current;

    }

    target = get_nearest_monster({min_xp:min_xp,max_att:max_attack});

}

//leech: setInterval(function(){respawn();},1500);
partyup=true;

var pwhitelist = ['Harold','Saboth', 'nobodyhere', 'nobodytanks'];

if (partyup)
{
    parent.window.addEventListener('keydown', (event) => {
   var keyName = event.key;
    if(keyName == 'p' || keyName == 'P')
    {
        invite_party_list();
        request_party_list()
    }
}, false);

setInterval(function()
{
    accept_party_list();
},20000);
}


//Adds all whitelisted party memebers to party
function invite_party_list() {
  for (members in pwhitelist) send_party_invite(pwhitelist[members],0);
}

//Accepts requests from whitelisted party memebers
function accept_party_list() {
    for (members in pwhitelist)
    {
        accept_party_request(pwhitelist[members]);
        accept_party_invite(pwhitelist[members]);
    }
}
function request_party_list() {
  for (members in pwhitelist) send_party_request(pwhitelist[members],0)
      }
  for (members in pwhitelist) send_party_invite(pwhitelist[members],0)

  for (members in pwhitelist) send_party_request(pwhitelist[members],0);


//Returns the party member with the lowest hp -> max_hp ratio.
function lowest_health_partymember() {
    var party = [];
    if (parent.party_list.length > 0) {
        var party = parent.party_list.map(
            function (member) {
                return {
                    name: member,
                    entity: parent.entities[member]
                }
            });
    }
    else {
        //Player is not in a party
        party.push(
        {
            name: character.name,
            entity: character
        });
    }

    //Populate health percentages
    for (id in party) {
        var member = party[id];

        if (member.name == character.name) {
            member.entity = character;
        }

        if (member.entity != null) {
            member.health = member.entity.hp / member.entity.max_hp;
        }
        else {
            member.health = 1;
        }
    }

    //Order our party array by health percentage
    party.sort(function (current, next) {
        return current.health - member.health;
    });

    //Return the lowest health
    return party[0].entity;
}