source: src/main/java/agents/anac/y2018/yeela/Yeela.java@ 343

package agents.anac.y2018.yeela;

import java.util.List;

import java.util.Vector;

import genius.core.AgentID;
import genius.core.Bid;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.Offer;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;

/**
 * group1.Agent1 returns the bid that maximizes its own utility for half of the negotiation session.
 * In the second half, it offers a random bid. It only accepts the bid on the table in this phase,
 * if the utility of the bid is higher than Example Agent's last bid.
 */
public class Yeela extends AbstractNegotiationParty {
    /**
         * 
         */
        private static final long serialVersionUID = -2676016971703971492L;

        private final String description = "yeela Agent";

    private Bid lastReceivedOffer; // offer on the table
    private Bid bestReceivedOffer; // best offer seen
    private Learner curLearner;
    private boolean firstGameAct;
    private double timeToGiveUp = 0.75;
    private List<Bid> bids;
    private NegotiationInfo m_info;
    @Override
    public void init(NegotiationInfo info) {
        super.init(info);

        System.out.println("Discount Factor is " + info.getUtilitySpace().getDiscountFactor());
        System.out.println("Reservation Value is " + info.getUtilitySpace().getReservationValueUndiscounted());
        
        firstGameAct = true;
        m_info = info;
        bids = new Vector<Bid>();
        
                curLearner = new Learner(getMaxUtilityBid(), info);
    }

    /**
     * When this function is called, it is expected that the Party chooses one of the actions from the possible
     * action list and returns an instance of the chosen action.
     *
     * @param list
     * @return
     */
    public Action chooseAction(List<Class<? extends Action>> list) {
        // According to Stacked Alternating Offers Protocol list includes
        // Accept, Offer and EndNegotiation actions only.
        double time = getTimeLine().getTime(); // Gets the time, running from t = 0 (start) to t = 1 (deadline).
                                               // The time is normalized, so agents need not be
                                               // concerned with the actual internal clock.

        System.out.println(time);

        // if we are first
        if (firstGameAct)
        {
                firstGameAct = false;
                bids.add(this.getMaxUtilityBid());
                return new Offer(this.getPartyId(), this.getMaxUtilityBid());
        }
        
        try
        {
                if (timeToGiveUp < time)
                {
                        return new Accept(this.getPartyId(), lastReceivedOffer);
                }

                // create new offer
                bids.add(curLearner.run(lastReceivedOffer));

                // decide whether to accept counter offer
                for (Bid bid : bids)
                {
                        if (m_info.getUtilitySpace().getUtility(lastReceivedOffer) == m_info.getUtilitySpace().getUtility(bid))
                        {
                                return new Accept(this.getPartyId(), lastReceivedOffer);
                        }
                }

                // decide whether to offer previous counter offer since its better than newly suggested offer
                if (m_info.getUtilitySpace().getUtility(bestReceivedOffer) > m_info.getUtilitySpace().getUtility(bids.get(bids.size() - 1)))
                {
                        return new Offer(this.getPartyId(), bestReceivedOffer);
                }

                // suggest our new offer
                return new Offer(this.getPartyId(), bids.get(bids.size() - 1));
        }
        catch (Exception e)
                {
                        e.printStackTrace();
                return new Accept(this.getPartyId(), lastReceivedOffer);
        }
    }

    /**
     * This method is called to inform the party that another NegotiationParty chose an Action.
     * @param sender
     * @param act
     */
    @Override
    public void receiveMessage(AgentID sender, Action act) {
        super.receiveMessage(sender, act);

        if (act instanceof Offer) { // sender is making an offer
            Offer offer = (Offer) act;
            
            // storing last received offer
            lastReceivedOffer = offer.getBid();
            
            if ((null == bestReceivedOffer) || (m_info.getUtilitySpace().getUtility(bestReceivedOffer) < m_info.getUtilitySpace().getUtility(lastReceivedOffer)))
            {
                bestReceivedOffer = lastReceivedOffer;
            }
            firstGameAct = false;
        }
    }

    /**
     * A human-readable description for this party.
     * @return
     */

    public String getDescription() {
        return description;
    }

    private Bid getMaxUtilityBid() {
        try
        {
            return this.utilitySpace.getMaxUtilityBid();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}