Soya/Python base 5

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
# -*- indent-tabs-mode: t -*-

# Soya 3D tutorial
# Copyright (C) 2004 Jean-Baptiste LAMY
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA


# basic-5: Event management : un controle de la chenille controllé par le clavier

# Dans cette leçon notre chenille va nous obéir !
# Vous allez apprendre comment utiliser les évenements de SDL avec Soya.
# Utilisez les touches directionelles pour contrôler la chenille.


# Importation des modules de Soya.
# Le module soya.sdlconst contient toutes les constantes de SDL.

import sys, os, os.path, soya, soya.sdlconst

soya.init()
soya.path.append(os.path.join(os.path.dirname(sys.argv[0]), "data"))

# Création de la scene.

scene = soya.World()


# La classe CaterpillarHead est similaire à la classe CaterpillarHead de la précédente leçon.

class CaterpillarHead(soya.Body):
        def __init__(self, parent):
                soya.Body.__init__(self, parent, soya.Model.get("caterpillar_head"))
                self.speed                  = soya.Vector(self, 0.0, 0.0, 0.0)
                self.rotation_y_speed = 0.0
                
        def begin_round(self):
                soya.Body.begin_round(self)
                
                # Boucle de tous les évenements Soya / SDL.
                # Chaque évenement est un tuple ; la première valeur indique les types d'évènements
                # et les autres valeurs dépendant du type. Les évenements existants sont :
                #  - (KEYDOWN, keysym, modifier) où keysym est un code de touche (une constante K_*)
                #    et un modifieur est un drapeau combinant plusieurs constantes MOD_* (pour tester la présence du
                #    modifieur, do e.g. for left shift: modifier & soya.sdlconst.MOD_LSHIFT).
                #  - (KEYUP, keysym, modifier)
                #  - (MOUSEMOTION, x, y, xrel, yrel) où x et y sont les coordonnées de la souris (en pixels)
                #    , xrel et yrel sont des coordonnées relatives de la souris (la différence entre le prochain évenement).
                #  - (MOUSEBUTTONDOWN, button, x, y) où button est le numéro de bouton de souris et x et y sont les coordonnées de la souris.
                #    Les numéros de boutons de la souris sont :
                #    - 1 : gauche
                #    - 2 : milieu
                #    - 3 : droite
                #    - 4 : molette haut
                #    - 5 : molette bas
                #  - (MOUSEBUTTONUP, button, x, y)
                #  - (JOYAXISMOTION, axis, value) XXX
                #  - (JOYBUTTONDOWN, button) XXX
                #  - (VIDEORESIZE, new_width, new_height)
                
                for event in soya.process_event():
                        
                        # Verification des touches préssées.
                        
                        if event[0] == soya.sdlconst.KEYDOWN:
                                
                                # Les flèches du haut et du bas met la vitesse (speed) de la chenille à une valeur positive ou négative.
                                
                                if   event[1] == soya.sdlconst.K_UP:     self.speed.z = -0.2
                                elif event[1] == soya.sdlconst.K_DOWN:   self.speed.z =  0.1
                                
                                # Les flèches gauche et droite modifient la vitesse de rotation.
                                
                                elif event[1] == soya.sdlconst.K_LEFT:   self.rotation_y_speed =  10.0
                                elif event[1] == soya.sdlconst.K_RIGHT:  self.rotation_y_speed = -10.0
                                
                                # En appuyant sur échap ou 'q'la boucle principale main_loop sera quittée, et termine ainsi le programme
                                # soya.MAIN_LOOP.stop() est la bonne manière de terminer l'application, et cause
                                # le retournement de la méthode MainLoop.main_loop().
                                
                                elif event[1] == soya.sdlconst.K_q:      soya.MAIN_LOOP.stop()
                                elif event[1] == soya.sdlconst.K_ESCAPE: soya.MAIN_LOOP.stop()
                                
                        # On regarde les touches qui ne sont pas appuiées.
                        
                        elif event[0] == soya.sdlconst.KEYUP:
                                
                                # Quand les touches haut ou bas sont libérés, la vitesse (speed) est remise à zero.
                                
                                if   event[1] == soya.sdlconst.K_UP:     self.speed.z = 0.0
                                elif event[1] == soya.sdlconst.K_DOWN:   self.speed.z = 0.0
                                
                                # Quand les flèches gauche et droite sont libérés, la vitesse de rotation est mise à zero.
                                
                                elif event[1] == soya.sdlconst.K_LEFT:   self.rotation_y_speed = 0.0
                                elif event[1] == soya.sdlconst.K_RIGHT:  self.rotation_y_speed = 0.0

                        elif event[0] == soya.sdlconst.QUIT:
                                soya.MAIN_LOOP.stop()
                                
                # On fait la rotation.
                
                self.rotate_y(self.rotation_y_speed)
                
        def advance_time(self, proportion):
                soya.Body.advance_time(self, proportion)
                self.add_mul_vector(proportion, self.speed)


# La classe CaterpillarPiece n'a pas changé depuis le dernier tutorial.

class CaterpillarPiece(soya.Body):
        def __init__(self, parent, previous):
                soya.Body.__init__(self, parent, soya.Model.get("caterpillar"))
                self.previous = previous
                self.speed = soya.Vector(self, 0.0, 0.0, -0.2)
                
        def begin_round(self):
                soya.Body.begin_round(self)
                self.look_at(self.previous)
                if self.distance_to(self.previous) < 1.5: self.speed.z =  0.0
                else:                                     self.speed.z = -0.2
                
        def advance_time(self, proportion):
                soya.Body.advance_time(self, proportion)
                self.add_mul_vector(proportion, self.speed)
                

# Création de la tête de la chenille et de 10 pièces de son corps.

caterpillar_head = CaterpillarHead(scene)
caterpillar_head.rotate_y(90.0)

previous_caterpillar_piece = caterpillar_head
for i in range(10):
        previous_caterpillar_piece = CaterpillarPiece(scene, previous_caterpillar_piece)
        previous_caterpillar_piece.x = i + 1
        
# Création de la lampe.

light = soya.Light(scene)
light.set_xyz(2.0, 5.0, 0.0)

# Création de la caméra.

camera = soya.Camera(scene)
camera.set_xyz(0.0, 15.0, 15.0)
camera.look_at(caterpillar_head)
soya.set_root_widget(camera)

soya.MainLoop(scene).main_loop()