Sujets

1

Python / PySFML sur raspberryPi

« le: Décembre 05, 2014, 10:25:23 am »

Bonjour, quelqu'un saurait comment installer PySFML sur raspberryPi ? Ou "compiler"  ( je sais que python ne se compile pas ) /  "packager" pour qu'un programme s’exécute sur l'os de ce mini pc ? (un dérivé de debian il me semble )

2

Python / BUG ? une touche ( R_ALT ) qui en actionne deux autres

« le: Février 28, 2014, 09:04:33 am »

bonjour

Je me demandais si il n'y avait pas un bug avec la touche ALT de droite qui actionne aussi la touche contrôle de gauche.

Est ce un bug ou c'est Windows qui impose ça ?

ce code retourne 37 puis 43 lorsqu'on appuis sur la touche ALT de droite ( 37 étant : contrôle gauche )

import sfml as sf

def main():
    # Creation de la fenetre principale
    window = sf.RenderWindow(sf.VideoMode(800, 600), 'SFML Shader example')
    window.framerate_limit = 60

    # Demarage de la boucle principale
    while window.is_open :
        # gestion des evenements de la fenetre
        for evt in window.events :
                       
            if type(evt) is sf.CloseEvent :
                window.close()
            if type(evt) is sf.KeyEvent and evt.pressed :
               
                # Affichage du code de la touche qu'on presse
                print(evt.code)
           
                if evt.code == sf.Keyboard.ESCAPE :
                    window.close()

        # Netoyage de la fenetre
        window.clear()
       
        window.display()

if __name__ == '__main__':
    main()
 

3

Python / movement d'objet

« le: Février 17, 2014, 08:09:15 pm »

Bonjour

J'aimerai créer une classe qui affiche un personnage à l’écran et ses mouvements

j'ai lue dans le forum qu'on ne pouvait pas hériter de sf.Sprite mais uniquement de sf.Drawable ou sf.TransformableDrawable et à l’intérieur on crée le sprite qui affichera un bout de la texture

J'ai donc codé une petite classe Perso

Mais quand je veux bouger le personnage ( avec .move(x,y) ) il ne bouge pas. .position n'a aucun effet non plus. La position de l'objet change mais pas le sprite. J'ai l'impression que le sprite est indépendant de l'objet

Qu'est ce que j'ai oublié ?

import sfml as sf

# ----- CLASSE -----

class Perso (sf.TransformableDrawable) :

    def __init__(self,texture):
        sf.Drawable.__init__(self)
        print("perso chargé ! ")
        self.imgTexture = sf.Texture.from_file(texture)
        self.persoSprite = sf.Sprite(self.imgTexture)
       
    def getImage(self,direction):
        if   direction == 'down' :
            self.persoSprite.texture_rectangle = sf.Rectangle((0, 0), (32, 32))
        elif direction == 'up' :
            self.persoSprite.texture_rectangle = sf.Rectangle((0, 96), (32, 32))
        elif direction == 'left' :
            self.persoSprite.texture_rectangle = sf.Rectangle((0, 32), (32, 32))
        elif direction == 'right' :
            self.persoSprite.texture_rectangle = sf.Rectangle((0, 64), (32, 32))
        else :
            print("ERROR : class Perso : ... ")
           
    def draw(self, target, states):
        states = sf.RenderStates()
        target.draw(self.persoSprite,states)


# ----- MAIN -----
       
if __name__ == '__main__' :

    window = sf.RenderWindow(sf.VideoMode(800, 600), "PySFML test")
    window.framerate_limit = 60
   
    # On crée une instance de Perso()
    player = Perso('resources/mperso.png')
    player.getImage('down')
    player.position = (150, 50)
   
    # On démarre la boucle de jeu
    while window.is_open :
        # on gère les évènements
        for event in window.events :
            if type(event) is sf.CloseEvent :
                window.close()
       
        # On dessine le niveau
        window.clear()
        window.draw(player)  
        player.move(sf.Vector2(2,0))
        print(player.position)

        window.display()  

4

Python / traduire le tuto c++ des vertexArray et le comprendre :)

« le: Février 11, 2014, 06:00:26 pm »

Bonjour

Je viens de débuter sur SFML

Je souhaiterai convertir mon projet de jeux 2d ( basé sur un affichage de tileset et de sprite ) en PyGame, loin d'être fini mais PyGame n’étant pas assez véloce dans certain domaine je voulais essayer SFML pour comparer. Puis apparemment cette librairie offre plus de possibilité

J’essaie de traduire le tuto en C++ des vertexarray ( celui qui charge un tileset et l'affiche ) mais je galère quand même pas mal

Voila l'url du tuto C++
http://www.sfml-dev.org/tutorials/2.1/graphics-vertex-array-fr.php

et voici mon début de traduction :

import sfml as sf

class TileMap (sf.Drawable) :

    def __init__ (self):
        sfml.Drawable.__init__(self)
       
        # on declare la texture et le VertexArray
        self.m_tileset = sf.Texture
        self.m_vertices = sf.VertexArray(sf.PrimitiveType.QUADS)
     
    def load (self,tileset, tileSize, tiles, width, height) :
       
        # on charge la texture
        self.m_tileset = sf.Texture.from_file(tileset)

        # on redimensionne le tableau de vertex pour qu'il puisse contenir tout le niveau
        self.m_vertices.resize(width * height * 4);
       
        # on remplit le tableau de vertex, avec un quad par tuile
        for i in range(width) :
            for j in range(height) :
               
           
                # on récupère le numéro de tuile courant
                tileNumber = tiles[i + j * width];

               
               
               
                # on en déduit sa position dans la texture du tileset
                #
                # déjà la ça déconne ...
                #
                tu = tileNumber % (self.m_tileset.size.x / tileSize.x);
                tv = tileNumber // (self.m_tileset.size.x / tileSize.x);
               
               
               
                # on récupère un pointeur vers le quad à définir dans le tableau de vertex
                self.quad = self.m_vertices[(i + j * width) * 4]
               
                print(type(self.quad))
               
                # on définit ses quatre coins
                #
                # C'est la que je ne comprend pas ... un type(self.quad) m'indique que c'est un vertex
                # hors un vertex ne n'est pas iterable donc d’où vient le quad[2]
                #
                self.quad[0].position = sf.Vector2(i * tileSize.x, j * tileSize.y)
                self.quad[1].position = sf.Vector2((i + 1) * tileSize.x, j * tileSize.y)
                self.quad[2].position = sf.Vector2((i + 1) * tileSize.x, (j + 1) * tileSize.y)
                self.quad[3].position = sf.Vector2(i * tileSize.x, (j + 1) * tileSize.y)

                # on définit ses quatre coordonnées de texture
                self.quad[0].tex_coords = sf.Vector2(tu * tileSize.x, tv * tileSize.y)
                self.quad[1].tex_coords = sf.Vector2((tu + 1) * tileSize.x, tv * tileSize.y)
                self.quad[2].tex_coords = sf.Vector2((tu + 1) * tileSize.x, (tv + 1) * tileSize.y)
                self.quad[3].tex_coords = sf.Vector2(tu * tileSize.x, (tv + 1) * tileSize.y)




# On crée la fenêtre principale
window = sf.RenderWindow(sf.VideoMode(800, 600), "PySFML test")
# window.vertical_synchronization = True
# window.framerate_limit = 60
# icon = sf.Image.from_file("data/icon.bmp")
# window.icon = icon.pixels  
     
       
level = [
        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
        1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
        0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0,
        0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0,
        0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1,
        0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1,
    ]
tm = TileMap()
tm.load("resources/tileset1a.jpg",sf.Vector2(32,32),level,16,8)

window.draw(tm)
window.display()
 

Je ne comprend pas cette histoire de quad, qui est un vertex et qui serait iterrable

version C++ :

                // on récupère un pointeur vers le quad à définir dans le tableau de vertex
                sf::Vertex* quad = &m_vertices[(i + j * width) * 4];

                // on définit ses quatre coins
                quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);