RCHost 1.7

import org.rsbot.script.Script;
import org.rsbot.script.ScriptManifest;
import org.rsbot.script.wrappers.RSArea;
import org.rsbot.script.wrappers.RSTile;
import org.rsbot.script.wrappers.RSItem;
import org.rsbot.script.wrappers.RSNPC;
import org.rsbot.script.wrappers.RSObject;
import org.rsbot.script.wrappers.RSPlayer;
import org.rsbot.script.wrappers.RSInterface;
import org.rsbot.script.wrappers.RSComponent;
import org.rsbot.event.listeners.PaintListener;
import org.rsbot.event.listeners.MessageListener;
import org.rsbot.event.events.MessageEvent;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.Formatter;



@ScriptManifest (
    name = "RCHost",
    version = 1.7,
    description = "Runecrafting host",
    keywords = { "runecrafting", "rune", "host", "multi" },
    authors = { "airevent" },
    website = ""
)
public class RCHost extends Script implements MessageListener, PaintListener {
    private int startAirs;
    private int startExp;
    private double startTime;
    private String tradeText = "wishes to trade with you.";
    private int runeEssenceID = 1436;
    private int runeEssenceCertID = 1437;
    private int airRuneID = 556;
    private int airTiaraID = 5527;
    private int airAltarID = 2478;
    private int airAltarExitID = 2465; // or 7389
    private int airAltarEnterID = 2452;
    private RSArea airAltarInners = new RSArea(2837, 4826, 2850, 4841);
    private int tradeOffered = 0;
    private boolean tradeRequest = false;

    private int POS_UNKNOWN = 0;
    private int POS_INNERS  = 1;



    private String dateFormat( int seconds ) {
        Formatter f = new Formatter();
        return f.format("%02d:%02d:%02d",
            (int)(seconds/60/60),
            (int)(seconds/60%60),
            (int)(seconds%60)
        ).toString();
    }



    private boolean fail( String msg ) {
        log.severe("Fatal error: " + msg);
        stopScript();
        return false;
    }



    private int pos() {
        RSTile player = getMyPlayer().getLocation();

        if ( this.airAltarInners.contains(player) ) {
            return POS_INNERS;
        } else {
            return POS_UNKNOWN;
        }
    }



    private String progress() {
        int time = (int)((System.currentTimeMillis() - this.startTime) / 1000);
        if ( time == 0 ) return "initialising ... ";

        int crafted = inventory.getCount(true, this.airRuneID) - this.startAirs;
        int exp = skills.getCurrentExp(skills.RUNECRAFTING) - this.startExp;

        return "HOST" +
            "; time: " + this.dateFormat(time) +
            "; airs: " + crafted +
            "; exp: " + exp;
    }



    private boolean isTrading() {
        return ( interfaces.get(334).isValid() || interfaces.get(335).isValid() );
    }



    private boolean isAssistMenu() {
        return ( interfaces.get(301).isValid() );
    }



    public void onRepaint( Graphics g1 ) {
        Graphics2D g = (Graphics2D)g1;
        g.drawString(this.progress(), 10, 330);
    }



    public void onFinish() {
        log(this.progress());
    }



    public boolean onStart() {
        /*if ( this.pos() == POS_UNKNOWN ) {
            log.severe("unknown player position; go to air altar");
            return false;
        }

        if ( !equipment.containsAll(this.airTiaraID) ) {
            log.severe("no air tiara equipped");
            return false;
        }

        if ( !inventory.contains(this.runeEssenceCertID) ) {
            log.severe("no rune essence certificates in inventory");
            return false;
        }

        if ( !inventory.contains(this.airRuneID) ) {
            log.severe("no air runes in inventory");
            return false;
        }

        if ( inventory.getCount(false, this.runeEssenceID) + 2 != inventory.getCount() ) {
            log.severe("unknown items in inventory");
            return false;
        }*/

        this.startAirs = inventory.getCount(true, this.airRuneID);
        this.startExp = skills.getCurrentExp(skills.RUNECRAFTING);
        this.startTime = System.currentTimeMillis();

        camera.setPitch(90);
        return true;
    }



    public void messageReceived( MessageEvent e ) {
        String who = e.getSender();
        String msg = e.getMessage();
        RSPlayer carrier = players.getNearest(who);

        sleep(20);

        if ( this.isTrading() ) return;
        if ( !msg.contains(this.tradeText) ) return;
        if ( carrier == null ) return;

        if ( inventory.getCount(false, this.runeEssenceID) == 0 ) {
            this.tradeRequest = true;
        }
    }



    private void tradeAccept() {
        RSComponent chat = interfaces.get(137).getComponent(58);
        RSComponent row;

        if ( chat == null ) return;

        for ( int i=0; i<100; ++i ) {
            row = chat.getComponent(i);
            if ( row == null ) break;
            if ( !row.getText().contains(this.tradeText) ) continue;
            this.tradeRequest = false;
            this.tradeOffered = 0;
            mouse.click(row.getCenter(), true);
            break;
        }
    }



    private void trade() {
        if ( trade.inTradeMain() ) {
            int count = trade.getNumberOfItemsOffered();

            if ( count == 0 ) return;

            if ( count > 26 ) {
                trade.declineTrade();
                return;
            }

            if ( inventory.getCount(false, this.runeEssenceID) > 0 ) {
                trade.declineTrade();
                return;
            }

            RSItem ess[] = trade.getItemsOffered();

            for ( int i=0; i<ess.length; ++i ) {
                if ( ess[i].getID() != this.runeEssenceID ) {
                    trade.declineTrade();
                    return;
                }
            }

            if ( this.tradeOffered != count ) {
                if ( this.tradeOffered > count ) {
                    trade.declineTrade();
                    return;
                }

                if ( trade.offer(this.runeEssenceCertID, count-this.tradeOffered) ) {
                    sleep(1000,1100);

                    if ( trade.isWealthOffered() ) {
                        this.tradeOffered = count;
                    }
                }
            }

            if ( count == this.tradeOffered ) {
                trade.acceptTrade();
            }
        } else if ( trade.inTradeSecond() ) {
            this.tradeOffered = 0;
            trade.acceptTrade();
            sleep(900,1100);
        }
    }



    public int loop() {
        if ( interfaces.canContinue() ) {
            camera.moveRandomly(random(500,700));
            interfaces.clickContinue();
            return random(50,90);
        }

        if ( this.isAssistMenu() ) {
            walking.walkTileMM(getMyPlayer().getLocation().randomize(1,1));
            return random(500,900);
        }

        if ( this.isTrading() ) {
            try { this.trade(); } catch ( Exception e ) {}
            return random(50,90);
        }

        if ( this.tradeRequest ) {
            this.tradeAccept();
            return random(50,90);
        }

        if ( inventory.getCount(false, this.runeEssenceID) > 0 ) {
            RSObject altar = objects.getNearest(this.airAltarID);

            if ( altar != null ) {
                camera.moveRandomly(random(500,700));
                camera.turnTo(altar);
                altar.doClick();
                return random(900,1100);
            } else {
                this.fail("cant find air altar");
            }
        }

        /*if ( inventory.getCount(true, this.runeEssenceCertID) < 26 ) {
            this.fail("ran out of ess; stopping");
            return 0;
        }*/

        return random(50,90);
    }
}