###############################
#					#
#	dilemma.soar	#
#					#
###############################

##		This is the soar code for the PrisonerŐs Dilemma
##		N.B. It is buggy and needs modification

##		I.		Build the top-space: prisoners-dilemma		
##
##		II.		Fetch-problem operator.					
##
## 		III. 		This reads the strategy number		
##				entered in the Tcl interface 	
##				and passes it to Soar using the I/O link		
##
##  		IV.		Contains the operators used for choosing 		
##				cooperation or defection for all			
##				strategies except the evolutionary strategy.	
##
##  		V.		EVOLVING STRATEGY. Contains the operators used		
##				for choosing cooperation or defection for			
##				the evolutionary strategy.  The operators			
##				chosen are evaluated by comparing their 			
##				effectiveness with respect to the scores of 		
##				both players. This doesnŐt search for score		
##				maximisation but compares the payoffs received		
##				by the two players in that round.				
##
## 		VI.		WORK OUT SCORES. This embodies the payoff matrix.  	
##				Scores for the round are calculated and running 	
##				totals updated.						
##
## 		VII.		Choose an operator when there is an impasse. 	
##				Modified from Hungry-Thirsty 2.  A new space	
##				is created to deal with tied operators.		
##				Operators are evaluated and given preferences 	
##				accordingly.						
##
## 		VIII.		Takes the strategy number input by the user and		
##				returns values for the strategies chosen 			
##				for each player.							

	
#########################################################################
##												#
##		I.		Modified from Able III					#
##				Build the top-space: prisoners-dilemma		#
##												#
#########################################################################

## Top Goal
## Elaborate the top goal with a PS (prisoners-dilemma). 


sp {pd*initial-ps-and-state
   (state <s> ^superstate nil)
-->
   (<s> ^name top-state 
	^problem-space prisoners-dilemma ^round 1 ^p1choice none
	^p2choice none ^p1total 0 ^p2total 0 ^turn p1
      ^strategy-number none ^achieved yes)}


#########################################################################
##												#
##		II.		Fetch-problem operator.					#
##				Modified from Able III.					#
##												#
#########################################################################

## Propose Operator fetch-problem
## This operator is called at
## initialization.

sp {pd*propose-operator*fetch-problem
   (state <s> ^problem-space prisoners-dilemma
	      ^achieved yes)
-->
   (<s> ^operator <o> + <)
     (<o> ^name fetch-problem)}

## Fetch-problem simply reads in the details of the problem that has
## already been selected by the user/modeller.

sp {pd*fetch-problem*remove-old-problem
   (state <s> ^problem-space prisoners-dilemma
	      ^problem <old-pb>
	      ^operator <o>)
     (<o> ^name fetch-problem -^finished)
-->
   (<s> ^problem <old-pb> -)}

sp {pd*fetch-problem*remove-other-stuff
  (state <s> ^problem-space prisoners-dilemma
	     ^operator <o>
	     ^problem-name <pname> ^strategy-number <snum> ^achieved yes)
    (<o> ^name fetch-problem -^finished)
-->
   (<s> ^problem-name <pname> - ^strategy-number <snum> - ^achieved  yes -)}

sp {pd*fetch-problem*elaborate*main-get
   (state <s> ^problem-space prisoners-dilemma
	      ^operator <o>)
     (<o> ^name fetch-problem)
-->
(<s> ^achieved yes - no +)     
(<o> ^finished t)
   (tcl | makegameprogresswindow |)}


## Terminate fetch-problem


sp {pd*fetch-problem*terminate
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number <s-number> ^achieved no
	      ^operator <o>)
     (<o> ^name fetch-problem)
-->
   (<s> ^operator <o> @)}

## Trace the fetch-problem operator with the strategy number.

format-watch -stack -add o fetch-problem \
  {%id (fetch-problem: %v[strategy-number])}

format-watch -object -add o fetch-problem \
  {%id (fetch-problem: %v[strategy-number])}


#########################################################################
##												#
## 		III. 		Modified from Able III.  This reads the 		#
##				strategy number entered in the Tcl interface 	#
##				and passes it to Soar using the I/O link		#
##												#
#########################################################################

# Elaborate the top state with the output link

sp {top-state*elaborate*io
  (state <s> ^io <io>)
-->
  (<io> ^output-link <ol>)}

## Throw up a dialog to get the strategy number.
## This then comes in via the IO input-link

sp {pd*read-strategy-number
    (state <s> ^problem-space prisoners-dilemma
	       -^operator.name fetch-problem
	       ^achieved yes)
-->
    (tcl | selectstrategy |)}

## Pull the strategy-number off the input link and stick it on the operator

sp {pd*elaborate*fetch-problem*strategy-number
   (state <s> ^problem-space prisoners-dilemma 
              ^io.input-link.strategy-number <sn>
              ^operator <o>)
     (<o> ^name fetch-problem
          -^finished t)
--> 
   (<s> ^strategy-number <sn>)}

	

#########################################################################
##												#
##  		IV.		Contains the operators used for choosing 		#
##				cooperation or defection for all			#
##				strategies except the evolutionary strategy.	#
##												#
#########################################################################  		
										 			

## COOPERATE- player 1

## Propose choose coop a
sp {pd*propose-op*p1-choose-coop-a
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 1 ^p1choice none ^turn p1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-coop)}

## Propose choose coop b
sp {pd*propose-op*p1-choose-coop-b
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 3 ^p2hasdefected no 
	^p1choice none ^turn p1)   
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-coop)}

## Propose choose coop c
sp {pd*propose-op*p1-choose-coop-c
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 4 ^p2lastmove coop 
	^p1choice none ^turn p1)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-coop)}

## Propose choose coop e
sp {pd*propose-op*p1-choose-coop-e
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 4 ^p1choice none ^turn p1)
  (<s> ^round 1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-coop)}

## Propose choose coop d
sp {pd*propose-op*p1-choose-coop-d
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 5 ^p2lastmove coop 
	^p1choice none ^turn p1)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-coop)}

## Apply choose coop
sp {pd*apply-op-*p1-choose-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p1choice none ^turn p1)
 	(<o> ^name p1-choose-coop)
  -->
	(<s> ^p1choice none - coop + ^turn p1 - p2 + )}

## Terminate choose coop
sp {pd*teminate-op*p1-choose-coop
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^operator <o>)
  (<o> ^name p1-choose-coop)
  (<s> ^p1choice coop)
  -->
  (<s> ^operator <o> @)}


## COOPERATE- player 2

## Propose choose coop a
sp {pd*propose-op*p2-choose-coop-a
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 1 ^p2choice none ^turn p2)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-coop)}

## Propose choose coop b
sp {pd*propose-op*p2-choose-coop-b
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 3 ^p1hasdefected no 
	^p2choice none ^turn p2)   
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-coop)}

## Propose choose coop c
sp {pd*propose-op*p2-choose-coop-c
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 4 ^p1lastmove coop 
	^p2choice none ^turn p2)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-coop)}

## Propose choose coop e
sp {pd*propose-op*p2-choose-coop-e
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 4 ^p1choice none ^turn p2)
  (<s> ^round 1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-coop)}

## Propose choose coop d
sp {pd*propose-op*p2-choose-coop-d
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 5 ^p1lastmove coop 
	^p2choice none ^turn p2)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-coop)}

## Apply choose coop
sp {pd*apply-op-*p2-choose-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p2choice none ^turn p2)
	(<o> ^name p2-choose-coop)	
  -->
	(<s> ^p2choice none - coop + ^turn p2 - p1 + )}

## Terminate choose coop
sp {pd*teminate-op*p2-choose-coop
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^operator <o>)
  (<o> ^name p2-choose-coop)
  (<s> ^p2choice coop)
  -->
  (<s> ^operator <o> @)}


## DEFECT- player 1

## Propose choose def a
sp {pd*propose-op*p1-choose-def-a
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 2 ^p1choice none ^turn p1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def)}

## Propose choose def b
sp {pd*propose-op*p1-choose-def-b
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 3 ^p2hasdefected yes 
	^p1choice none ^turn p1)   
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def)}

## Propose choose def c
sp {pd*propose-op*p1-choose-def-c
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 4 ^p2lastmove def 
	^p1choice none ^turn p1)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def)}

## Propose choose def d
sp {pd*propose-op*p1-choose-def-d
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 5 ^p2lastmove def 
	^p1choice none ^turn p1)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def)}

## Propose choose def e
sp {pd*propose-op*p1-choose-def-e
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 5 ^p1choice none ^turn p1)
  (<s> ^round 1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def)}

## Apply choose def
sp {pd*apply-op-*p1-choose-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p1choice none ^turn p1)
	(<o> ^name p1-choose-def)	
  -->
	(<s> ^p1choice none - def + ^turn p1 - p2 + )}

## Terminate choose def
sp {pd*teminate-op*p1-choose-def
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def)
  (<s> ^p1choice def)
  -->
  (<s> ^operator <o> @)}

## DEFECT- player 2

## Propose choose def a
sp {pd*propose-op*p2-choose-def-a
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 2 ^p2choice none ^turn p2)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def)}

## Propose choose def b
sp {pd*propose-op*p2-choose-def-b
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 3 ^p1hasdefected yes 
	^p2choice none ^turn p2)   
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def)}

## Propose choose def c
sp {pd*propose-op*p2-choose-def-c
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 4 ^p1lastmove def 
	^p2choice none ^turn p2)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def)}

## Propose choose def d
sp {pd*propose-op*p2-choose-def-d
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 5 ^p1lastmove def 
	^p2choice none ^turn p2)
  (<s> ^round >1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def)}

## Propose choose def e
sp {pd*propose-op*p2-choose-def-e
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 5 ^p1choice none ^turn p2)
  (<s> ^round 1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def)}

## Apply choose def
sp {pd*apply-op-*p2-choose-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p2choice none ^turn p2)
	(<o> ^name p2-choose-def)	
  -->
	(<s> ^p2choice none - def + ^turn p2 - p1 +)}

## Terminate choose def
sp {pd*teminate-op*p2-choose-def
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def)
  (<s> ^p2choice def)
  -->
  (<s> ^operator <o> @)}


###############################################################################
##													#
##  		V.		EVOLVING STRATEGY. Contains the operators used		#
##				for choosing cooperation or defection for			#
##				the evolutionary strategy.  The operators			#
##				chosen are evaluated by comparing their 			#
##				effectiveness with respect to the scores of 		#
##				both players. This doesnŐt search for score		#
##				maximisation but compares the payoffs received		#
##				by the two players in that round.				#
##													#
###############################################################################

## COOPERATE- player 1

## Propose choose coop evolve
sp {pd*propose-op*p1-choose-coop-evolve
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 6 ^p1choice none ^turn p1)
  -->
  (<s> ^operator <o> )
  (<o> ^name p1-choose-coop-evolve)}

## Apply choose coop
sp {pd*apply-op*p1-choose-coop-evolve
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1choice none ^turn p1)
	(<s> ^operator <o> )
	(<o> ^name p1-choose-coop-evolve)	
  -->
	(<s> ^p1choice none - coop + ^turn p1 - p2 + )}


## Evaluate operator
sp {pd*eval-op*p1-choose-coop-evolve-a
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1score <val1> ^p2score <val2> <val1> > <val2>)
	(<s> ^operator <o>)
	(<o> ^name p1-choose-coop-evolve)
  -->
   	(<s> ^operator <o> >)}


## Evaluate operator
sp {pd*eval-op*p1-choose-coop-evolve-b
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1score <val1>  ^p2score <val2> <val1> = <val2>) 
	(<s> ^operator <o>)
	(<o> ^name p1-choose-coop-evolve)
  -->
   	(<s> ^operator <o> =)}

## Evaluate operator
sp {pd*eval-op*p1-choose-coop-evolve-c
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1score <val1> ^p2score <val2> <val1> < <val2>)
	(<s> ^operator <o>)
	(<o> ^name p1-choose-coop-evolve)
  -->
   	(<s> ^operator <o> <)}



## DEFECT- player 1

## Propose choose def evolve
sp {pd*propose-op*p1-choose-def-evolve
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp1 6 ^p1choice none ^turn p1)
  -->
  (<s> ^operator <o>)
  (<o> ^name p1-choose-def-evolve)}

## Apply choose def
sp {pd*apply-op-*p1-choose-def-evolve
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p1choice none ^turn p1)
	(<o> ^name p1-choose-def-evolve)	
  -->
	(<s> ^p1choice none - def + ^turn p1 - p2 + )}

## Evaluate operator
sp {pd*eval-op*p1-choose-def-evolve-a
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1score <val1> ^p2score <val2> <val1> > <val2>)
	(<s> ^operator <o>)
	(<o> ^name p1-choose-def-evolve)
  -->
   	(<s> ^operator <o> >)}

## Evaluate operator
sp {pd*eval-op*p1-choose-def-evolve-b
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1score <val1> ^p2score <val2> <val1> = <val2>)
	(<s> ^operator <o>)
	(<o> ^name p1-choose-def-evolve)
  -->
   	(<s> ^operator <o> =)}

## Evaluate operator
sp {pd*eval-op*p1-choose-def-evolve-c
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1score <val1> ^p2score <val2> <val1> < <val2>)
	(<s> ^operator <o>)
	(<o> ^name p1-choose-def-evolve)
  -->
   	(<s> ^operator <o> <)}



## COOPERATE- player 2

## Propose choose coop evolve
sp {pd*propose-op*p2-choose-coop-evolve
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 6 ^p2choice none ^turn p2)
  -->
  (<s> ^operator <o> )
  (<o> ^name p2-choose-coop-evolve)}

## Apply choose coop
sp {pd*apply-op-*p2-choose-coop-evolve
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p2choice none ^turn p2)
	(<o> ^name p2-choose-coop-evolve)	
  -->
	(<s> ^p2choice none - coop + ^turn p2 - p1 + )}


## Evaluate operator
sp {pd*eval-op*p2-choose-coop-evolve-a
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p2score <val2> ^p1score <val1> <val2> > <val1>)
	(<s> ^operator <o>)
	(<o> ^name p2-choose-coop-evolve)
  -->
   	(<s> ^operator <o> >)}

## Evaluate operator
sp {pd*eval-op*p2-choose-coop-evolve-b
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p2score <val2> ^p1score <val1> <val2> = <val1>)
	(<s> ^operator <o>)
	(<o> ^name p2-choose-coop-evolve)
  -->
   	(<s> ^operator <o> =)}

## Evaluate operator
sp {pd*eval-op*p2-choose-coop-evolve-c
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p2score <val2> ^p1score <val1> <val2> < <val1>)
	(<s> ^operator <o>)
	(<o> ^name p2-choose-coop-evolve)
  -->
   	(<s> ^operator <o> <)}



## DEFECT- player 2

## Propose choose def evolve
sp {pd*propose-op*p2-choose-def-evolve
  (state <s> ^problem-space prisoners-dilemma )
  (<s> ^strategynumberp2 6 ^p2choice none ^turn p2)
  -->
  (<s> ^operator <o>)
  (<o> ^name p2-choose-def-evolve)}

## Apply choose def
sp {pd*apply-op-*p2-choose-def-evolve
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^p2choice none ^turn p2)
	(<o> ^name p2-choose-def-evolve)	
  -->
	(<s> ^p2choice none - def + ^turn p2 - p1 + )}

## Evaluate operator
sp {pd*eval-op*p2-choose-def-evolve-a
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p2score <val2> ^p1score <val1> <val2> > <val1>)
	(<s> ^operator <o>)
	(<o> ^name p2-choose-def-evolve)
  -->
   	(<s> ^operator <o> >)}

## Evaluate operator
sp {pd*eval-op*p2-choose-def-evolve-b
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p2score <val2> ^p1score <val1> <val2> = <val1>)
	(<s> ^operator <o>)
	(<o> ^name p2-choose-def-evolve)
  -->
   	(<s> ^operator <o> =)}

## Evaluate operator
sp {pd*eval-op*p2-choose-def-evolve-c
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p2score <val2> ^p1score <val1> <val2> < <val1>)
	(<s> ^operator <o>)
	(<o> ^name p2-choose-def-evolve)
  -->
   	(<s> ^operator <o> <)}


###############################################################################
##													#
## 		VI.		WORK OUT SCORES. This embodies the payoff matrix.  	#
##				Scores for the round are calculated and running 	#
##				totals updated.							#
##													#
###############################################################################	
			


## Mutual cooperation score operator
sp {pd*propose-op*scores-coop-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1choice coop ^p2choice coop ^round <round>)
  -->
   (<s> ^operator <o>)
   (<o> ^name score-coop-coop)}

sp {pd*apply-op*scores-coop-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^round <round>)
	(<o> ^name score-coop-coop)
  -->
   (<s> ^p1score 3 ^p2score 3 ^round <round> + 1)
   (tcl | updategameprogresswindow |)
   (<s> ^p1choice coop - none + ^p2choice coop - none +)}

sp {pd*terminate-op*scores-coop-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o>)
	(<o> ^name score-coop-coop)
	(<s> ^p1score 3 ^p2score 3)
 -->
   (<s> ^operator <o> @)}

## Player 1 coops, player2 defects score operator
sp {pd*propose-op*scores-coop-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1choice coop ^p2choice def ^round <round>)
  -->
   (<s> ^operator <o>)
   (<o> ^name score-coop-def)}

sp {pd*apply-op*scores-coop-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^round <round>)
	(<o> ^name score-coop-def)
  -->
   (<s> ^p1score 0 ^p2score 5 ^round <round> + 1)
   (tcl | updategameprogresswindow |)
   (<s> ^p1choice coop - none + ^p2choice def - none +)}


sp {pd*terminate-op*scores-coop-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o>)
	(<o> ^name score-coop-def)
	(<s> ^p1score 0 ^p2score 5)
 -->
   (<s> ^operator <o> @)}


## Player 1 defects, player 2 coops score operator
sp {pd*propose-op*scores-def-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1choice def ^p2choice coop ^round <round>)
  -->
   (<s> ^operator <o>)
   (<o> ^name score-def-coop)}

sp {pd*apply-op*scores-def-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^round <round>)
	(<o> ^name score-def-coop)
  -->
   (<s> ^p1score 5 ^p2score 0 ^round <round> + 1)
   (tcl | updategameprogresswindow |)
   (<s> ^p1choice def - none + ^p2choice coop - none +)}


sp {pd*terminate-op*scores-def-coop
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o>)
	(<o> ^name score-def-coop)
	(<s> ^p1score 5 ^p2score 0)
 -->
   (<s> ^operator <o> @)}


## Mutual defection score operator
sp {pd*propose-op*scores-def-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^p1choice def ^p2choice def ^round <round>)
  -->
   (<s> ^operator <o>)
   (<o> ^name score-def-def)}

sp {pd*apply-op*scores-def-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o> ^round <round>)
	(<o> ^name score-def-def)
  -->
   (<s> ^p1score 1 ^p2score 1 ^round <round> + 1) 
   (tcl | updategameprogresswindow |)
   (<s> ^p1choice def - none + ^p2choice def - none +)}


sp {pd*terminate-op*scores-def-def
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o>)
	(<o> ^name score-def-def)
	(<s> ^p1score 1 ^p2score 1)
 -->
   (<s> ^operator <o> @)}


## Operator for updating running totals
sp {pd*propose-op*update-totals
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^ready-to-update-totals yes
	     ^p1score <score1> ^p2score <score2>
	     ^p1total <total1> ^p2total <total2>)
  -->
   (<s> ^operator <o>)
   (<o> ^name update-totals)}

sp {pd*apply-op*update-totals
	(state <s> ^problem-space prisoners-dilemma)
	(<s> ^operator <o>)
	(<o> ^name update-totals)
  -->
   (<s> ^p1total <score1>+<total1> ^p2total <score2>+<total2>
        ^ready-to-update-totals yes - no +)}

sp {pd*terminate-op*update-totals
	(state <s> ^problem-space prisoners-dilemma)
      (<s> ^ready-to-update-totals no ^operator <o>)
	(<o> ^name update-totals)
  -->
   (<s> ^operator <o> @)}


#########################################################################
##												#
## 		VII.		Choose an operator when there is an impasse. 	#
##				Modified from Hungry-Thirsty 2.  A new space	#
##				is created to deal with tied operators.		#
##				Operators are evaluated and given preferences 	#
##				accordingly.						#
##												#
#########################################################################

sp {pd*propose-space*selection
	(state <s> ^superstate <ss> ^choices multiple)
-->
	(<s> ^problem-space <p> + <p> <)
	(<p> ^name selection)}

### Create evaluate operator in selection problem space.
## the squirrelly bracket indicates a set of grouped clauses, the not
## sign indicates that the set of clauses mustn't be matched for the 
## production to fire.
### Create evaluate operator in selection problem space.


sp {selection*propose*evaluate-object
  (state <s> ^problem-space.name selection ^item <x>)
 -{(<s> ^evaluation <e>)
   (<e> ^object <x> ^value t)}
   -->
  (<o> ^state <s> ^name evaluate-object ^object <x>)
  (<s> ^operator <o> +)}

###
### Reconsider evaluation operator after it finishes to allow next one
### in.
###

sp {selection*terminate*evaluate-object
   (state <s>  ^operator <o>)
   (<s> ^evaluation <e>)
   (<o> ^object <x>)
   (<e> ^object <x> ^value <val>)
   -->
   (<s> ^operator <o> @)}

## Evaluate operators

sp {selection*evaluate*p1-choose-coop
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p1-choose-coop)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality excellent)}

sp {selection*evaluate*p1-choose-def
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p1-choose-def)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality good)}

sp {selection*evaluate*p2-choose-coop
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p2-choose-coop)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality excellent)}

sp {selection*evaluate*p2-choose-def
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p2-choose-def)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality good)}

sp {selection*evaluate*p1-choose-coop-evolve
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p1-choose-coop-evolve)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality excellent)}

sp {selection*evaluate*p1-choose-def-evolve
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p1-choose-def-evolve)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality good)}


sp {selection*evaluate*p2-choose-coop-evolve
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p2-choose-coop-evolve)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality excellent)}

sp {selection*evaluate*p2-choose-def-evolve
  (state <s> ^problem-space.name selection ^operator <eval>
             ^superstate <ss>)
  (<eval> ^name evaluate-object ^object <o>)
  (<o> ^name p2-choose-def-evolve)
  -->
  (<s> ^evaluation <e> + &)
  (<e> ^value t ^object <o> ^quality good)}


## Rank operators according to evaluation

sp {selection*evaluation*excellent-good
	(state <s> ^problem-space.name selection ^superstate <ss>)
	(<s> ^evaluation <e1> <e2>)
	(<e1> ^value t ^object <o1> ^quality excellent)
	(<e2> ^value t ^object <o2> ^quality good)
-->
	(<ss> ^operator <o1> > <o2> ^operator <o1> =)}


###############################################################################
##													#
## 		VIII.		Takes the strategy number input by the user and		#
##				returns values for the strategies chosen 			#
##				for each player.							#
##													#
###############################################################################


sp {pd*elaborate*strategy1
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 1)
-->
(<s> ^strategynumberp1 1 ^strategynumberp2 1)}

sp {pd*elaborate*strategy2
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 2)
-->
(<s> ^strategynumberp1 1 ^strategynumberp2 2)}

sp {pd*elaborate*strategy3
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 3)
-->
(<s> ^strategynumberp1 1 ^strategynumberp2 3)}

sp {pd*elaborate*strategy4
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 4)
-->
(<s> ^strategynumberp1 1 ^strategynumberp2 4)}

sp {pd*elaborate*strategy5
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 5)
-->
(<s> ^strategynumberp1 1 ^strategynumberp2 5)}

sp {pd*elaborate*strategy6
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 6)
-->
(<s> ^strategynumberp1 1 ^strategynumberp2 6)}

sp {pd*elaborate*strategy7
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 7)
-->
(<s> ^strategynumberp1 2 ^strategynumberp2 1)}

sp {pd*elaborate*strategy8
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 8)
-->
(<s> ^strategynumberp1 2 ^strategynumberp2 2)}

sp {pd*elaborate*strategy9
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 9)
-->
(<s> ^strategynumberp1 2 ^strategynumberp2 3)}

sp {pd*elaborate*strategy10
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 10)
-->
(<s> ^strategynumberp1 2 ^strategynumberp2 4)}

sp {pd*elaborate*strategy11
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 11)
-->
(<s> ^strategynumberp1 2 ^strategynumberp2 5)}

sp {pd*elaborate*strategy12
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 12)
-->
(<s> ^strategynumberp1 2 ^strategynumberp2 6)}

sp {pd*elaborate*strategy13
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 13)
-->
(<s> ^strategynumberp1 3 ^strategynumberp2 1)}

sp {pd*elaborate*strategy14
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 14)
-->
(<s> ^strategynumberp1 3 ^strategynumberp2 2)}

sp {pd*elaborate*strategy15
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 15)
-->
(<s> ^strategynumberp1 3 ^strategynumberp2 3)}

sp {pd*elaborate*strategy16
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 16)
-->
(<s> ^strategynumberp1 3 ^strategynumberp2 4)}

sp {pd*elaborate*strategy17
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 17)
-->
(<s> ^strategynumberp1 3 ^strategynumberp2 5)}

sp {pd*elaborate*strategy18
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 18)
-->
(<s> ^strategynumberp1 3 ^strategynumberp2 6)}

sp {pd*elaborate*strategy19
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 19)
-->
(<s> ^strategynumberp1 4 ^strategynumberp2 1)}

sp {pd*elaborate*strategy20
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 20)
-->
(<s> ^strategynumberp1 4 ^strategynumberp2 2)}

sp {pd*elaborate*strategy21
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 21)
-->
(<s> ^strategynumberp1 4 ^strategynumberp2 3)}

sp {pd*elaborate*strategy22
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 22)
-->
(<s> ^strategynumberp1 4 ^strategynumberp2 4)}

sp {pd*elaborate*strategy23
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 23)
-->
(<s> ^strategynumberp1 4 ^strategynumberp2 5)}

sp {pd*elaborate*strategy24
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 24)
-->
(<s> ^strategynumberp1 4 ^strategynumberp2 6)}


sp {pd*elaborate*strategy25
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 25)
-->
(<s> ^strategynumberp1 5 ^strategynumberp2 1)}

sp {pd*elaborate*strategy26
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 26)
-->
(<s> ^strategynumberp1 5 ^strategynumberp2 2)}

sp {pd*elaborate*strategy27
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 27)
-->
(<s> ^strategynumberp1 5 ^strategynumberp2 3)}

sp {pd*elaborate*strategy28
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 28)
-->
(<s> ^strategynumberp1 5 ^strategynumberp2 4)}

sp {pd*elaborate*strategy29
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 29)
-->
(<s> ^strategynumberp1 5 ^strategynumberp2 5)}

sp {pd*elaborate*strategy30
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 31)
-->
(<s> ^strategynumberp1 5 ^strategynumberp2 6)}

sp {pd*elaborate*strategy31
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 31)
-->
(<s> ^strategynumberp1 6 ^strategynumberp2 1)}

sp {pd*elaborate*strategy32
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 32)
-->
(<s> ^strategynumberp1 6 ^strategynumberp2 2)}

sp {pd*elaborate*strategy33
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 33)
-->
(<s> ^strategynumberp1 6 ^strategynumberp2 3)}

sp {pd*elaborate*strategy34
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 34)
-->
(<s> ^strategynumberp1 6 ^strategynumberp2 4)}

sp {pd*elaborate*strategy35
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 35)
-->
(<s> ^strategynumberp1 6 ^strategynumberp2 5)}

sp {pd*elaborate*strategy36
   (state <s> ^problem-space prisoners-dilemma
	      ^strategy-number 36)
-->
(<s> ^strategynumberp1 6 ^strategynumberp2 6)}