Please use python

$1$a$)$Modify the Game class so it takes as input two player classes. These will be assigned as players in Game. Modify also the play method so that it optionally takes arguments for the player indices $($default $0$ and $1).$ Use these player indices to refer to players inside the play method $($this feature will be used in Problem $2).$ Set up $100$ rounds of a game between two identical random choice players $.$ Output the winning scores at the end.

$1$b$)$ Using inheritance define a new type of player. This player should alternate their choice $($so if one round they defect, the next round they cooperate and so

on$).$ You can call this player Flipper. Implement the game between this player and the player who randomly chooses their action each time. Is there a difference between the strategies?

$1$c$)$Set up another player type called TitForTat. This player initially cooperates, but then takes the same action as the opponent's last action.

$1$d$)$Come up with your own strategy for a player and set them up$.$

$1$e$)$ Play your player against the TitForTat player. Create a plot which shows total points after $100$ games for each player. Let's run multiple $100$ game sessions. Run $10$ sessions, starting from zero each time and clearing the player histories. Plot the points won by each player versus the session number.

$2$a$)$Set up a new class MultiPlayerGame which inherits from Game $.$ Modify the method so that it now takes a list of players as input. Use the operator so that it can take any arbitrary length list, and perform the appropriate update inside the method. Add also two methods: a reset method that clears the history and scores of all players; and a tournament method that plays each player against each other player. Have each player perform num$\_$turns $=100$ games and then save the results in a results array, where the row and column specify the index of the players playing. The parameter num$\_$turns can be passed in to the tournament method $($default $100).$

$2$b$)$Set up two additional players: a player who always cooperates and a player who always defects.

$2$c$)$Define a player which is slower to respond to the Opponent than TitForTat.

$2$d$)$Play the players against each other. Sum up their winnings at the end and plot as a bar graph. On the x$-$axis label each player type. You should have at least six player types, but you can include more if you wish.

class Player:

def $\_\_$init$\_\_($self$)$:

self.coop $=1$

self.defect $=0$

self.own$\_$choice$\_$history $=[]$

self.opponent$\_$choice$\_$history $=[]$

self.score$\_$history $=[]$

def choose$($self$)$:

action $=$ np$.$random.randint$(0,2)$

return action

def update$\_$score$($self$,$score$)$:

self.score$\_$history.append$($score$)$

def update$\_$choice$\_$history$($self$,$self$\_$choice,other$\_$choice$)$:

self.own$\_$choice$\_$history.append$($self$\_$choice$)$

self.opponent$\_$choice$\_$history.append$($other$\_$choice$)$

def get$\_$total$($self$)$:

scores $=$ np$.$sum$($self$.$score$\_$history$)$

return scores

class Game:

def $\_\_$init$\_\_($self$)$:

self.num$\_$players $=2$

self.players $=[]$

self.sucker $=0$

self.winner $=5$

self.coop $=3$

self.defector $=1$

self.players.append$($Flipper$())$

self.players.append$($TitForTat$())$

def play$($self$)$:

c$1=$ self.players$[0].$choose$()$

c$2=$ self.players$[1].$choose$()$

if c$1==1$:

if c$2==0$:

p$1=$ self.sucker

p$2=$ self.winner

else:

p$1=$ self.coop

p$2=$ self.coop

else:

if c$2==0$:

p$1=$ self.defector

p$2=$ self.defector

else:

p$1=$ self.winner

p$2=$ self.sucker

self.players$[0].$update$\_$score$($p$1)$

self.players$[1].$update$\_$score$($p$2)$

self.players$[0].$update$\_$choice$\_$history$($c$1,$c$2)$

self.players$[1].$update$\_$choice$\_$history$($c$2,$c$1)$

def final$\_$tally$($self$)$:

tallies $=$ np$.$zeros$($self$.$num$\_$players$)$

i $=0$

for player in self.players:

tallies$[$i$]=$ player.get$\_$total$()$

i$+=1$

return tallies

game$1=$ Game$()$

num$\_$turns $=100$

for i in range$($num$\_$turns$)$:

game$1.$play$()$

print$($game$1.$final$\_$tally$())$