source: src/main/java/bargainingchips/players/BasicAgent.java@ 330

package bargainingchips.players;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import bargainingchips.Bundle;
import bargainingchips.NegotiationContext;
import bargainingchips.OutcomeSpace;
import bargainingchips.actions.Accept;
import bargainingchips.actions.Bid;
import bargainingchips.actions.Offer;
import bargainingchips.actions.OfferBy;
import bargainingchips.outcomes.Outcome;
import bargainingchips.utilityfunctions.UtilityFunction;

/**
 * Basic agent, by Tim Baarslag
 */
public class BasicAgent extends Agent 
{
        private Offer lastReceivedOffer = null;
        
        /**
         * For sellers, dummy coordinator queues are created but are never linked up
         */
        public BasicAgent(String name, UtilityFunction u, NegotiationContext nc, 
                        BlockingQueue<Offer> in, BlockingQueue<OfferBy> out) 
        {
                super(name, u, nc, in, out, 
                                new LinkedBlockingQueue<CoordinationMessage>(),
                                new LinkedBlockingQueue<StatusMessage>());
        }

        @Override
        protected Offer sendOffer()
        {
                // Nothing received yet
                if (lastReceivedOffer == null)
                        return new Bid(getNextBid());
                
                // Our last bid got accepted. We are also accepting (and we should notify the coordinator).
                if (lastReceivedOffer.isAccept())                       
                        return new Accept(lastReceivedOffer);
                
                Bundle lastReceivedBid = lastReceivedOffer.getBundle();
                Bundle nextBid = getNextBid();
                
                double lastUtil = lastReceivedBid != null ? u.getUtility(lastReceivedBid) : 0;
                double nextUtil = nextBid != null ? u.getUtility(nextBid) : 0;

                // Accept
                if (nextUtil <= lastUtil)
                        return new Accept(lastReceivedOffer);
                // Counter offer based actions
                else 
                {
                        try {
                                Thread.sleep(5000);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        return new Bid(nextBid);
                }
                
        }

        /**
         * Get the next bid we should do
         */
        protected Bundle getNextBid() 
        {
                OutcomeSpace outcomeSpace = negotiationContext.getOutcomeSpace();
                return outcomeSpace.getBidNearUtility(getTargetUtility(), u, this);
        }

        @Override
        protected void receiveOffer(Offer o) 
        {
                lastReceivedOffer = o;
        }
        
        @Override
        protected void receiveOutcome(Outcome outcome) 
        {
                System.out.println(this + " is done with outcome " + outcome + ". Should clean up now.");               
        }

        /**
         * Only the best bid is good enough.
         */
        private double getTargetUtility() 
        {
                return 1.0;
        }       
        
        @Override
        protected Offer sendOpeningOffer() 
        {
                return null;
        }

        /**
         * Messaging with the coordinator can happen below
         */
        @Override
        protected void receiveCoordinationMessage(CoordinationMessage cpoll) 
        {
                // Update the utility function
                u = cpoll.getUtilityFunction();
        }
        
        @Override
        protected StatusMessage sendStatusMessage() 
        {
                return null;
        }
}