Casino online

Mercato forex

Ricordiamoci sempre che stiamo scrivendo in .Net, un insieme di linguaggi orientati agli oggetti. Sulla base di questo, potrete facilmente capire perchè servirà una classe per ogni oggetto presente sulla scena. Tuttavia, non sarà necessaria una classe diversa per ogni entità e, anzi, in molti casi ne basterà solo una. Questa classe si chiama GameObject e rappresenta un generico oggetto nel gioco: ha molte proprietà, che ne determinano tutte le caratteristiche, e un metodo Draw che lo disegna sullo schermo tenendo conto di tutte le variabili in gioco.

Imports Microsoft.Xna.Framework
Imports Microsoft.Xna.Framework.Graphics

Public Class GameObject
    Protected _Position As Vector2
    Protected _Velocity As Vector2
    Protected _Rotation As Single
    Protected _Center As Vector2
    Protected _Sprite As Texture2D
    Protected _Color As Color
    Protected _Scale As Single
    Protected _Enabled As Boolean = True

    Public Overridable Property Position() As Vector2
        Get
            Return _Position
        End Get
        Set(ByVal Value As Vector2)
            _Position = Value
        End Set
    End Property

    Public Overridable Property Velocity() As Vector2
        Get
            Return _Velocity
        End Get
        Set(ByVal Value As Vector2)
            _Velocity = Value
        End Set
    End Property

    Public Overridable Property Rotation() As Single
        Get
            Return _Rotation
        End Get
        Set(ByVal Value As Single)
            _Rotation = Value
        End Set
    End Property

    Public Overridable Property Center() As Vector2
        Get
            Return _Center
        End Get
        Set(ByVal Value As Vector2)
            _Center = Value
        End Set
    End Property

    Public Overridable Property Sprite() As Texture2D
        Get
            Return _Sprite
        End Get
        Set(ByVal value As Texture2D)
            _Sprite = value
        End Set
    End Property

    Public Overridable Property Color() As Color
        Get
            Return _Color
        End Get
        Set(ByVal value As Color)
            _Color = value
        End Set
    End Property

    Public Overridable Property Scale() As Single
        Get
            Return _Scale
        End Get
        Set(ByVal value As Single)
            _Scale = value
        End Set
    End Property

    Public Overridable Property Enabled() As Boolean
        Get
            Return _Enabled
        End Get
        Set(ByVal value As Boolean)
            _Enabled = value
        End Set
    End Property

    Public Overridable Sub Draw(ByVal Batch As SpriteBatch)
        If Me.Enabled Then
            Batch.Draw(Me.Sprite, Me.Position, Nothing, Me.Color, _ 
            Me.Rotation, Me.Center, Me.Scale, SpriteEffects.None, 0)
        End If
    End Sub

    Sub New()
        Me.Color = Graphics.Color.White
        Me.Position = Vector2.Zero
        Me.Rotation = 0
        Me.Scale = 1.0
        Me.Velocity = Vector2.Zero
    End Sub

    Sub New(ByVal Sprite As Texture2D)
        Me.New()
        Me.Sprite = Sprite
        Me.Center = Me.Position + New Vector2( _ 
            Me.Sprite.Width * Me.Scale / 2, Me.Sprite.Height * Me.Scale / 2)
    End Sub
End Class 

Prima di descriverne le proprietà vorrei far notare tre particolari:

1. Tutte le proprietà che indicano un singolo punto non sono di tipo Point, ma di tipo Vector2. È questa la classe che si usa in XNA per determinare una posizione sullo schermo. Inoltre, è anche più precisa, poiché le coordinate possono essere espresse come numeri decimali Single
2. L'immagine dell'oggetto è rappresentata da un oggetto Texture2D. Allo stesso modo, in XNA le immagini non sono rappresentate dalle classi Image o Bitmap, ma da questa Texture2D
3. Anche se non si nota, la struttura Color non è quella a cui siamo abituati, perchè si tratta di Xna.Framework.Graphics.Color e non della solita Drawing.Color. Nonostante ciò essa mantiene comunque tutte le sue proprietà statiche

Ed ecco le descrizioni:

• Position : la posizione dell'oggetto nel piano
• Velocity : la velocità dell'oggetto, rappresentata come un vettore
• Rotation : l'angolo di rotazione dell'oggetto, espresso in radianti
• Center : il centro dell'oggetto. Serve per calcolare correttamente la rotazione. Il codice che trova il centro dell'oggetto l'ho già scritto io
• Sprite : l'immagine dell'oggetto. Qualsiasi immagine, in XNA ma in generale nell'ambito della scrittura di videogiochi, si chiama sprite
• Color : la variazione di colore dell'immagine
• Scale : fattore di zoom
• Enabled : determina se l'oggetto sia visibile
• Draw(B As SpriteBatch) : disegna l'oggetto sullo schermo usando i parametri impostati

Ecco alcuni esempi visivi dell'applicazione di queste proprietà:















Ora iniziamo, ad esempio, a dichiarare un nuovo GameObject che costituirà la mazza del giocatore. Nella classe Game dichiariamo una nuova variabile privata:

Private Bat As GameObject 

E la inizializziamo in LoadContent. Useremo il secondo overload di New, quello che un solo parametro di tipo Texture2D, ma ci manca l'immagine della mazza. Frugando nelle mie cartelle ho trovato questa, presa da Game Maker 6:



Scaricate questa immagine e salvatela nella cartella bin\Debug del vostro progetto:

Imports Microsoft.Xna.Framework
Imports Microsoft.Xna.Framework.Input
Imports Microsoft.Xna.Framework.Graphics

Public Class Game
    Inherits Microsoft.Xna.Framework.Game

    Private Graphics As GraphicsDeviceManager
    Private Batch As SpriteBatch
    
    'Bat rappresenta la mazza del giocatore
    Private Bat As GameObject
    
    'Questa funzione carica un'immagine dalla cartella del programma.
    'La definisco perchè in seguito sarà molto utile per
    'rendere più leggibile il codice
    Private Function GetTexture(ByVal Name As String) As Texture2D
        Return Texture2D.FromFile(Me.Graphics.GraphicsDevice, _ 
            My.Application.Info.DirectoryPath & "\" & Name)
    End Function

    Sub New()
        Me.Graphics = New GraphicsDeviceManager(Me)
        Me.Content.RootDirectory = "Content"
    End Sub

    Protected Overrides Sub Initialize()
        Batch = New SpriteBatch(Me.Graphics.GraphicsDevice)
        MyBase.Initialize()
    End Sub

    Protected Overrides Sub LoadContent()
        MyBase.LoadContent()
        
        'Carica l'oggetto Bat con l'immagine della mazza
        Bat = New GameObject(GetTexture("Bat.png"))
        'Imposta la posizione della mazza.
        'Me.Graphics.GraphicsDevice.Viewport è una proprietà di
        'tipo Rectangle, ma, ancora una volta, non si tratta di Drawing.Rectangle,
        'ma di Xna.Framework.Graphics.Rectangle, una struttura ricca di 
        'nuovi e utili metodi, ancora migliore del vecchio Rectangle.
        'Con questo codice, la mazza si trova esattamente nel centro del
        'piano di gioco, e 40 pixel sopra il margine inferiore.
        Bat.Position = New Vector2( _ 
            Me.Graphics.GraphicsDevice.Viewport.Width / 2, _ 
            Me.Graphics.GraphicsDevice.Viewport.Height - 40)
    End Sub

    Protected Overrides Sub UnloadContent()
        MyBase.UnloadContent()
    End Sub

    Protected Overrides Sub Update(ByVal GameTime As GameTime)
        'Questo lo potete anche cancellare
        'Dal prossimo capitolo non ci sarà più, poiché non stiamo
        'usando il joypad, ma la tastiera
        If GamePad.GetState(PlayerIndex.One).Buttons.Back = _ 
            ButtonState.Pressed Then
            Me.Exit()
        End If

        MyBase.Update(GameTime)

    End Sub

    Protected Overrides Sub Draw(ByVal gameTime As GameTime)
        'Tinge lo schermo di bianco
        Me.Graphics.GraphicsDevice.Clear(Color.White)

        'Tutte le chiamate a Draw devono essere comprese tra
        'Batch.Begin, che inizializza il disegno...
        Batch.Begin()
        
        Bat.Draw(Batch)
        
        '... e Batch.End, che lo termina
        Batch.End()

        MyBase.Draw(gameTime)
    End Sub
End Class 

Facendo correre il programma vedrete una finestra dallo sfondo bianco e l'immagine della mazza in basso al centro. Niente di più.



Un'ultima osservazione su questo codice:

Bat.Position = New Vector2( _ 
    Me.Graphics.GraphicsDevice.Viewport.Width / 2, _ 
    Me.Graphics.GraphicsDevice.Viewport.Height - 40) 

Come ho detto e scritto in tutti i capitoli della guida e in tutti i miei articoli sulla grafica, la posizione di un oggetto (spesso espressa dalla proprietà Location) determina il punto superiore sinistro dell'immagine. In XNA, invece, la proprietà Position indica il centro dell'immagine: posizionare un oggetto alle coordinate 50;50 signifca che il suo centro viene posto a quelle coordinate: