source: src/main/java/agents/anac/y2019/ibasic/boacomponents/IBasicOM.java@ 201

package agents.anac.y2019.ibasic.boacomponents;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import genius.core.Bid;
import genius.core.bidding.BidDetails;
import genius.core.boaframework.NegotiationSession;
import genius.core.boaframework.OpponentModel;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Objective;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AdditiveUtilitySpace;
import genius.core.utility.Evaluator;
import genius.core.utility.EvaluatorDiscrete;

public class IBasicOM extends OpponentModel{
        
        private double learnCoef;
        private int learnValueAddition;
        private int amountOfIssues;
        private double goldenValue;
        private List<Bid> bidhistory = new ArrayList<>();
    
        public void init(NegotiationSession negotiationSession, Map<String, Double> parameters) {
                this.negotiationSession = negotiationSession;
                this.learnCoef = 0.2;
                opponentUtilitySpace = (AdditiveUtilitySpace) negotiationSession.getUtilitySpace().copy();
                learnValueAddition = 1;
                amountOfIssues = opponentUtilitySpace.getDomain().getIssues().size();
                goldenValue = learnCoef / amountOfIssues;
                initializeModel();
        }
        
        //Used to determine what the agents opponent model estimates the utility to be for the bid that is given to the method.
        @Override
        public double getBidEvaluation(Bid bid) {
                double result = 0;
                try {
                        result = opponentUtilitySpace.getUtility(bid);
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return result;
        }
        
        //Used to update the opponent model.
        @Override
        protected void updateModel(Bid bid, double time) {
                bidhistory.add(bid);
                //Does nothing if the opponent model is smaller than 2
                if (negotiationSession.getOpponentBidHistory().size() < 2) {
                        return;
                }
                int NumberOfUnchanged = 0;
                
                //Gets the last two bids from the opponent
                BidDetails oppBid = negotiationSession.getOpponentBidHistory()
                                .getHistory()
                                .get(negotiationSession.getOpponentBidHistory().size() - 1);
                BidDetails prevOppBid = negotiationSession.getOpponentBidHistory()
                                .getHistory()
                                .get(negotiationSession.getOpponentBidHistory().size() - 2);
                
                // maakt een map aan met alle issues en of deze hetzelfde zijn (0) of niet
                HashMap<Integer, Integer> lastDiffSet = determineDifference(prevOppBid,
                                oppBid);
                for (Integer i : lastDiffSet.keySet()) {
                        if (lastDiffSet.get(i) == 0)
                                NumberOfUnchanged++;
                }
                
                //Counts the number of changes in values from the last two bids bids
                                for (Integer i : lastDiffSet.keySet()) {
                                        if (lastDiffSet.get(i) == 0)
                                                NumberOfUnchanged++;
                                }

                                // The total sum of weights before normalization.
                                double totalSum = 1D + goldenValue * NumberOfUnchanged;
                                // The maximum possible weight
                                double maximumWeight = 1D - (amountOfIssues) * goldenValue / totalSum;

                                // re-weighing issues while making sure that the sum remains 1
                                for (Integer i : lastDiffSet.keySet()) {
                                        Objective issue = opponentUtilitySpace.getDomain()
                                                        .getObjectivesRoot().getObjective(i);
                                        double weight = opponentUtilitySpace.getWeight(i);
                                        double newWeight;
                                        
                                        if (lastDiffSet.get(i) == 0 && weight < maximumWeight) {
                                                newWeight = (weight + goldenValue) / totalSum;
                                        } else {
                                                newWeight = weight / totalSum;
                                        }
                                        opponentUtilitySpace.setWeight(issue, newWeight);
                                }

                                // Then for each issue value that has been offered last time, a constant
                                // value is added to its corresponding ValueDiscrete.
                                try {
                                        for (Entry<Objective, Evaluator> e : opponentUtilitySpace
                                                        .getEvaluators()) {
                                                EvaluatorDiscrete value = (EvaluatorDiscrete) e.getValue();
                                                IssueDiscrete issue = ((IssueDiscrete) e.getKey());
                                                /*
                                                 * add constant learnValueAddition to the current preference of
                                                 * the value to make it more important
                                                 */
                                                ValueDiscrete issuevalue = (ValueDiscrete) oppBid.getBid()
                                                                .getValue(issue.getNumber());
                                                Integer eval = value.getEvaluationNotNormalized(issuevalue);
                                                value.setEvaluation(issuevalue, (learnValueAddition + eval));
                                        }
                                } catch (Exception ex) {
                                        ex.printStackTrace();
                                }
        }
        
        // initialize model, with all weights set to 1
        private void initializeModel() {
                double commonWeight = 1D / amountOfIssues;

                for (Entry<Objective, Evaluator> e : opponentUtilitySpace
                                .getEvaluators()) {

                        opponentUtilitySpace.unlock(e.getKey());
                        e.getValue().setWeight(commonWeight);
                        try {
                                for (ValueDiscrete vd : ((IssueDiscrete) e.getKey())
                                                .getValues())
                                        ((EvaluatorDiscrete) e.getValue()).setEvaluation(vd, 1);
                        } catch (Exception ex) {
                                ex.printStackTrace();
                        }
                }
        }
        
        //The method that determines the difference in values for each issue between bids that it receives. 
        private HashMap<Integer, Integer> determineDifference(BidDetails first,
                        BidDetails second) {

                HashMap<Integer, Integer> diff = new HashMap<Integer, Integer>();
                try {
                        for (Issue i : opponentUtilitySpace.getDomain().getIssues()) {
                                Value value1 = first.getBid().getValue(i.getNumber());
                                Value value2 = second.getBid().getValue(i.getNumber());
                                diff.put(i.getNumber(), (value1.equals(value2)) ? 0 : 1);
                        }
                } catch (Exception ex) {
                        ex.printStackTrace();
                }
                
                return diff;
        }
        
        public double MapValue(double curmin, double curmax, double tarmin, double tarmax, double curval)
        {
                return tarmin + (tarmax - tarmin) * ((curval - curmin)/ (curmax - curmin));
        }
        
          //this method makes a list with the predicted utility of the opponent 10 last bids and returns  
                //a ratio between 0 (not conceding) and 1(very much conceding)
                public double EvaluateConsessionOpp() {
                        ArrayList<Double> oppbidlist = new ArrayList<>();
                        double averageconsession = 0;
                        if(bidhistory.size() > 10) {
                                oppbidlist.clear();
                                for(int i = bidhistory.size() -1; i > bidhistory.size() -11; i--) {
                                        oppbidlist.add(getBidEvaluation(bidhistory.get(i)));
                                }
                        }
                        if(oppbidlist.size() != 0) {
                                averageconsession = CalcConsession(oppbidlist);
                        }
                        return averageconsession;
                }
                
                //Calculates the concession of the opponent by counting the times an opponent
                // offers a lower bid than his last lowest bid
                private double CalcConsession(List<Double> oppbids) {
                        double lowestbid = .9;
                        double score = 0;
                        for(double bids : oppbids) {
                                if(bids < lowestbid) {
                                        score++;
                                        lowestbid = bids;
                                }
                        }
                        return MapValue(0, oppbids.size() -1, 0, 1, score);
                }
}