source: src/main/java/parties/AlternatingMultipleOffers/RandomAmopParty.java

package parties.AlternatingMultipleOffers;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

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.actions.OfferForVoting;
import genius.core.actions.Reject;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.protocol.AlternatingMultipleOffersProtocol;
import genius.core.protocol.DefaultMultilateralProtocol;

public class RandomAmopParty extends AbstractNegotiationParty {

        private final static float P_ACCEPT = 0.3f;

        private List<Bid> receivedBids = new ArrayList<Bid>();
        private Random rnd = new Random();

        enum Phase {
                OFFER, VOTE
        };

        private Phase phase = Phase.OFFER;

        /**
         * We need to keep track of the number of votes we already did.
         */
        private int votingIndex = 0;

        @Override
        public Action chooseAction(List<Class<? extends Action>> possibleActions) {
                if (possibleActions.contains(OfferForVoting.class)) {
                        Bid bid = generateRandomBid();
                        addOffer(bid);
                        return new OfferForVoting(getPartyId(), bid);
                }
                if (possibleActions.contains(Accept.class)) {
                        setPhase(Phase.VOTE);
                        if (votingIndex >= receivedBids.size()) {
                                throw new IllegalStateException("Received more requests for vote (" + (votingIndex + 1)
                                                + ") than number of received offers (" + receivedBids.size() + ")!");
                        }
                        Bid bid = receivedBids.get(votingIndex++);

                        if (rnd.nextFloat() < P_ACCEPT) {
                                return new Accept(getPartyId(), bid);
                        } else {
                                return new Reject(getPartyId(), bid);
                        }
                }
                throw new IllegalStateException("Unknown action request " + possibleActions);
        }

        /**
         * Try to track which phase we are in...
         * 
         * @param newPhase
         *            the phase that we supposedly are in now.
         */
        private void setPhase(Phase newPhase) {
                if (phase != newPhase) {
                        phase = newPhase;
                        if (phase == Phase.OFFER) {
                                // entered new offer round
                                if (receivedBids.size() != votingIndex) {
                                        System.out.println("Warning: entered new Offer round but we voted only on " + votingIndex
                                                        + " of the " + receivedBids);
                                }
                                votingIndex = 0;
                                receivedBids.clear();
                        }
                }
        }

        private void addOffer(Bid bid) {
                setPhase(Phase.OFFER);
                receivedBids.add(bid);
        }

        @Override
        public void receiveMessage(AgentID sender, Action action) {
                if (action instanceof OfferForVoting) {
                        addOffer(((Offer) action).getBid());
                } else if (action instanceof Accept || action instanceof Reject) {
                        setPhase(Phase.VOTE);
                } else {
                        System.out.println("Warning: ignoring unknown message " + action);
                }
        }

        @Override
        public Class<? extends DefaultMultilateralProtocol> getProtocol() {
                return AlternatingMultipleOffersProtocol.class;
        }

        @Override
        public String getDescription() {
                return "Random AMOP Party";
        }

}