testcase_6_trade.py

import adjudicator
import constants

class Debug_Dice:
	def __init__(self):
		
		self.value_list = [[4,5]]
		
		self.die_1 = None
		self.die_2 = None
		self.double = False
		self.double_counter = 0

	def roll(self,ignore=False):
		
		if len(self.value_list)!=0:
			[self.die_1,self.die_2] = self.value_list.pop()
		
			self.double = self.die_1 == self.die_2
			if not ignore:
				self.double_counter += self.double
			
			print('Roll a {die_1} and a {die_2}'.format(die_1=self.die_1, die_2=self.die_2))
			
class Agent_1:
	def __init__(self, id):
		self.id = id
	
	def getBMSTDecision(self, state):
		return None
	
	def respondTrade(self,state):
		return True

	def buyProperty(self, state):
		return False
	
	def auctionProperty(self, state):
		return 180
	
	def receiveState(self, state):
		pass
	
class Agent_2:
	def __init__(self, id):
		self.id = id
		self.PLAYER_TURN_INDEX = 0
		self.PROPERTY_STATUS_INDEX = 1
		self.PLAYER_POSITION_INDEX = 2
		self.PLAYER_CASH_INDEX = 3
		self.PHASE_NUMBER_INDEX = 4
		self.PHASE_PAYLOAD_INDEX = 5
		
		self.BALTIC_AVENUE = 3
		
	def getBMSTDecision(self, state):
		
		baltic = constants.space_to_property_map[self.BALTIC_AVENUE]
		
		baltic_propertyValue = state[self.PROPERTY_STATUS_INDEX][baltic]
		
		payload = state[self.PHASE_PAYLOAD_INDEX]
		
		if (baltic_propertyValue != -1):
			return ("T",0,[21],200,[self.BALTIC_AVENUE])
		
		return None
		
	def buyProperty(self, state):
		return False

	def auctionProperty(self, state):
		return 200
	
	def receiveState(self, state):
		pass

def compare_states(state1,state2):
	
	if not isinstance(state1,type(state2)) or (len(state1)!=len(state2)):
		print("Inconsistent type or length detected for First argument")
		return false
	else:
		count = 0
		
		if (state1[0] == state2[0]): count+=1
		
		flag = True
		for property,property2 in zip(state1[1],state2[1]):
			if property != property2:
				flag = False
		if flag: count+=1
		
		if (state1[2][0] == state2[2][0]) and (state1[2][1] == state2[2][1]): count+=1
		if (state1[3][0] == state2[3][0]) and (state1[3][1] == state2[3][1]): count+=1
		if (state1[4] == state2[4]): count+=1
		
		if len(state1[5]) == len(state2[5]):
			flag = True
			for key,key2 in zip(state1[5],state2[5]):
				if state1[5][key] != state2[5][key]:
					 flag = False
			if flag: count+=1
		
		if count == 6:
			return True
		else:
			print( str(count)+"/"+str(len(state2))+" arguments are correct."  )
			return False
	
def testcase_6(Adjudicator,AgentOne,AgentTwo):
	
	print("Test #6 Description:")
	print("AgentTwo will fall on Jail(Just Visting)(Position 10).")
	print("He wants to trade Kentucky Avenue(Position 21) in exchange for Baltic Avenue(Position 3) and $200.")
	print("AgentOne accepts.")
	
	
	input_state =  [11, [ 0,  1,  0,  1,  0,  0, -1,  0,  -2,  -2,  1,  0,  0,  0, -1,  0,  0,
        0,  1, -1,  0,  0,  0,  0,  0,  1,  0,  1,  0,  0], [3, 1], [580, 350], 4, {}]
	
	output_state = [12, [ 0,  -1,  0,  1,  0,  0, -1,  0,  -2,  -2,  1,  0,  0,  0, 1,  0,  0,
        0,  1, -1,  0,  0,  0,  0,  0,  1,  0,  1,  0,  0], [3, 10], [380, 550], 0, {}]

	
	no_of_turns = 12
	
	adjudicator = Adjudicator(AgentOne,AgentTwo,input_state,Debug_Dice,no_of_turns)
	adjudicator.runGame()
	
	final_state = adjudicator.state
	
	result = compare_states(final_state,output_state)
	
	if result: print("Pass")
	else:
		print("Fail")
		print("Received Output:")
		print(final_state)
	
	print("")
	
	return result
	

#Execution
testcase_6(adjudicator.Adjudicator,Agent_1,Agent_2)