1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
 
namespace MetalX.Efeitos
{
    class Fade
    {
        #region atributos
        Texture2D textura;
        SpriteFont fonte;
        estadoImg meuEstado;
        int alfaAtual;
        double tempoEsperaAcender;
        double tempoEsperaFim;
        double tempoAcesa;
        double horaInicioAcesa;
 
        int velAlfa;
 
        #endregion
 
 
        #region enums
 
        /// 
        /// enum for the image state
        /// 
        public enum estadoImg
        {
            Apagada,
            Acendendo,
            Acesa,
            Apagando,
            PreFim,
            Fim
        }
 
        #endregion
 
 
 
        #region propriedades
 
        public int Width { get { return textura.Width; } }
        public int Height { get { return textura.Height; } }
 
        /// 
        /// Atribute for MeuEstado
        /// 
        public estadoImg MeuEstado { get { return meuEstado; }
                                     set { meuEstado = value; } }
 
        /// 
        /// Valor em segundos, podendo ser fracionario que se espera para
        /// comecar a imagem
        public double TempoEsperaAcender { set { tempoEsperaAcender = value; }
                                           get { return tempoEsperaAcender; } }
 
        /// 
        /// warning!! the alfa value must be between 0 and 255
        /// 
        public int AlfaAtual { set { alfaAtual = value; }
                               get { return alfaAtual; } }
 
        /// 
        /// value in seconds, the value may be fractional. is the time waited 
        /// waited to draw another image
        public double TempoEsperaFim { set { tempoEsperaFim = value; }
                                       get { return tempoEsperaFim; } }
 
        /// 
        /// The velocity that alfa changes
        /// 
        public int VelAlfa { get { return velAlfa; } set { velAlfa = value; } }
 
        /// 
        /// time to wait in seconds of the duration of the fully painted image
        /// 
        public double TempoAcesa { get { return tempoAcesa; }
                                   set { tempoAcesa = value; } }
 
        /// 
        /// the exact time of the end of the last image state
        /// 
        public double HoraInicioAcesa { set { horaInicioAcesa = value; }
                                        get { return horaInicioAcesa; } }
 
        #endregion
 
        /// 
        /// Class construtor
        /// 
        /// 

parameter passed to be used to load the image
///

the adress of the image
///

the velocity of changing alfa
///

time waited before start drawing the image
///

time waited on the image state fully draw
///

time waited after the draw becomes transparent
public Fade(Game1 game, string theFilePathAndName, int inc,
double tempoEsperaAcender, Double tAcesa, double tempoEsperaFim)
{
TempoEsperaFim = tempoEsperaFim;
fonte = game.Content.Load<SpriteFont>(@”fonts\arial”);
TempoEsperaAcender = tempoEsperaAcender;
TempoAcesa = tAcesa;
AlfaAtual = 0;
MeuEstado = estadoImg.Apagada;
textura = game.Content.Load<Texture2D>(theFilePathAndName) as Texture2D;
tempoEsperaAcender = 2;
velAlfa = inc;
}



///
/// updates the object
///
///

game time
public void Update(GameTime theGameTime)
{
switch (MeuEstado)
{
// caso inicial, espera para comecar a acender
case estadoImg.Apagada:
// atualiza o contador de espera para acender
tempoEsperaAcender -= theGameTime.ElapsedGameTime.TotalSeconds;
// testa se ja tá na hora de comecar a acender
if (tempoEsperaAcender <= 0)
MeuEstado = estadoImg.Acendendo; // comeca a acender
break;

// caso onde a imagem esta comecando a acender
case estadoImg.Acendendo:
AlfaAtual += velAlfa; // incrementa o canal de alfa
if (AlfaAtual > 255)
{
MeuEstado = estadoImg.Acesa;
AlfaAtual = 255;
HoraInicioAcesa = theGameTime.TotalRealTime.TotalSeconds;
}
break;

// caso onde a imagem está acesa e ela tem que esperar um tempo acesa
case estadoImg.Acesa:
// se o tempo q ela está acesa passar do tempo q foi dito
// para ela ficar
if (TempoAcesa <= theGameTime.TotalRealTime.TotalSeconds
- HoraInicioAcesa)
{
MeuEstado = estadoImg.Apagando;
}
break;

// caso em que a imagem está apagando
case estadoImg.Apagando:
AlfaAtual -= velAlfa; // vai diminuido o alfa
if (AlfaAtual <= 0) // se tiver apagado tudo, muda o estado
{
MeuEstado = estadoImg.PreFim;
AlfaAtual = 0;
HoraInicioAcesa = theGameTime.TotalRealTime.TotalSeconds;
}
break;

// caso a imagem apague, espera por um tempo dps permite outra
// imagem aparecer
case estadoImg.PreFim:
if (TempoEsperaFim <= theGameTime.TotalRealTime.TotalSeconds
- HoraInicioAcesa)
{
MeuEstado = estadoImg.Fim;
}
break;
// nao faz nada qnd apaga
case estadoImg.Fim:
break;
}
}

///
/// the method draw
///
///

the spritebatch
///

the position X
///

the position Y
public void Draw(SpriteBatch theBatch, int theXPosition, int theYPosition)
{
theBatch.Draw(textura,
new Rectangle(theXPosition, theYPosition, textura.Width, textura.Height),
new Color(255, 255, 255, (byte)MathHelper.Clamp(alfaAtual, 0, 255)));
}

}
}