jameslin101/pie_simulator

## pie_simulator
import random

class Slice():

    def __init__(self, pie_type, loc, size):
        self.pie_type = pie_type;
        self.loc = loc;
        self.size = size;

    def __str__(self):
        return "type:{0} loc:{1} size:{2}".format(self.pie_type, self.loc, self.size)

class DestPie():

    def __init__(self):
        self.locs = [False, False, False, False, False, False]
        self.pie_type = None

    def clear(self):
        points = self.locs.count(True)
        self.locs = [False, False, False, False, False, False]
        self.pie_type = None
        return points

    def complete(self):
        return all(self.locs[i] == True for i in self.locs)

    def add_slice(self,slice):
        #check if pie size is correct
        if self.pie_type != None and self.pie_type != slice.pie_type:
            return False

        #check if each space we need are empty
        for i in range(slice.size):
            loc_to_check = slice.loc + i;
            if loc_to_check > 5:
                loc_to_check = loc_to_check - 6;
            if self.locs[loc_to_check] != False:
                print("cant fit")
                return False

        #if empty fill in pie_type, locs and return slice_size
        self.pie_type = slice.pie_type
        for i in range(slice.size):
            loc_to_check = slice.loc + i;
            if loc_to_check > 5:
                loc_to_check = loc_to_check - 6;
            self.locs[loc_to_check] = True

        return slice.size

class Game():

    #settings

    def __init__(self, pie_types, slice_size_probs, target_points = 500):
        self.pie_types = pie_types
        self.slice_sizes = [1,2,3,4,5]
        self.slice_size_probs = slice_size_probs
        self.dest_pies = []
        for i in range(6):
            self.dest_pies.append(DestPie())
        self.slices_placed = 0
        self.points = 0
        self.target_points = target_points

    def generate_random_slice(self):
        slice_size = random.choices(
             population=self.slice_sizes,
             weights=self.slice_size_probs,
             k=1)[0]
        slice = Slice(random.choice(self.pie_types), random.choice(range(6)), slice_size)
        print(slice)
        return slice

    def play(self):
        turn = 0
        no_more_moves = False
        while turn < 100 and self.points < self.target_points and no_more_moves == False:
            turn += 1
            slice = self.generate_random_slice()
            found_place = False

            print("Turn: {0}, Slice {1}:, Points: {2}".format(str(turn), slice, self.points))

            #find a pie to place the slice
            for idx, pie in enumerate(self.dest_pies):
                result = pie.add_slice(slice)
                if result != False:
                    found_place = True
                    self.slices_placed += result
                    print("slice added to pie {0}".format(idx))
                    break;

            if not found_place:
                print("Game over on turn {0}!".format(turn))
                no_more_moves = True;

            #check if pies clear
            for idx, pie in enumerate(self.dest_pies):
                if pie.complete():
                    self.points += pie.clear()
                    print("pie {0} cleared!".format(idx))
                    idx_after = idx + 1
                    idx_before = idx - 1
                    if idx == 5:
                        idx_after = 0
                    if idx == 0:
                        idx_before = 5
                    print("adjacent pie {0} cleared!".format(idx_after))
                    self.points += self.dest_pies[idx_after].clear()
                    print("adjacent pie {0} cleared!".format(idx_before))
                    self.points += self.dest_pies[idx_before].clear()

        return self.points

game = Game(['a'],[.4,.3,.2,0,0])
game.play()
	import random

	class Slice():

	def __init__(self, pie_type, loc, size):
	self.pie_type = pie_type;
	self.loc = loc;
	self.size = size;

	def __str__(self):
	return "type:{0} loc:{1} size:{2}".format(self.pie_type, self.loc, self.size)

	class DestPie():

	def __init__(self):
	self.locs = [False, False, False, False, False, False]
	self.pie_type = None

	def clear(self):
	points = self.locs.count(True)
	self.locs = [False, False, False, False, False, False]
	self.pie_type = None
	return points

	def complete(self):
	return all(self.locs[i] == True for i in self.locs)

	def add_slice(self,slice):
	#check if pie size is correct
	if self.pie_type != None and self.pie_type != slice.pie_type:
	return False

	#check if each space we need are empty
	for i in range(slice.size):
	loc_to_check = slice.loc + i;
	if loc_to_check > 5:
	loc_to_check = loc_to_check - 6;
	if self.locs[loc_to_check] != False:
	print("cant fit")
	return False

	#if empty fill in pie_type, locs and return slice_size
	self.pie_type = slice.pie_type
	for i in range(slice.size):
	loc_to_check = slice.loc + i;
	if loc_to_check > 5:
	loc_to_check = loc_to_check - 6;
	self.locs[loc_to_check] = True

	return slice.size

	class Game():

	#settings

	def __init__(self, pie_types, slice_size_probs, target_points = 500):
	self.pie_types = pie_types
	self.slice_sizes = [1,2,3,4,5]
	self.slice_size_probs = slice_size_probs
	self.dest_pies = []
	for i in range(6):
	self.dest_pies.append(DestPie())
	self.slices_placed = 0
	self.points = 0
	self.target_points = target_points

	def generate_random_slice(self):
	slice_size = random.choices(
	population=self.slice_sizes,
	weights=self.slice_size_probs,
	k=1)[0]
	slice = Slice(random.choice(self.pie_types), random.choice(range(6)), slice_size)
	print(slice)
	return slice

	def play(self):
	turn = 0
	no_more_moves = False
	while turn < 100 and self.points < self.target_points and no_more_moves == False:
	turn += 1
	slice = self.generate_random_slice()
	found_place = False

	print("Turn: {0}, Slice {1}:, Points: {2}".format(str(turn), slice, self.points))

	#find a pie to place the slice
	for idx, pie in enumerate(self.dest_pies):
	result = pie.add_slice(slice)
	if result != False:
	found_place = True
	self.slices_placed += result
	print("slice added to pie {0}".format(idx))
	break;

	if not found_place:
	print("Game over on turn {0}!".format(turn))
	no_more_moves = True;

	#check if pies clear
	for idx, pie in enumerate(self.dest_pies):
	if pie.complete():
	self.points += pie.clear()
	print("pie {0} cleared!".format(idx))
	idx_after = idx + 1
	idx_before = idx - 1
	if idx == 5:
	idx_after = 0
	if idx == 0:
	idx_before = 5
	print("adjacent pie {0} cleared!".format(idx_after))
	self.points += self.dest_pies[idx_after].clear()
	print("adjacent pie {0} cleared!".format(idx_before))
	self.points += self.dest_pies[idx_before].clear()

	return self.points

	game = Game(['a'],[.4,.3,.2,0,0])
	game.play()