You are on page 1of 6

Clase canvas

import javax.microedition.lcdui.Canvas;
/* La clase Canvas permite manejar eventos de bajo nivel y dibujar en pantallas con las primitivas
grficas, escribir texto y dibujar imgenes, por esta razn se utiliza como base para realizar juego.
*/

import javax.microedition.lcdui.Graphics;
/*
Proporciona sencilla capacidad de representacin geomtrica
*/
import javax.microedition.lcdui.Font; //clase representa fuentes y medidas de fuente

public class canvas extends Canvas implements Runnable {


//Declaraciones de variables para el desarrollo de este proyecto.

int ancho, alto, player1X, player1Y, player2X, player2Y, anchoPlayer, altoPlayer;


//Esta primera parte de variables corresponde a jugador1 y jugador2 para poder disear
// las pequeas barritas donde se encargara de pegarle a la pelota.
// recordar que como el ancho y alto se tiene que poner ciertas medidas.

int move, ballX, ballY, anchoBall, altoBall, moveBallX, moveBallY;


//Al igual que las medias y variables de jugador1 y jugador2 esto es para la polota de PingPong

int scoreP1, scoreP2;


// Nota: en el metodo paint(Graphics g) hay asiganamos las medidas de amobos jugadores.
// Recuerda que son las barritas que golpean a la pelota de PingPong
//velocidad del juego (long delay)

long delay = 60L;


boolean enJuego, enPausa, up, down, left, right;
main midlet;
public canvas(main midlet) {
this.setFullScreenMode(true); //Controla si el lienzo est en modo de pantalla completa o en
modo normal.
// Nota que es lienzo: es el espacio en el que pintamos o trabajamos cuando se utilizan aplicaciones de
diseo grfico.

this.midlet = midlet;
}
public void initGame() {
ancho = this.getWidth(); //el getWidth me sirve para poner sin ningn problema la dimensin de un
//Color que va abarcar mi pantalla de la aplicacin. Esto Corresponde al tamao en ancho

alto = this.getHeight(); // el getHeight realiza lo mismo que getWidth solo que su tamao
// corresponde a lo alto.

//dimensiones de los jugadores

anchoPlayer = ancho / 24;


altoPlayer = alto / 8;
//dimensiones del pelota

anchoBall = ancho / 28;


altoBall = alto / 24;
ballX = ancho / 2 - anchoBall / 2;
ballY = alto / 2 - altoBall / 2;
move = alto / 32;
moveBallX = moveBallY = -move / 2;
scoreP1 = scoreP2 = 0;
player1Y = player2Y = alto / 2 - altoPlayer / 2;
player1X = 0;
player2X = ancho - anchoPlayer;
enJuego = true;
enPausa = false;
up = down = left = right = false;
new Thread(this).start();
}
public void run() { // el mtodo run().En Java un hilo es un objeto con capacidad de correr en forma
concurrente

while (enJuego) {
this.repaint();
this.serviceRepaints(); //Este mtodo bloquea hasta las solicitudes pendientes han sido
administrados .
//Si no hay repinta pendientes, o si este lienzo no es visible en la pantalla , esta llamada no hace nada
//y devuelve inmediatamente.
//que es Repaints repinta solamente aquellos Componentes que necesitan ser repintados

Thread.yield(); //Hace que el objeto hilo de ejecucin actual para detener temporalmente y
//permiten otros hilos para ejecutar .

try {
Thread.sleep(delay); //Hace que el hilo se est ejecutando actualmente para dormir
//(cesar temporalmente la ejecucin) por el nmero especificado de milisegundos.

} catch (InterruptedException ie) {


ie.printStackTrace(); //Este mtodo imprime una traza de la pila para el flujo de salida de error
//que es la traza Ayuda a encontrar encontrar errores.
//Ayuda a depurar depurar programas programas (multihilo multihilo,distribuidos distribuidos, etc)
//Permite Permite mejorar mejorar el rendimiento rendimiento.

}
}
}

//mover arriba abajo el player presionando tecla

protected void keyPressed(int keycode) {


//Se llama cuando se presiona una tecla .
//El mtodo getGameAction () puede ser llamado para determinar qu juego de accin , en su caso ,
//se asigna a la tecla. Clase lienzo tiene una implementacin vaca de este mtodo , y la subclase
//tiene que redefinirla si quiere escuchar este mtodo.

if (!enPausa) {
switch (getGameAction(keycode)) {
case UP:
up = true;
break;
case DOWN:
down = true;
break;
case LEFT:
// Implementar cdigo cuando presionas tecla izquierda

break;
case RIGHT:
// Implementar cdigo cuando presionas tecla derecha.

break;
case FIRE:
midlet.salirDelJuego();
break;
}
}
}
//mover arriba abajo el player soltando tecla

protected void keyReleased(int keycode) {


//Se llama cuando se suelta una tecla .

if (!enPausa) {
switch (getGameAction(keycode)) {
case UP:
up = false;
break;
case DOWN:
down = false;
break;
case LEFT:
// Implementar cdigo cuando sueltas tecla izquierda

break;
case RIGHT:
// Implementar cdigo cuando sueltas tecla derecha.
break;
case FIRE:
midlet.salirDelJuego();
break;
}
}
}

//movimiento del player1 arriba abajo

public void realizarMovimiento() {


if (!enPausa) {
if (up) {
player1Y -= move;
if (player1Y < 0) {
player1Y = 0;
}
}
if (down) {
player1Y += move;
if ((player1Y + altoPlayer) > alto) {
player1Y = alto - altoPlayer;
}
}
if (left) {
}
if (right) {
}
}
}
public void moverPelota() {
ballX += moveBallX;
ballY += moveBallY;
//colisiones de la ball con los player 1 y 2

if (ballY >= player1Y && ballY <= (player1Y + altoPlayer) && ballX >= player1X &&
ballX <= (player1X + anchoPlayer)) {
moveBallX = moveBallX * -1;
}
if (ballY >= player2Y && ballY <= (player2Y + altoPlayer) && ballX >= player2X &&
ballX <= (player2X + anchoPlayer)) {
moveBallX = moveBallX * -1;
}
if (ballX < 0 || ballX > ancho) {
if (ballX < 0) {
scoreP2++;
} else if (ballX > ancho) {
scoreP1++;
}
ballX = ancho / 2 - anchoBall / 2;
ballY = alto / 2 - altoBall / 2;
moveBallX = moveBallX *= -1;
moveBallY = moveBallY * -1;
}
if (ballY < 0 || ballY > alto) {
moveBallY = moveBallY * -1;
}
}

//movimieto de la pelota junto al player 2

public void generarMovimientoArtificial() {


if (player2Y < (ballY - altoBall / 2)) {
if (moveBallY > 0) {
player2Y += move;
}
} else if ((player2Y > ballY)) {
if (moveBallY < 0) {
player2Y -= move;
}
}
if ((player2Y + altoPlayer) > alto) {
player2Y = alto - altoPlayer;
}
if (player2Y < 0) {
player2Y = 0;
}
}
public void paint(Graphics g) {
//color del fondo

g.setColor(0,0,255); // Por lo regular g.setColor recibe 4 parmetros solo se utiliza para poner color
//este nmero 0,0,255 corresponde a que estoy poniendo un color azul de fondo.

g.fillRect(0, 0, ancho, alto); // Al igual que el g.setColor recibe 4 parmetros la coordenada


x,y,ancho y alto
//la diferencia es que g.fillRect es para la dimensin de la pantalla.
//Nota Importante xfavor: Estoy llamando mis variables ancho, alto esto donde estas recuerda
// el mtodo public void initGame() hay yo asigno que alto es = this.getHeight()
// y que ancho es igual a = getWidth()
moverPelota();
generarMovimientoArtificial();
realizarMovimiento();
drawplayer1(g);
drawplayer2(g);
drawball(g);
//color del texto

g.setColor(255,255,0);
Font f = Font.getFont(Font.FACE_MONOSPACE, Font.STYLE_BOLD,
Font.SIZE_LARGE);
g.setFont(f);
//puntuacion

g.drawString("" + scoreP1, 25, 20, Graphics.LEFT | Graphics.BOTTOM);


g.drawString("" + scoreP2, ancho - 25, 20, Graphics.RIGHT | Graphics.BOTTOM);
//que hace g.drawString Dibuja la cadena especificada usando el tipo de letra y el color actual.
//La posicin x, y es la posicin del punto de anclaje.

}
public void drawball(Graphics g) {
//color rojo

g.setColor(255,0,0);
g.fillRect(ballX, ballY, anchoBall, altoBall);
}

public void drawplayer1(Graphics g) {


// color blanco

g.setColor(255,255,255);
g.fillRect(player1X, player1Y, anchoPlayer, altoPlayer);
}
public void drawplayer2(Graphics g) {
//color verde

g.setColor(0,255,0);
g.fillRect(player2X, player2Y, anchoPlayer, altoPlayer);
//que es lo que hace el g.fillRect Rellena el rectngulo especificado con el color actual .
//Si cualquiera de anchura o altura es cero o menos , no se dibuja nada

}
}

Clase main
import javax.microedition.midlet.MIDlet;
/* Define informacin mvil aplicaciones de dispositivos
* de perfil y las interacciones entre la aplicacin y el
* entorno en el que se ejecuta la aplicacin.
*/

import javax.microedition.lcdui.Display;
/* La clase Display es la encargada de administrar
la pantalla. Adems de otros mtodos relativos a
las capacidades grficas del dispositivo
*/

public class main extends MIDlet {


Display pantalla;
canvas pc;
public main() {
pantalla = Display.getDisplay(this);
}
public void startApp() {
pc = new canvas(this);
pantalla.setCurrent(pc);
pc.initGame();
}
public void pauseApp() {
// Equipo se preguntaran xq no esta programado este metodo facil
// recordar xfavor que la aplicacion no tiene una pausa ya que el jugador2 realiza
// Movientos x si solo. El metodo de esto es public void generarMovimientoArtificial()

}
public void destroyApp(boolean unconditional) {
/*destroyApp Esto puede ocurrir porque el MIDlet haya
finalizado su ejecucin o porque una aplicacin prioritaria
necesite ser ejecutada en memoria en lugar del MIDlet. Una
vez destruido el MIDlet, ste libera todos los recursos ocupados.
*/
notifyDestroyed(); // Esto solo notifica que el metodo se cumpla en este caso como salir.

System.gc();

}
public void salirDelJuego() {
notifyDestroyed();
System.gc();
}
}