def __init__(self, data, TemplateManager, InputManager):
# DEVELOPMENT VERSION
self.version = "DEV 1.0"
# INPUT COLLECTOR
self.sysinput = InputManager()
# TEMPLATE BUILDER
self.template = TemplateManager()
# FULL DATABASE
self.database = deepcopy(data)
# CURRENT TIME
self.datetime = datetime.today().strftime("%d-%m-%Y")
self.calculate()
def __init__(self):
vsync = config.IS_VSYNC
if config.IS_FULLSCREEN:
self.__window = window.Window( fullscreen=True, vsync=vsync )
else:
width,height = config.WIN_SIZE
self.__window = window.Window( width=width, height=height, fullscreen=False, vsync=vsync )
self.__winSize = winSize = ( self.__window.width, self.__window.height )
self.__camera = Camera( winSize )
self.__hud = HUD( winSize )
self.__inputManager = InputManager()
self.__window.on_key_press = self.__inputManager.key_pressed
self.__window.on_key_release = self.__inputManager.key_released
if config.IS_FPS_LIMIT:
clock.set_fps_limit( FPS_LIMIT )
glDepthFunc( GL_LEQUAL )
glEnable( GL_DEPTH_TEST )
self.__world = GameWorld(self) # to musi być na końcu
def __init__(self):
vsync = config.IS_VSYNC
if config.IS_FULLSCREEN:
self.__window = window.Window(fullscreen=True, vsync=vsync)
else:
width, height = config.WIN_SIZE
self.__window = window.Window(width=width, height=height, fullscreen=False, vsync=vsync)
self.__winSize = winSize = (self.__window.width, self.__window.height)
self.__camera = Camera(winSize)
self.__hud = HUD(winSize)
self.__inputManager = InputManager()
self.__window.on_key_press = self.__inputManager.key_pressed
self.__window.on_key_release = self.__inputManager.key_released
if config.IS_FPS_LIMIT:
clock.set_fps_limit(FPS_LIMIT)
glDepthFunc(GL_LEQUAL)
glEnable(GL_DEPTH_TEST)
self.__world = GameWorld(self) # to musi być na końcu
if state:
print "\tdown is pushed"
if not state:
print "\tdown is released"
# SPACJA
print
state = subject.get_key_state("space")
if state:
print "\tspace is pushed"
if not state:
print "\tspace is released"
# Utworzenie InputManagera i włączenie go do pygleta
manager = InputManager()
window = Window()
window.on_key_press = manager.key_pressed
window.on_key_release = manager.key_released
# Tworzymy 3 obiekty obserwujące
ops1 = ConcreteInputObserver('ops1')
ops2 = ConcreteInputObserver('ops2')
ops3 = ConcreteInputObserver('ops3')
# dodajemy obserwatorów
manager.register_observer(ops1)
manager.register_observer(ops2)
manager.register_observer(ops3)
# usuwamy obserwatorów
class Main(object):
def __init__(self, data, TemplateManager, InputManager):
# DEVELOPMENT VERSION
self.version = "DEV 1.0"
# INPUT COLLECTOR
self.sysinput = InputManager()
# TEMPLATE BUILDER
self.template = TemplateManager()
# FULL DATABASE
self.database = deepcopy(data)
# CURRENT TIME
self.datetime = datetime.today().strftime("%d-%m-%Y")
self.calculate()
# PRINT SYSTEM DATA
def test(self):
print(json.dumps(self.database, indent=2))
# CLEAR CONSOLE
def clear_console(self):
os.system("clear")
# MAIN DECORATOR
def wrapper(func):
def wrap(self, *args, **kwargs):
self.clear_console()
func(self, *args, **kwargs)
self.calculate()
return wrap
# BUILD TEMPLATE
def build(self, type, export=False):
time = self.datetime
data = self.database["activities"]
temp = self.template.build(type, data, {
"time": time
})
if export:
fname = "Export/{0} {1}.txt".format(type, self.database["today"])
with open(fname, "w", encoding="utf-8") as txtfile:
txtfile.write(temp)
else:
print(temp)
# CALCULATE ACTIVITY TIME IN MINUTES
def calculate(self, index=-1):
activities = self.database["activities"]
arr_length = len(self.database["activities"])
if index <= -1:
for x in range(arr_length):
self.calculate(x)
else:
activity = activities[index]
# IF ITS NOT DONE, SKIP
if activity["status"] == "PEND":
return 0
start = datetime.strptime(activity["start"], "%H:%M")
stop = datetime.strptime(activity["stop"], "%H:%M")
# UPDATE EACH ACTICITY WITH ITS WORK TIME
activity["minutes"] = ( (abs(stop - start)).seconds / 60 )
return activity
# ADD NEW ACTIVITY
@wrapper
def add_activity(self):
activities = self.database["activities"]
activity = self.sysinput.get_activity()
activity.update({
"id": len(activities) + 1
})
activities.append(activity)
# CHANGE EXISTING ACTIVITY
def update_activity(self, activity_id, key, value):
activities = self.database["activities"]
for activity in activities:
if activity["id"] == activity_id:
activity[key] = value
# EXPORT DATA
@wrapper
def save_data(self):
with open("data.json", "w", encoding="utf-8") as jsonfile:
json.dump(self.database, jsonfile, ensure_ascii=False, indent=4)
class App(object):
def __init__(self):
vsync = config.IS_VSYNC
if config.IS_FULLSCREEN:
self.__window = window.Window(fullscreen=True, vsync=vsync)
else:
width, height = config.WIN_SIZE
self.__window = window.Window(width=width, height=height, fullscreen=False, vsync=vsync)
self.__winSize = winSize = (self.__window.width, self.__window.height)
self.__camera = Camera(winSize)
self.__hud = HUD(winSize)
self.__inputManager = InputManager()
self.__window.on_key_press = self.__inputManager.key_pressed
self.__window.on_key_release = self.__inputManager.key_released
if config.IS_FPS_LIMIT:
clock.set_fps_limit(FPS_LIMIT)
glDepthFunc(GL_LEQUAL)
glEnable(GL_DEPTH_TEST)
self.__world = GameWorld(self) # to musi być na końcu
def get_window_coords(self):
""" Zwraca współrzędne czworokąta, w którym można rysować. """
return self.__camera.windowCoords
def register_input_observer(self, obj):
self.__inputManager.register_observer(obj)
def get_window_dim(self):
""" Zwraca wymiary okna (szerokość, wysokość) """
return (float(self.__window.width), float(self.__window.height))
def get_window_draw_dim(self):
""" Zwraca współrzędne, w których należy rysować (szerokość, wysokość). """
return (1000.0, 750.0)
# return (800.0, 600.0)
def main_loop(self):
""" Pętla główna gry. """
self.__timeElapsed = 0.0 # czas jaki upłynął od początku gry
splash = Splash(self, self.__camera, config.SPLASH_DISPLAY_TIME)
while not self.__window.has_exit:
self.__window.dispatch_events()
# update świata i HUDa
dt = clock.tick() * config.DTIME_MULTIPLY
self.__timeElapsed += dt
if config.PRINT_FPS and dt > 0.001:
print "FPS:", 1.0 / dt
# ustaw kamerę
self.__camera.set3d()
# narysuj splash screen albo grę
if self.__timeElapsed < config.SPLASH_DISPLAY_TIME:
splash.update(dt)
splash.draw()
else:
self.__world.update(dt)
# self.__hud.update( dt )
# narysuj świat
self.__camera.set3d()
self.__world.draw()
# # narysuj HUD
# self.__camera.set2d()
# self.__hud.draw()
self.__window.flip()
class GameLogic(ShowBase):
def __init__(self,pandaBase):
self.pandaBase = pandaBase
self.pandaBase.enableParticles()
self.accept("DemarrerPartie",self.startGame)
#Vérifier si la connexion à la base de donnée est bien établite
try:
# CREE LE DAO ET LE DTO
self.leDao = DAO_B_Oracle("e1529743","AAAaaa111","delta/decinfo.edu")
self.leDto = self.leDao.lire()
self.leDto.verifier()
self.leDao.deconnection()
except:
self.leDto = DTOdefault()
ctypes.windll.user32.MessageBoxA(0, "Erreur lors de la connexion a la base de donnee. Les valeurs par defaut sont utilisees !", "Valeurs par defaut", 0)
def setup(self,niveau):
self.setupBulletPhysics()
self.setupCamera()
self.setupMap(niveau)
self.setupLightAndShadow()
#Création d'une carte de base
#self.carte.creerCarteParDefaut()
if (niveau != "quick"):
print("hasard")
self.map.construireMapDto()
else:
self.map.construireMapHasard()
#A besoin des éléments de la map
self.setupControle()
self.setupInterface()
#Fonction d'optimisation
#DOIVENT ÊTRE APPELÉE APRÈS LA CRÉATION DE LA CARTE
#Ça va prendre les modèles qui ne bougent pas et en faire un seul gros
#en faisant un seul gros noeud avec
self.map.figeObjetImmobile()
#DEBUG: Décommenter pour affiche la hiérarchie
#self.pandaBase.startDirect()
messenger.send("ChargementTermine")
def startGame(self,niveau):
self.setup(niveau)
print (niveau)
#On démarrer l'effet du compte à rebour.
#La fonction callBackDebutPartie sera appelée à la fin
self.interfaceMessage.effectCountDownStart(self.leDto.mess_countdown_time[2],self.callBackDebutPartie)
#self.row[2], row[3]interfaceMessage.effectMessageGeneral(self.leDto.mess_accueil_content[1],self.leDto.mess_accueil_time[2])
def setupBulletPhysics(self):
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.mondePhysique = BulletWorld()
self.mondePhysique.setGravity(Vec3(0, 0, -9.81))
self.mondePhysique.setDebugNode(self.debugNP.node())
taskMgr.add(self.updatePhysics, "updatePhysics")
taskMgr.add(self.updateCarte, "updateCarte")
def setupCamera(self):
#On doit désactiver le contrôle par défaut de la caméra autrement on ne peut pas la positionner et l'orienter
self.pandaBase.disableMouse()
#Le flag pour savoir si la souris est activée ou non n'est pas accessible
#Petit fail de Panda3D
taskMgr.add(self.updateCamera, "updateCamera")
self.setupTransformCamera()
def setupTransformCamera(self):
#Défini la position et l'orientation de la caméra
self.positionBaseCamera = Vec3(0,-18,32)
camera.setPos(self.positionBaseCamera)
#On dit à la caméra de regarder l'origine (point 0,0,0)
camera.lookAt(render)
def setupMap(self,niveau):
self.map = Map(self.mondePhysique, self.leDto, niveau)
#On construire la carte comme une coquille, de l'extérieur à l'intérieur
#Décor et ciel
self.map.construireDecor(camera)
#Plancher de la carte
self.map.construirePlancher()
#Murs et éléments de la map
def setupLightAndShadow(self):
#Lumière du skybox
plight = PointLight('Lumiere ponctuelle')
plight.setColor(VBase4(1,1,1,1))
plnp = render.attachNewNode(plight)
plnp.setPos(0,0,0)
camera.setLight(plnp)
#Simule le soleil avec un angle
dlight = DirectionalLight('Lumiere Directionnelle')
dlight.setColor(VBase4(0.8, 0.8, 0.6, 1))
dlight.get_lens().set_fov(75)
dlight.get_lens().set_near_far(0.1, 60)
dlight.get_lens().set_film_size(30,30)
dlnp = render.attachNewNode(dlight)
dlnp.setPos(Vec3(-2,-2,7))
dlnp.lookAt(render)
render.setLight(dlnp)
#Lumière ambiante
alight = AmbientLight('Lumiere ambiante')
alight.setColor(VBase4(0.25, 0.25, 0.25, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
#Ne pas modifier la valeur 1024 sous peine d'avoir un jeu laid ou qui lag
dlight.setShadowCaster(True, 1024,1024)
#On doit activer l'ombre sur les modèles
render.setShaderAuto()
def setupControle(self,):
#Créer le contrôle
#A besoin de la liste de tank pour relayer correctement le contrôle
self.inputManager = InputManager(self.map.listTank,self.debugNP,self.pandaBase)
self.accept("initCam",self.setupTransformCamera)
def setupInterface(self):
self.interfaceTank = []
self.interfaceTank.append(InterfaceTank(0,self.map.listTank[0].couleur))
self.interfaceTank.append(InterfaceTank(1,self.map.listTank[1].couleur))
self.interfaceMessage = InterfaceMessage(self.leDto)
def callBackDebutPartie(self):
#Quand le message d'introduction est terminé, on permet aux tanks de bouger
self.inputManager.debuterControle()
#Mise à jour du moteur de physique
def updateCamera(self,task):
#On ne touche pas à la caméra si on est en mode debug
if(self.inputManager.mouseEnabled):
return task.cont
vecTotal = Vec3(0,0,0)
distanceRatio = 1.0
if (len(self.map.listTank) != 0):
for tank in self.map.listTank:
vecTotal += tank.noeudPhysique.getPos()
vecTotal = vecTotal/len(self.map.listTank)
vecTotal.setZ(0)
camera.setPos(vecTotal + self.positionBaseCamera)
return task.cont
#Mise à jour du moteur de physique
def updatePhysics(self,task):
dt = globalClock.getDt()
messenger.send("appliquerForce")
self.mondePhysique.doPhysics(dt)
#print(len(self.mondePhysique.getManifolds()))
#Analyse de toutes les collisions
for entrelacement in self.mondePhysique.getManifolds():
node0 = entrelacement.getNode0()
node1 = entrelacement.getNode1()
self.map.traiterCollision(node0, node1)
return task.cont
def updateCarte(self,task):
#print task.time
self.map.update(task.time)
return task.cont
def setupControle(self,):
#Créer le contrôle
#A besoin de la liste de tank pour relayer correctement le contrôle
self.inputManager = InputManager(self.map.listTank,self.debugNP,self.pandaBase)
self.accept("initCam",self.setupTransformCamera)
state = subject.get_key_state("down");
if state:
print "\tdown is pushed"
if not state:
print "\tdown is released"
# SPACJA
print
state = subject.get_key_state("space");
if state:
print "\tspace is pushed"
if not state:
print "\tspace is released"
# Utworzenie InputManagera i włączenie go do pygleta
manager = InputManager()
window = Window()
window.on_key_press = manager.key_pressed
window.on_key_release = manager.key_released
# Tworzymy 3 obiekty obserwujące
ops1 = ConcreteInputObserver('ops1')
ops2 = ConcreteInputObserver('ops2')
ops3 = ConcreteInputObserver('ops3')
# dodajemy obserwatorów
manager.register_observer(ops1)
manager.register_observer(ops2)
manager.register_observer(ops3)
# usuwamy obserwatorów
class GameLogic(ShowBase):
def __init__(self, pandaBase):
#######################AJOUTER #########################################################
self.pandaBase = pandaBase
self.accept("DemarrerPartie", self.startGame)
self.unDTO = DTOBalance()
self.setupBalance()
self.attribueurBonus = AttributionBonus()
self.accept("MortJoueur", self.finDePartie)
self.accept("AjoutFavori", self.ajoutFavori)
self.accept("updateArmurie", self.updateArmurie)
self.accept("escape", exit)
def finDePartie(self, idPerdant):
self.tempsFin = time.time()
tempsPartie = self.tempsFin - self.tempsDebut
for tank in self.map.listTank:
if tank.identifiant != idPerdant:
vieGagnant = tank.pointDeVie
vieMax = tank.pointDeVieMax
vieJoueur100 = 100 * vieGagnant / vieMax
idGagnant = tank.identifiant
#Ajout des bonus
if idGagnant == 0:
idJoueurGagnant = self.leDTOUsers.getIdUser(self.username1)
idJoueurPerdant = self.leDTOUsers.getIdUser(self.username2)
messenger.send(
"AttribuerBonus",
[idJoueurGagnant, self.username1, vieJoueur100, tempsPartie])
else:
idJoueurGagnant = self.leDTOUsers.getIdUser(self.username2)
idJoueurPerdant = self.leDTOUsers.getIdUser(self.username1)
messenger.send(
"AttribuerBonus",
[idJoueurGagnant, self.username2, vieJoueur100, tempsPartie])
self.map.DTOStat.definitionGagnant(idJoueurGagnant)
####Ajout nb fois jouer
if self.idNiveau != 000:
self.unDAOUser = DAOOracleUsers()
self.unDAOUser.updateNbFoisNivJouer(idJoueurGagnant, self.idNiveau)
self.unDAOUser.updateNbFoisNivJouer(idJoueurPerdant, self.idNiveau)
self.DAOStats.ecrireStatsFinPartie()
def updateArmurie(self, listeInfo):
print listeInfo
self.unDAOUser = DAOOracleUsers()
for info in listeInfo:
self.unDAOUser.updateNbArmes(info[0], info[1])
print "un update!"
def setup(self):
self.setupBulletPhysics()
self.setupCamera()
self.setupMap()
self.setupLightAndShadow()
#Création d'une carte de base
if self.idNiveau == 000:
self.map.construireMapHasard()
else:
self.map.creerCarteParDefaut()
#A besoin des éléments de la map
self.setupControle()
self.setupInterface()
#Fonction d'optimisation
#DOIVENT ÊTRE APPELÉE APRÈS LA CRÉATION DE LA CARTE
#Ça va prendre les modèles qui ne bougent pas et en faire un seul gros
#en faisant un seul gros noeud avec
self.map.figeObjetImmobile()
#DEBUG: Décommenter pour affiche la hiérarchie
#self.pandaBase.startDirect()
messenger.send("ChargementTermine")
def startGame(self, idNiveau, leDTOMap, leDTOUsers, username1, username2,
listeArmes):
self.listeArmes = listeArmes
self.username1 = username1
self.username2 = username2
self.idNiveau = idNiveau
self.leDTOMap = leDTOMap
self.leDTOUsers = leDTOUsers
self.tempsDebut = time.time()
self.setup()
self.DAOStats = DAOStatistiques(self.map.DTOStat)
self.DAOStats.ecrireInfosDebutPartie()
#On démarrer l'effet du compte à rebour.
#La fonction callBackDebutPartie sera appelée à la fin
self.interfaceMessage.effectCountDownStart(
self.unDTO.getValue("messageCompteRebour"),
self.callBackDebutPartie)
self.interfaceMessage.effectMessageGeneral(
self.unDTO.getValue("messageAccueilContenu"),
self.unDTO.getValue("messageAccueilDuree"))
def setupBulletPhysics(self):
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.mondePhysique = BulletWorld()
self.mondePhysique.setGravity(Vec3(0, 0, -9.81))
self.mondePhysique.setDebugNode(self.debugNP.node())
taskMgr.add(self.updatePhysics, "updatePhysics")
taskMgr.add(self.updateCarte, "updateCarte")
def setupCamera(self):
#On doit désactiver le contrôle par défaut de la caméra autrement on ne peut pas la positionner et l'orienter
self.pandaBase.disableMouse()
#Le flag pour savoir si la souris est activée ou non n'est pas accessible
#Petit fail de Panda3D
taskMgr.add(self.updateCamera, "updateCamera")
self.setupTransformCamera()
def setupTransformCamera(self):
#Défini la position et l'orientation de la caméra
self.positionBaseCamera = Vec3(0, -18, 32)
camera.setPos(self.positionBaseCamera)
#On dit à la caméra de regarder l'origine (point 0,0,0)
camera.lookAt(render)
def setupMap(self):
self.map = Map(self, self.mondePhysique, self.idNiveau, self.leDTOMap,
self.leDTOUsers, self.username1, self.username2,
self.listeArmes)
#On construire la carte comme une coquille, de l'extérieur à l'intérieur
#Décor et ciel
self.map.construireDecor(camera)
#Plancher de la carte
self.map.construirePlancher()
#Murs et éléments de la map
def setupLightAndShadow(self):
#Lumière du skybox
plight = PointLight('Lumiere ponctuelle')
plight.setColor(VBase4(1, 1, 1, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(0, 0, 0)
camera.setLight(plnp)
#Simule le soleil avec un angle
dlight = DirectionalLight('Lumiere Directionnelle')
dlight.setColor(VBase4(0.8, 0.8, 0.6, 1))
dlight.get_lens().set_fov(75)
dlight.get_lens().set_near_far(0.1, 60)
dlight.get_lens().set_film_size(30, 30)
dlnp = render.attachNewNode(dlight)
dlnp.setPos(Vec3(-2, -2, 7))
dlnp.lookAt(render)
render.setLight(dlnp)
#Lumière ambiante
alight = AmbientLight('Lumiere ambiante')
alight.setColor(VBase4(0.25, 0.25, 0.25, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
#Ne pas modifier la valeur 1024 sous peine d'avoir un jeu laid ou qui lag
dlight.setShadowCaster(True, 1024, 1024)
#On doit activer l'ombre sur les modèles
render.setShaderAuto()
def setupControle(self, ):
#Créer le contrôle
#A besoin de la liste de tank pour relayer correctement le contrôle
self.inputManager = InputManager(self.map.listTank, self.debugNP,
self.pandaBase)
self.accept("initCam", self.setupTransformCamera)
def setupInterface(self):
self.interfaceTank = []
self.interfaceTank.append(
InterfaceTank(0, self.map.listTank[0].couleur))
self.interfaceTank.append(
InterfaceTank(1, self.map.listTank[1].couleur))
self.interfaceMessage = InterfaceMessage(self)
def callBackDebutPartie(self):
#Quand le message d'introduction est terminé, on permet aux tanks de bouger
self.inputManager.debuterControle()
#Mise à jour du moteur de physique
def updateCamera(self, task):
#On ne touche pas à la caméra si on est en mode debug
if (self.inputManager.mouseEnabled):
return task.cont
vecTotal = Vec3(0, 0, 0)
distanceRatio = 1.0
if (len(self.map.listTank) != 0):
for tank in self.map.listTank:
vecTotal += tank.noeudPhysique.getPos()
vecTotal = vecTotal / len(self.map.listTank)
vecTotal.setZ(0)
camera.setPos(vecTotal + self.positionBaseCamera)
return task.cont
#Mise à jour du moteur de physique
def updatePhysics(self, task):
dt = globalClock.getDt()
messenger.send("appliquerForce")
self.mondePhysique.doPhysics(dt)
#print(len(self.mondePhysique.getManifolds()))
#Analyse de toutes les collisions
for entrelacement in self.mondePhysique.getManifolds():
node0 = entrelacement.getNode0()
node1 = entrelacement.getNode1()
self.map.traiterCollision(node0, node1)
return task.cont
def updateCarte(self, task):
self.map.update(task.time)
return task.cont
def setupBalance(self):
unDAO = DAOOracleBalance()
if Connexion().getCurseur() != None:
self.unDTO = unDAO.read()
def ajoutFavori(self, identifiant):
self.unDAOUser = DAOOracleUsers()
if identifiant == 0:
idJoueur = self.leDTOUsers.getIdUser(self.username1)
else:
idJoueur = self.leDTOUsers.getIdUser(self.username2)
self.unDAOUser.ajoutAuFavori(self.idNiveau, idJoueur)
def exit(self):
Connexion.seDeconnecter()
exit()
class GameLogic(ShowBase):
def __init__(self, pandaBase):
self.pandaBase = pandaBase
self.pandaBase.enableParticles()
self.accept("DemarrerPartie", self.startGame)
self.accept("DemarrerMenuNiveau", self.startMenu)
self.accept("DemarrerConnexion", self.startConnexion)
self.accept("tankElimine", self.gameOver)
self.accept("DemarrerPageFinPartie", self.pageFinPartie)
def pageFinPartie(self):
self.dao = DAO_Oracle()
# on affiche les résultats de fin de partie seulement si la connexion oracle fonctionne
if self.dao.getConnexionState():
self.pageFinPartie = InterfaceFinPartie()
def gameOver(self, idPerdant):
# si la connexion oracle fonctionone, on insère les données dans la bd
dao = DAO_Oracle()
if dao.getConnexionState():
#mettre l'état du joueur gagnant à Vrai
if idPerdant == 0:
indexGagnant = 1 # joueur 2 a gagné
elif idPerdant == 1:
indexGagnant = 0 # joueur 1 a gagné
DTO.joueurs[indexGagnant].vainqueur = True
# ajuster les niveaux des deux joueurs
analyse = AnalyseDTOJoueur()
# for i in range(2):
tanks = self.map.listTank
#ajouter les expériences pour joueur 1
levelUp1 = DTO.joueurs[0].updateExperience(tanks[0], tanks[1])
#ajouter les expériences pour joueur 2
ancienLevel = DTO.joueurs[1].calculerLevel()
DTO.joueurs[1].updateExperience(tanks[1], tanks[0])
nouveauLevel = DTO.joueurs[1].calculerLevel()
if (nouveauLevel > ancienLevel):
levelUp = True
#ajouter les statistiques d'armes au DTO
for i in range(len(self.map.listTank)):
DTO.joueurs[i].tank = self.map.listTank[i]
# ajouter la date de fin de partie
now = datetime.datetime.now()
DTO.finPartie = datetime.datetime.now()
self.dao = DAO_Oracle()
self.dao.envoyerStatistiques()
# après que tous les nouvelles statistiques sont calculées et/ou envoyées
# on affiche les résultats de la partie
messenger.send("DemarrerPageFinPartie")
# sinon, on ne fait qu'afficher le nom du joueur gagnant
else:
pass
def setup(self):
self.setupBulletPhysics()
self.setupCamera()
self.setupMap()
self.setupLightAndShadow()
#Création d'une carte de base
#self.carte.creerCarteParDefaut()
if DTO.mapSelectionne == None:
self.map.construireMapHasard()
else:
self.map.construireMapChoisi()
# le temps de début de partie
now = datetime.datetime.now()
DTO.debutPartie = now
#A besoin des éléments de la map
self.setupControle()
self.setupInterface()
#Fonction d'optimisation
#DOIVENT ÊTRE APPELÉE APRÈS LA CRÉATION DE LA CARTE
#Ça va prendre les modèles qui ne bougent pas et en faire un seul gros
#en faisant un seul gros noeud avec
self.map.figeObjetImmobile()
#DEBUG: Décommenter pour affiche la hiérarchie
#self.pandaBase.startDirect()
messenger.send("ChargementTermine")
def startGame(self):
# self.menu.run()
self.setup()
#On démarrer l'effet du compte à rebour.
#La fonction callBackDebutPartie sera appelée à la fin
self.interfaceMessage.effectCountDownStart(3, self.callBackDebutPartie)
self.interfaceMessage.effectMessageGeneral(
"Appuyer sur F1 pour l'aide", 3)
def startMenu(self):
self.menu = InterfaceMenuNiveaux()
def startConnexion(self):
self.menuConnexion = InterfaceConnexion()
def setupBulletPhysics(self):
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.mondePhysique = BulletWorld()
self.mondePhysique.setGravity(Vec3(0, 0, -9.81))
self.mondePhysique.setDebugNode(self.debugNP.node())
taskMgr.add(self.updatePhysics, "updatePhysics")
taskMgr.add(self.updateCarte, "updateCarte")
def setupCamera(self):
#On doit désactiver le contrôle par défaut de la caméra autrement on ne peut pas la positionner et l'orienter
self.pandaBase.disableMouse()
#Le flag pour savoir si la souris est activée ou non n'est pas accessible
#Petit fail de Panda3D
taskMgr.add(self.updateCamera, "updateCamera")
self.setupTransformCamera()
def setupTransformCamera(self):
#Défini la position et l'orientation de la caméra
self.positionBaseCamera = Vec3(0, -18, 32)
camera.setPos(self.positionBaseCamera)
#On dit à la caméra de regarder l'origine (point 0,0,0)
camera.lookAt(render)
def setupMap(self):
self.map = Map(self.mondePhysique)
#On construire la carte comme une coquille, de l'extérieur à l'intérieur
#Décor et ciel
self.map.construireDecor(camera)
#Plancher de la carte
self.map.construirePlancher()
#Murs et éléments de la map
def setupLightAndShadow(self):
#Lumière du skybox
plight = PointLight('Lumiere ponctuelle')
plight.setColor(VBase4(1, 1, 1, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(0, 0, 0)
camera.setLight(plnp)
#Simule le soleil avec un angle
dlight = DirectionalLight('Lumiere Directionnelle')
dlight.setColor(VBase4(0.8, 0.8, 0.6, 1))
dlight.get_lens().set_fov(75)
dlight.get_lens().set_near_far(0.1, 60)
dlight.get_lens().set_film_size(30, 30)
dlnp = render.attachNewNode(dlight)
dlnp.setPos(Vec3(-2, -2, 7))
dlnp.lookAt(render)
render.setLight(dlnp)
#Lumière ambiante
alight = AmbientLight('Lumiere ambiante')
alight.setColor(VBase4(0.25, 0.25, 0.25, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
#Ne pas modifier la valeur 1024 sous peine d'avoir un jeu laid ou qui lag
dlight.setShadowCaster(True, 1024, 1024)
#On doit activer l'ombre sur les modèles
render.setShaderAuto()
def setupControle(self, ):
#Créer le contrôle
#A besoin de la liste de tank pour relayer correctement le contrôle
self.inputManager = InputManager(self.map.listTank, self.debugNP,
self.pandaBase)
self.accept("initCam", self.setupTransformCamera)
def setupInterface(self):
self.interfaceTank = []
self.interfaceTank.append(
InterfaceTank(0, self.map.listTank[0].couleur))
self.interfaceTank.append(
InterfaceTank(1, self.map.listTank[1].couleur))
self.interfaceMessage = InterfaceMessage()
def callBackDebutPartie(self):
#Quand le message d'introduction est terminé, on permet aux tanks de bouger
self.inputManager.debuterControle()
#Mise à jour du moteur de physique
def updateCamera(self, task):
#On ne touche pas à la caméra si on est en mode debug
if (self.inputManager.mouseEnabled):
return task.cont
vecTotal = Vec3(0, 0, 0)
distanceRatio = 1.0
if (len(self.map.listTank) != 0):
for tank in self.map.listTank:
vecTotal += tank.noeudPhysique.getPos()
vecTotal = vecTotal / len(self.map.listTank)
vecTotal.setZ(0)
camera.setPos(vecTotal + self.positionBaseCamera)
return task.cont
#Mise à jour du moteur de physique
def updatePhysics(self, task):
dt = globalClock.getDt()
messenger.send("appliquerForce")
self.mondePhysique.doPhysics(dt)
#Analyse de toutes les collisions
for entrelacement in self.mondePhysique.getManifolds():
node0 = entrelacement.getNode0()
node1 = entrelacement.getNode1()
self.map.traiterCollision(node0, node1)
return task.cont
def updateCarte(self, task):
self.map.update(task.time)
return task.cont
class App(object):
def __init__(self):
vsync = config.IS_VSYNC
if config.IS_FULLSCREEN:
self.__window = window.Window( fullscreen=True, vsync=vsync )
else:
width,height = config.WIN_SIZE
self.__window = window.Window( width=width, height=height, fullscreen=False, vsync=vsync )
self.__winSize = winSize = ( self.__window.width, self.__window.height )
self.__camera = Camera( winSize )
self.__hud = HUD( winSize )
self.__inputManager = InputManager()
self.__window.on_key_press = self.__inputManager.key_pressed
self.__window.on_key_release = self.__inputManager.key_released
if config.IS_FPS_LIMIT:
clock.set_fps_limit( FPS_LIMIT )
glDepthFunc( GL_LEQUAL )
glEnable( GL_DEPTH_TEST )
self.__world = GameWorld(self) # to musi być na końcu
def get_window_coords(self):
''' Zwraca współrzędne czworokąta, w którym można rysować. '''
return self.__camera.windowCoords
def register_input_observer(self, obj):
self.__inputManager.register_observer(obj)
def get_window_dim(self):
''' Zwraca wymiary okna (szerokość, wysokość) '''
return (float(self.__window.width), float(self.__window.height))
def get_window_draw_dim(self):
''' Zwraca współrzędne, w których należy rysować (szerokość, wysokość). '''
return (1000.0, 750.0)
# return (800.0, 600.0)
def main_loop(self):
''' Pętla główna gry. '''
self.__timeElapsed = 0.0 # czas jaki upłynął od początku gry
splash = Splash(self, self.__camera, config.SPLASH_DISPLAY_TIME)
while not self.__window.has_exit:
self.__window.dispatch_events()
# update świata i HUDa
dt = clock.tick() * config.DTIME_MULTIPLY
self.__timeElapsed += dt
if config.PRINT_FPS and dt>0.001:
print "FPS:", 1.0/dt
# ustaw kamerę
self.__camera.set3d()
# narysuj splash screen albo grę
if self.__timeElapsed < config.SPLASH_DISPLAY_TIME:
splash.update(dt)
splash.draw()
else:
self.__world.update( dt )
# self.__hud.update( dt )
# narysuj świat
self.__camera.set3d()
self.__world.draw()
# # narysuj HUD
# self.__camera.set2d()
# self.__hud.draw()
self.__window.flip()
import pygame
from inputManager import InputManager
from gameObject import game_objects, GameObject, add
from map.canvas import Background
from map.matrixMap import generate_map
from point import Point
from boxes import Boxes
from createPlayer import createplayer, playerL
from createBoxes import createBoxes, bs
from createLines import createLines, lines
# 0. setup game
inputManager = InputManager()
# bg = Background()
# add(bg)
# player = Player(inputManager)
createplayer(inputManager)
point = Point()
add(point)
# add(player)
createBoxes()
createLines()
generate_map("assets/maps/map2.json")
# 1. Init pygame
pygame.init()
# 2. Set screen
SIZE = (32 * 25, 20 * 32)
canvas = pygame.display.set_mode(SIZE)
pygame.display.set_caption('Hello baibe')
# 3. Clock
