Skip to content

Instantly share code, notes, and snippets.

@matbo81

matbo81/AffSaison.py

Last active December 16, 2015 03:49
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save matbo81/5372975 to your computer and use it in GitHub Desktop.
Save matbo81/5372975 to your computer and use it in GitHub Desktop.
Download ZIP
a little sport-tennis-leaugue-simulation my first bigger python-realisation development time: ca. 3 month please start game with start.py and enjoy oh, caution, it is in german....
Raw
AffSaison.py
######### Projekt Affentennis
######### Element : Eine Saison-Liga-Simulation
######### Prototyp
######### Ziel : Eine einfache Umsetzung im Rahmen
######### meiner Vorstellung einer sehr bescheidenen Karrieresimulation
######### Beschreibung : 3 Ligen, je 8 Spieler, 3 Turniere, 2 Spieler gegeneinander,
######### Interaktion in Form von Staerke-Can't Stop Würfelspiel
######### graphische Plattform : textbasierend
######### Start : 02.12.12
import random
import time
import csv
#############################################################
########### Die Klasse Player wird angelegt #####
########### Sie bildet die Grundlage fuer jeden Spieler #####
class Player:
'''
rund um einen Affentennis-Spieler:
Faehigkeiten
Statistik, Ligazugehoerigkeit
Spielen
'''
def __init__(self, name, staerke, liga):
self.name = name
self.staerke = int(staerke)
self.liga = liga
self.punkte = 0
self.rank = 0
self.matches = 0
self.matchesEver = 0
self.wins = 0
self.losts = 0
self.challenges = 0
self.gamesPos = 0
self.gamesNeg = 0
### alle Matches eines Jahres kommen in eine eigene Liste in der Liste
self.matchInfos = [[]]
self.histRank = []
self.histLiga = [liga,]
self.histCups = [[]]
def __str__(self):
return (self.name + ", Staerke " + str(self.staerke) + ", Punkte: "
+ str(self.punkte) + ", Rang: " + str(self.rank) + ", Liga: "
+ str(self.liga) +(", Spiele /g /v : {} /{} /{}"
.format(str(self.matches), str(self.wins), str(self.losts)))
+ "\ngespielte Turniere: " + str(self.challenges)
+ ("\ngewonnene Spielpunkte: " + str(self.gamesPos))
+ ("\nverlorene Spielpunkte: " + str(self.gamesNeg)))
########### GETTER ############
def get_name(self):
return self.name
def get_staerke(self):
return self.staerke
def get_points(self):
return self.punkte
def get_rank(self):
return self.rank
def get_liga(self):
return self.liga
def get_matches(self):
return self.matches
def get_matchesEver(self):
return self.matchesEver
def get_wins(self):
return self.wins
def get_losts(self):
return self.losts
def get_challenges(self):
return self.challenges
def get_gamesPos(self):
return self.gamesPos
def get_gamesNeg(self):
return self.gamesNeg
def get_gamesSum(self):
return (self.gamesPos - self.gamesNeg)
def get_winChances(self):
return [self.get_name() for chance in range(self.get_staerke())]
########### UPDATER ############
def update_stats(self, match, win, lose, punkte, gamesPos, gamesNeg):
''' (Anzahl: matchesSaison,matchesEver, wins, loses, punkte, gamesPos, gamesNeg) '''
self.matches += match
self.matchesEver += match
self.wins += win
self.losts += lose
self.punkte += punkte
self.gamesPos += gamesPos
self.gamesNeg += gamesNeg
def update_rank(self, ranks):
self.rank = ranks
def update_liga(self, liga):
self.liga = liga
def update_challenges(self):
self.challenges += 1
def update_matchInfos(self, match, name, rnd):
self.matchInfos[game.turner.year-1].append([name, rnd, match])
def reset(self):
self.punkte = 0
self.histRank.append(self.rank)
self.histLiga.append(self.liga)
self.histCups.append([])
self.rank = 0
self.matches = 0
self.wins = 0
self.losts = 0
self.challenges = 0
self.gamesPos = 0
self.gamesNeg = 0
self.matchInfos.append([])
################ AUSLAGERN ??!! #####
### achtung wird aber noch benutzt! ###
def compare(self):
return self.name + "({})".format(str(self.staerke))
# end-class
#############################################################
########### Die Klasse PlayerDict wird angelegt #####
########### Sie ist ein Dictionary mit allen Spielern #####
########### Dieses Dict dient als Grundlage der Liga #####
class PlayerDict:
'''
Ein Dictionary aller im Game vorkommenden Player-Instanzen,
wobei der Key der Player-Name und der Wert die Instanz selber ist
'''
def __init__(self):
self.playerDict = {}
def __str__(self):
return self.playerDict
########### GETTER ############
def get_playerDict(self):
return self.playerDict.copy()
def get_nameList(self, liga = [1,2,3,4]):
nL = ([n.get_name() for n in self.playerDict.values() if int(n.get_liga()) in liga])
nL.sort()
return nL
########### UPDATER ############
def add_player(self, pl):
self.playerDict[pl.get_name()]=pl
# end_class
#############################################################
########### Die Klasse OneMatch wird angelegt ##############
########### 2 Variabeln fuer jede Partei ##############
class OneMatch:
'''
Sie besitzt verschiedene Attribute:
in der Grundversion
2 Variabeln fuer Gegnerseite A (es ist eine Liste, weil ja vielleicht auch...)
2 Variabeln fuer Gegnerseite B (...mal ein Doppel gespielt werden kann)
erweiterbar durch z.B.:
(Standort, Platzverhaeltnisse, Wetter
Spielereignisse, Spielerstaerken beeinflussende Eigenschaften etc.)
die Methoden berechnen folgendes und returnieren:
-die Gewinnwahrscheinlichkeit
-anhand Gewinnwahrscheinlichkeit den Sieger, den Verlierer
-updated die Stats der beteiligten Spieler
-das Ergebnis und der Ergebnisverlauf ist "getbar"
-man kann ein Spiel im Spiel einzeln berechnen (z.B (1, 0)) oder
das komplette Spiel bis zur einer variablen Siegbedingung (3, 1).
Die Klasse Match soll solange "leben" bis das Turnier vorbei ist.
'''
def __init__(self, player1, player2, name):
self.name = name
self.player1 = player1
self.player2 = player2
self.score = [0, 0]
self.scorePro = []
self.over = False
def __str__(self):
return ("Spieler1: " + self.player1, "\nSpieler2: " + self.player2,
"\nScore: " + str(self.score),
"\nScorePro: " + str(self.scorePro), "Over: " + str(self.over))
########### GETTER ############
def get_player1(self):
return self.player1
def get_player2(self):
return self.player2
def get_score(self):
return self.score
def get_scorePro(self):
return self.scorePro
def get_vs(self):
return [self.get_player1(), self.get_player2()]
def get_player1_staerke(self):
return self.player1.get_staerke()
def get_player2_staerke(self):
return self.player2.get_staerke()
def get_player1_rank(self):
return self.player1.get_rank()
def get_player2_rank(self):
return self.player2.get_rank()
def get_chances_name(self):
return [
self.player1.get_winChances(),
self.player2.get_winChances()
]
def get_chances(self):
return [0 for chance in self.get_chances_name()[0]] + [1 for chance in self.get_chances_name()[1]]
def get_winner(self):
return self.score.index(max(self.score))
def get_loser(self):
return self.score.index(min(self.score))
def get_winner_name(self):
return self.get_vs()[self.get_winner()]
def get_loser_name(self):
return self.get_vs()[self.get_loser()]
def get_over(self):
return self.over
########### UPDATER ############
def update_score(self):
self.score[random.choice(self.get_chances())] += 1
self.scorePro.append(tuple(self.score))
def update_over(self):
self.over = not self.over
def matchEffect(self, punkte):
self.over = True
maxMin = [max(self.score), min(self.score)]
self.get_winner_name().update_stats(1, 1, 0, punkte, maxMin[0], maxMin[1])
self.get_loser_name().update_stats(1, 0, 1, 0, maxMin[1], maxMin[0])
########### SPECIAL ############
def finish_Match(self, scoreMax):
while max(self.get_score()) < scoreMax:
self.update_score()
self.over = True
# end-class
#############################################################
########### Die Klasse Challenge wird angelegt #############
########### Eine Liste mit allen Matches #############
class Challenge:
def __init__(self, name, ligaInst, punkte, time):
self.name = name
self.ligaInst = ligaInst
self.liga = ligaInst.name
self.punkte = punkte
self.time = time
self.maxScore = 3
self.players = []
self.numPlayers = 0
self.matches = []
self.matchstat = []
self.rndNames = []
### control: [0] => init_rounds
self.controll = [False,]
self.winners = []
def __str__(self):
return ("\nTurniername: " + self.name,
"\nLiganame: " + self.liga,
"\nPunkteliste: " + str(self.punkte),
"\nmaxScore: " + str(self.maxScore),
"\nSpielerliste: " + str(self.players),
"\nAnzahl Spieler: " + str(self.numPlayers),
"\ndie Match-Objekte: " + str(self.matches),
"\ndie Runden-Namen: " + str(self.rndNames))
########### GETTER ############
def get_active(self):
return self.active
def get_name(self):
return self.name
def get_liga(self):
return self.liga
def get_punkte(self):
return self.punkte
def get_maxScore(self):
return self.maxScore
def get_players(self):
return self.players.copy()
def get_numPlayers(self):
return self.numPlayers
def get_rndNames(self):
return self.rndNames
def get_matches(self):
return self.matches
def get_matchstat(self):
return self.matchstat
########### SETTER ############
def set_name(self, new):
self.name = new
def set_liga(self, new):
self.liga = new
def set_punkte(self, new):
self.punkte = new
def set_maxScore(self, new):
self.maxScore = new
def set_players(self, new):
self.players = new.copy()
self.set_numPlayers()
def set_numPlayers(self):
self.numPlayers = len(self.players)
########### PLAYER-LIST MANAGER ############
def add_player(self, pl):
self.players.append(pl)
self.set_numPlayers()
def sort_players(self):
self.players = self.helpToPosition()
########### PROCESS MANAGER ############
def update_active(self, part):
self.active[part] = not self.active[part]
def init_rounds(self):
reader = csv.reader(open("turniere.csv"), delimiter=";")
rN = {int(tu[1]) : tu[2] for tu in reader if int(tu[0]) == 2}
if self.numPlayers in [2, 4, 8, 16, 32] and not self.controll[0]:
self.rndNames.append(rN[self.numPlayers])
self.matches.append([])
self.matchstat.append(False)
self.numPlayers /= 2
self.init_rounds()
elif self.numPlayers == 1 and self.rndNames:
self.set_numPlayers()
self.controll[0] = True
def init_matches(self):
self.sort_players()
pot = self.players.copy()
rnd = self.matches.index([])
while pot:
pl2 = pot.pop(random.randrange((len(pot)/2),len(pot)))
pl1 = pot.pop(0)
self.matches[rnd].append(OneMatch(pl1, pl2, self.name))
pl1.update_matchInfos(self.matches[rnd][-1], self.name, self.rndNames[rnd])
pl2.update_matchInfos(self.matches[rnd][-1], self.name, self.rndNames[rnd])
########### CONTROL MANAGER ############
def control(self):
if (game.turner.turn) in self.time:
self.play()
########### RESET MANAGER ############
def reset(self):
self.players.clear()
self.numPlayers = 0
self.matches = []
self.matchstat.clear()
self.rndNames.clear()
self.controll.clear()
self.controll = [False,]
########### PLAY MANAGER ############
def play(self):
rndX = self.matchstat.index(False)
for match in self.matches[rndX]:
match.finish_Match(self.maxScore)
match.matchEffect(self.punkte[rndX])
self.players.remove(match.get_loser_name())
self.matchstat[rndX] = True
if len(self.players) == 1:
self.winners.append(self.players[0])
self.players[0].histCups[game.turner.year-1].append(self.name)
########### HELPER ############
def helpToPosition(self):
newStandings = []
for pl in self.players:
points = pl.get_points()
gamSum = pl.get_gamesSum()
division = pl.get_liga() * (-1)
name = pl.name
newStandings.append([points, gamSum, division, name])
newStandings.sort(reverse=True)
return [self.ligaInst.plDict[pl[-1]] for pl in newStandings]
# end-class
#############################################################
########### Die Klasse Standings wird angelegt #####
########### Sie ist eine Liste mit allen Spielern #####
########### in Reihenfolge ihrer gesammelten Punkte #####
class Standings:
'''
Eine Liste mit den Namen der Spieler in der Reihenfolge
ihrer Punkte absteigend. Eine Methode soll eine huebsche
Tabellen-Ausgabe erzeugen.
'''
def __init__(self, name, division, apes, downLimit):
self.name = name
self.division = division
self.plDict = apes.playerDict
##### list-liste, wobei Index [0] = points, [1] Differenz gamesPos-gamesNeg
##### und [-1] immer der Name des Spielers ist
self.standings = [pl for pl in self.plDict.values() if pl.liga == self.division]
self.turnierListe = {}
self.turnierOrder = []
####### Attribute, die die Absteiger aus dieser und die Aufsteiger
####### in diese Liga behandeln. "downLimit" = Anzahl der Ab- bzw. Aufsteiger
self.downLimit = downLimit
self.positioning()
def __str__(self):
return ("Liganame = " + str(self.name)
+ "\nLigadivision = " + str(self.division)
+ "\nLigaspieler = " + str(self.standings)
)
########### GETTER ############
def get_standings(self):
#### keine VERAENDERUNGEN ausserhalb der Klasse !! ####
return self.standings
def get_playerNames(self):
return [pl.name for pl in self.standings]
def get_name(self):
return self.name
def get_division(self):
return self.division
########### ADDER ############
def add_turnier(self, tName, punkte, time, game):
'''(str, list)'''
self.turnierListe[tName] = Challenge(tName, self, punkte, time)
game.saison.add_turnier(tName, self.turnierListe[tName])
self.turnierOrder.append(self.turnierListe[tName])
self.playersToTurnier(tName)
def playersToTurnier(self, tu):
self.turnierListe[tu].set_players(self.standings)
self.turnierListe[tu].init_rounds()
########### UPDATER ############
def update_standings(self):
self.standings = self.helpToPosition()
def update_playerRanks(self):
for pl in self.get_standings():
rank = 1 + (self.get_standings().index(pl))
pl.update_rank(rank)
def update_downUps(self):
if self.downLimit:
otherLiga = game.saison.division[self.division+1]
for pl in self.standings[-self.downLimit:]:
otherLiga.standings.insert(self.downLimit,self.standings.pop())
pl.liga = otherLiga.division
for pl in otherLiga.standings[:self.downLimit]:
self.standings.append(otherLiga.standings.pop(0))
pl.liga = self.division
########### RESET ############
def reset(self):
for pl in self.standings:
pl.reset()
for tu in self.turnierListe.values():
tu.reset()
self.playersToTurnier(tu.name)
########### POSITIONING ############
def positioning(self):
self.update_standings()
self.update_playerRanks()
########### HELPER-SPECIALS ############
def helpToPosition(self):
newStandings = []
for pl in self.standings:
points = pl.get_points()
gamSum = pl.get_gamesSum()
division = pl.get_liga() * (-1)
name = pl.name
newStandings.append([points, gamSum, division, name])
newStandings.sort(reverse=True)
return [self.plDict[pl[-1]] for pl in newStandings]
# end-class
#################################################################################
##################### Hier wird die Saison verwaltet ################
#################################################################################
class Saison:
def __init__(self, plDict):
########## kreiere eine Tabelle (Standings-Instanz)
########## fuelle diese Tabelle mit Spielern
self.plDict = plDict
self.ligen = {}
self.division = {}
self.turnierListe = {}
self.plans = []
self.winners = []
def __str__(self):
return ("Ligen = " + str(self.ligen)
+"\nTurnierliste = " + str(turnierListe)
)
########### GETTER ############
def get_ligen(self):
return self.ligen.copy()
def get_turnierListe(self):
return self.turnierListe.copy()
########### UPDATER ############
def add_liga(self, liganame, division, downLimit):
self.ligen[liganame] = Standings(liganame, division, self.plDict, downLimit)
self.division[division] = self.ligen[liganame]
def add_turnierOrder(self, tN):
self.turnierOrder.append(tN)
def add_player(self, liganame, pl, liga):
self.ligen[liganame].add_player(pl, 1)
def add_turnier(self, name, chall):
'''(str, list)'''
self.turnierListe[name] = chall
def update_allLiga(self):
for liga in self.ligen.values():
liga.positioning()
def update_plans(self, turn):
self.plans.clear()
for liga in self.ligen.values():
for tu in liga.turnierListe.values():
if turn in tu.time:
self.plans.append(tu)
def goPlans(self, action):
for tu in self.plans:
if action == "init":
tu.init_matches()
else:
tu.control()
self.update_allLiga()
########### RESET ############
def results(self):
## der Meister der Liga 1 wird gespeichert fuer die ewigen Annalen
self.winners.append(self.division[1].standings[0])
## Auf- und Abstieg wird ausgewertet
for liga in self.ligen.values():
liga.update_downUps()
def reset(self):
for liga in self.ligen.values():
liga.reset()
# end-class
#################################################################################
################# die Klasse User #############
################# verwaltet den User #############
################# - den spielenden Affen #############
################# - die Aktionspunkte #############
################# - Name, naechstes Spiel, etc. #############
#################################################################################
class User:
def __init__(self, name, ape):
self.name = name
self.ape = ape
def get_standing(self):
return game.saison.division[self.ape.liga]
def get_turnier(self):
liga = game.saison.division[self.ape.liga]
turn = game.turner.turn
turnier = [tu for tu in liga.turnierListe.values() if (turn) in tu.time]
if turnier: return turnier[0]
else: False
def get_opponent(self):
year = game.turner.year-1
mI = self.ape.matchInfos[year]
if not len(mI) or mI[-1][-1].over:
return False
player1, player2 = mI[-1][-1].player1, mI[-1][-1].player2
pl1 = "{} ({})".format(player1.name, player1.staerke)
pl2 = "{} ({})".format(player2.name, player2.staerke)
opponent = pl1 if (player1.name != self.ape.name) else pl2
return opponent
# end-class
#################################################################################
################# die Klasse TurnController #############
################# -bestimmt den aktuellen User #############
################# -steuert die Aktionszuweisung #############
################# -zieht die Faeden zwischen den Zugrunden #############
#################################################################################
class TurnController:
def __init__(self, game, turnsEnd):
self.userorder = []
self.userused = []
self.turnsEnd = turnsEnd
self.turn = 1
self.year = 0
self.setup_firstTurn(game)
def set_userorder(self, new):
self.userorder = new.copy()
def turnInfo(self):
return game.users[self.userorder[0]]
def nextUser(self):
self.userused.append(self.userorder.pop(0))
return len(self.userorder)
def order_userList(self):
self.set_userorder(self.userused)
self.userused.clear()
def setup_firstTurn(self, game):
self.turn = 1
self.year += 1
game.saison.goPlans("init")
def turnPlay(self):
game.saison.goPlans("play")
def newRound(self):
self.turn += 1
self.order_userList()
game.saison.update_plans(self.turn)
game.saison.goPlans("init")
def saisonEnd(self):
self.order_userList()
self.setup_newSeason()
self.setup_firstTurn(game)
def setup_newSeason(self):
game.saison.results()
game.saison.reset()
# end-class
#################################################################################
################# die Klasse Game #############
################# verwaltet das Spiel #############
################# - die User #############
################# - alle Player #############
#################################################################################
class Game:
def __init__(self):
self.users = {}
self.apes = PlayerDict()
self.saison = Saison(self.apes)
self.liga = 1
self.turnsEnd = 0
self.init_apes()
self.init_saison()
self.testM = self.init_testM()
self.turner = TurnController(self, self.turnsEnd)
def add_ape(self, name, staerke, liga):
self.apes.add_player(Player(name, staerke, liga))
def init_apes(self):
##### das Spieler-Dict
reader = csv.reader(open("players.csv"), delimiter=";")
for pl in reader:
if pl[0]: continue
name = pl[1]
staerke = pl[2]
liga = int(pl[3])
self.apes.add_player(Player(name, staerke, liga))
def init_saison(self):
reader = csv.reader(open("ligen.csv"), delimiter=";")
for liga in reader:
if liga[0]: continue
ligaName = liga[1]
division = int(liga[2])
downLimit = int(liga[3])
self.saison.add_liga(ligaName, division, downLimit)
reader = csv.reader(open("turniere.csv"), delimiter=";")
for tu in reader:
if not int(tu[0]):
name = tu[1]
liga = self.saison.get_ligen()[tu[2]]
punkte = [int(x) for x in tu[3]]
time = [int(tu[4][x]+tu[4][x+1]) for x in range(0, len(tu[4]), 2)]
liga.add_turnier(name, punkte, time, self)
if self.turnsEnd < max(time)+1: self.turnsEnd = max(time)+1
def init_testM(self):
return Testmatch(self.apes)
def set_users(self, new):
self.users = new
# end-class
#################################################################################
################# class Testmatch #################
################# User kann Testmatche spielen mit Spielern #################
################# seiner Wahl und kann alle Ergebnisse #################
################# hinterher einsehen. #################
#################################################################################
class Testmatch:
'''
Hier werden die Testmatches abgehandelt, archiviert und abgerufen.
'''
def __init__(self, playerList):
self.name = "Testmatch"
self.playerList = playerList.playerDict
self.pNames = playerList.get_nameList()
self.player1 = self.playerList[self.pNames[0]]
self.player2 = self.playerList[self.pNames[1]]
self.matches = [OneMatch(self.player1, self.player2, self.name),]
self.score = 3
def __str__(self):
return ("\nalle Matches : \n" + self.matches
+ "\ndie PlayerList : \n" + self.playerList
+ "\nSpieler Oben : " + self.player1
+ "\nSpieler Unten : " + self.player2
+ "\nGewinnsaetze : " + self.score)
########### GETTER ############
def get_matches(self):
return self.matches
def get_playerList(self):
return self.playerList
def get_spieler1(self):
return self.player1
def get_spieler2(self):
return self.player2
def get_score(self):
return self.score
########### SETTER ############
def set_playerList(self, new):
self.playerList = new
def set_player1(self, new):
self.player1 = new
def set_player2(self, new):
self.player2 = new
def set_score(self, new):
self.score = new
########### ADDER ############
def add_match(self):
if not self.matches[-1].get_over():
self.matches.pop(-1)
self.matches.append(OneMatch(self.player1, self.player2, self.name))
# end_class
#################################################################################
################# Starte das Programm mit folgenden Features #############
#################################################################################
game = Game()
''' naechste Aufgabe:
'''
Raw
ligen.csv
We can make this file beautiful and searchable if this error is corrected: No commas found in this CSV file in line 0.
1;eine 1 in Spalte A bedeutet Zeile wird nicht übernommen;;
1;Name;Divsion;Absteiger
;Liga 1;1;3
;Liga 2;2;3
;Liga 3;3;0
Raw
Menu.py
from AffSaison import game
import Texte
#################################################################################
#################################################################################
################# Baustelle Projekt Menue als Klasse ##################
#################################################################################
#################################################################################
#################################
### Hilfe fuer die Ausgabe ###
#################################
'''
Dies ist die "normale" Menuevorlage mit Randelementen.
Über den Parameter "menu" wird die komplette moegliche Auswahl uebergeben.
Am Schluß wird nur ueberprueft ob die User-Eingabe gueltig ist. Ist sie es,
wird die Funktion "goOn" aufgerufen mit dem ausgewählten "String".
'''
def menuHeader(name):
##### Rahmen mit Menuetitel
menuWidth = Texte.mw()
print("\n"+("-" * (len(name) +6 )).center(menuWidth))
print("-- {} --".format(name).center(menuWidth))
def menuOptions(options, special, standOpt, standInp):
##### listet die Auswahlmoeglichkeiten fuer den User auf:
if not standOpt[0]:
return
menuWidth = Texte.mw()
##options
print("-" * menuWidth)
if special:
for s in special:
print(s.center(menuWidth, "-"))
for n in range(0, len(options)):
print(" {} ==> {:14} ".format(n+1, options[n]).center(menuWidth, "-"))
print("-" * menuWidth)
for n in range(0, len(standOpt)):
print(" {:3} ==> {:14} ".format(standInp[n].center(3," "), standOpt[n]).center(menuWidth, "-"))
print("-" * menuWidth)
Texte.turnInfo()
def menuInput(options, special, standInp, standOpt):
##### Solange nach Eingabe fragen, bis sie gueltig ist?
if not standOpt[0]:
return (Texte.hitWords(2))
enter = 0
condition = [str(x) for x in range(1, len(options)+1)] + standInp + special
#######nur debug-print########
#print("Input-Condition = " + str(condition))
#######einfach loeschen falls nicht mehr gebraucht####
while not enter in condition:
enter = input(Texte.hitWords(3))
if enter in special:
return enter
elif enter in standInp:
return (standOpt[standInp.index(enter)])
return (options[int(enter)-1])
# end-function'''
#################################################################################
################# Die Klasse Menu wird angelegt ##################
################# Jedes Menue-Bild wird zu einem Objekt ##################
class Menu:
'''
Fuer jedes Menuefach eine eigene Instanz
Eine Menueliste beinhaltet folgende Unterlisten:
menu = [str"", list[list[],list[], str""*], method, list[list[str""*], list[str""*]]]
str -> "Menuetitel",
list -> Optionen : [[standardOpt], [standardInp], options],
method -> False ODER ein Methodenaufruf ohne Klammern!,
list -> [False, ["",]] ODER Spezialoptionen : [["specialOpt"], [specialInp]]
]
'''
def __init__(self, menulist):
### [name, [[standOpt],[standInp], options], execs, [[specOpt], [specInp]]] ###
self.name = menulist[0]
self.options = menulist[1][2:]
self.execs = menulist[2]
self.specOpt = menulist[3][0]
self.specInp = menulist[3][1]
self.standOpt = menulist[1][0]
self.standInp = menulist[1][1]
def __str__(self):
return ("\nEine Instanz der Klasse Menu mit folgenden Attributen:"
+ "\nMenuetitel = " + self.name
+ "\nMenueauswahl normal = " + str(self.options)
+ "\nMenueauswahl spezial = " + str(self.specOpt)
+ "\nMenueauswahl standard = " + str(self.standOpt)
+ "\nMenue Screen/ execs = " + str(self.execs))
########### GETTER ############
def get_name(self):
return self.name
def get_options(self):
return self.options
########### UPDATER ############
def update_options(self, new):
self.options = new
def update_execs(self, new):
self.execs = new
def update_specOpt(self, new):
self.specOpt = new
def update_specInp(self, new):
self.specInp = new
########### ACTION ############
def makeHeader(self):
if self.execs:
self.execs()
else:
menuHeader(self.name)
def makeOptions(self):
menuOptions(self.options, self.specOpt, self.standOpt, self.standInp)
def makeInput(self):
return menuInput(self.options, self.specInp, self.standInp, self.standOpt)
# end-class
#################################################################################
################# Die Klasse MenuController wird angelegt ##################
################# Sie soll die komplette User-Eingabe und ##################
################# die entsprechende Bildausgabe steuern ##################
class MenuController:
'''
verwaltet die Eingabe des Users und gibt das entsprechende Menue aus
'''
def __init__(self):
#Texte.debugMenuControllerMenuPrint(menuAll)
self.menu = {menuList[0] : Menu(menuList) for menuList in Texte.menusDict(2)}
self.titles = Texte.menusDict(1)
self.menuNow = self.menu[self.titles[1]]
self.last = [self.titles[1], self.titles[1]]
self.cV = Texte.ChallView()
self.menu[self.titles[7]] = False ##7=quit
self.menu[self.titles[6]].update_execs(self.cV.testMatch) ##6=Testmatch
self.menu[self.titles[12]].update_execs(self.cV.testMplay) ##12=Anpfiff (Playtest)
self.menu[self.titles[13]].update_execs(self.cV.testMplayer) ##13=Spieler oben
self.menu[self.titles[14]].update_execs(self.cV.testMplayer) ##14=Spieler oben
self.menu[self.titles[15]].update_execs(self.cV.testMarchiv) ##15=Testmatch Archiv
self.menu[self.titles[16]].update_execs(self.cV.testMscore) ##16=Testmatch Gewinnsätze
self.menu[self.titles[28]].update_execs(self.cV.viewTurning) ##28=Turn
def __str__(self):
return ("\nDie Instanz der Klasse MenuController mit folgenden Attributen:"
+ "\nMenue-Dict = " + str(self.menu)
+ "\naktuelles Menue = " + self.menuNow.get_name())
########### GETTER ############
def get_menu(self):
return self.menu
def get_menuNow(self):
return self.menuNow
########### ACTION ############
def showMenu(self):
self.get_menuNow().makeHeader()
self.get_menuNow().makeOptions()
#######nur debug-print#######
# print("zurueck-Liste = " + str(self.last))
#######einfach loeschen falls nicht mehr gebraucht####
enter = self.last_check(self.get_menuNow().makeInput())
#######nur debug-print#######
# print("Ist Enter Turn? = " + str(enter))
#######einfach loeschen falls nicht mehr gebraucht####
self.update_menuNow(self.menu[enter])
########### UPDATER ############
def update_menuNow(self, menu):
self.menuNow = menu
def update_lastPlus(self, menu):
self.last.append(menu)
if len(self.last) > 9:
self.last.pop(2)
def update_lastMinus(self):
if len(self.last) > 2:
self.last.pop(-1)
return self.last[-1]
########### HELPER ############
def last_check(self, enter):
if enter == self.titles[11]:
enter = self.update_lastMinus()
else:
self.update_lastPlus(enter)
## Hier werden Menues aktualisiert ##
if enter == self.titles[3]: #3=Spielerliste
for name in self.titles[30]: #30=liNames
liga = self.titles[29][name]
self.menu[name].update_options([])
self.menu[name].update_execs(self.cV.viewAllpl)
self.menu[name].update_specOpt([self.titles[18]]) #18=PlayerOpts
self.menu[name].update_specInp(liga.get_playerNames())
elif enter == self.titles[4]: #4=tabellen
liga = game.turner.turnInfo().get_standing()
self.cV.standInf = [liga.name, liga.standings]
self.menu[enter].update_execs(self.cV.viewStand)
self.menu[enter].update_specOpt([self.titles[18]]) #18=PlayerOpts
self.menu[enter].update_specInp(liga.get_playerNames())
for name in self.titles[30]: #30=liNames
liga = self.titles[29][name]
self.menu[name].update_options([])
self.menu[name].update_execs(self.cV.viewStand)
self.menu[name].update_specOpt([self.titles[18]]) #18=PlayerOpts
self.menu[name].update_specInp(liga.get_playerNames())
elif enter == self.titles[9]: #9=turniere
self.cV.turnier = game.turner.turnInfo().get_turnier()
self.menu[self.titles[9]].update_execs(self.cV.view)
for name in self.titles[30]: #30=liNames
liga = self.titles[29][name]
self.menu[name].update_options([tN.name for tN in liga.turnierOrder])
self.menu[name].update_execs(self.titles[17]) #17=noExecs
self.menu[name].update_specOpt(self.titles[20][0]) #20[0]=noSpecOpt
self.menu[name].update_specInp(self.titles[20][1]) #20[1]=noSpecInp
elif enter == self.titles[13]: #13=Spieler oben
self.cV.up = True
elif enter in self.titles[26]: #26=turniernamen
self.cV.turnier = self.titles[26][enter]
self.menu[enter].update_execs(self.cV.view)
elif enter in game.apes.get_nameList():
self.cV.player = game.apes.playerDict[enter]
self.menu[enter].update_execs(self.cV.viewPl)
elif enter in self.titles[30]:
liga = self.titles[29][enter]
self.cV.standInf = [liga.name, liga.standings]
return enter
# end-class
def gameStart():
'''
Beginne das Spiel mit dem Menue
'''
##### Erstelle die Main-Spiel-Verwaltungs-Instanz
main = MenuController()
#print(main.__str__())
#print(main.get_menu()["Hauptmenue"].__str__())
##### Solange der Spieler das Spiel nicht mit QUITT beendet, wird das
##### aktuelle Menue am Bildschirm ausgegeben.
while main.get_menuNow():
main.showMenu()
##### ein wuerdiger Abgang à la Tom & Jerry
print(Texte.hitWords(1))
#end-function
Texte.intro()
gameStart()
Raw
players.csv
We can make this file beautiful and searchable if this error is corrected: No commas found in this CSV file in line 0.
1;eine 1 in Spalte bedeute: Zeile wird nicht übernommen;;
1;Name;Stärke;Liga
;Coco;10;1
;Ugh;10;1
;Zonk;9;1
;Bongo;9;1
;Lulu;8;1
;Alf;8;1
;Jimbo;7;1
;Haze;7;1
1;;;
;Kumba;7;2
;Mhhhm;7;2
;Kok;6;2
;Gogo;6;2
;Hasch;6;2
;Kosch;5;2
;Okahn;5;2
;Einstein;5;2
1;;;
;Caesar;6;3
;Chita;5;3
;KingKong;5;3
;Lothar;4;3
;Schimp;4;3
;ZwieZ;4;3
;Sponge;3;3
;Findus;2;3
Raw
start.py
import Menu
Raw
Texte.py
from AffSaison import game
import Texte
######### Projekt Affentennis
######### Element : Eine Saison-Liga-Simulation
######### Prototyp
######### Unterelement : Texte
######### Beschreibung : In dieser Datei sollen moeglichst saemtliche relevante
######### Spieltexte abgelegt sein, die von der Haupdatei abgerufen
######### werden.
from AffSaison import game, User
import random
import time
#####################################################################################################
########################### Hilfsfunktionen, die u.a. Texte formatieren #############################
#####################################################################################################
#################################
### Hilfe fuer Menuebreite ###
#################################
def mw():
return 30
# end-function
#################################################################################
################# Turnier-Information, folgende Infos: ##############
################# die Liga, Turniername, maximale Spieler- ##############
################# Turnierpunkte, aktuelle Runde, alle noch ##############
################# vorhandenen Spieler, und am Schluß den Sieger ##############
#################################################################################
#################################################################################
################# die Klasse ChallView - macht alles huebsch sichtbar #########
#################################################################################
class ChallView:
def __init__(self):
self.mew = mw()
self.turnier = False
self.player = False
self.standInf = False
self.up = False
def viewTurning(self):
turner = game.turner
if turner.nextUser():
return
elif turner.turn < turner.turnsEnd:
mW = self.mew
matchAll = {}
print("\n" * 5)
print("Spieltag, turn {}".format(turner.turn))
for name in turner.userused:
user = game.users[name]
if user.get_opponent():
matchAll[user.name] = user.ape.matchInfos[turner.year-1][-1].copy()
cup, rnd = matchAll[user.name][0], matchAll[user.name][1]
match = matchAll[user.name][2]
player1 = ("({1:}) {0:}".format(match.player1.name, match.player1.staerke))
player2 = ("{0:} ({1:})".format(match.player2.name, match.player2.staerke))
pls = ("{} vs {}".format(player1, player2))
print("=" * (mW*2))
print("User: {}, Affe: {}, {}, {}".format(user.name, user.ape.name, cup, rnd))
print("{0:25} >> << ".format(pls))
hit = user.ape.staerke
matchAll[user.name].append(hit)
bad = hit
chance = 9
lucky = True
while lucky:
if bad > 1: bad -= 1
if chance > 2: chance -= 1
print("Affen pushen mit W10er? {}-10 = Staerke {}, 1-{} = Staerke {}, Chance: {}%".format((11-chance), hit+1, (10-chance), bad, chance*10))
enter = ""
while not enter in ["1","2"]:
enter = input("Taste 1 -> JA und 2 -> NEIN: ")
if enter == "1":
result = random.choice(range(1,11))
if result + chance > 10:
hit += 1
print("{}\nUnglaublich, deine Staerke betraegt jetzt {}.".format(result, hit))
continue
else:
hit = bad
print("{}\nUppsi !! Das war's dann. Dein Affe spielt das Match mit Staerke {}".format(result, bad))
lucky = False
user.ape.staerke = hit
else:
print("=" * (mW*2))
print("User: {}, Affe: {} \n >> SPIELFREI <<".format(user.name, user.ape.name))
print("=" * (mW*2))
turner.turnPlay()
maxMatch = []
for name in turner.userused:
user = game.users[name]
if user.name in matchAll:
match = matchAll[user.name][2]
result = "Gewonnen!" if user.ape.name == match.get_winner_name().name else "Verloren!"
matchAll[user.name].append(result)
if len(match.scorePro) > len(maxMatch): maxMatch = match.scorePro
if maxMatch:
print("Spielverlauf, turn {}".format(turner.turn))
for x in range(1,len(maxMatch)+1):
for name in turner.userused:
user = game.users[name]
if user.name in matchAll:
def aux(old):
new = ""
for sc in old:
score = "{}:{}".format(sc[0], sc[1])
new += score
if sc != old[-1] : new += ", "
return new
# end sub-function
cup, rnd = matchAll[user.name][0], matchAll[user.name][1]
match = matchAll[user.name][2]
result = matchAll[user.name][4]
score = match.scorePro[:x] if x < len(match.scorePro) else match.scorePro
score = aux(score)
player1 = ("({1:}) {0:}".format(match.player1.name, match.player1.staerke))
player2 = ("{0:} ({1:})".format(match.player2.name, match.player2.staerke))
pls = ("{} vs {}".format(player1, player2))
print("=" * (mW*2))
print("User: {}, Affe: {}, {}, {}".format(user.name, user.ape.name, cup, rnd))
if x < len(match.scorePro):
print("{0:25} >> {1:} << ".format(pls, score))
else:
print("{0:25} >> {1:} << {2:}".format(pls, score, result))
user.ape.staerke = matchAll[user.name][3]
print("=" * (mW*2))
if x < len(maxMatch) : input()
input('Mit "Enter" folgt turn {}\n'.format(turner.turn+1))
turner.newRound()
else:
self.saisonEnd(turner)
# end-function
def saisonEnd(self, turner):
def aux(old):
new = ""
for pl in old:
new += pl.name
if pl != old[-1] : new += ", "
return new
# end-sub-function
mW = self.mew * 2
meister = game.saison.division[1].standings[0].name
if not (len(meister) % 2): meister + (" ")
liga1 = game.saison.division[1].name
print("\n"*3)
print("<>" * (mW // 2))
print("<>" + " "*(mW-4) + "<>")
print("<>" + "Abschluß Saison {}".format(turner.year).center(mW-4) + "<>")
print("<>" + " "*(mW-4) + "<>")
print("<>" + "^^^^^^^".center(mW-4) + "<>")
print("<>" + "^^^^^^^^^^^^^".center(mW-4) + "<>")
print("<>" + "^^^^Meister^^^^".center(mW-4) + "<>")
print("<>" + "{}".format(liga1).center(15, "^").center(mW-4) + "<>")
print("<>" + "^^^^^^^^^^^^^^^".center(mW-4) + "<>")
print("<>" + "{}".format(meister).center(15, "^").center(mW-4) + "<>")
print("<>" + "^^^^^^^^^^^^^".center(mW-4) + "<>")
print("<>" + "^^^^^^^".center(mW-4) + "<>")
print("<>" + " "*(mW-4) + "<>")
print("<>" + " "*(mW-4) + "<>")
print("<>" + "Ab- und Aufsteiger".center(mW-4) + "<>")
print("<>" + " "*(mW-4) + "<>")
for x in range(1, len(game.saison.division)):
liga = game.saison.division[x]
ligaDown = game.saison.division[x+1]
if not liga.downLimit: continue
ups = ligaDown.standings[:liga.downLimit]
downs = liga.standings[-liga.downLimit:]
print("<>" + "Absteiger aus {}: {}".format(liga.name, aux(downs)).center(mW-4) + "<>")
print("<>" + "Aufsteiger in {}: {}".format(liga.name, aux(ups)).center(mW-4) + "<>")
print("<>" + " "*(mW-4) + "<>")
print("<>" * (mW // 2))
print("\n"*8)
input("Druecke 'Enter' und die neue Saison beginnt!")
turner.saisonEnd()
# end-function
def viewPl(self):
'''
bereitet eine huebsche Printausgabe fuer die individuelle Spielerstatistik vor
'''
pl = self.player
mW = self.mew
print ("*" *mW)
print ("Name : " + pl.name)
print ("Staerke : " + str(pl.staerke))
print ("Punkte : " + str(pl.punkte))
print ("Rank : " + str(pl.rank))
print ("Liga : " + str(pl.liga))
print ("Matches / Ges : {} / {}".format(str(pl.matches), str(pl.matchesEver)))
print ("gew / ver : {} / {}".format(str(pl.wins), str(pl.losts)))
print ("Turniere : " + str(pl.challenges))
print ("Spiele gew:ver : {}:{}".format(str(pl.gamesPos), str(pl.gamesNeg)))
print ("Match-Historie".center(mW))
for msYear in range(len(pl.matchInfos)):
print("=" * (mW*2))
print("im Jahre {} in Liga {}".format(msYear+1, pl.histLiga[msYear]).center(mW))
if msYear+1 < game.turner.year:
new = ""
for x in pl.histCups[msYear]:
new += x
if x != pl.histCups[msYear][-1] : new += ", "
if not new: new = "Keine"
print(" Platz: {}, Turniersiege: {}".format(pl.histRank[msYear], new))
for name, rnd, match in pl.matchInfos[msYear]:
player1 = ("({1:}) {0:}".format(match.player1.name, match.get_player1_staerke()))
player2 = ("{0:} ({1:})".format(match.player2.name, match.get_player2_staerke()))
pls = ("{} vs {}".format(player1, player2))
p1Score = match.get_score()[0]
p2Score = match.get_score()[1]
sc = ("{}:{}".format(p1Score, p2Score))
print("{0:25} >> {1:} << {2:}, {3:}".format(pls, sc, name, rnd))
print("=" * (mW*2))
# end-function
def view(self):
''' class, int
gibt den kompletten, gewuenschten Spieltag aus
mit Infos zu dem Turniernamen, aktuelle Runde
und allen Paarungen.
'''
if not self.turnier:
return False
menuWidth = int(self.mew * (5/3))
tliga = self.turnier.get_liga()
tname = self.turnier.get_name()
tmatches = self.turnier.get_matches()
tpunkte = self.turnier.get_punkte()
trndNames = self.turnier.get_rndNames()
time = self.turnier.time
print("\n"+("§" * (len(tliga) +6 )).center(menuWidth))
print("§§ {} §§".format(tliga).center(menuWidth))
print(("§" * (len(tname) +6 )).center(menuWidth))
print("§§ {} §§".format(tname).center(menuWidth))
print("§" * menuWidth)
for rnd in range(len(trndNames)):
print("§§" + "{} (turn {})".format(trndNames[rnd], time[rnd]).center(menuWidth-4) + "§§")
print("§§" + ("Siegpunkte : {}".format(tpunkte[rnd])).center(menuWidth-4) + "§§")
print("§§" + " "*(menuWidth-4) + "§§")
if len(tmatches[rnd]):
for match in tmatches[rnd]:
pl1, pl2 = match.get_player1(), match.get_player2()
player1 = ("({1:>2}) {0:>11}".format(pl1.name, pl1.staerke))
player2 = ("{0:<11} ({1:>2})".format(pl2.name, pl2.staerke))
if not match.over:
print("§§" + (" {} vs {}".format(player1, player2).center(menuWidth-4)) + "§§")
else:
p1Score = match.get_score()[0]
p2Score = match.get_score()[1]
print("§§" + (" {0:} {1:>2} : {2:<2} {3:}".format(player1, p1Score, p2Score, player2).center(menuWidth-4)) + "§§")
print("§§" + " "*(menuWidth-4) + "§§")
print("§§" + "-"*(menuWidth-4) + "§§")
print("§" * menuWidth)
# end-function
def viewStand(self):
'''
bereitet die Überschrift der Tabelle vor fuer einen huebschen Print.
Eigentlich soll hier die komplette Tabelle kreiert werden, aber
leider weiß ich nicht wie ich ein Objekt samt Methode uebergeben soll
ohne in dieser "Unterstuetzungsdatei" das Main-Programm zu importieren.
Wenn ich naemlich dieses importiere, laeuft der Run im Main nicht mehr.
'''
liga = self.standInf[0]
playerList = self.standInf[1]# self.playerList
mwH = self.mew + 14
nL = "** " + liga + " **"
rank = 0
print("\n" + ("*"*len(nL)).center(mwH))
print(nL.center(mwH))
print("*" * mwH)
print(" Pl * Spieler * Ma * Pu * Sg:Sv * Di ".center(mwH, "*"))
print("*"*mwH)
for pl in playerList:
rank += 1
name = pl.name
matchs = pl.get_matches()
points = pl.punkte
gamPos = pl.get_gamesPos()
gamNeg = pl.get_gamesNeg()
diff = gamPos-gamNeg
print("{0:>3} * {1:11}*{2:>3} *{3:>3} *{4:>3}:{5:<2} *{6:>3} ".format(rank, name, matchs, points, gamPos, gamNeg, diff).center(mwH, "*"))
print("*"*mwH)
# end-function
def viewAllpl(self):
mW = self.mew
liga = self.standInf[0]
playerList = self.standInf[1]# self.playerList
nL = "** " + liga + " **"
namen = [pl.name for pl in playerList]
namen.sort()
print("\n" + ("*"*len(nL)).center(mW))
print(nL.center(mW))
print("*" * mW)
for pl in namen:
print(" {:14} ".format(pl).center(mW, "*"))
print("*"*mW)
# end-function
###################################################################
################# TESTMATCH-AUSGABEN ##############
###################################################################
def testMatch(self):
menuWidth = self.mew
title = "Testmatch"
match = game.testM.matches[-1]
player1 = match.player1
player2 = match.player2
name1 = player1.name
staerke1 = "(" + str(player1.staerke) + ")"
name2 = player2.name
staerke2 = "(" + str(player2.staerke) + ")"
score = match.get_score()
middle = "vs "
maxScore = "Gewinnsaetze {}".format(game.testM.score)
pl1 = "{:4} {:<14}{:}".format(staerke1, name1, score[0])
pl2 = "{:4} {:<14}{:}".format(staerke2, name2, score[1])
print("\n"+("^" * (len(title) +6 )).center(menuWidth))
print("^^ {} ^^".format(title).center(menuWidth))
print("^" * menuWidth)
print((" " * (menuWidth-2)).center(menuWidth, "^"))
print("{:^28}".format(pl1).center(menuWidth, "^"))
print("{:^28}".format(middle).center(menuWidth, "^"))
print("{:^28}".format(pl2).center(menuWidth, "^"))
print((" " * (menuWidth-2)).center(menuWidth, "^"))
print("{:^28}".format(maxScore).center(menuWidth, "^"))
print((" " * (menuWidth-2)).center(menuWidth, "^"))
print("^" * menuWidth)
# end_functions
def testMplay(self):
score = game.testM.score
matches = game.testM.matches
if matches[-1].get_over():
game.testM.add_match()
match = matches[-1]
print("\nWillkommen zu einem {} !".format(match.name))
print("\nDie Hoehe der Staerke ergibt die Anzahl der Namen im 'Chancen'-Topf.")
print("Der Chancen-Topf fuer dieses Match sieht so aus: ", match.get_chances())
if input("\nMit Enter geht das Match los! 0 = Abbruch") == "0":
return
print("\n" + match.player1.name, " vs ", match.player2.name)
while max(match.get_score()) < score:
match.update_score()
time.sleep(0.5)
print("( {} : {} )".format(match.get_score()[0], match.get_score()[1]), end = '')
time.sleep(0.3)
match.update_over()
print("\nDer Gewinner ist {} mit einem {} : {} ".format(match.get_winner_name().name, match.get_score()[0], match.get_score()[1]))
print ("Die Menge jubelt !!!!\n")
input("\nMit Enter geht es zurueck!")
# end_functions
def testMplayer(self):
def aux(playerA, playerB):
playerList2 = tester.playerList.copy();
playerList2.pop(playerB.name)
playerList3 = ["{} ({})".format(pl.name, pl.staerke) for pl in playerList2.values()]
playerList3.sort()
playerNames = tester.pNames.copy()
playerNames.remove(playerB.name)
enter = False
options = {
"0" : playerA,
"1" : random.choice(list(playerList2.values()))
}
print("folgende Optionen:")
print("0 ==> Abbruch \n1 ==> zufaellige Spielerwahl \nName ==> gezielte Spielerwahl")
print("\nSpielerpool: ")
for pl in playerList3:
print(pl, end = '')
if not pl == playerList3[-1]:
print(", ", end = '')
print("\nWer soll spielen?")
while not enter in playerNames and not enter in options:
enter = str(input("Bitte eine Optionsnummer oder einen Namen eingeben: "))
if enter in options:
return options[enter]
return playerList2[enter]
# end-sub-function
tester = game.testM
plUp = tester.player1
plDown = tester.player2
if self.up:
tester.set_player1(aux(plUp, plDown))
self.up = False
else:
tester.set_player2(aux(plDown, plUp))
tester.add_match()
# end-function
def testMarchiv(self):
matches = game.testM.matches
print("\nArchiv aller Testmatches:")
for match in matches:
player1 = match.player1
player2 = match.player2
name1 = player1.name
staerke1 = player1.staerke
name2 = player2.name
staerke2 = player2.staerke
scoreList = match.get_scorePro()
score = ["{}:{}".format(score[0], score[1]) for score in scoreList]
print("{0:^8} ({1:}) vs {2:^8} ({3:}) {4:}".format(name1, staerke1, name2, staerke2, str(score)))
if (matches.index(match)+1) % 5 == 0:
if input("\nMit Enter geht es weiter! 0 = Abbruch") == "0":
return
# end-functions
def testMscore(self):
scores = [0, 1, 2, 3, 4, 5, 6]
enter = "69"
print("\nÄndern der Gewinnsaetze:")
print("Bitte einen dieser Werte {} eingeben".format(str(scores[1:])))
while not enter.isdigit() or not int(enter) in scores:
enter = input("0 bedeutet der aktuelle Wert.\n")
scores[0] = game.testM.score
game.testM.set_score(scores[int(enter)])
# end-function
# end_class
#################################
### Hilfe fuer getMenu ###
#################################
def menusDict(thatDict):
############## Bezeichnungen der Menuetitel ##############
hauptmenu = "Hauptmenue"
saison = "Saison"
spielerliste = "Spielerliste"
tabellen = "Tabellen"
standing = "Tabelle"
match = "Testmatch"
quit_ = "Quit"
spieler = "Spieler"
turnier = "Turniere"
draw = "Spielplan"
back = "Zurueck"
turn = "Turn"
playTest = "Anpfiff"
playerUp = "Spieler oben"
playerDown = "Spieler unten"
archiv = "Archiv"
testScore = "Gewinnsaetze"
fixture = "Spielplan"
tests = "Testen"
noExecs = False
player_T = " Name ==> {:14} ".format("Statistik")
matchStyle = ["Schnell", "Mittel", "Spannung"]
noSpecial = [False, ["keine Spezialoptionen",]]
noOptions = [[False], [False], False]
signs = ["<", "0", "666"]
ligen = game.saison.get_ligen()
liNames = [liga for liga in ligen]
liNames.sort()
turniernamen = game.saison.get_turnierListe()
standard = [[back, hauptmenu], [signs[0], signs[1]]]
titles = { 1 : hauptmenu, 2 : saison, 3 : spielerliste, 4 : tabellen, 5 : standing,
6 : match, 7 : quit_, 8 : spieler, 9 : turnier, 10 : fixture, 11 : back,
12 : playTest, 13 : playerUp, 14 : playerDown, 15 : archiv, 16 : testScore,
17 : noExecs, 18 : player_T, 19 : matchStyle, 20 : noSpecial, 21 : noOptions,
22 : signs, 23 : None, 24 : None, 25 : None,
26 : turniernamen, 27 : standard, 28 : turn, 29 : ligen, 30 : liNames
}
if thatDict == 1: return titles
############## Erstelle die MenueListe ##############
'''
Eine Menueliste beinhaltet folgende Unterlisten:
menu = [str"", list[list[],list[], str""*], method, list[list[str""*], list[str""*]]]
str -> "Menuetitel",
list -> Optionen : [[standardOpt], [standardInp], options],
method -> False ODER ein Methodenaufruf ohne Klammern!,
list -> [False, ["",]] ODER Spezialoptionen : [["specialOpt"], [specialInp]]
]
'''
menuAll = [
[hauptmenu, [[back, quit_],[signs[0], signs[2]], tabellen, turnier, tests, turn], noExecs, noSpecial],
[tests, standard + [spielerliste, match], noExecs, noSpecial],
[spielerliste, standard + liNames, noExecs, noSpecial],
[tabellen, standard + liNames, noExecs, noSpecial],
[turnier, standard + liNames, noExecs, noSpecial],
[match, standard + [playTest, playerUp, playerDown, testScore, archiv], noExecs, noSpecial],
[playTest, noOptions, noExecs, noSpecial],
[playerUp, noOptions, noExecs, noSpecial],
[playerDown, noOptions, noExecs, noSpecial],
[archiv, standard + [match], noExecs, noSpecial],
[testScore, noOptions, noExecs, noSpecial],
[turn, noOptions, noExecs, noSpecial]
]
for liga in liNames:
menuAll += [[liga, standard, noExecs, noSpecial]]
for player in ligen[liga].get_playerNames():
menuAll += [[player, standard, noExecs, noSpecial]]
for turnier in turniernamen.values():
menuAll += [[turnier.get_name(), standard, noExecs, noSpecial]]
#menuAll += [[turn, noOptions, noExecs, noSpecial]]
return menuAll
# end-function
#################################
### Hilfe fuer menuOptions ###
#################################
def turnInfo():
mW = mw()
tC = game.turner
user = tC.turnInfo()
name = user.name
rank = user.ape.rank
liga = user.ape.liga
turn = tC.turn
year = tC.year
ape = ("{} ({})".format(user.ape.name, user.ape.staerke))
opp = user.get_opponent() if user.get_opponent() else "?"
print("^" * mW)
print("User : {}, Affe: {}".format(name, ape))
print("Platz: {}, Liga: {}".format(rank, liga))
print("turn : {}, Jahr: {}".format(turn, year))
print("naechster Gegner: {}".format(opp))
print("^" * mW)
print("-" * mW)
# end-function
#################################
### Hilfe fuer feste Woerter ###
#################################
def hitWords(word):
words = {
1 : "Vielen Dank fuer die Bluuumen....!",
2 : "Zurueck",
3 : "Deine Auswahl: "
}
return words[word]
# end-function
#################################
### Hilfe fuer debbuging ###
#################################
def debugMenuControllerMenuPrint(menuAll):
x=0
for menu in menuAll:
print(str(x) + " = " + str(menu))
x+=1
# end-function
##################################################################################
################# verschiedene Match-Abwicklungsfunktionen ##############
################# 1) 1 schnelle : die Spielpaarungen + Ergebnisse ##############
################# 2) 1 mittlere : jede Partie einzeln mit Infos ##############
################# 3) 1 langsame : jeder Punkte einer Partie ##############
##################################################################################
######## die schnelle Variante
def playVersion1(match, maxScore, punkte):
''' class OneMatch, int, int
'''
match.finish_Match(maxScore)
match.matchEffect(punkte)
# end-function
######## die mittlere Variante
def playVersion2(match, maxScore, punkte):
''' class OneMatch, int, int
'''
menuWidth = mw()
sW = menuWidth-2
print("\n/" + "-"*sW + "\\")
print("|" + ("{0:^11} vs {1:^11}".format(match.get_player1(), match.get_player2()).center(sW)) + "|")
match.finish_Match(maxScore)
print("|" + (" ({0:^0}.) ({1:^0}) {2:>0} : {3:<0} ({4:^0}) ({5:^0}.)".format(match.get_player1_rank(), match.get_player1_staerke(), match.get_score()[0], match.get_score()[1], match.get_player2_staerke(), match.get_player2_rank())).center(sW) + "|")
print("|" + ("Der Gewinner ist " + match.get_winner_name()).center(sW) + "|")
print("\\" + "-"*sW + "/")
match.matchEffect(punkte)
input("\nMit Enter gehts weiter!")
# end-function
######## die spannende (langsame) Variante
######## funktioniert aber nur so wie gedacht, bei laufendem Python-Programm
def playVersion3(match, maxScore, punkte):
''' class OneMatch, int, int
'''
menuWidth = mw()
sW = menuWidth-2
print("\n/" + "-"*sW + "\\")
print("|" + ("{0:^11} vs {1:^11}".format(match.get_player1(), match.get_player2()).center(sW)) + "|")
print("|" + (" ({0:^0}.) ({1:^0}) {2:>0} : {3:<0} ({4:^0}) ({5:^0}.)".format(match.get_player1_rank(), match.get_player1_staerke(), match.get_score()[0], match.get_score()[1], match.get_player2_staerke(), match.get_player2_rank())).center(sW) + "|")
print("|" + "-" * sW + "|")
input(" Mit Enter beginnt das Match! ")
while max(match.get_score()) < maxScore:
match.update_score()
time.sleep(0.5)
print(" ({}:{})".format(str(match.get_score()[0]), str(match.get_score()[1])), end = '')
time.sleep(0.3)
print("\n|" + "-" * sW + "|")
print("|" + ("Der Gewinner ist " + match.get_winner_name()).center(sW) + "|")
print("\\" + "-"*sW + "/")
match.matchEffect(punkte)
input("\nMit Enter gehts weiter!")
# end-function
###################################################################
###################################################################
################# Intro und User-Abfrage ##############
###################################################################
def intro():
mW = mw()
number = ""
users = {}
userorder = []
ligen = game.saison.get_ligen()
liNames = [liga for liga in ligen]
liNames.sort()
plnames = {liga : ligen[liga].get_playerNames() for liga in liNames}
players = game.apes.get_playerDict()
print ()
print (("^" * (mW-4)).center(mW))
print (("^" * (mW-2)).center(mW))
print ("^" * mW)
print ("^^^^^^ " * 2 + "^^^^^^")
print ("^^^^^^ " * 2 + "^^^^^^")
print ("^^^^^^ " * 2 + "^^^^^^")
print ("^" * mW)
print (("^" * (mW-2)).center(mW))
print (("^" * (mW-4)).center(mW))
print ("WILLKOMMEN IM AFFENTENNIS".center(mW))
print ("Wieviele User nehmen teil?".center(mW))
print ("^" * mW)
while not number in [str(x) for x in range(1,5)]:
number = input("1-4 : ".rjust(mW//2))
print ("^" * mW)
for user in range(int(number)):
players["1"] = players[random.choice([names for liga in plnames.values() for names in liga])]
user += 1
name = ""
print ("User {}, wie ist dein Name?".format(user).center(mW))
print ("^" * mW)
while not name or len(name) > 10:
name = input("1-10 Zeichen : ".rjust(mW//2))
print ("^" * mW)
print ("{}, suche dir einen Affen aus.".format(name).center(mW))
print("\nSpielerpool nach Ligen sortiert")
print("**Spielerstaerke in Klammern**\n")
for liga in liNames:
print ("{}".format(liga).center(mW))
for pl in plnames[liga]:
if pl in [ape.ape.name for ape in users.values()]:
continue
print("{} ({})".format(pl, players[pl].get_staerke()), end = '')
if not pl == plnames[liga][-1]:
print(", ", end = '')
print ("\n" + "^" * mW)
enter = False
while not enter in players:
enter = str(input("Name oder 1 fuer Zufall: "))
print ("^" * mW)
users[name] = (User(name, players[enter]))
userorder.append(name)
game.turner.set_userorder(userorder)
game.set_users(users)
# end-function
Raw
turniere.csv
We can make this file beautiful and searchable if this error is corrected: No commas found in this CSV file in line 0.
1;eine 1 in Spalte A bedeutet Zeile wird nicht übernommen;;;
1;Spieleranzahl;Rundenbezeichnung;;
2;32;Runde 1;;
2;16;Achtelfinale;;
2;8;Viertelfinale;;
2;4;Halbfinale;;
2;2;Finale;;
1;Name;Liga;Punkte;Spieltage(time)
0;Erdnuss-Cup;Liga 1;123;020304
0;Bananen-Cup;Liga 1;122;060708
0;Jungle-Cup;Liga 1;111;101112
1;;;;
0;Baum-Cup;Liga 2;121;020304
0;Gorilla-Cup;Liga 2;121;060708
0;Hängen-Cup;Liga 2;121;101112
1;;;;
0;Brüll-Cup;Liga 3;222;020304
0;Fell-Cup;Liga 3;222;060708
0;Bart-Cup;Liga 3;222;101112
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment