Finalmente in questi giorni sono riuscito a decidermi a comprare una xBox 360.
Si sono stanto tanto stronzo che per tutti questi anni ho sviluppato con XNA solo su pc.
Ma ora adesso che avevo la mia adorata console (piccolo momento di gloria: la slim è una cosa fantastica ^__^) dovevo trovare il modo di svilupparci sopra in modo appropriato.
Il problema principale stava nel fatto che non avevo ora come ora la possibilithttp://www.blogger.com/img/blank.gifà di pagare l'abbonamento annuale di 75€ per l'XNA creator club. E sul sito MSDNAA della mia università non c'era nemmeno più la possibilità di richiedere l'abbonamento studenti.
Ma per fortuna il WEB ci viene in aiuto. Può darsi che queste info siano ugualmente recuperabili da altre parti sul web, ma ho deciso lo stesso di condividerle tramite questo blog.
La Microsoft ha messo a disposizione di tutti gli studenti DEL MONDO (o perlomeno di moltissimi paesi) la possiblità di usufruire di molti http://www.blogger.com/img/blank.gifsuoi prodotti (certificati) in modo gratuito o scontato.
Il segreto di tutto questo è il progetto DreamSpark, a cui potete accedere tramite www.dreamspark.com.
Non voglio stare a farla tanto lunga: in parole povere questo permette a tutti gli stundenti universitari di qualsiasi facoltà (basta che sia registrata negli elenchi della Microsoft) di accedere ai loro prodotti.
Ma vediamo come utilizzare tutto ciò per ottenere un account studente di 12 mesi per Xna creator Club (oramai di dovrebbe dire App Hub O_O).
Come presequisito è necessario essere studenti iscritti ad una qualche facoltà italiana!
La prima cosa da fare è accedere con il vostro LiveID (MI RACCOMANDO! DOVETE ACCEDERE CON IL LiveID A CUI E' COLLEGATA LA GAMERTAG CHE UTILIZZATE SULLA VOSTRA CONSOLE!) ed andare qua https://users.create.msdn.com/Register/ e selezionare la voce Student quando vi verrà richiesto.
Premendo next, al prossimo passo vi verrrà richiesta la certificazione tramite DreamSpark. Naturalmente si parte dal presesupposto che voi non l'abbiate, e quindi dovrete premere su Visit DreamSpark now to get verified.
Fatto ciò verrete reindirizzati al sito di DreamSpark, il quale vi chiederà di inserire alcuni dati fondamentali.
Step1
Vi chiederà di inserire il paese in cui risiedete, poi selezionate Verify as a Student, e nell'ultima voce Get Verified through my School
Step2
Selezionate la vostra università nell'elenco di quelle disponibili per il vostro paese (se non è presente allora è un bel problema... ma non credo che ci dovrebbero essere atenei italiani mancanti).
Step3
Adesso dovete inserire la vostra mail da studente, quella data dal vostro dipartimento per intenderci. A questa mail sarà inviata una mail con il codice per poter completare la verifica su DreamSpark.
Voi potreste chiedere "Chi mi vieta di inserire una mail diversa?". Io non ho provato... ma non credo che sia molto complicato verificare al volo se la mail che inserite viene gestita dei server dell'università che avete scelto.
Quindi è bene inserire il vostro vero indirizzo e-mail di dipartimento.
Step4
Andate a leggere la mail che vi è arrivata. All'interno troverete il codice ed il link da visitare (dove appunto vi verrà richiesto di inserire il codice) per completare la registrazione.
Step5
Ok ora siete verificati su DreamSpark!
Tornate alla registrazione su App Hub, ripetere la procedura vista prima, selezionando sempre Student. Solo che questa volta mamma Microsoft si http://www.blogger.com/img/blank.gifaccorgerà della registrazione a DreamSpark e vi farà procedere.
Ora non dovete far altro che seguire tutti i passi, riempire tutti i campi (NOTA: le info che inserite du App Hub devono essere coerenti con quelle inserite sulla vostra gamerTag, se no il sistema si altera e vi chiede di modificare i dati), ed alla fine avrete il vostro account!
Nota: per chi vuole anche delle immagini sono riuscito a trovare proprio ora questo topic!
Guida alla verifica su DreamSpark.
Ora non dovete far altro che accendere la vostra console, accedere con la gamerTag relativa all'indirizzo/LiveID con cui vi siete registrati su App Hub.
Nel market place, sotto la lettera X, troverete l'XNA Game Studio Connect (NOTA: il programmino è scaricabile anche da chi non si è registrato ad App Hub, solo che se l'account non soddisfa il tipo di registrazione il programma non parte -.-).
Ora non ci resta che collegare la nostra console al pc.
Per fare questo dobbiamo fare alcuni altri passi.
Connect xBox Step1
Dovete lanciare Xna Game Studio Connect. Quando sarà partito vedrete a schermo un codice. Segnatevelo da qualche parte perchè vi servirà.
Connect xBox Step2
Dal vostro pc dovete andare nel menù Tutti i programmi/Microsoft Xna Game Studio 4.0/ e selezionare la voce XNA Game Studio Device Center.
Qua dovrete selezionare la vostra console, dargli un nome, e quando richiesto inserire il codice che vi siete segnati prima.
Ok tutto fatto!
Pc e console sono collegati.
Per provare qualcosa adesso dovete fare quando segue:
con Xna Game Studio Connect attivo sulla console ed in attesa di connessione dal vostro pc, dovete aprire Visual Studio (o Visual C#), aprire un progetto Xna (di tipo xBox360) e lanciarlo.
Il progetto verrà compilato e distribuito sulla console in automatico. E potrete provarlo direttamente li!
Tanto per gradire: funziona anche il debug! Cioè potete mettere dei break point nel codice, e l'esecuzione del gioco sulla console si bloccherà al raggiungimento del break point. :))
Certo non potrete modificare al volo il codice come si fa in locale, ma una cosa pur sempre utile.
Spero di essere stato il più possibile chiaro.
In seguito pubblicherò altri articoli sulle prove e sulle performance ottenute eseguendo vari progetti sulla console.
Per ogni chiarimento chiedete pure tramite mail o tramite commenti.
Saluti a tutti!
Odino
Continua a leggere!
The Xna-Way: Tutorial 11: Spippolando con il gamePad
Ho recentemenete acquistato tramite Amazon.it il gamepad della xbox 360 con cavo usb, in modo da poterlo utilizzare su pc, e da poter provare direttamente su di esso le funzionalità del pad, che altrimenti sarebbero disponibili solo sulla console.
Ho cominciato a giocarci, e questo è quanto ne ho ricavato fino ad ora.
Il pad in se per se è un ottimo prodotto. Ma questo già si sapeva :)
Xna mette a dispozizione il GamePadState per poter interrogare lo stato del nostro pad. Come per tastiera e mouse, possiamo recuperare lo stato corrente del nostro pad tramite il metodo GamePad.GetState(PlayerIndex), dove PlayerIndex indica il numero del giocatore/pad di cui vogliamo lo stato (il giocatore è identificato sul pad dal let acceso attorno al pulsante centrale, ed il valore di PlayerIndex varia tra 1 e 4).
Tra i valori ed i metodi messi a disposizione da tale oggetto possiamo mettere in evidenza:
ThumbStick: ha due proprietà, Left e Right, che permettono di sapere la posizione dei due stick analogici del pad.
Left e Right sono dei Vector2, quindi a loro volta hanno i valori per X ed Y. I valori che possono assumere variano in [-1,+1] (estremi compresi), dove -1 significa che lo stick è completamente a sinistra/basso, 1 significa che lo stick è completamente a destra/alto. Lo 0 significa che lo stick non è stato mosso. Valori intermedi rappresentano posizione intermedie dello stick nelle varie direzioni.
Triggers: i due grilletti posteriori del pad, oltre che come dei semplici bottoni (LeftTrigger e RightTrigger) che hanno stato rilasciato/premuto, possono essere identificati tramite questa proprietà, che contiene a sua volta due valori Left e Right, di tipo float. Questi due valori, varianti tra [0,1], estremi compresi, mi dicono quanto il grilletto è premuto, con 0 = rilasciato, 1 = completamente premuto, e valori intermedi, come prima, identificano posizioni intermedie.
Dpad: identifica lo stato delle "frecce direzionali" del pad. Le direzioni possibili sono 4, ma possono essere combinate due a due. Tramite questo oggetto possiamo controllare quali delle direzioni sono premute.
Notate che il Dpad è completamente diverso dallo stick sinistro, quindi quando muovete lo stick sinistro non cambiate in nessun modo lo stato del Dpad (come era stato portato a credere inizialmente -.-), e viceversa.
Spero che queste poche e brevi considerazioni personali sull'uso del gamepad possano tornare utili a qualcuno. Se avrò altro da aggiungere aggiornerò il post.
A presto.
Odino
Continua a leggere!
Ho cominciato a giocarci, e questo è quanto ne ho ricavato fino ad ora.
Il pad in se per se è un ottimo prodotto. Ma questo già si sapeva :)
Xna mette a dispozizione il GamePadState per poter interrogare lo stato del nostro pad. Come per tastiera e mouse, possiamo recuperare lo stato corrente del nostro pad tramite il metodo GamePad.GetState(PlayerIndex), dove PlayerIndex indica il numero del giocatore/pad di cui vogliamo lo stato (il giocatore è identificato sul pad dal let acceso attorno al pulsante centrale, ed il valore di PlayerIndex varia tra 1 e 4).
Tra i valori ed i metodi messi a disposizione da tale oggetto possiamo mettere in evidenza:
ThumbStick: ha due proprietà, Left e Right, che permettono di sapere la posizione dei due stick analogici del pad.
Left e Right sono dei Vector2, quindi a loro volta hanno i valori per X ed Y. I valori che possono assumere variano in [-1,+1] (estremi compresi), dove -1 significa che lo stick è completamente a sinistra/basso, 1 significa che lo stick è completamente a destra/alto. Lo 0 significa che lo stick non è stato mosso. Valori intermedi rappresentano posizione intermedie dello stick nelle varie direzioni.
Triggers: i due grilletti posteriori del pad, oltre che come dei semplici bottoni (LeftTrigger e RightTrigger) che hanno stato rilasciato/premuto, possono essere identificati tramite questa proprietà, che contiene a sua volta due valori Left e Right, di tipo float. Questi due valori, varianti tra [0,1], estremi compresi, mi dicono quanto il grilletto è premuto, con 0 = rilasciato, 1 = completamente premuto, e valori intermedi, come prima, identificano posizioni intermedie.
Dpad: identifica lo stato delle "frecce direzionali" del pad. Le direzioni possibili sono 4, ma possono essere combinate due a due. Tramite questo oggetto possiamo controllare quali delle direzioni sono premute.
Notate che il Dpad è completamente diverso dallo stick sinistro, quindi quando muovete lo stick sinistro non cambiate in nessun modo lo stato del Dpad (come era stato portato a credere inizialmente -.-), e viceversa.
Spero che queste poche e brevi considerazioni personali sull'uso del gamepad possano tornare utili a qualcuno. Se avrò altro da aggiungere aggiornerò il post.
A presto.
Odino
Continua a leggere!
The Xna-Way: Tutorial 10: Sprite Sheet & 2D Animation
Vi siete mai imbattuti, mentre ricercavate risorse grafiche per i vostri giochi, negli sprite sheet? Immagini contenenti frame delle animazioni di personaggi, effetti speciali o altro?
(Nota: molto belli sono quelli rippati dai vecchi giochi per il SNES, che potete trovare su alcuni siti, i cui link metterò alla fine del post).
Vediamo un piccolo esempio su come possono essere utilizzati.
Il codice sarà allegato alla fine del post!
La strutturazione del codice per come l'ho pensata io è la seguente:
- TextureCollection: un catalogo contenente tutte le texture2D caricate nel gioco, accedibili tramite un id unico
- SpriteSheetCollection: un catalogo contenente gli SpriteSheet definiti per il gioco, anche questi accedibili tramite un id unico
- AnimationDescCollection: un catalogo contenente la descrizione delle animazioni definite per il gioco, anche queste accedibili trami un id unico
Le collezioni sopra definite sono definite come statiche, in modo che possano essere accedibili da ogni parte del codice.
VI sono poi altre classi:
- SpriteSheet: rappresenta un'immagine divisa in frame. Contiene l'identificatore della texture all'interno della TextureCollection, il numero di frame sull'asse X e sull'asse Y, oltre che un metodo per calcolare il rettangolo relativo al frammento di immagine che si vuole utilizzare.
-AnimationDesc: contiene una collezione di frame che specificano l'animazione, oltre a dire se l'animazione deve essere ripetuta all'infinito o meno.
- Frame: speficifica quale SpriteSheet utilizzare e quale è l'id del frammento da utilizzare (NOTA: I frammenti contentuni all'interno di uno spriteSheet sono numerati da 0 al numero massimo -1, partendo dall'angolo in alto a sinistra e procedendo da destra verso sinistra, e dall'alto verso il basso).
- Animation: è l'oggetto che implementa l'animazione vera e propria. Contiene l'id della descrizione dell'animazione che si sta utilizzando, il frame corrente (cioè dove siamo arrivati a riprodurre l'animazione), il tempo passato dall'ultimo aggiornamento (in modo da poter avanzare il frame corrente al momento giusto), e la posizione dell'animazione nella vista del gioco.
Infine arriviamo al componente principale:
- AnimationManager: è il gameComponent che si preoccupa di gestire ed animare gli oggetti Animation che gli vengono dati in pasto.
Ecco il codice per le classi principali:
E questo è il codice per il Game:
Come potete vedere non è nulla di trascendentale o di così complicato come poteva sembrare.
Vi allego anche la soluzione per Xna4 (se il link non funziona contattatemi):
Soluzione Visual Sutdio
Ed ecco un buonissimo sito con tantissimi spriteSheet!
Sprite Database
Alla prossima!
Odino
Continua a leggere!
(Nota: molto belli sono quelli rippati dai vecchi giochi per il SNES, che potete trovare su alcuni siti, i cui link metterò alla fine del post).
Vediamo un piccolo esempio su come possono essere utilizzati.
Il codice sarà allegato alla fine del post!
La strutturazione del codice per come l'ho pensata io è la seguente:
- TextureCollection: un catalogo contenente tutte le texture2D caricate nel gioco, accedibili tramite un id unico
- SpriteSheetCollection: un catalogo contenente gli SpriteSheet definiti per il gioco, anche questi accedibili tramite un id unico
- AnimationDescCollection: un catalogo contenente la descrizione delle animazioni definite per il gioco, anche queste accedibili trami un id unico
Le collezioni sopra definite sono definite come statiche, in modo che possano essere accedibili da ogni parte del codice.
VI sono poi altre classi:
- SpriteSheet: rappresenta un'immagine divisa in frame. Contiene l'identificatore della texture all'interno della TextureCollection, il numero di frame sull'asse X e sull'asse Y, oltre che un metodo per calcolare il rettangolo relativo al frammento di immagine che si vuole utilizzare.
-AnimationDesc: contiene una collezione di frame che specificano l'animazione, oltre a dire se l'animazione deve essere ripetuta all'infinito o meno.
- Frame: speficifica quale SpriteSheet utilizzare e quale è l'id del frammento da utilizzare (NOTA: I frammenti contentuni all'interno di uno spriteSheet sono numerati da 0 al numero massimo -1, partendo dall'angolo in alto a sinistra e procedendo da destra verso sinistra, e dall'alto verso il basso).
- Animation: è l'oggetto che implementa l'animazione vera e propria. Contiene l'id della descrizione dell'animazione che si sta utilizzando, il frame corrente (cioè dove siamo arrivati a riprodurre l'animazione), il tempo passato dall'ultimo aggiornamento (in modo da poter avanzare il frame corrente al momento giusto), e la posizione dell'animazione nella vista del gioco.
Infine arriviamo al componente principale:
- AnimationManager: è il gameComponent che si preoccupa di gestire ed animare gli oggetti Animation che gli vengono dati in pasto.
Ecco il codice per le classi principali:
Show∇
1: /// <summary>
2: /// rappresenta un singolo frame dell'animazione
3: /// Si caratterizza per l'id dello spriteSheet e per il frammento di immagine utilizzato dal frame
4: /// </summary>
5: public class Frame
6: {7: /// <summary>
8: /// Id dello spriteSheet che deve essere presente nella spriteSheetCollection
9: /// </summary>
10: public long IdSpriteSheet { get; private set; }
11: /// <summary>
12: /// Id del frammento dell'immagine che si utilizza per il particolare frame
13: /// </summary>
14: public int IdFragment { get; private set; }
15: 16: /// <summary>
17: /// Costruisce un frame per l'animazione
18: /// </summary>
19: /// <param name="idSpriteSheet">Id di riferimento per lo spriteSheet che deve essere presente nella spriteSheetCollection</param>
20: /// <param name="idFragment">Id del frammento dell'immagine che si utilizza per il particolare frame</param>
21: public Frame(long idSpriteSheet, int idFragment)
22: {23: this.IdSpriteSheet = idSpriteSheet;
24: this.IdFragment = idFragment;
25: } 26: } 27: 28: /// <summary>
29: /// Descrive come è fatta un'animazione
30: /// </summary>
31: public class AnimationDesc
32: {33: /// <summary>
34: /// Lista dei frame che compongono l'animazione
35: /// </summary>
36: public List<Frame> FrameList { get; set; }
37: 38: /// <summary>
39: /// Vale true se l'animazione deve ripetersi
40: /// False altrimenti
41: /// </summary>
42: public bool Loop { get; set; }
43: 44: /// <summary>
45: /// Crea la descrizione di un'animazione che non si ripete dopo la fine
46: /// </summary>
47: public AnimationDesc()
48: : this(false)
49: { 50: } 51: 52: /// <summary>
53: /// Crea la descrizione di un'animazione permettendo di configurare la ripetizione
54: /// </summary>
55: /// <param name="loop">True se si vuol far ripetere l'animazione, false altrimenti</param>
56: public AnimationDesc(bool loop)
57: {58: FrameList = new List<Frame>();
59: Loop = loop; 60: } 61: } 62: 63: /// <summary>
64: /// Definisce un'animazione da visualizzare a schermo dall'AnimationManager
65: /// </summary>
66: public class Animation
67: {68: /// <summary>
69: /// Posizione (nel range dello schermo) in cui viene visualizzata l'animazione
70: /// </summary>
71: public Vector2 Position { get; set; }
72: 73: /// <summary>
74: /// Frame corrente dell'animazione
75: /// </summary>
76: public int CurrentFrame { get; set; }
77: 78: /// <summary>
79: /// Id dell'AnimationDesc utilizzata
80: /// </summary>
81: public long IdAnimationDesc { get; private set; }
82: 83: /// <summary>
84: /// Tempo passato dall'ultimo cambio di frame
85: /// </summary>
86: public int ElapsedTime { get; set; }
87: 88: /// <summary>
89: /// Crea una nuova Animazione con riferimento all'AnimationDesc con id passato. Creata in posizione (0,0)
90: /// </summary>
91: /// <param name="idAnimation">Id dell'AnimationDesc presente nella AnimationsDescCollection</param>
92: public Animation(long idAnimationDesc)
93: : this(idAnimationDesc, Vector2.Zero)
94: { 95: } 96: 97: /// <summary>
98: /// Crea una nuova Animazione con riferimento all'AnimationDesc con id passato.
99: /// </summary>
100: /// <param name="idAnimation">Id dell'AnimationDesc presente nella AnimationsDescCollection</param>
101: /// <param name="position">Posizione dell'Animazione</param>
102: public Animation(long idAnimationDesc, Vector2 position)
103: {104: this.IdAnimationDesc = idAnimationDesc;
105: this.Position = position;
106: ElapsedTime = 0; 107: } 108: } 109: 110: /// <summary>
111: /// Component per il rendering della Animation a schermo
112: /// </summary>
113: public class AnimationManager : Microsoft.Xna.Framework.DrawableGameComponent
114: {115: //spritebatch su cui disegnare
116: SpriteBatch spriteBatch = null;
117: 118: /// <summary>
119: /// lista delle animazioni da eseguire. Un'animazione viene automaticamente rimossa al termine della sua animazione
120: /// </summary>
121: public List<Animation> AnimationList { get; set; }
122: 123: public AnimationManager(Game game)
124: : base(game)
125: {126: AnimationList = new List<Animation>();
127: } 128: 129: 130: protected override void LoadContent()
131: {132: spriteBatch = new SpriteBatch(Game.GraphicsDevice);
133: base.LoadContent();
134: } 135: 136: public override void Initialize()
137: {138: base.Initialize();
139: } 140: 141: public override void Update(GameTime gameTime)
142: {143: int delta = gameTime.ElapsedGameTime.Milliseconds;
144: 145: AnimationDesc desc = null;
146: for (int i = AnimationList.Count - 1; i >= 0; i--)
147: { 148: desc = AnimationsDescCollection.AnimationCollection[AnimationList[i].IdAnimationDesc];149: if (!desc.Loop && AnimationList[i].CurrentFrame == desc.FrameList.Count - 1)
150: AnimationList.RemoveAt(i);151: else if (desc.Loop && AnimationList[i].CurrentFrame == desc.FrameList.Count - 1)
152: AnimationList[i].CurrentFrame = 0; 153: } 154: 155: for (int i = 0; i < AnimationList.Count; i++)
156: { 157: desc = AnimationsDescCollection.AnimationCollection[AnimationList[i].IdAnimationDesc]; 158: AnimationList[i].ElapsedTime += delta;159: if (AnimationList[i].ElapsedTime >= 40)
160: { 161: AnimationList[i].ElapsedTime -= 40; 162: AnimationList[i].CurrentFrame++; 163: } 164: } 165: 166: base.Update(gameTime);
167: } 168: 169: public override void Draw(GameTime gameTime)
170: { 171: spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);172: AnimationDesc desc = null;
173: for (int i = 0; i < AnimationList.Count; i++)
174: { 175: desc = AnimationsDescCollection.AnimationCollection[AnimationList[i].IdAnimationDesc]; 176: Frame current = desc.FrameList[AnimationList[i].CurrentFrame]; 177: SpriteSheet spriteSheet = SpriteSheetCollection.SpritesSheetCollection[current.IdSpriteSheet]; 178: 179: Texture2D img = TextColl.TextureCollection[spriteSheet.IdTexture]; 180: Rectangle sRec = spriteSheet.GetRectangle(current.IdFragment);181: spriteBatch.Draw(img, AnimationList[i].Position - new Vector2(sRec.Width / 2, sRec.Height / 2),
182: sRec, Color.White); 183: } 184: spriteBatch.End(); 185: 186: base.Draw(gameTime);
187: } 188: }HideΔ
E questo è il codice per il Game:
Show∇
1: public class Game1 : Microsoft.Xna.Framework.Game
2: { 3: GraphicsDeviceManager graphics; 4: SpriteBatch spriteBatch; 5: 6: SpriteFont font; 7: 8: AnimationManager animMng; 9: 10: //stato del mouse al ciclo precedente
11: MouseState lastMS; 12: 13: public Game1()
14: {15: graphics = new GraphicsDeviceManager(this);
16: Content.RootDirectory = "Content";
17: 18: graphics.PreferredBackBufferWidth = 800; 19: graphics.PreferredBackBufferHeight = 600; 20: 21: TextColl.Initialize(); 22: SpriteSheetCollection.Initialize(); 23: AnimationsDescCollection.Initialize(); 24: 25: Components.Add((animMng = new AnimationManager(this)));
26: 27: IsMouseVisible = true;
28: } 29: 30: protected override void Initialize()
31: {32: base.Initialize();
33: } 34: 35: protected override void LoadContent()
36: {37: spriteBatch = new SpriteBatch(GraphicsDevice);
38: 39: font = Content.Load<SpriteFont>("font");
40: 41: TextColl.TextureCollection.Add(0, Content.Load<Texture2D>("prova"));
42: 43: SpriteSheet ss = new SpriteSheet(0, 5, 2);
44: SpriteSheetCollection.SpritesSheetCollection.Add(0, ss); 45: 46: AnimationDesc ad = new AnimationDesc();
47: ad.FrameList.Add(new Frame(0, 0));
48: ad.FrameList.Add(new Frame(0, 1));
49: ad.FrameList.Add(new Frame(0, 2));
50: ad.FrameList.Add(new Frame(0, 3));
51: ad.FrameList.Add(new Frame(0, 4));
52: AnimationsDescCollection.AnimationCollection.Add(0, ad); 53: 54: lastMS = Mouse.GetState(); 55: } 56: 57: protected override void UnloadContent()
58: { 59: } 60: 61: protected override void Update(GameTime gameTime)
62: {63: if (Keyboard.GetState().IsKeyDown(Keys.Escape))
64: this.Exit();
65: 66: if (lastMS.LeftButton == ButtonState.Released && Mouse.GetState().LeftButton == ButtonState.Pressed)
67: { 68: MouseState ms = Mouse.GetState();69: Animation anim = new Animation(0, new Vector2(ms.X, ms.Y));
70: animMng.AnimationList.Add(anim); 71: } 72: lastMS = Mouse.GetState();73: base.Update(gameTime);
74: } 75: 76: protected override void Draw(GameTime gameTime)
77: { 78: GraphicsDevice.Clear(Color.CornflowerBlue); 79: 80: base.Draw(gameTime);
81: } 82: }HideΔ
Come potete vedere non è nulla di trascendentale o di così complicato come poteva sembrare.
Vi allego anche la soluzione per Xna4 (se il link non funziona contattatemi):
Soluzione Visual Sutdio
Ed ecco un buonissimo sito con tantissimi spriteSheet!
Sprite Database
Alla prossima!
Odino
Continua a leggere!
The Xna-Way: Tutorial 9 (Trick): Ordine dei DrawableGameComponent/GameComponent
Vi siete mai trovati a dover aggiungere diversi GameComponent al vostro progetto?
Bè credo di si, dato che sono il componente fondamentale su cui si basa XNA.
E scommetto che molti si sono trovati nella situazione in cui un Component esegua il metodo Update prima di un altro, o che vengano eseguiti i metodi Draw in un ordine che non è quello desiderato... producendo in questo modo effetti del tutto errati.
Ma c'è un semplicisso modo per ovviare a tutto questo.
La classe GameComponent espongono due proprietà interessanti:
- UpdateOrder: indica in quale ordine i componenti devono eseguire il loro metodo Update (questo se sono attivi). L'ordine è relativo agli altri componenti presenti nella stessa collezione. Naturalmente i GameComponent con valori più bassi verrano aggiornati prima.
- DrawOrder: indica in quale ordine verrano eseguiti i metodi Draw dei vari componenti.
Queste due proprietà sono molto utili quando si lavora con componenti che si devono "passare" dai, o per i quali è necessario che lo stato (o la parte di stato) del gioco sui cui operano sia stata prima aggiornata da un altro componente.
Lo stesso dicasi per l'ordine del rendering della scena. Ciò torna molto utile nel caso si abbia più DrawableGameComponent i quali operano su SpriteBatch differenti per esempio. Così potremmo delegare ai vari componenti il render di una parte della vista, per poi comporre il tutto assieme con pochissimo sforzo.
Spero vi sia utile (a me lo è stato^^).
Per qualsiasi dubbio contattatemi pure.
A presto.
Odino
Continua a leggere!
Bè credo di si, dato che sono il componente fondamentale su cui si basa XNA.
E scommetto che molti si sono trovati nella situazione in cui un Component esegua il metodo Update prima di un altro, o che vengano eseguiti i metodi Draw in un ordine che non è quello desiderato... producendo in questo modo effetti del tutto errati.
Ma c'è un semplicisso modo per ovviare a tutto questo.
La classe GameComponent espongono due proprietà interessanti:
- UpdateOrder: indica in quale ordine i componenti devono eseguire il loro metodo Update (questo se sono attivi). L'ordine è relativo agli altri componenti presenti nella stessa collezione. Naturalmente i GameComponent con valori più bassi verrano aggiornati prima.
- DrawOrder: indica in quale ordine verrano eseguiti i metodi Draw dei vari componenti.
Queste due proprietà sono molto utili quando si lavora con componenti che si devono "passare" dai, o per i quali è necessario che lo stato (o la parte di stato) del gioco sui cui operano sia stata prima aggiornata da un altro componente.
Lo stesso dicasi per l'ordine del rendering della scena. Ciò torna molto utile nel caso si abbia più DrawableGameComponent i quali operano su SpriteBatch differenti per esempio. Così potremmo delegare ai vari componenti il render di una parte della vista, per poi comporre il tutto assieme con pochissimo sforzo.
Spero vi sia utile (a me lo è stato^^).
Per qualsiasi dubbio contattatemi pure.
A presto.
Odino
Continua a leggere!
X-RPG Builder 2D - aggiornamento 8
Lo sviluppo del progetto è attualmente sospeso causa studi universitari, che mi portano via la maggior parte del tempo, e nel tempo che mi rimane mi sono messo a sviluppare un altro proggetto, che spero porterà alla nascita di un Indie Game da poter poi inserire nel Market Place della Microsft.
Per qualsiasi domanda sul progetto X-Rpg Builder 2D (quando riprenderà, come funzionano certi particolari, come sono state realizzate le strutture dati, etc) contattatemi via e-email.
A presto.
Odino
E questo è il resto. Continua a leggere!
Per qualsiasi domanda sul progetto X-Rpg Builder 2D (quando riprenderà, come funzionano certi particolari, come sono state realizzate le strutture dati, etc) contattatemi via e-email.
A presto.
Odino
E questo è il resto. Continua a leggere!
X-RPG Builder 2D - aggiornamento 7
E' passato un bel di tempo dall'ultimo aggiornamento.
Cosa è successo nel frattempo?
Tante cose. Tanti intoppi, altre faccende da sbrigare che mi hanno tenuto lontano dallo sviluppo.
Solo da poco ho ripreso a mettere mano al codice.
Sto ora lavorando alla parte game del progetto, sviluppando i components e le classi che dovranno mandare effettivamente avanti il gioco.
Ho sviluppato parte del sistema di generazione e gestione delle azioni (e del corrispettivo codice da eseguire) scatenate dagli eventi di gioco.
Per esempio adesso sto lavorando sulla parte del menù di interazione con l'untente, e questo è l'effetto per ora ottenuto.
C'è ancora molto da fare.
E con il ricominciare delle lezioni può darsi che il tempo che passerò a sviluppare il tutto diminuirà drasticamente. Ma piano piano si porterà tutto a compimento.
Alla prossima!
Continua a leggere!
Cosa è successo nel frattempo?
Tante cose. Tanti intoppi, altre faccende da sbrigare che mi hanno tenuto lontano dallo sviluppo.
Solo da poco ho ripreso a mettere mano al codice.
Sto ora lavorando alla parte game del progetto, sviluppando i components e le classi che dovranno mandare effettivamente avanti il gioco.
Ho sviluppato parte del sistema di generazione e gestione delle azioni (e del corrispettivo codice da eseguire) scatenate dagli eventi di gioco.
Per esempio adesso sto lavorando sulla parte del menù di interazione con l'untente, e questo è l'effetto per ora ottenuto.
C'è ancora molto da fare.
E con il ricominciare delle lezioni può darsi che il tempo che passerò a sviluppare il tutto diminuirà drasticamente. Ma piano piano si porterà tutto a compimento.
Alla prossima!
Continua a leggere!
X-RPG Builder 2D - aggiornamento 6
Piccolo aggiornamento sull'editor ed in parte sul game Engine.
Ho dovuto separare in modo drastico la libreria base per l'Rpg dal resto della logica dell'applicazione, in modo da avere un ottimo riutilizzo del codice tra editor e motore del gioco.
Adesso l'engine e l'editor specializzano solo le classi necessarie alla gestione delle immagini, mentre la parte di caricamento è rimasta la solita.
Quindi ho dovuto riscrivere buona parte dell'engine, e ho cominciato a strutturare i vari gameComponents che dovranno girare in background nel gioco.
Per quanto riguarda l'editor adesso sto strutturando la gestione e la personalizzazione degli eventi, compreso il codice degli eventi. Il codice degli eventi potrà anche portare all'esecuzione di codice C# personale.
Quello che voglio fare è ottenere, dalla struttura del codice degli eventi, la produzione di codice C# che dopo dovrà essere compilato ed eseguito: cioè voglio che durante la fase di esportazione del progetto mi venga generato il codice C# relativo allo pseudo codice degli eventi. In questo modo non dovrò costruirmi un interprete personalizzato per il codice.
Eccovi un'immagine di come si presenta in questo momento l'editor degli eventi:
Vi saluto.
A presto con altri aggiornamenti :)
Ciau
Continua a leggere!
Ho dovuto separare in modo drastico la libreria base per l'Rpg dal resto della logica dell'applicazione, in modo da avere un ottimo riutilizzo del codice tra editor e motore del gioco.
Adesso l'engine e l'editor specializzano solo le classi necessarie alla gestione delle immagini, mentre la parte di caricamento è rimasta la solita.
Quindi ho dovuto riscrivere buona parte dell'engine, e ho cominciato a strutturare i vari gameComponents che dovranno girare in background nel gioco.
Per quanto riguarda l'editor adesso sto strutturando la gestione e la personalizzazione degli eventi, compreso il codice degli eventi. Il codice degli eventi potrà anche portare all'esecuzione di codice C# personale.
Quello che voglio fare è ottenere, dalla struttura del codice degli eventi, la produzione di codice C# che dopo dovrà essere compilato ed eseguito: cioè voglio che durante la fase di esportazione del progetto mi venga generato il codice C# relativo allo pseudo codice degli eventi. In questo modo non dovrò costruirmi un interprete personalizzato per il codice.
Eccovi un'immagine di come si presenta in questo momento l'editor degli eventi:
Vi saluto.
A presto con altri aggiornamenti :)
Ciau
Continua a leggere!
Iscriviti a:
Post (Atom)
