source: anac2020/agentKT/src/main/java/geniusweb/exampleparties/simpleshaop/NegotiationStrategy.java

package geniusweb.exampleparties.simpleshaop;

import java.math.BigDecimal;

import geniusweb.issuevalue.Bid;


public class NegotiationStrategy {
        private CompRegress compRegress;
        private NegotiationInfo negotiationInfo;
        
        private BigDecimal reserveValue;
        
        private BigDecimal A11 = BigDecimal.ZERO; // utility - A: hardliner, B: hardliner
        private BigDecimal A12 = BigDecimal.ZERO; // utility - A: hardliner, B: conceder
        private BigDecimal A21 = BigDecimal.ZERO; // utility - A: conceder,  B; hardliner
        private BigDecimal A22 = BigDecimal.ZERO; // utility - A: conceder,  B: conceder
        
        //static private BigDecimal timeFinal = BigDecimal.ONE;
        static private BigDecimal probFinal = BigDecimal.valueOf(0.5); // probability of own agent compromising first on last round when both agents concede
        
        
        public NegotiationStrategy(CompRegress compRegress, NegotiationInfo negotiationInfo, Bid reserveBid) {
                this.compRegress = compRegress;
                this.negotiationInfo = negotiationInfo;
                this.reserveValue = compRegress.getUtil(reserveBid);
        }
        
        ////////////////////////////////////////////////////////////////////////////////
        // select methods for accept and end negotiation
        ////////////////////////////////////////////////////////////////////////////////
        
        /**
         * selectAccept - decide whether to perform Action: Accept
         * 
         * @param offeredBid - Bid; the bid offered by opponent
         * @param time - double; time of negotiation
         * 
         * @return boolean - true if our agent should accept the offered bid
         */
        public boolean selectAccept(Bid offeredBid, BigDecimal time) {
                try {
                        BigDecimal offeredBidUtil = compRegress.getUtil(offeredBid);
                        return offeredBidUtil.compareTo(getThreshold(time)) >= 0;
                } catch (Exception e) {
                        System.out.println("selectAccept failed");
                        e.printStackTrace();
                        return false;
                }
        }
        
        /**
         * selectEndNegotiation - decide whether to end negotiation
         */
        public boolean selectEndNegotiation(BigDecimal time) {
                return reserveValue.compareTo(getThreshold(time)) >= 0;
        }
        
        ////////////////////////////////////////////////////////////////////////////////
        // method getThreshold and its helper methods
        ////////////////////////////////////////////////////////////////////////////////
        
        /**
         * getThreshold - returns threshold
         */
        public BigDecimal getThreshold(BigDecimal time) {
                BigDecimal threshold = BigDecimal.ONE;
                updateGameMatrix();
                BigDecimal target = getExpectedUtilInFinal();
                
                threshold = target.add((BigDecimal.ONE.subtract(target)).multiply(BigDecimal.ONE.subtract(time)));
                
                return threshold;
        }
        
        /**
         * updateGameMatrix - used in getThreshold
         */
        private void updateGameMatrix() {
                BigDecimal utilConcede = negotiationInfo.getBestOfferedUtil();
                
                A11 = reserveValue;
                A12 = BigDecimal.ONE;
                
                if (utilConcede.compareTo(reserveValue) >= 0) A21 = utilConcede;
                else A21 = reserveValue;
                
                A22 = (probFinal.multiply(A21)).add((BigDecimal.ONE.subtract(probFinal)).multiply(A12));
        }
        
        /**
         * getExpectedUtilInFinal - used in getThreshold
         */
        private BigDecimal getExpectedUtilInFinal() {
                BigDecimal q = getOpponentProbHardliner();
                return (q.multiply(A21)).add((BigDecimal.ONE.subtract(q)).multiply(A22));
        }
        
        /**
         * getOpponentProbHardliner - used in getExpectedUtilInFinal, calculate opponent's probability of choosing hardliner strategy in final round
         */
        private BigDecimal getOpponentProbHardliner() {
                double q = 1.0;
                double A11d = A11.doubleValue();
                double A12d = A12.doubleValue();
                double A21d = A21.doubleValue();
                double A22d = A22.doubleValue();
                
                if ((A12d - A22d != 0) && (1.0 - (A11d - A21d) / (A12d - A22d) != 0)) {
                        q = 1.0 / (1.0 - (A11d - A21d) / (A12d -A22d));
                }
                if (q < 0.0 || q > 1.0) {
                        q = 1.0;
                }
                return BigDecimal.valueOf(q);
        }

        
}