Come implementare lo scorrimento parallasse in Python Arcade

Aggiungi una dimensione extra al tuo scorrimento laterale con livelli che scorrono in modo indipendente.

L'aggiunta di effetti visivi ai tuoi giochi può migliorare notevolmente l'esperienza del giocatore e rendere i giochi più coinvolgenti. Una tecnica popolare per raggiungere questo obiettivo è lo scorrimento della parallasse.

Lo scorrimento parallasse crea un'illusione di profondità spostando più strati di immagini o oggetti a velocità diverse, creando un senso di immersione nel mondo di gioco. Implementare lo scorrimento parallasse nei tuoi giochi utilizzando la libreria Arcade non solo è facile ma aggiunge anche un tocco professionale ai tuoi progetti.

Crea un gioco semplice

Prima di iniziare, assicurati di avere pip installato sul tuo dispositivo. Usa questo comando per installare la libreria arcade:

pip install arcade

Successivamente, crea un gioco semplice utilizzando la libreria Arcade. In questo gioco, il giocatore potrà muoversi a sinistra e a destra e ci saranno piattaforme con cui il giocatore potrà interagire.

Lo script simple-game.py definisce una classe Player che eredita dalla classe arcade.Sprite. Imposta una posizione iniziale e variabili di movimento per il giocatore. Il codice include anche una classe Platform che rappresenta piattaforme rettangolari. Ogni piattaforma ha una posizione, una dimensione e un colore specifici.

La classe MyGame è responsabile della configurazione del gioco, inclusa la creazione del lettore e delle piattaforme e la gestione del disegno, degli aggiornamenti e degli eventi di input.

Ecco come appare il gioco platform di base a questo punto:

Impostazione dei livelli

Per ottenere lo scorrimento parallasse, crea diversi livelli che si muovono a velocità diverse. Per questo esempio, crea cinque livelli. Ogni livello avrà una velocità di scorrimento diversa per creare un senso di profondità.

class Layer(arcade.SpriteList):
    def __init__(self, scroll_speed):
        super().__init__()
        self.scroll_speed = scroll_speed
class MyGame(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        arcade.set_background_color(arcade.color.WHITE)
        self.player = None
        self.platforms = None
        self.layers = []
    def setup(self):
        self.player = Player()
        self.platforms = arcade.SpriteList()
        gray = arcade.color.GRAY
        red = arcade.color.RED
        brown = arcade.color.BROWN
        yellow = arcade.color.YELLOW
        w = SCREEN_WIDTH // 2
        h = SCREEN_HEIGHT // 2
        self.platforms.append(Platform(w, h - 100, 200, 20, yellow))
        self.platforms.append(Platform(w, h + 100, 200, 20, yellow))
        layers_data = [
            (Layer(0.2), Platform(w, h, 800, 600, gray)),
            (Layer(0.5), Platform(w, h - 200, 400, 20, red)),
            (Layer(0.5), Platform(w, h + 200, 400, 20, red)),
            (Layer(1.0), Platform(w, h - 300, 200, 20, brown)),
            (Layer(1.0), Platform(w, h + 300, 200, 20, brown))
        ]
        for layer, platform in layers_data:
            layer.append(platform)
            self.layers.append(layer)
    # Rest of the code remains the same

Implementazione dello scorrimento parallasse

Per implementare lo scorrimento parallasse, aggiorna la posizione di ciascun livello in base alla velocità di scorrimento e al movimento del giocatore. Crea un nuovo file denominato parallax-scrolling.py e aggiungi il codice con gli aggiornamenti seguenti:

class MyGame(arcade.Window):
    # ...
    def on_draw(self):
        arcade.start_render()
        for layer in self.layers:
            layer.draw()
        self.platforms.draw()
        self.player.draw()
    def update(self, delta_time):
        self.player.update()
        for layer in self.layers:
            for sprite in layer:
                change = self.player.change_x * layer.scroll_speed
                sprite.center_x -= change
    # ...

Di seguito è riportato l'output:

Nel metodo on_draw, disegna ogni livello utilizzando gli strumenti di disegno della sala giochi prima di disegnare le piattaforme e il giocatore. Ciò garantisce che i livelli vengano visualizzati dietro il lettore e le piattaforme.

Nel metodo aggiorna, esegui l'iterazione su ogni livello e aggiorna la posizione di ogni sprite nel livello in base al movimento orizzontale del giocatore (self.player.change_x) e allo scorrimento del livello velocità (layer.scroll_speed). Moltiplicando il movimento del giocatore per la velocità di scorrimento, puoi ottenere l'effetto di scorrimento della parallasse.

Regolazione della velocità di scorrimento

Per creare un effetto di scorrimento parallasse visivamente più accattivante, puoi regolare la velocità di scorrimento per diversi livelli. Sperimentare velocità diverse può aggiungere profondità e rendere il mondo di gioco più coinvolgente.

class MyGame(arcade.Window):
    # ...
    def setup(self):
       # ...
        layers_data = [
            (Layer(1.2), Platform(w, h, 800, 600, gray)),
            (Layer(2.5), Platform(w, h - 200, 400, 20, red)),
            (Layer(3.0), Platform(w, h + 200, 400, 20, red)),
            (Layer(4.0), Platform(w, h - 300, 200, 20, brown)),
            (Layer(5.0), Platform(w, h + 300, 200, 20, brown))
        ]
        # ...
    # ...

Sentiti libero di sperimentare diverse velocità di scorrimento per ottenere l'effetto di scorrimento parallasse desiderato per il tuo gioco.

Comprese funzionalità aggiuntive

Lo scorrimento parallasse apre un mondo di possibilità per migliorare il tuo gioco. Combinandolo con altre funzionalità, puoi creare un'esperienza davvero accattivante e coinvolgente. Ecco alcune funzionalità aggiuntive che puoi incorporare nel tuo gioco per completare l'effetto di scorrimento parallasse:

Effetti di sfondo dinamici

Puoi sfruttare i livelli di scorrimento parallasse per aggiungere effetti di sfondo dinamici. Ad esempio, puoi simulare condizioni meteorologiche come pioggia, neve o foglie che cadono. Ogni livello può avere il proprio set di effetti particellari che reagiscono al movimento del giocatore, creando un ambiente più coinvolgente e realistico.

Crea un nuovo file denominato background-effects.py e aggiungi il codice con gli aggiornamenti seguenti:

class Raindrop(arcade.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.texture = arcade.make_soft_square_texture(
            3, blue, outer_alpha=100)
        self.center_x = x
        self.center_y = y
class BackgroundLayer(arcade.SpriteList):
    def __init__(self, scroll_speed):
        super().__init__()
        self.scroll_speed = scroll_speed
        self.raindrops = arcade.SpriteList()
    def update(self):
        for raindrop in self.raindrops:
            raindrop.center_y -= self.scroll_speed * 5 
            if raindrop.center_y < -10:
                raindrop.remove_from_sprite_lists()
    def draw(self):
        super().draw()
        self.raindrops.draw()
class MyGame(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        arcade.set_background_color(arcade.color.WHITE)
        self.background_layer = BackgroundLayer(0.2)
        # ...
    def setup(self):
        # ...
        self.background_layer.raindrops.append(
            Raindrop(SCREEN_WIDTH // 2, SCREEN_HEIGHT + 10))
    def update(self, delta_time):
        self.player.update()
        self.background_layer.update()
    def on_draw(self):
        arcade.start_render()
        self.background_layer.draw()
        self.platforms.draw()
        self.player.draw()

Ecco l'output:

Migliori pratiche per lo scorrimento parallasse

Ecco alcune best practice per implementare lo scorrimento parallasse nei tuoi giochi.

Pianifica attentamente i tuoi livelli

Prima di implementare lo scorrimento parallasse, prenditi il tempo necessario per pianificare e progettare i tuoi livelli. Considera gli elementi che desideri includere in ciascun livello e il modo in cui contribuiranno all'effetto visivo complessivo. Posizionare strategicamente oggetti e sfondi su diversi livelli può creare un'esperienza più coinvolgente.

Ottimizza dimensioni e formati delle immagini

Se decidi di utilizzare immagini per i tuoi livelli di scorrimento parallasse, ottimizza le loro dimensioni e formati per ridurre al minimo le dimensioni dei file e migliorare le prestazioni. Comprimi le immagini e utilizza formati appropriati (come JPEG o PNG) per ridurre l'utilizzo della memoria e i tempi di caricamento.

Testare le prestazioni su diversi dispositivi

Assicurati che la tua implementazione dello scorrimento parallasse funzioni bene su una varietà di dispositivi e dimensioni dello schermo. Metti alla prova il tuo gioco su piattaforme e dispositivi diversi per identificare eventuali colli di bottiglia nelle prestazioni o problemi di compatibilità.

Prendi in considerazione l'ottimizzazione del codice o la modifica del numero e della complessità dei livelli, se necessario. Bilancia il fascino visivo dello scorrimento parallasse con l'usabilità e la giocabilità del tuo gioco.

Incorpora transizioni fluide

Transizioni fluide tra i livelli possono migliorare la qualità visiva complessiva dello scorrimento parallasse. Utilizza funzioni di andamento o tecniche di interpolazione per creare transizioni graduali mentre il giocatore si muove o la telecamera esegue una panoramica. Ciò può aiutare a ridurre gli effetti discordanti e creare un'esperienza più fluida e piacevole.

Seguendo queste best practice, puoi assicurarti che l'implementazione del parallax scrolling sia fluida, visivamente accattivante e perfettamente integrata nel tuo gioco.

Rendi i giochi più divertenti con lo scorrimento parallasse

Con lo scorrimento parallasse puoi trasformare un semplice gioco in un'avventura visivamente sbalorditiva. Che si tratti di un platform, di uno sparatutto o di un gioco senza fine, lo scorrimento con parallasse aggiunge quello strato extra di rifinitura che affascina i giocatori e li spinge a tornare per saperne di più.

Quindi vai avanti e inizia a implementare lo scorrimento parallasse nei tuoi giochi utilizzando la libreria Arcade in Python.