Tópico I

Submarino

16 Abril de 2010
Introducción
Este proyecto llamado “Submarino”, consiste en la realización de un juego de
estrategia muy conocido por muchos y que su funcionamiento se describe a
continuación.

Este juego consiste en que al mover una bomba por una cuadricula, y este
mismo quede situado en una posición, y al momento de tirarla se adivine si se
encuentra o no el submarino, pretendiendo que si el tiro es cercano, el
submarino cambie su posición inicial para tratar de eludir el siguiente tiro, el
juego termina si el jugador acierta su tiro y hunde el submarino. En el
transcurso de este documento conoceremos y entenderemos de una mejor
manera su funcionamiento y la manera en como fue creado, también
conoceremos el objetivo de la realización de este juego, una aplicación para
dispositivos móviles (celulares).

Objetivo
El objetivo de crear este juego es conocer mas a fondo lo que es la
programación de dispositivos móviles, así como usar todas las herramientas
que se han visto hasta este momento.
Al conocer mas acerca de la programación de dispositivos móviles, nos damos
cuenta que los códigos son muy parecidos a las aplicaciones que veníamos
creando anteriormente, así con la ayuda de estas podemos complementar y
desarrollar de una mejor manera este proyecto. También se tiene el
conocimiento de la manera en la que se administras los dispositivos móviles,
ya que son equipos demasiado limitados, como puede ser su memoria de
almacenamiento o su memoria RAM, su sistema operativo y los gráficos que
estos dispositivos pueden soportar. Tomando en cuenta todas estas
características se procede a la implementación para desarrollar el siguiente
juego.
Diagrama de Flujo
El siguiente diagrama muestra la manera en como se fue creando cada parte de este juego,
se realizo en Visio 2007.
Inicio

Dibujar cuadricula

Barco x-----valor aleatorio

Barco y----valor aleatorio
P----valor aleatorio
i----0
J----0
M i,j----0
R-----0
Barco---imagen «barco.png»
misil---misil «misil.png»
Acierto---acierto»acierto.png»
Fallar---fallar»fallar.png»

M(barco x,barco y)-----1 1

No

2 ¿ se presiono tecla?

No

Si

2
¿flecha hacia arriba? Si J----j-1 J <0 Si J----0

No No

¿flecha hacia abajo? Si J--- j+1 J >7 Si J----7

No

¿flecha hacia la
derecha?

¿flecha hacia la
izquierda?
Parte 2.

¿ se presionó tecla de
2 No disparo?

M i,j=1 Si «impacto»

Fin
No

3
X----- |barco x-i|
Y------|barcoy-j|

¿i<=1 and
Si Mover barco 2
j<=1?

No

X----|barco x+1i|

¿i<=1 and
si 3
j<=1?

No

«Falla»

2
Código de la aplicación “Submarino” realizado en (NetBeans
6.7).
Midlet

package Marino;

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class SubmarinoGameCanvasMidlet extends MIDlet

{
private Display display;

public void startApp()

{

display = Display.getDisplay(this);
SubmarinoGameCanvas gameCanvas = new
SubmarinoGameCanvas();
gameCanvas.start();
display.setCurrent(gameCanvas);
}
public Display getdisplay()
{
return display;
}
public void pauseApp() {
}

public void destroyApp(boolean unconditional)

{
exit();
}

public void exit()

{
System.gc();
destroyApp(false);
notifyDestroyed();
}

}
Canvas
package Marino;

import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;
import java.io.*;
import java.util.*;

public class SubmarinoGameCanvas extends GameCanvas implements Runnable {

private boolean Play;// para cilcar el juejo "verdadero"

private long delay;// retardos
private int currentX, currentY;// retiene la posicion actual 'X'
private int width;// Ancho pantalla
private int height;// Alto pantalla
private int auno;//a;
private int buno=0;//b=0;
//private int i=0;
private int uno;//equis; mismas variables
private int dos;//ye; mismas variables
private int xuno;//x;
private int yuno;//y;
private int subcerk;//cerca;
private int sublejos;//lejos;
private int posicion;//orientacion;
private int posx;//corx;
private int posy;//cory;
int matriz[][];
//Iniciando constructor

public SubmarinoGameCanvas() {
super(true);
width = getWidth();
height = getHeight();
posx=0;
posy=0;
int vary=getHeight()/20;
int varx=getWidth()/20;
Random randomx = new Random ();
Random randomy = new Random ();
Random randomz = new Random ();
posicion=randomz.nextInt(2);
uno= randomx.nextInt(varx);
dos= randomx.nextInt(vary);
 currentX = 0 ; // Centro horizontal
currentY = 0 ; // Centro vertial
posx = 0;
posy= 0;
delay = 30; // 30 ms
}

// Inicimos de manera automática en juego

public void start(){
Play = true;
Thread t = new Thread(this);
t.start();
}
public void stop(){
Play = false;
}
//enlazamos la parte principal del juego
public void run(){
Graphics g = getGraphics();
while (Play == true)
{
input();
paint(g);
try {
Thread.sleep(delay);
delay=30;
}
catch (InterruptedException ie) {}
}
}
//Entradas del usuario
public void input(){
int paramy=getHeight()/20;//numeroyy--variable
int keyStates = getKeyStates();
int paramx=getWidth()/20;//numeroxx--variable

// movimiento a la Izquierda
if ((keyStates & LEFT_PRESSED) != 0)

{
posx = Math.max(0, posx - 20);
xuno=xuno-1;
if (xuno<0){
xuno=0;
}
System.out.print("X");
System.out.println(xuno);
 if ( posx <0){
posx=0;

}
}
// Movimiento a la Derecha
if ((keyStates & RIGHT_PRESSED) !=0 )
if ( posx < width-25){
posx = Math.min(width,posx + 20);
xuno=xuno+1;
if(xuno>paramx){
xuno=paramx;
}
System.out.print("X");
System.out.println(xuno);

}
// Movimiento hacia Arriba
if ((keyStates & UP_PRESSED) != 0){
posy = Math.max(0, posy - 20);
yuno=yuno-1;
if (yuno<0){
yuno=0;
}
System.out.print("Y");
System.out.println(yuno);
if ( posy < 0){
posy=0;
}
}
// Movimiento hacia Abajo
if ((keyStates & DOWN_PRESSED) !=0)
if ( posy < height-50)
{
posy = Math.min(height,posy + 20);
yuno=yuno+1;
if (yuno>paramy){
yuno=paramy;
}
System.out.print("Y");
System.out.println(yuno);
}
// Para Disparar
if ((keyStates & FIRE_PRESSED) !=0){
System.out.println("Detectado el Fire");
if (matriz[xuno][yuno]==1){
 System.out.println("Felicidades ¡¡GANASTE!!");
auno=1;
}
else {
sublejos=1;
}
}
}

public void paint(Graphics g) {

int ancho=0;
int alto=0;
try{
Image img = Image.createImage("subma1.PNG");
Image img1 = Image.createImage("misil2.PNG");
Image img2 = Image.createImage("explo4.PNG");
g.drawImage(img, currentX, currentY, Graphics.TOP | Graphics.LEFT);
// Fondo de pantalla
g.setColor(0,0,255);
g.fillRect(0, 0, getWidth(), getHeight());
// Colocamos la imagen en el centro de la pantalla
ancho = getWidth();
alto = getHeight();
// Trazamos una matriz
g.fillRect(0, 0, ancho, alto);
g.setColor(255, 255,255);
int numx=ancho/20;
int numy=alto/20;
int secxx=0;
int secyy=0;
// ciclo para lineas horizontales
for (int i=0; i<=numx; i++){
g.drawLine(secxx, 0, secxx,height);
secxx=secxx+20;
}
// ciclo para lineas verticales
for (int j=0; j<=numy; j++){
g.drawLine(0, secyy, width,secyy);
secyy=secyy+20;
}
//creamos la matriz en donde se ocultara el submarino
matriz= new int [numx][numy];
// se llena con ceros
for (int i=0; i<numx;i++){
for (int j=0; j<numy; j++){
matriz[i][j]=0;
}
 }
// pocicion aleatoria al submarino dentro de la matriz y se le asigna un uno en medio
de ceros
// se especifica mediante el random orientacion si es horizontal o vertical 0 o 1
if (posicion==0){
if (uno==numx){
uno=uno-1;
}
matriz[uno][dos]=1;
matriz[uno+1][dos]=1;
}
else{
if (dos==numy){
dos=dos-1;
}
matriz[uno][dos]=1;
matriz[uno][dos+1]=1;
}
// si vale 1+ o 1- y que compare si son esos valores =1 gana si es cero pierde y para
estar cerca
// que compare el valor de uno y dos con los que va contar (xuno,yuno)
if (posicion==0){
g.drawImage(img, uno*20, dos*20, Graphics.TOP | Graphics.LEFT);
g.drawImage(img, (uno*20)+20, dos*20, Graphics.TOP | Graphics.LEFT);
}
if (posicion==1){
g.drawImage(img, uno*20, dos*20, Graphics.TOP | Graphics.LEFT);
g.drawImage(img, uno*20, (dos*20)+20, Graphics.TOP | Graphics.LEFT);
}
if (sublejos==1){
g.setColor(255, 0, 0);
g.drawString("LEJOS!!", 20, 0, Graphics.TOP |Graphics.LEFT);
sublejos=0;
delay=300;
}
/**if (subcerk==1){
g.drawString("CERCA", 20, 100, Graphics.TOP |Graphics.LEFT);
subcerk=0;
delay=400;
}*/
if (auno==1){
g.setColor(255, 0, 0);
g.drawString("¡¡¡Winner!!!!!", 20, 0, Graphics.TOP |Graphics.LEFT);
buno=1;
}
if (buno==1){
g.drawImage(img2, posx, posy, Graphics.TOP | Graphics.LEFT);
 buno=0;
auno=0;
delay=5000;
}
else{
g.drawImage(img1, posx, posy, Graphics.TOP | Graphics.LEFT);
}
flushGraphics();
}
catch (IOException ex)
{
System.err.println("Error al leer la imagen");
}
}
}

Fotos de la aplicación

Inicia la
Aplicación, la
bomba parte
superior y el
submarino
parte inferior,
en este caso
aparece el
submarino
para simular el
ejemplo.

En esta parte
se esta
simulando un
tiro lejano.
En esta
última parte
se muestra el
mensaje de
ganador y el
submarino
hundido, el
juego a
terminado.