def addBaum(self, inpDat, iTp, cP, yrG=0):
angP = Fkt.drawDst(inpDat.dI[iTp]['dAngKPlr_E'][1]['k'], self.cM,
self.dIA['dMinMax']['AngPol'])
angA = Fkt.drawDst(inpDat.dI[iTp]['dAngKAzm_E'][1]['k'], self.cM,
self.dIA['dMinMax']['AngAzm'])
Fkt.adjustAngles(angP, angA)
self.lB.append(
Baum(inpDat, self.cMk, iTp, np.array(cP), yrG, angP[0], angA[0]))
def addInitialBaeume(self, inpDat):
self.lB, self.dBGNotGerm = [], {}
for iTpB, lSPosSYB in self.dBG.items():
for k in range(len(lSPosSYB)):
cPos, yrGerm = lSPosSYB[k]
if yrGerm == 0:
self.addBaum(inpDat, iTpB, cPos, yrGerm)
else:
Fkt.addToDictL(self.dBGNotGerm, iTpB, lSPosSYB[k])
def getCoordKt(self):
lVDKt, lCKt = [V0_3D] * len(self.vDsK), [V0_3D] * len(self.vDsK)
lPSKt = ['End'] * len(self.vDsK)
lInpV = [np.array([cK for cK in self.pS]), 0, 0., 0., True]
# lInpV: [pSC, iSegS, cTDsK, cTLen, incTLen]
for k in range(len(self.vDsK)):
lPSKt[k] = Fkt.getRPsSK(self.lFDsK[k])
lInpV = Fkt.getInfoKt(lVDKt, lCKt, k, self.vDsK, lInpV,
self.lDirSeg, self.lLenSeg)
self.lKVD, self.lKC, self.lKPS = lVDKt, lCKt, lPSKt
def bewegen(self):
richtung = fk.zufaellige_richtung()
bewegunsrichtung = Karte.richtungen[richtung]
neuerStandort = (
self.standort[0] + bewegunsrichtung[0],
self.standort[1] + bewegunsrichtung[1])
if fk.ob_in_karte(neuerStandort, Karte.KoordinatenGrenze) is True:
neuerStandort = self.standort
return neuerStandort
def removeZwPinchKt(self, lZwRm, lIDZPinch):
Fkt.addLElToList(lIDZPinch, [Z.IDZ for Z in lZwRm])
for cZw in lZwRm:
for cKt in cZw.lKZw:
cKt.pinchIt = True
lZwKeep = []
for cZw in self.lZw:
if cZw not in lZwRm:
lZwKeep.append(cZw)
self.lZw = [cZw for cZw in lZwKeep]
if len(self.lZw) == 0:
self.pinchIt = True # remove this one
def __init__(self,
dInA,
dInTp,
cMk,
dFAdj,
dFPE,
dAnEP,
dAnEA,
IDZw,
lPathID,
yrGrm=0,
ageBm=0,
vS=P0,
sD='s',
vDPrv=vUz,
vDCur=vUz,
cAnV=0.,
cAnR=0.,
lenZw=1.,
lFDstK=[1],
ageZw=1):
self.dIA = dInA
self.dITp = dInTp
self.cMk = cMk
self.cM = self.dIA['Mode']
self.IDZ = IDZw
self.pathID = lPathID
self.yrG = yrGrm
self.ageB = ageBm
self.pS = vS
self.sDir = sD
self.vDirP = vDPrv
self.vDirC = vDCur
self.lFDsE = Fkt.drawDst(dFPE[self.sDir], self.cM,
self.dIA['dMinMax']['FctPEZw'])
self.lAnEP = Fkt.drawDst(dAnEP[self.sDir], self.cM,
self.dIA['dMinMax']['AngPol'])
self.lAnEA = Fkt.drawDst(dAnEA[self.sDir], self.cM,
self.dIA['dMinMax']['AngAzm'])
# Fkt.adjustAngles(self.lAnEP, self.lAnEA)
self.cAnVZ = cAnV
self.cAnRZ = cAnR
self.getSegments(lenZw)
self.lFDsK = lFDstK
self.vDsK = np.array([cFctK * self.lenZ for cFctK in self.lFDsK],
float)
self.getCoordKt()
self.arrX = np.array([self.pS[0]] + [cP[0] for cP in self.lPSegE])
self.arrY = np.array([self.pS[1]] + [cP[1] for cP in self.lPSegE])
self.arrZ = np.array([self.pS[2]] + [cP[2] for cP in self.lPSegE])
self.dFAd = dFAdj
self.ageZ = ageZw
def getFAdj(self):
lSRV_C, lSEV = self.dIA['dVDep']['lSRV_C'], self.dIA['dVDep']['lSEV']
dFAdj = {}
for cVar in lSRV_C:
# list of adjustment factors (lFA) for cur. response v.
# contains elements for all explanatory v.
lFA = Fkt.getLFAdj(lSEV, cVar, self.dTpAdj, self.dMMAdj, self.vDir,
vUz, self.cAnRZ, self.pKR, self.lenZ, self.ageZ,
self.ageB, self.sDirN, self.cM)
# list of according weights, as defined in dITp
lWts = [self.dITp['dCtWt'][cVar][cSEV] for cSEV in lSEV]
dFAdj[cVar] = Fkt.weightedGeoMean(lFA, lWts)
return dFAdj
def __init__(self, inpDat):
descrBG, ageBG = 'BaumGruppe', 0
self.dIA = inpDat.dI
self.cMk = Mosaik(self.dIA)
self.cM = self.dIA['Mode']
self.dBG = self.dIA['dBaumGruppe']
self.addInitialBaeume(inpDat)
self.nYrs = self.dIA['nYears']
self.lViewPlt = self.dIA['lViewPlt']
self.lYPltBG = self.dIA['lYPltBaumGruppe']
self.descBG = descrBG
self.ageBG = ageBG
self.cSonne = Sonne(self.dIA)
Fkt.seedRNG(self.cM)
def growBlaetter(self):
self.lBt = []
tOffsAngAzm = self.dITp['dOffsAngAzm'][self.nKKt][self.sDir]
self.offsAngAzm = Fkt.drawDst(tOffsAngAzm, self.cM,
self.dIA['dMinMax']['AngAzm'])
if self.dIA['modelBlatt']:
vN = Fkt.findRotAxis(self.vDirC, self.sZwTp, self.dIA['tolAngV'])
for iKKt in range(self.nKKt):
cAnBtPlr = self.lAnKPlr[iKKt] * self.dITp['fAngBlattPlr']
cAnKsAzm = self.lAnKAzm[iKKt] + self.offsAngAzm * self.iKtZw
cAnBtPlr, cAnKsAzm = Fkt.adjustAngPA(cAnBtPlr, cAnKsAzm)
vR = Fkt.rotatePt3D(self.vDirC, vN, cAnBtPlr)
vDB = Fkt.rotatePt3D(vR, self.vDirC, cAnKsAzm)
self.lBt.append(self.growBlatt(vDB, iKKt))
def __init__(self,
dInA,
dInTp,
cMk,
nKntnZw,
IDKnosp,
lPathID,
iKnosp,
yrGrm=0,
ageBm=0,
ageZw=-1,
lenZw=0.,
pCA=P0,
pR=0.,
sDPrv='s',
sDNxt='v',
vDZw=vUz,
vDK=vUz,
isGerm=True):
self.dIA = dInA
self.dITp = dInTp
self.cMk = cMk
self.cM = self.dIA['Mode']
self.dLenZw = self.dITp['dLengthZw']
self.dNNKZw = self.dITp['dNumNKZw']
self.dFPKZw = self.dITp['dFctPKZw']
self.dFPEZw = self.dITp['dFctPEZw']
self.dAnEPlr = self.dITp['dAngEPlr']
self.dAnEAzm = self.dITp['dAngEAzm']
self.dTpAdj = self.dITp['dTypeAdj']
self.dMMAdj = self.dITp['dMMFAdj']
self.nKZw = nKntnZw
self.IDKs = IDKnosp
self.pathID = lPathID
self.iKKt = iKnosp
self.yrG = yrGrm
self.ageB = ageBm
self.ageZ = ageZw
self.lenZ = lenZw
self.pKC = pCA
self.pKR = pR
self.sDirP = sDPrv
self.sDirN = sDNxt
self.vDirZw = vDZw
self.vDir = vDK
self.cAnVZ = Fkt.calcAngle2Vect3D(self.vDir, vUz)
self.cAnRZ = Fkt.calcAngle2Plains3D([self.vDirZw, vUz],
[self.vDir, self.vDirZw])
self.dFAd = self.getFAdj()
self.fGerm = isGerm
def __init__(self,
dInA,
dInTp,
cMk,
IDBlt,
vS=P0,
vDB=vUz,
vDZ=vUz,
lenBl=1.,
widBl=1.,
shpBl='circle',
ageBl=1):
self.dIA = dInA
self.dITp = dInTp
self.cMk = cMk
self.cM = self.dIA['Mode']
self.IDBt = IDBlt
self.pS = vS
self.vDirBt = vDB
self.vDirZw = vDZ
self.shpBt = shpBl
self.lenBt = lenBl
self.widBt = widBl
self.getArea()
self.pMid = self.pS + (self.lenBt / 2.) * self.vDirBt
self.pRBt = Fkt.getLenNewCS(self.pMid, self.vDirBt)
self.ageBt = ageBl
self.addToBlock()
def getDBlocks(self):
self.dBk, self.lBkID, lTT, tD = {}, [], [], self.dIA['tDimBkG']
nX, nY, aDRI = self.nX, self.nY, self.cSonne.aDRInv
# aPD = np.array(self.dIA['basisR3'] + [-v for v in self.dIA['basisR3']])
# aArea = np.array([self.aDim[1]*self.aDim[2], self.aDim[0]*self.aDim[2],
# self.aDim[0]*self.aDim[1]]*2)
# aLtCol = [np.dot(cPD, aDRI)*aArea[k] for k, cPD in enumerate(aPD)]
# aLtCol = np.array([max(aLtCol[k], aLtCol[k + 3]) for k in range(3)])
# aLtCol /= sum(aLtCol)
for i in reversed(range(self.nZ)):
tLZ = (i, self.nZ - i - 1)
for j in range(self.nY):
tLY = (j, self.nY - j - 1)
for k in range(self.nX):
tLX = (k, self.nX - k - 1)
tPMid = (-(nX // 2) * tD[0] + ((nX + 1) % 2) * tD[0] / 2. +
k * tD[0], -(nY // 2) * tD[1] +
((nY + 1) % 2) * tD[1] / 2. + j * tD[1],
tD[2] / 2. + i * tD[2])
pRSunl = Fkt.getLenNewCS(tPMid, aDRI)
lTT.append((pRSunl, tPMid, self.getTLayer(tLX, tLY, tLZ)))
self.getLAEdgeXtr([lTT[0][1], lTT[-1][1]])
lTT.sort(reverse=True)
for (i, (pRSunl, tPMid, tLC)) in enumerate(lTT):
self.lBkID.append((pRSunl, tLC))
self.dBk[tLC] = Block(self.dIA, self.aDim, self.tSigRays,
self.lAEdgeXtr, pRSunl, tPMid, tLC, i)
for keyBk in self.dBk:
self.updateBlock(keyBk)
def formPinchKnospen(self, dPrPKKt, tMnMx):
if self.fAct: # form Knospen
vN = Fkt.findRotAxis(self.vDirC, self.sZwTp, self.dIA['tolAngV'])
for iKKt in range(self.nKKt):
cAnKsAzm = self.lAnKAzm[iKKt] + self.offsAngAzm * self.iKtZw
tAn = Fkt.adjustAngPA(self.lAnKPlr[iKKt], cAnKsAzm)
self.lAnKPlr[iKKt], cAnKsAzm = tAn
vR = Fkt.rotatePt3D(self.vDirC, vN, self.lAnKPlr[iKKt])
vDKKt = Fkt.rotatePt3D(vR, self.vDirC, cAnKsAzm)
sDirN = Fkt.getSDir(self.sDir, vDKKt, vUz, self.dIA['tolAngV'])
self.lKKt.append(
Knospe(self.dIA, self.dITp, self.cMk, self.nKZw,
(self.IDKt, iKKt), self.pathID, iKKt, self.yrG,
self.ageB, self.ageZ, self.lenZ, self.pKC, self.pKR,
self.sDir, sDirN, self.vDirC, vDKKt))
self.lNumKs[1] += 1
self.pinchKnospen(dPrPKKt, tMnMx)
def pinchKnospen(self, dPrPKKt, tMnMx):
if self.ageZ <= 1: # pinch out Knospen
for cKKt in self.lKKt:
prPinch = Fkt.drawDst(dPrPKKt[self.sDir], self.cM, tMnMx)
if np.random.uniform() < prPinch:
cKKt.becomeInact()
self.lNumKs[0] += 1
self.lNumKs[1] -= 1
def decoratePlot(self, nF='Plot', pTitle=''):
plt.title(pTitle)
# plt.legend(loc = 'best')
plt.xlabel('x')
plt.ylabel('y')
# plt.zlabel('z')
plt.savefig(
Fkt.joinToPath(nF + self.dIA['nFEndPDF'], [self.dIA['nDPlots']]))
plt.close()
def growZweig(self, cLtPBk):
assert cLtPBk <= 1
if self.fGerm:
self.becomeInact()
dMnMx = self.dIA['dMinMax']
# draw a value for the length of this "Zweig"
lenZw = Fkt.drawVRel(self.dLenZw, self.nKZw, self.sDirN, self.cM,
dMnMx['LenZw'], dMnMx['NKZw'],
self.dFAd['LenZw'],
self.dITp['dDist']['NKZw'])
# adjust the "Zweig" length according to the available light
if self.dIA['lvlDbg'] > 0 and cLtPBk < 1:
print('lenZw (before):', lenZw,
'- current light propagated in block:', cLtPBk)
lenZw *= cLtPBk
if self.dIA['lvlDbg'] > 0:
print('lenZw (after):', lenZw)
# TODO - change
if lenZw < 10:
return 0
dInfo = {
'VertZ': self.cAnVZ,
'RelPZw': self.cAnRZ,
'RelPKt': self.pKR,
'LenZw': self.lenZ,
'AgeZw': 1,
'AgeBm': self.ageB
}
# draw a value for the number of "Knoten" on this "Zweig"
nKZw = Fkt.drawDict(self.dITp, dInfo, dMnMx, 'dDist', 'NKZw',
'dNumNKZw', 'dBndAr', 'dCtWt', self.sDirN,
self.cM)
# # adjust the number of "Knoten" according to the available light
# nKZw = max(1, round(nKZw*cLtPBk))
lFDstK = Fkt.drawLVRel(self.dFPKZw, nKZw, self.sDirN, self.cM,
dMnMx['FctPKZw'],
self.dITp['dDist']['NKZw'])
return Zweig(self.dIA, self.dITp, self.cMk, self.dFAd, self.dFPEZw,
self.dAnEPlr, self.dAnEAzm, self.IDKs, self.pathID,
self.yrG, self.ageB, self.pKC, self.sDirN,
self.vDirZw, self.vDir, self.cAnVZ, self.cAnRZ, lenZw,
lFDstK)
def verhalten(self, spieler):
durchqueren = fk.ja_nein_frage("Moechtest du das Moor auf die Gefahr zu versinken durchqueren?")
if durchqueren is True:
erfolg = spieler.fortschreiten(50, 1/2)
if erfolg is True:
spieler.geschicklichkeit +=2
print ("Du bist erfolgreich duch dieses Moor geschritten(+2 geschicklichkeit)")
elif erfolg is False:
spieler.sterben(3)
if durchqueren is False:
print ("Du kehrst um, weil du nicht riskieren moechtest vom Moor verschluckt zu werden")
return True
def verhalten(self, spieler):
durchqueren = fk.ja_nein_frage("Moechtest du durch den reißenden Fluss schwimmen?")
if durchqueren is True:
erfolg = spieler.fortschreiten(50, 1/2)
if erfolg is True:
spieler.geschicklichkeit +=2
print ("")
elif erfolg is False:
spieler.sterben(3)
if durchqueren is False:
print ("Du kehrst um, weil du nicht riskieren moechtest vom Moor verschluckt zu werden")
return True
def plotBlaetter(self, cAx):
lClrB, sPlWhich = self.dIA['lClrBltS1'], self.dIA['dPlot']['Blatt'][1]
mEW = self.dITp['wdEdgeBl']
if self.dIA['colSetBl'] == 'Autumn':
lClrB = self.dIA['lClrBltS2']
for cK in self.lK:
for cBt in cK.lBt:
if ((sPlWhich in ['All', 'Current'] and cBt.ageBt == 1) or
(sPlWhich in ['All', 'Previous'] and cBt.ageBt > 1)):
cCol = Fkt.getCol(lClrB, self.dIA['colModeBl'], cBt.ageBt)
mSz = np.average([cBt.lenBt, cBt.widBt])
mSz *= self.dITp['fMarkSzBl']
lX, lY, lZ = Fkt.getCCMidP(cBt.pS, cBt.vDirBt, cBt.lenBt)
cAx.plot(lX,
lY,
lZ,
linestyle='None',
marker='H',
ms=mSz,
markeredgewidth=mEW,
color=cCol)
def plotZweige(self, cAx):
fWdthZw, offsZWd = self.dIA['fWdthZw'], self.dIA['offsWdthZw']
lClrZw = self.dIA['lClrZweig']
for cK in self.lK:
for cZw in cK.lZw:
cLwd = cZw.ageZ * fWdthZw + offsZWd
cCol = Fkt.getCol(lClrZw, self.dIA['colModeZw'], cZw.ageZ)
cAx.plot(cZw.arrX,
cZw.arrY,
cZw.arrZ,
linestyle='solid',
linewidth=cLwd,
color=cCol)
def verhalten(self, spieler):
besteigen = fk.ja_nein_frage("Moechtest du die Berge ueberqueren?")
if besteigen is True:
erfolg = spieler.fortschreiten(15, 3/4)
if erfolg is True:
spieler.staerke += 0.5
print("Von der Spitze des Berges hast du eine wunderbare Aussicht.(+0,5 staerke)")
elif erfolg is False:
spieler.staerke -= 1.25
print ("Du bist abgestuerzt und verlierst, waehrend deiner Genesung staerke.(-1,25 staerke)")
elif besteigen is False:
print ("Da du die Berge nicht ueberqueren willst kehrst du um.")
return True
def getSegments(self, lenZw):
assert len(self.pS) == 3 and len(self.vDirC) == 3
if self.dIA['lvlDbg'] > 0 and (self.pS[2] < 0 or lenZw <= 0):
print('self.pS[2] =', self.pS[2], '/', 'lenZw =', lenZw)
assert self.pS[2] >= 0 and lenZw > 0
assert (len(self.lFDsE) == len(self.lAnEP)
and len(self.lAnEP) == len(self.lAnEA))
nE = len(self.lFDsE)
lDirSg, lPSgE = [V0_3D] * (nE + 1), [V0_3D] * (nE + 1)
lLenSg = [0.] * (nE + 1)
cAngChDr = Fkt.drawDst(self.dITp['dAngChDr'][self.sDir], self.cM,
self.dIA['dMinMax']['AngPol'])
lInpV = [
0,
np.array([cKS for cKS in self.pS]), self.vDirC, lenZw,
self.dITp['dPosZweig'][self.sDir], cAngChDr, self.dIA['tolAngV']
]
# lInpV: [pRC, pSC, vDC, lenC, cSPosZweig, cAngChDr, angTol]
Fkt.constructSeg(lDirSg, lPSgE, lLenSg, nE, lInpV, self.lFDsE,
self.lAnEP, self.lAnEA)
assert len(lDirSg) == len(lPSgE) and len(lDirSg) == len(lLenSg)
self.lDirSeg, self.lPSegE, self.lLenSeg = lDirSg, lPSgE, lLenSg
self.pE, self.lenZ = self.lPSegE[-1], sum(self.lLenSeg)
def __init__(self,
inpDat,
cMk,
iTp=1,
vS=P0,
yrGerm=0,
angPKm=0,
angAKm=0,
ageB=0,
lenKm=0):
descrB, cSPKtS, cSDrKtS = 'Keim', 'End', 'k'
IDK, iKZw, cPRKtS, lPathID = 0, 0, 0., []
self.dIA = inpDat.dI
self.dITp = inpDat.dI[iTp]
self.cMk = cMk
self.cM = self.dIA['Mode']
self.iT = iTp
self.tpB = self.dITp['strType']
self.specB = self.dITp['strNSpec']
self.descB = descrB
self.ageB = ageB
self.lenK = lenKm
self.pS = vS
self.yGerm = yrGerm
self.dPosZw = self.dITp['dPosZweig']
self.dPosBl = self.dITp['dPosBlatt']
self.lNumK = [0, 1, 1,
IDK] # num. inact., num. act., num. all, max. ID
self.dFAd = {cVar: 1. for cVar in self.dIA['dVDep']['lSRV_C']}
angPKm, angAKm = Fkt.adjustAngPA(angPKm, angAKm)
vDirP, vDirSl, ageZw = vUz, Fkt.convPolarToCart(1., angPKm, angAKm), -1
self.lK = [
Knoten(self.dIA, self.dITp, self.cMk, self.dFAd, IDK, lPathID,
iKZw, self.yGerm, self.ageB, ageZw, self.lenK, self.pS,
cPRKtS, cSPKtS, cSDrKtS, vDirP, vDirSl)
]
self.lIDZwPinch = []
def verhalten(self, spieler):
ueberquerung = fk.ja_nein_frage("Moechtest du die Schlucht durchklettern(ja/nein)")
if ueberquerung is True:
erfolg = spieler.fortschreiten(50, 3/4)
if erfolg is False:
spieler.sterben(2)
else:
print("Du hast die Schlucht erfolgreich durchklettert.(+2 geschicklichkeit)")
spieler.geschicklichkeit += 2
elif ueberquerung is False:
print("Du kehrst lieber um.")
return True
def spieler_erstellen():
name = input("Wie meochtest du heißen?")
geschlecht = ""
moegl_geschlechter = ("maennlich","weiblich","leo","zwitter")
while geschlecht not in moegl_geschlechter:
geschlecht = input("Welches Geschlecht bist du?(maennlich/weiblich)")
geschlecht = fk.text_anpassen(geschlecht)
geschicklichkeit = rd.randint(2,7)
staerke = rd.randint(2,7)
alter = rd.randint(17,42)
spieler = Klassen.Spieler(name,geschlecht,alter,geschicklichkeit,staerke)
print ("Hallo,",spieler.name," du bist",spieler.alter,"Jahre alt und",spieler.geschlecht)
return spieler
def verhalten(self, spieler):
durchqueren = fk.ja_nein_frage(
"Moechtest du durch den reißenden Fluss schwimmen?")
if durchqueren is True:
erfolg = spieler.fortschreiten(50, 1 / 2)
if erfolg is True:
spieler.geschicklichkeit += 2
print("")
elif erfolg is False:
spieler.sterben(3)
if durchqueren is False:
print(
"Du kehrst um, weil du nicht riskieren moechtest vom Moor verschluckt zu werden"
)
return True
def getIDSunNeighbours(self):
# print('self.lAEXtM =', self.lAEXtM, '- self.tSgR =', self.tSgR)
assert len(self.tSgR) == len(self.aDim)
self.lIDSunN, rgIDim = [], range(len(self.pM))
# self.lIDSunN = [() for _ in rgIDim]
lIDSunN = [[self.tLyr[k] for k in rgIDim]
for _ in range(len(self.tSgR))]
lPMidN = [
np.array([self.pM[k] for k in rgIDim])
for _ in range(len(self.tSgR))
]
for k in range(len(self.tSgR)):
lPMidN[k][k] -= self.tSgR[k] * self.aDim[k]
lIDSunN[k][k] -= 1
# print('lPMidN[', k, '] =', lPMidN[k], '- lIDSunN[', k, '] =', lIDSunN[k])
if Fkt.isInRange(self.lAEXtM, self.tSgR, lPMidN[k]):
self.lIDSunN.append((tuple(lIDSunN[k]), k))
def verhalten(self, spieler):
durchqueren = fk.ja_nein_frage(
"Moechtest du das Moor auf die Gefahr zu versinken durchqueren?")
if durchqueren is True:
erfolg = spieler.fortschreiten(50, 1 / 2)
if erfolg is True:
spieler.geschicklichkeit += 2
print(
"Du bist erfolgreich duch dieses Moor geschritten(+2 geschicklichkeit)"
)
elif erfolg is False:
spieler.sterben(3)
if durchqueren is False:
print(
"Du kehrst um, weil du nicht riskieren moechtest vom Moor verschluckt zu werden"
)
return True
def verhalten(self, spieler):
besteigen = fk.ja_nein_frage("Moechtest du die Berge ueberqueren?")
if besteigen is True:
erfolg = spieler.fortschreiten(15, 3 / 4)
if erfolg is True:
spieler.staerke += 0.5
print(
"Von der Spitze des Berges hast du eine wunderbare Aussicht.(+0,5 staerke)"
)
elif erfolg is False:
spieler.staerke -= 1.25
print(
"Du bist abgestuerzt und verlierst, waehrend deiner Genesung staerke.(-1,25 staerke)"
)
elif besteigen is False:
print("Da du die Berge nicht ueberqueren willst kehrst du um.")
return True
def getDZwCat(self, sCat='ageZ'):
dZwCat = {}
for cK in self.lK:
if len(cK.lZw) > 0:
for cZw in cK.lZw:
if sCat == 'ageZ':
Fkt.adToDictCount(dZwCat, cZw.ageZ)
elif sCat == 'ageB':
Fkt.adToDictCount(dZwCat, cZw.ageB)
elif sCat == 'yrG':
Fkt.adToDictCount(dZwCat, cZw.yrG)
return dZwCat
def verhalten(self, spieler):
ueberquerung = fk.ja_nein_frage(
"Moechtest du die Schlucht durchklettern(ja/nein)")
if ueberquerung is True:
erfolg = spieler.fortschreiten(50, 3 / 4)
if erfolg is False:
spieler.sterben(2)
else:
print(
"Du hast die Schlucht erfolgreich durchklettert.(+2 geschicklichkeit)"
)
spieler.geschicklichkeit += 2
elif ueberquerung is False:
print("Du kehrst lieber um.")
return True
def bewegen(self, richtung):
if richtung in Karte.richtungen:
bewegunsrichtung = Karte.richtungen[richtung]
neuerStandort = (
self.standort[0] + bewegunsrichtung[0],
self.standort[1] + bewegunsrichtung[1])
if fk.ob_in_karte(neuerStandort, Karte.KoordinatenGrenze) is True:
neuerStandort = self.standort
print("du Hast den Rand der Karte erreichst und kannst nicht mehr weitergehen")
return neuerStandort
else:
print("Es faellt mir schwer nach", richtung, " zu laufen. Moegliche Richtungen: nord, ost, sued, west")
return self.standort
self.erschoepfung += 1
def eqDstScaling(self, cAx):
dD = {'x': [0, None, None], 'y': [1, None, None], 'z': [2, None, None]}
for cB in self.lB:
for cKt in cB.lK:
Fkt.fillDictMinMax(dD, cKt.pKC)
for cZw in cKt.lZw:
Fkt.fillDictMinMax(dD, cZw.pS)
Fkt.fillDictMinMax(dD, cZw.pE)
cRg_2 = math.ceil(max([dD[cC][2] - dD[cC][1] for cC in dD]) / 2.)
dMid = {cC: (dD[cC][2] + dD[cC][1]) / 2. for cC in dD}
if cRg_2 > 0:
cAx.set_xlim3d(dMid['x'] - cRg_2, dMid['x'] + cRg_2)
cAx.set_ylim3d(dMid['y'] - cRg_2, dMid['y'] + cRg_2)
cAx.set_zlim3d(0, 2 * cRg_2)
def growKnoten(self, lKN, mxIDKt, iKN, cY):
for k in range(len(self.lKC)):
iKN += 1
dInfo = {
'VertZ': self.cAnVZ,
'RelPZw': self.cAnRZ,
'RelPKt': self.lFDsK[k],
'LenZw': self.lenZ,
'AgeZw': self.ageZ,
'AgeBm': self.ageB
}
nKKt = Fkt.drawDict(self.dITp, dInfo, self.dIA['dMinMax'], 'dDist',
'NKKt', 'dNumNKKt', 'dBndAr', 'dCtWt',
self.sDir, self.cM)
# print('Growing Knoten with ID', mxIDKt + iKN, '.')
lKN.append(
Knoten(self.dIA, self.dITp, self.cMk, self.dFAd, mxIDKt + iKN,
self.pathID + [self.IDZ], k, cY, self.ageB, self.ageZ,
self.lenZ, self.lKC[k], self.lFDsK[k],
self.lKPS[k], self.sDir, self.vDirP, self.lKVD[k],
len(self.vDsK), nKKt))
self.lKZw = [cKt for cKt in lKN[-len(self.lKC):]]
return iKN
# Für schnelles Umschalten der zu zeigenden Plots
y = True
n = False
a = n
b = n
c = n
d = n
e = n
if a:
x1 = np.linspace(-4, 4, 101)
x2 = np.linspace(-4, 4, 101)
X1, X2 = np.meshgrid(x1, x2)
rosenbrock = 100 * (X2 - X1**2)**2 + (1 - X1)**2
fu.plotte_Funktion_surf_contf(X1, X2, rosenbrock, "Rosenbrock")
if b:
x1 = np.linspace(-4, 4, 101)
x2 = np.linspace(-4, 4, 101)
X1, X2 = np.meshgrid(x1, x2)
himmelblau = (X1**2 + X2 - 11)**2 + (X1 + X2**2 - 7)**2
fu.plotte_Funktion_surf_contf(X1, X2, himmelblau, "Himmelblau")
if c:
x1 = np.linspace(-4, 4, 101)
x2 = np.linspace(-4, 4, 101)
X1, X2 = np.meshgrid(x1, x2)
bazaraa_shetty = (X1 - 2)**4 + (X1 - 2 * X2)**2
fu.plotte_Funktion_surf_contf(X1, X2, bazaraa_shetty, "bazaraa/shetty")
def addBlattData(self, dITp, cIDObj, cAObj=-1):
Fkt.adToDictCount(self.dNBt, dITp['iTp'])
Fkt.addToDictL(self.dIDBt, dITp['iTp'], cIDObj)
if cAObj >= 0:
Fkt.adToDictCount(self.dABt, dITp['iTp'], cAObj)
self.cABtLtC += cAObj * dITp['tPrpDLC'][0]
def main():
while True:
if spieler.lebend <= 0:
break
eingabe = input("Was willst du tun?")
eingabe = fk.text_anpassen(eingabe)
monsterliste = []
if spieler.leben < spieler.maximalesleben:
spieler.leben += 2
if eingabe.startswith("gehen"):
if eingabe == "gehen":
aktuelleRichtung = input("gehen? In welche Richtung(nord/ost/sued/west)")
elif eingabe.startswith("gehen "):
aktuelleRichtung = eingabe[6:]
else:
aktuelleRichtung = eingabe[5:]
if aktuelleRichtung == "himmel" or aktuelleRichtung == "hoelle":
spieler.sterben(0)
if spieler.lebend <= 0:
break
vorherigerstandort = spieler.standort
spieler.standort = spieler.bewegen(aktuelleRichtung)
print("Du bist jetzt: ", (spieler.wo().name))
bleiben = spieler.wo().verhalten(spieler)
if bleiben is True:
spieler.standort = vorherigerstandort
print("Dein Standort ist:",(spieler.wo().name))
else:
pass
monsterentstehung = rd.randint(0, 4)
if monsterentstehung <= 4:
monsterliste.append(((zombie_erstellen(monsterliste.__len__())).name)())
for monster in monsterliste:
monster.standort = monster.bewegen()
print(monsterliste.index(monster))
if monster.standort == spieler.standort:
print(
"Plötzlich taucht ein Gestalt auf, welche auf dich zugerannt kommt und anfängt dich zu attackieren.")
spieler.kaempfen(monster, monsterliste)
if eingabe.startswith("stop"):
beenden = fk.ja_nein_frage("Moechtest du das Spiel wirklich verlassen?")
if beenden is True:
print("Auf Wiedersehen.")
break
if eingabe.startswith("wo"):
print(spieler.wo().name)
print(spieler.wo().beschreibung)
if eingabe.startswith("help"):
print(
"Du kannst gehen, indem du 'gehen' und danach die Himmelsrichtung,in welche du gehen willst, schreibst.")
print("Mit dem Befehl 'wo' erfaerst du wo du bist.")
print(
"Und wenn du das Spiel verlassen moechtest schreibe einfach, wenn du gefragt wirst was du tun willst, 'stop'.")
