def killOldLoosers(self):

        maxAgeWinQuota = -5000
        worstPlayer = None

        # if under this level, you might get killed
        thresh = self.getMostSuccessfulPlayer().getWinRate() * 0.4

        if thresh < 0.05:
            return  # not even best player can really play.  dont run algorithm

        for playerName, p in self.players.items():

            #p.setProhibitLearn(False)
            pass

            if p.getTotTrained() < 500:
                continue  # dont kill to young players

            if p.getWinRate(
            ) < 0.02:  # Such bad player, with this age. simply kill it!
                print(
                    "Killing a really bad player {a}. trained {b}, winrate {c}"
                    .format(a=p.getName(),
                            b=p.getTotTrained(),
                            c=p.getWinRate()))
                self.removePlayer(worstPlayer)
                self.addPlayer(
                    luffAIPlayer3.luffAIPlayer3(
                        self.defs.characterX,
                        "B" + str(random.randint(0, 10000))))
                self.reElectLeader()
                return

            if p.getWinRate(
            ) > thresh:  # This player is above the thresh. This is OK!
                continue

            ageWinQuota = p.getTotTrained() / p.getWinRate()

            if ageWinQuota > maxAgeWinQuota:
                maxAgeWinQuota = ageWinQuota
                worstPlayer = p

        if worstPlayer is not None:
            print("Throwing out old, bad player {a}. trained {b}, winrate {c}".
                  format(a=worstPlayer.getName(),
                         b=worstPlayer.getTotTrained(),
                         c=worstPlayer.getWinRate()))
            self.removePlayer(worstPlayer)
            self.addPlayer(
                luffAIPlayer3.luffAIPlayer3(
                    self.defs.characterX, "G" + str(random.randint(0, 10000))))
            self.reElectLeader()
    def trainPlayer(self):

        if len(self.players) == 0:
            self.addPlayer(
                luffAIPlayer3.luffAIPlayer3(self.defs.characterX, "i1"))  # PUT
            self.addPlayer(
                luffAIPlayer3.luffAIPlayer3(self.defs.characterX, "i2"))  # PUT
            self.addPlayer(
                luffAIPlayer3.luffAIPlayer3(self.defs.characterX, "i3"))  # PUT
            self.addPlayer(
                luffAIPlayer3.luffAIPlayer3(self.defs.characterX, "i4"))  # PUT

        self.addBenchmarkPlayers()
        self.runTournament(statsFromAllMatches=False, verbose=False)
    def removeWorstPlayerIfnotYoungest(self):
        worst = self.getWorstPlayer()
        youngest = self.getYoungestPlayer()

        if worst.getName() != youngest.getName():
            if (worst.getWinRate() + 0.01) < youngest.getWinRate():
                reElect = False
                # So, the worst player is also older than the youngest player..
                # Simply through out this player and inject a new one
                print(
                    "Throwing out {a} that was worse than a younger player! winrate worst: {b} winrate younger: {c}"
                    .format(a=worst.getName(),
                            b=worst.getWinRate(),
                            c=youngest.getWinRate()))
                if worst.getProhibitLearn():
                    # The worst player was the leader. Need to select a new leader.
                    reElect = True
                self.removePlayer(worst)
                self.addPlayer(
                    luffAIPlayer3.luffAIPlayer3(
                        self.defs.characterX,
                        "W" + str(random.randint(0, 10000))))

                if reElect:
                    self.reElectLeader()
    def humanGame(self, AIPlayer):
        human = humanPlayer.luffHumanPlayer(defs.definitions().characterO,
                                            "playerHumanO")
        AIPlayer = luffAIPlayer3.luffAIPlayer3(self.defs.characterX, AIPlayer)

        while True:
            self.gameEngine.runNewGame(human,
                                       AIPlayer,
                                       useAllAvailPos=False,
                                       verbose=True)
    def restorePlayerObjects(self):

        for nextPlayerName, p in self.players.items():

            try:
                p.getTotTrained()
                # Player object already exists...
            except:
                # No matching object. create it..
                self.players[nextPlayerName] = luffAIPlayer3.luffAIPlayer3(
                    self.defs.characterX, nextPlayerName)
from flask import Flask
from flask import jsonify
from flask_cors import CORS
import json
import numpy
import luffAIPlayer3
import definitions as defs
import luffGameBoard

app = Flask(__name__)
cors = CORS(app)

AIPlayerName = "W8277"
AIPlayer = luffAIPlayer3.luffAIPlayer3(defs.definitions().characterX,
                                       AIPlayerName)


# ################################################################
# TBD
# ################################################################
@app.route("/")
def hello():
    return "Gomuko server is running!"


# ################################################################
# TBD
# ################################################################
@app.route("/<string:gameBoard>/<string:lastMove>")
def hello2(gameBoard, lastMove):