Como desenvolver um jogo em Java ME - Parte 2 - Revision history

Hamishwillee: Hamishwillee - Bot addition of Template:ArticleMetaData

2011-11-10T04:26:13Z

Hamishwillee - Bot addition of Template:ArticleMetaData

Hamishwillee: Hamishwillee - Fix categories

2011-07-14T10:39:07Z

Hamishwillee - Fix categories

Hamishwillee: Hamishwillee - Automated change of category from Lang-PT to Unlikely Category. (Moving)

2011-07-14T05:19:09Z

Hamishwillee - Automated change of category from Lang-PT to Unlikely Category. (Moving)

Kiran10182 at 13:05, 27 May 2011

2011-05-27T13:05:45Z

Dcrocha at 19:41, 29 November 2007

2007-11-29T19:41:10Z

Dcrocha at 19:30, 29 November 2007

2007-11-29T19:30:53Z

Dcrocha at 19:22, 29 November 2007

2007-11-29T19:22:25Z

Dcrocha: New page: Já que a interação com o usuário é uma das preocupações principais em qualquer aplicação móvel, devido ao tamanho das telas, é importante que você entenda o básico desta facet...

2007-11-29T19:19:27Z

New page: Já que a interação com o usuário é uma das preocupações principais em qualquer aplicação móvel, devido ao tamanho das telas, é importante que você entenda o básico desta facet...

New page

Já que a interação com o usuário é uma das preocupações principais em qualquer aplicação móvel, devido ao tamanho das telas, é importante que você entenda o básico desta faceta dos MIDlets. Neste artigo, você aprenderá quais elementos de UI estão disponíveis em um MIDlet e como usá-los para criar a interface para o nosso clone do jogo Arkanoid.

Qualquer interação com um usuário é feita através de um componente de UI. De fato, quando você criou o simples "Hello World" na parte 1 deste artigo, você usou um elemento chamado Alert para mostrar uma mensagem na tela. Esta mensagem foi mostrada na tela na realidade com a ajuda de outro elemento de UI chamado Display.

Vamos iniciar com uma discussão da arquitetura completa dos componentes gráficos.

== Arquitetura ==

O MIDP 2.0 fornece classes gráficas em um pacote, javax.microedition.lcdui. Se você está se perguntando o que "LCDUI" significa, a resposta é "Liquid Crystal Display User Interface (LCD UI)". Para que você possa mostrar um elemento gráfico na tela, você precisa usar uma classe que implemente a interface <tt>Displayable</tt>. Tal classe pode ter um título, um ticker e certos comandos associados a si, entre outras características.

A classe Display gerencia o que está sendo mostrado na tela. O método estático getDisplay(MIDlet midlet) lhe fornece acesso ao Display do seu midlet. Assim você pode usar o método setCurrent(Displayable d) para escolher o que mostrar na tela em dado momento. VOcê pode ter apenas um Displayable sendo mostrado de cada vez. Lembra-se do código de nossa última lição?
<code java>
Display.getDisplay(this).setCurrent(alert);
</code>

As classes Displayable do MIDP 2.0 pacote javax.microedition.lcdui podem ser divididas em dois grupos: as de alto nível e as de baixo nível.

O grupo de alto nível é implementado através da classe Screen, e o de baixo nível através da classe Canvas; ambas essas classes e suas subclasses implementam a interface Displayable, como pode ser visto na figura abaixo:

[[Image:UI-Displayable-Classes.png]]

== Interface de alto nível ==

As classes do grupo de alto nível são perfeitas para o desenvolvimento de MIDlets que devem rodar no maior número de devices possível, pois as mesmas não fornecem controle exato sobre o modo com o qual são mostrada. Ao contrário, elas são altamente abstratas, para permitir que o dispositivo em si gerencie a melhor forma de mostrá-las na tela, de acordo com suas capacidades de hardware. Abaixo você pode ver um diagrama de classes das mesmas:

[[Image:UI-HighLevel-Elements.png]]

Como você pode ver, existem várias classes que fornecem elementos gráficos, então vamos analisar cada uma delas.

=== Command ===

Um MIDlet interage com o usuário através de comandos. Um comando é o equivalente a um item de menu em uma aplicação desktop, e pode somente ser associado a um único elemento de UI. A classe Displayable permite que o usuário adicione um comando a ela utilizando o método addCommand(Command command). Um elemento Displayable pode ter múltiplos comandos associados a si.

A classe Command contém informações sobre um comando. Esta informação é encapsulada em quatro propriedades, a saber: um label curto, um longo, um tipo de comando, e uma prioridade. Em nossa aplicação "HelloWorld" criamos um comando fornecendo esses valores no seu construtor:

<code java>
// adds a command to exit the Midlet
comExit = new Command("Exit", Command.EXIT, 1);
</code>

Note que comandos são imutáveis, uma vez criados.

Especificar um tipo de comando permite que o device rodando o MIDlet mapeie quaisquer teclas predefinidas no device àquele comando. Por exemplo, um comando cujo tipo seja "OK" será mapeado à tecla "OK"do aparelho. Os outros tipos são: BACK, CANCEL, EXIT, HELP, ITEM, SCREEN e STOP. O tipo SCREEN relaciona-se com um comando definido para aplicação para a tela atual. Tanto SCREEN quanto ITEM provavelmente nunca serão mapeados a uma tecla específica do aparelho, mas sim apenas quando estiverem em destaque.

Para receber feedback do acionamento dos comandos, seu midlet precisa implementar a interface CommandListener, e o método commandAction(). Já fizemos isso em nosso midlet HelloWorld:

<code java>
alert.addCommand(comExit);
// adds a listener to the form
alert.setCommandListener(this);
[...]
public void commandAction(Command cmd, Displayable display) {
if (cmd == comExit) {
exit();
}
}
</code>

Como você pode ver, o método commandAction() recebe dois parâmetros: o Comando sendo executado e o Displayable atualmente sendo mostrado na tela.

=== Alert ===

Como você se lembra, utilizamos um alerta em nosso midlet Hello World; este elemento representa uma tela que mostra alguma mensagem ao usuário e aguarda um período de tempo antes de proceder para o próximo Displayable. Um alerta pode conter uma string de texto, um título e uma imagem. O uso ideal de um Alert é para informar ao usuário sobre erros ou alguma condição excepcional.

=== TextBox ===

A classe TextBox é uma Screen que permite ao usuário entrar e editar texto. Este elemento pode ser adaptado para suas necessidades especiais. Você pode restringir o número máximo de caracteres que o usuário pode digitar , e também o tipo de texto que é aceito. Existem seis flags para restringir o conteúdo: ANY, EMAILADDR, NUMERIC, PHONENUMBER, URL, and DECIMAL. ANY permite todos os tipos de texto, enquanto as outras flags atuam de acordo com seus nomes.

De maneira similar, existem seis flags que afetam o display em si. Estas são: PASSWORD, UNEDITABLE, SENSITIVE, NON_PREDICTIVE, INITIAL_CAPS_WORD, and INITIAL_CAPS_SENTENCE.
Por exemplo, para aceitar apenas endereços de e-mail em um textbox, você precisa definir a flag TextField.EMAILADDR usando o método setConstraints(). Para fazer este campo de texto ser apenas de leitura, você precisa combinar a flag com TextField.UNEDITABLE. Isto é feito utilizando-se uma operação bitwise OR entre as duas, como se segue: setConstraints(TextField.EMAILADDR | TextField.UNEDITABLE);.

Para definir o conteúdo de um textbox, você pode usar o médoto setString() para definir o conteúdo completo, ou insert() para inserir mais texto em adição ao que já está digitado. A listagem mais abaixo (a terceira) mostra como usar ambos os métodos:

=== List ===

Uma lista contém um conjunto de escolhas. Quando uma lista está presente no Display, o usuário pode interagir com a mesma selecionando elementos e rolando através deles. A lista pode ser configurada para ser:

* Choice.EXCLUSIVE - apenas um elemento pode ser selecionado
* Choice.MULTIPLE - múltiplos elementos podem ser selecionados
* Choice.IMPLICIT - o elemento em destaque é automaticamente selecionado

=== Form ===

A Form is a Screen that contains an arbitrary mixture of items. In general, any subclass of the Item class may be contained within a form. The implementation handles layout, traversal, and scrolling. The entire contents of the Form scrolls together.

There are eight Item types that can be added to a form.
* StringItem, a label that cannot be modified by the user. This item may contain a title and text, both of which may be null to allow it to act as a placeholder. The Form class provides a shortcut for adding a StringItem, without a title: append(String text)
* DateField, allows the user to enter date/time in one of three formats: DATE, TIME, or DATE_TIME.
* TextField, same as a TextBox.
* ChoiceGroup same as a List.
* Spacer, used for positioning UI elements by putting some space between them. This element is an invisible UI element and can be set to a particular size.
* Gauge, a gauge is used to simulate a progress bar. However, this progress bar look can also be used in an interactive mode by the user. For example, if you wanted to show the user a volume control, a gauge would be used to show an interactive knob.
* ImageItem, an item that holds an image! Like the StringItem, the Form class provides a shortcut method for adding an image: append(Image image). More about images in a later section.
* CustomItem, it's an abstract class that allows the creation of subclasses that have their own appearances, their own interactivity, and their own notification mechanisms. If you require a UI element that is different from the supplied elements, you can subclass CustomItem to create it for addition to a form.

=== User Interface Examples ===
In order to learn how to use all these classes let’s create a simple interface for our Arkanoid game. We will implement the following screens:

[[Image:UI-Exercise-GameInteface.png]]

For each of these game screens we are going to create a init[ScreenName] method that will inicialize the screen and returns the created Displayable element.

For the Main Menu we will use the List component to show the main options, check the code bellow:
<code java>
public Displayable initMainForm() {
if (mainForm == null) {
// creates a implicit List where the current element is
// the selected
mainForm = new List("Menu", List.IMPLICIT);
// append list options
mainForm.append("New Game", null);
mainForm.append("Options", null);
mainForm.append("Scores", null);
mainForm.append("Help", null);
mainForm.append("Exit", null);

// adds a select Command
comSelect = new Command("Select", Command.ITEM, 1);
mainForm.setSelectCommand(comSelect);

// adds a listener to the form
mainForm.setCommandListener(this);
}
return mainForm;
}
</code>
For the settings menu we choose a Form element where we added a Choice Group for Sound Options ( On-Off)
<code java>
public Displayable initSettingsForm() {
// check if already created
if (settingsForm == null) {
settingsForm = new Form("Settings");
settingsForm.addCommand(initBackCommand());
settingsForm.setCommandListener(this);
// creates a choice Group for sound options
soundChoice = new ChoiceGroup("Sound", List.EXCLUSIVE);
soundChoice.append("On", null);
soundChoice.append("Off", null);
// appends the choice to the form
settingsForm.append(soundChoice);
}

return settingsForm;
}
</code>
For the help screen we choosed a simple Form with an static message:
<code java>
public Displayable initHelpForm() {
if (helpForm == null) {
helpForm = new Form("Help");
helpForm
.append("User cursors to move your pad, don't let "+
"the ball go by you, hit all the bricks!");
helpForm.setCommandListener(this);
helpForm.addCommand(initBackCommand());
}
return helpForm;
}
</code>

To introduce a new high score we are going to use a Form with an TextField and a Date Field:

<code java>
public Displayable initNewHighScore(int score, int pos) {
if (newHighScoreForm == null) {
newHighScoreForm = new Form("New High Score");
newHighScoreForm.setCommandListener(this);
// create items
highScoreName = new TextField("Name", "", 20, TextField.ANY);
highScoreValue = new StringItem("Score", Integer.toString(score));
highScorePosition = new StringItem("Position", Integer.toString(pos));
// create save command
highScoreSave = new Command("Save", Command.OK, 1);
// append command and itens to screen
newHighScoreForm.addCommand(highScoreSave);
newHighScoreForm.append(highScoreName);
newHighScoreForm.append(highScoreValue);
newHighScoreForm.append(highScorePosition);
}
// update score
highScoreValue.setText(Integer.toString(score));
// update pos
highScorePosition.setText(Integer.toString(pos)+1);
return newHighScoreForm;
}
</code>

We are going to leave the game screen for the next lesson but at the moment let's create a method that emulates the end of the game and use it instead.

<code java>
public void endGame(int lifes, int score, int time) {
Displayable nextScreen = initMainForm();
String message;
if (lifes == 0) {
message = "Game Over!!";
} else {
message = "You Win!";
}
int pos = isHighScore(score);
if (pos != -1) {
nextScreen = initNewHighScore(score, pos);
}

display(new Alert(message, message, null, AlertType.INFO), nextScreen);
}
</code>

Now that we have all our screens created we need to link them in the commandAction method. Let's rewrite our code:

<code java>
public void commandAction(Command cmd, Displayable display) {
// check what screen is being displayed
if (display == mainForm) {
// check what command was used
if (cmd == comSelect) {
switch (mainForm.getSelectedIndex()) {
case (0):
// At the moment just go directly to the end of the game
endGame(1, 200, 50);
break;
case (1):
display(initSettingsForm());
break;
case (2):
display(initScoreForm());
break;
case (3):
display(initHelpForm());
break;
case (4):
exit();
break;
}
}
} else if (display == highScoreForm) {
if (cmd == comBack) {
display(initMainForm());
}
} else if (display == settingsForm) {
if (cmd == comBack) {
soundOn = soundChoice.getSelectedIndex() == 0;
display(initMainForm());
}
} else if (display == helpForm) {
if (cmd == comBack) {
display(initMainForm());
}
} else if (display == newHighScoreForm) {
if (cmd == highScoreSave) {
int pos = Integer.parseInt(highScorePosition.getText())-1;
// advance all the scores
for ( int i = scores.length-1; i > pos ; i--){
scores[i].name = scores[i-1].name;
scores[i].value = scores[i-1].value;
scores[i].when = scores[i-1].when;
}
// insert new score
scores[pos].name = highScoreName.getString();
scores[pos].value = Integer.parseInt(highScoreValue.getText());
scores[pos].when = new Date();
display(initScoreForm());
}
}
}
</code>

Inside the commandAction you specify all the menu logic for our midlet, deciding what to do next depending of what display is being showed and what Command was selected.
From the main menu we simple redirect the user for each specific screen. For the other screens, at the moment, we only have an back command. The only exception is the NewHighScores form where a save command already stores the information to an scores array.

You may have noticed the use of an the display() method, this is a simple helper method to active an Displayable.
<code java>
public void display(Displayable display) {
// shows display in the screen.
Display.getDisplay(this).setCurrent(display);
}
</code>

Noe just run you midlet and finally you can enjoy your first Game Interface! Next lesson we are going to implement the Game Screen, see you soon.

Downloads:
*[http://sergioestevao.com/midp/wp-content/uploads/2007/11/lesson2-source.rar Full Source Code]
*[http://sergioestevao.com/midp/wp-content/uploads/2007/11/formacao2.jad Jad File]
*[http://sergioestevao.com/midp/wp-content/uploads/2007/11/formacao2.jar Jar File]

[[Category:Java]][[Category:Java ME]][[Category:Games]][[Category:How To]][[Category:Code Examples]]

← Older revision		Revision as of 04:26, 10 November 2011
Line 1:		Line 1:
−	[[Category:Java ME]]	+	{{ArticleMetaData
		+	\|sourcecode= <!-- Link to example source code e.g. [[Media:The Code Example ZIP.zip]] -->
		+	\|installfile= <!-- Link to installation file (e.g. [[Media:The Installation File.sis]]) -->
		+	\|devices= <!-- Devices tested against - e.g. ''devices=Nokia 6131 NFC, Nokia C7-00'') -->
		+	\|sdk= <!-- SDK(s) built and tested against (e.g. [http://linktosdkdownload/ Nokia Qt SDK 1.1]) -->
		+	\|platform= <!-- Compatible platforms - e.g. Symbian^1 and later, Qt 4.6 and later -->
		+	\|devicecompatability= <!-- Compatible devices e.g.: All* (must have internal GPS) -->
		+	\|dependencies= <!-- Any other/external dependencies e.g.: Google Maps Api v1.0 -->
		+	\|signing=<!-- Signing requirements - empty or one of: Self-Signed, DevCert, Manufacturer -->
		+	\|capabilities=<!-- Capabilities required by the article/code example (e.g. Location, NetworkServices. -->
		+	\|keywords= <!-- APIs, classes and methods (e.g. QSystemScreenSaver, QList, CBase -->
		+	\|id= <!-- Article Id (Knowledge base articles only) -->
		+	\|language=Lang-Portuguese
		+	\|translated-by= <!-- [[User: XXXXX]] -->
		+	\|translated-from-title=<!-- Title only -->
		+	\|translated-from-id= <!-- Id of translated revision -->
		+	\|review-by=<!-- After re-review: [[User:username]] -->
		+	\|review-timestamp=<!-- After re-review: YYYYMMDD -->
		+	\|update-by=<!-- After significant update: [[User:username]]-->
		+	\|update-timestamp=<!-- After significant update: YYYYMMDD -->
		+	\|creationdate=20071129
		+	\|author=[[User:Dcrocha]]
		+	}}[[Category:Java ME]]
	Já que a interação com o usuário é uma das preocupações principais em qualquer aplicação móvel, devido ao tamanho das telas, é importante que você entenda o básico desta faceta dos MIDlets. Neste artigo, você aprenderá quais elementos de UI estão disponíveis em um MIDlet e como usá-los para criar a interface para o nosso clone do jogo Arkanoid.		Já que a interação com o usuário é uma das preocupações principais em qualquer aplicação móvel, devido ao tamanho das telas, é importante que você entenda o básico desta faceta dos MIDlets. Neste artigo, você aprenderá quais elementos de UI estão disponíveis em um MIDlet e como usá-los para criar a interface para o nosso clone do jogo Arkanoid.

@@ Line 1: / Line 1: @@
 Já que a interação com o usuário é uma das preocupações principais em qualquer aplicação móvel, devido ao tamanho das telas, é importante que você entenda o básico desta faceta dos MIDlets. Neste artigo, você aprenderá quais elementos de UI estão disponíveis em um MIDlet e como usá-los para criar a interface para o nosso clone do jogo Arkanoid.
@@ Line 286: / Line 287: @@
 *[http://sergioestevao.com/midp/files/2009/04/formacao2.jar Jar File]
-[[Category:Java ME_(Português)]][[Category:Code Examples]][[Category:Lang-Portuguese]]
+[[Category:Code Examples]][[Category:Lang-Portuguese]]

← Older revision		Revision as of 05:19, 14 July 2011
Line 286:		Line 286:
	*[http://sergioestevao.com/midp/files/2009/04/formacao2.jar Jar File]		*[http://sergioestevao.com/midp/files/2009/04/formacao2.jar Jar File]

−	[[Category:Java ME_(Português)]][[Category:~~Exemplos de código Java ME~~]][[Category:Lang-PT]]	+	[[Category:Java ME_(Português)]][[Category:Code Examples]][[Category:Lang-Portuguese]]

@@ Line 282: / Line 282: @@
 <strong>Downloads:</strong>
-*[http://sergioestevao.com/midp/wp-content/uploads/2007/11/lesson2-source.rar Full Source Code]
+*[http://sergioestevao.com/midp/files/2009/04/lesson2-source.rar Full Source Code]
-*[http://sergioestevao.com/midp/wp-content/uploads/2007/11/formacao2.jad Jad File]
+*[http://sergioestevao.com/midp/files/2009/04/formacao2.jad Jad File]
-*[http://sergioestevao.com/midp/wp-content/uploads/2007/11/formacao2.jar Jar File]
+*[http://sergioestevao.com/midp/files/2009/04/formacao2.jar Jar File]
 [[Category:Java ME_(Português)]][[Category:Exemplos de código Java ME]][[Category:Lang-PT]]

@@ Line 86: / Line 86: @@
 Existem oito tipos de Item que podem ser adicionados a um Form:
-There are eight Item types that can be added to a form.
+* <strong>StringItem</strong>, um rótulo que não pode ser modificado pelo usuário. Este item pode conter um título e texto, e ambos podem ser nulos para marcar o local como um placeholder. A classe Form provê um atalho para se adicionar um StringItem sem título: append(String text)
-* <strong>StringItem</strong>, a label that cannot be modified by the user. This item may contain a title and text, both of which may be null to allow it to act as a placeholder. The Form class provides a shortcut for adding a StringItem, without a title: append(String text)
+* <strong>DateField</strong>, permite que o usuário entre valores de dados e tempo em um dos três formatos: DATE, TIME, or DATE_TIME.
-* <strong>DateField</strong>, allows the user to enter date/time in one of three formats: DATE, TIME, or DATE_TIME.
+* <strong>TextField</strong>, o mesmo que um TextBox.
-* <strong>TextField</strong>, same as a TextBox.
+* <strong>ChoiceGroup</strong> o mesmo que uma List.
-* <strong>ChoiceGroup</strong> same as a List.
+* <strong>Spacer</strong>, usado para posicionar elementos de UI através da colocação de alguns espaços entre eles. Este elemento é invisível e pode ter seu tamanho definido para qualquer valor.
-* <strong>Spacer</strong>, used for positioning UI elements by putting some space between them. This element is an invisible UI element and can be set to a particular size.
+* <strong>Gauge</strong>, é usado para simular uma barra de progresso. Entretanto, esta barra de progresso também pode ser usada de modo interativo pelo usuário, por exemplo como um controle de volume.
-* <strong>Gauge</strong>, a gauge is used to simulate a progress bar. However, this progress bar look can also be used in an interactive mode by the user. For example, if you wanted to show the user a volume control, a gauge would be used to show an interactive knob.
+* <strong>ImageItem</strong>, um item que possui uma imagem. Como o StringItem, a classe Form também fornece um atalho para adicionar uma imagem:: append(Image image). Mais sobre imagem em uma seção posterior.
-* <strong>ImageItem</strong>, an item that holds an image! Like the StringItem, the Form class provides a shortcut method for adding an image: append(Image image). More about images in a later section.
+* <strong>CustomItem</strong>, é uma classe abstrata que permite a criação de subclasses de Item que tenha sua própria aparência customizável, assim como sua interatividade e mecanismos de notificação. Se você deseja um componente gráfico que seja muito diferente dos elementos fornecidos por padrão, você pode criar um CustomItem e adicioná-lo a um Form.
-* <strong>CustomItem</strong>, it's an abstract class that allows the creation of subclasses that have their own appearances, their own interactivity, and their own notification mechanisms. If you require a UI element that is different from the supplied elements, you can subclass CustomItem to create it for addition to a form.
-=== User Interface Examples ===
+=== Exemplos de interface gráfica ===
 In order to learn how to use all these classes let’s create a simple interface for our Arkanoid game. We will implement the following screens:

@@ Line 96: / Line 96: @@
 === Exemplos de interface gráfica ===
-In order to learn how to use all these classes let’s create a simple interface for our Arkanoid game. We will implement the following screens:
+Para aprender a usar todas essas classes, vamos criar uma interface simples para o nosso jogo Arkanoid. Implementaremos as seguintes telas:
 [[Image:UI-Exercise-GameInteface.png]]
-For each of these game screens we are going to create a init[ScreenName] method that will inicialize the screen and returns the created Displayable element.
+Para cada uma das telas criaremos um método init[ScreenName] que inicializará cada uma das telas e retornará o elemento Displayable criado.=
 <code java>
 public Displayable initMainForm() {
@@ Line 126: / Line 127: @@
+}
 </code>
-For the settings menu we choose a Form element where we added a Choice Group for Sound Options ( On-Off)
+Para o menu de configurações escolhemos um elemento Form onde adicionamos um ChoiceGroup para opções de Som (On-Off)
 <code java>
 public Displayable initSettingsForm() {
@@ Line 145: / Line 147: @@
+}
 </code>
-For the help screen we choosed a simple Form  with an static message:
 <code java>
 public Displayable initHelpForm() {
@@ Line 160: / Line 163: @@
 </code>
-To introduce a new high score we are going to use a Form with an TextField and a Date Field:
+Para introduzir um novo high score usaremos um Form com um TextField e um Date Field:
 <code java>
@@ Line 187: / Line 190: @@
 </code>
-We are going to leave the game screen for the next lesson but at the moment let's create a method that emulates the end of the game and use it instead.
+Deixaremos a tela de jogo para a próxima lição, mas no momento vamos criar um método que simula o final do jogo e usá-lo:
 <code java>
@@ Line 207: / Line 210: @@
 </code>
-Now that we have all our screens created we need to link them in the commandAction method. Let's rewrite our code:
+Agora que temos todas as nossas telas, precisamos ligá-las ao método commandAction(). Vamos reescrever nosso código:
 <code java>
@@ Line 266: / Line 269: @@
 </code>
-Inside the commandAction you specify all the menu logic for our midlet, deciding what to do next depending of what display is being showed and what Command was selected.
+Dentro do método commmandAction() você especifica toda a lógica do menu para nosso midlet, decidindo o que fazer dependendo de qual displayable está sendo mostrado e de qual comando foi selecionado. A partir do menu principal simplesmente redirecionamos o usuário para cada tela específica. Para as outras telas, temos apenas um comando, "Back", por enquanto. A única exceção é a tela NewHighScores onde um comando "Save" guarda os high scores em um vetor.
-From the main menu we simple redirect the user for each specific screen. For the other screens, at the moment, we only have an  back command. The only exception is the NewHighScores form where a save command already stores the information to an scores array.
-You may have noticed the use of an the display() method, this is a simple helper method to active an Displayable.
+Você pode ter notado o uso do método display(), que é apenas um simples helper para ativar um Displayable.
 <code java>
 public void display(Displayable display) {
@@ Line 277: / Line 279: @@
 </code>
-Noe just run you midlet and finally you can enjoy your first Game Interface! Next lesson we are going to implement the Game Screen, see you soon.
+Agora rode seu midlet e finalmente você terá sua primeira interface gráfica. Na próxima lição, implementaremos a tela Game Screen.
 <strong>Downloads:</strong>
@@ Line 284: / Line 286: @@
 *[http://sergioestevao.com/midp/wp-content/uploads/2007/11/formacao2.jar Jar File]
-[[Category:Java]][[Category:Java ME]][[Category:Games]][[Category:How To]][[Category:Code Examples]]
+[[Category:Java ME_(Português)]][[Category:Exemplos de código Java ME]][[Category:Lang-PT]]

@@ Line 82: / Line 82: @@
 === Form ===
-A Form is a Screen that contains an arbitrary mixture of items. In general, any subclass of the Item class may be contained within a form. The implementation handles layout, traversal, and scrolling. The entire contents of the Form scrolls together.
+Um Form é uma Screen que contém uma mistura arbitrária de itens. Em geral, qualquer subclasse da classe Item pode estar contida dentro de um Form. A implementação ajusta o layout, traversal e scrolling. Todo o conteúdo de um form é rolado (scrolled) de forma conjunta.
 There are eight Item types that can be added to a form.