Practica Numero 8, PROJECT 09 HIGH LEVEL PROGRAMING
Embedded Files
¿Cuál es el objetivo de este proyecto y describa que debe hacer para desarrollarlo?
El objetivo principal de este proyecto es llegar a la correcta implementación y programación de un juego de computadora, haciendo uso de Jack, Notepad++. En nuestro caso para esta practica se tiene pensado implementar el juego de la serpiente, ya que la programación que lleva este juego es simple, los scripts serán por separado, por ejemplo, uno para la serpiente, uno para la fruta etc.
Desarrollo de la practica:
PARTE 1: SCRIPT FRUIT.JACK
1) class Fruit {
field int x, y, size;
2) Fruit new (int Ax, int Ay, int Asize) {
let x = Ax;
let y = Ay;
let size = Asize;
do draw();
return this;
}
3) method int getX() { return x; }
method int getY() { return y; }
4) method void place() {
let x = Random.between(0, 32);
let y = Random.between(0, 16);
while (Memory.peek((x/16)+(y*32)+16384)) {
let x = Random.between(0, 32);
let y = Random.between(0, 16);
}
do draw();
return;
}
5) method void draw() {
do Screen.setColor(true);
do Screen.drawRectangle(x, y, x + size - 1, y + size - 1);
do Screen.setColor(false);
do Screen.drawRectangle(x + 3, y + 3, x + size - 4, y + size - 4);
return;
}
6) method void dispose() {
do Memory.deAlloc(this);
return;
}
}
Explicación Código:
Los códigos resaltados tienen un numeral, con este serán explicados posteriormente.
Numero 1: Encargado de abrir la clase y asignación de valores.
Numero 2: En esta parte del código se realiza la creación de la fruta y se pone de forma aleatoria la ubicación de la fruta, puede ser ubicada en cualquier parte de la zona.
Numero 3: Son los métodos de tipo retorno.
Numero 4: Cuando la fruta inicial es comida por la serpiente, en esta parte se encarga de la creación de una nueva fruta y ubicación aleatoria para poder continuar con el juego.
Numero 5: Este es el método encargado para dibujar la fruta sobre la zona.
Numero 6: Método encargado para darle el final a la fruta. Cuando es comida por la serpiente, por lo tanto, es indispensable el return al final del código.
PARTE 2:LIST.JACK
1) class List {
field int x, y;
field List next;
2) Constructor List new(int Ax, int Ay) {
let x = Ax;
let y = Ay;
let next = null;
return this;
}
3) method int getX() { return x; }
method int getY() { return y; }
method int getNext() { return next; }
4) method void setNext(List n) { let next = n; return; }
5) method void dispose() {
if (~(next = null)) {
do next.dispose();
}
6) do Memory.deAlloc(this);
return;
}
}
Explicación Código:
Los códigos resaltados tienen un numeral, con este serán explicados posteriormente.
Numero 1: Encargado de abrir la clase lista. Contiene un ¨field List next¨, encargado de dar una referencia al siguiente elemento.
Numero 2: Nos construye una lista.
Numero 3: Son los métodos de tipo retorno.
Numero 4: Aplicación del método Set.
Numero 5: En este apartado se realiza la eliminación de la lista creada incluida la cola.
Numero 6: Utiliza una rutina del sistema operativo para reciclar este objeto. Es indispensable el return al final del código.
Parte 3: MAIN JACK
1) class Main {
function void main() {
var SnakeGame game;
let game = SnakeGame.new();
do game.run();
do game.dispose();
return;
}
}
Explicación Código:
Los códigos resaltados tienen un numeral, con este serán explicados posteriormente.
Numero 1: En esta clase main se inicia un nuevo juego de la serpiente y el programa empieza a ejecutarse.
Parte 4: QUEUE.JACK
1)Contener de cola
class Queue {
field int size;
field List tail;
field List head;
1) Creador de Queue.
constructor Queue new(int x, int y) {
let head = List.new(x, y);
let size = 1;
let tail = head;
return this;
}
2) Accesorios.
method int size() { return size; }
3) Empuja un nuevo elemento al final.
method void push(int x, int y) {
var List newElem;
let newElem = List.new(x, y);
do tail.setNext(newElem);
let tail = newElem;
let size = size + 1;
return;
}
4) Aparece un elemento al frente.
method List pop() {
var List nextElem, retElem;
let nextElem = head.getNext();
let retElem = List.new(head.getX(), head.getY());
do Memory.deAlloc(head);
let head = nextElem;
let size = size - 1;
return retElem;
}
5) Busca datos dentro de una cola.
method boolean contains(int x, int y) {
var List current;
let current = head;
while (~(current = null)) {
if ((current.getX() = x) & (current.getY() = y)) {
return true;
}
let current = current.getNext();
}
return false;
}
6) Elimina esta cola.
method void dispose() {
do head.dispose();
do Memory.deAlloc(this);
return;
}
}
PARTE 5: RANDOM.JACK
1) Generador Congruencial Lineal (LCG) para generar números aleatorios.
Modificado para Hack para cubrir toda la pantalla.
class Random {
static int x;
2) Establece una nueva semilla Mod.
function void seed(int seed) {
let x = Math.mod(seed, 16);
return;
}
3) Devuelve el siguiente número aleatorio. Puede ser negativo o positivo.
function int next() {
let x = 7919 + (17*x);
return x;
}
4) Devuelve un valor aleatorio entre x (incluido) e y (no incluido)
y debe ser mayor que x.
function int between(int x, int y) {
var int diff, res;
let diff = y - x + 1;
let res = Math.mod(Random.next(), diff) + x;
if (res = y) { let res = res - 1; }
return res * 16;
}
}
PARTE 7: SNAKE.JACK
1) Creación clase Snake
class Snake {
field int x, y;
field int direction;
field int length, size;
field Queue elements;
2) Creacion de la serpiente.
constructor Snake new(int Ax, int Ay, int Asize) {
let x = Ax;
let y = Ay;
let direction = 3; // right
let length = 1;
let size = Asize;
let elements = Queue.new(x, y);
do paintSquare(true, x, y);
return this;
}
3) Método set.
method void incrementLength() { let length = length + 1; return; }
4) Establecer solo la dirección correcta.
method void setDirection(int d) {
if (~(Math.mod(d,2) = Math.mod(direction, 2))) {
let direction = d;
}
return;
}
5) Dibujar o borrar el elemento de una serpiente.
method void paintSquare(boolean color, int x, int y) {
do Screen.setColor(color);
do Screen.drawRectangle(x, y, x + size - 1, y + size - 1);
return;
}
6) Dibuja la cabeza recién posicionada y la cola clara.
method void draw() {
var List tail;
do elements.push(x, y);
if (length < elements.size()) {
let tail = elements.pop();
do paintSquare(false, tail.getX(), tail.getY());
}
do paintSquare(true, x, y);
return;
}
7) Devuelve verdadero si se come fruta.
method boolean crashesWith(Fruit f) {
return ((x = f.getX()) & (y = f.getY()));
}
8) Devuelve verdadero si no está dentro de los límites o si se estrelló contra sí mismo.
method boolean crashed() {
return ((x < 0) | (x > 511) | (y < 0) | (y > 255)
| elements.contains(x, y));
}
9) Mueve la serpiente en la dirección actual.
method void move() {
// 1 - LEFT, 2 - DOWN, 3 - RIGHT, 4 - UP
if (direction = 1) { let x = x - size; }
if (direction = 2) { let y = y - size; }
if (direction = 3) { let x = x + size; }
if (direction = 4) { let y = y + size; }
return;
}
10) Se deshace del cuerpo de la serpiente y de sí mismo.
method void dispose() {
do elements.dispose();
do Memory.deAlloc(this);
return;
}
}
1) Creación clase Snake
class Snake {
field int x, y;
field int direction;
field int length, size;
field Queue elements;
2) Creacion de la serpiente.
constructor Snake new(int Ax, int Ay, int Asize) {
let x = Ax;
let y = Ay;
let direction = 3; // right
let length = 1;
let size = Asize;
let elements = Queue.new(x, y);
do paintSquare(true, x, y);
return this;
}
3) Método set.
method void incrementLength() { let length = length + 1; return; }
4) Establecer solo la dirección correcta.
method void setDirection(int d) {
if (~(Math.mod(d,2) = Math.mod(direction, 2))) {
let direction = d;
}
return;
}
5) Dibujar o borrar el elemento de una serpiente.
method void paintSquare(boolean color, int x, int y) {
do Screen.setColor(color);
do Screen.drawRectangle(x, y, x + size - 1, y + size - 1);
return;
}
6) Dibuja la cabeza recién posicionada y la cola clara.
method void draw() {
var List tail;
do elements.push(x, y);
if (length < elements.size()) {
let tail = elements.pop();
do paintSquare(false, tail.getX(), tail.getY());
}
do paintSquare(true, x, y);
return;
}
7) Devuelve verdadero si se come fruta.
method boolean crashesWith(Fruit f) {
return ((x = f.getX()) & (y = f.getY()));
}
8) Devuelve verdadero si no está dentro de los límites o si se estrelló contra sí mismo.
method boolean crashed() {
return ((x < 0) | (x > 511) | (y < 0) | (y > 255)
| elements.contains(x, y));
}
9) Mueve la serpiente en la dirección actual.
method void move() {
// 1 - LEFT, 2 - DOWN, 3 - RIGHT, 4 - UP
if (direction = 1) { let x = x - size; }
if (direction = 2) { let y = y - size; }
if (direction = 3) { let x = x + size; }
if (direction = 4) { let y = y + size; }
return;
}
10) Se deshace del cuerpo de la serpiente y de sí mismo.
method void dispose() {
do elements.dispose();
do Memory.deAlloc(this);
return;
}
}
1) Creación clase Snake
class Snake {
field int x, y;
field int direction;
field int length, size;
field Queue elements;
2) Creacion de la serpiente.
constructor Snake new(int Ax, int Ay, int Asize) {
let x = Ax;
let y = Ay;
let direction = 3; // right
let length = 1;
let size = Asize;
let elements = Queue.new(x, y);
do paintSquare(true, x, y);
return this;
}
3) Método set.
method void incrementLength() { let length = length + 1; return; }
4) Establecer solo la dirección correcta.
method void setDirection(int d) {
if (~(Math.mod(d,2) = Math.mod(direction, 2))) {
let direction = d;
}
return;
}
5) Dibujar o borrar el elemento de una serpiente.
method void paintSquare(boolean color, int x, int y) {
do Screen.setColor(color);
do Screen.drawRectangle(x, y, x + size - 1, y + size - 1);
return;
}
6) Dibuja la cabeza recién posicionada y la cola clara.
method void draw() {
var List tail;
do elements.push(x, y);
if (length < elements.size()) {
let tail = elements.pop();
do paintSquare(false, tail.getX(), tail.getY());
}
do paintSquare(true, x, y);
return;
}
7) Devuelve verdadero si se come fruta.
method boolean crashesWith(Fruit f) {
return ((x = f.getX()) & (y = f.getY()));
}
8) Devuelve verdadero si no está dentro de los límites o si se estrelló contra sí mismo.
method boolean crashed() {
return ((x < 0) | (x > 511) | (y < 0) | (y > 255)
| elements.contains(x, y));
}
9) Mueve la serpiente en la dirección actual.
method void move() {
// 1 - LEFT, 2 - DOWN, 3 - RIGHT, 4 - UP
if (direction = 1) { let x = x - size; }
if (direction = 2) { let y = y - size; }
if (direction = 3) { let x = x + size; }
if (direction = 4) { let y = y + size; }
return;
}
10) Se deshace del cuerpo de la serpiente y de sí mismo.
method void dispose() {
do elements.dispose();
do Memory.deAlloc(this);
return;
}
}
PARTE 8: SNAKEGAME.JACK
Implementa un juego de serpiente simple. Este juego le permite al usuario controlar una serpiente que crece en longitud a medida que avanza el juego, persiguiendo y comiendo la fruta. Cuando comienza el juego, se muestra un cuadrado de 16 por 16 píxeles en la esquina superior izquierda de la pantalla. El usuario controla la serpiente de la siguiente manera. Las 4 teclas de flecha se utilizan para mover la serpiente hacia arriba, abajo, izquierda y derecha. La tecla 'q' se usa para salir del juego.
1) Creación clase Snakegame.
class SnakeGame {
field Snake snake;
field Fruit fruit;
field int score, scoreInc;
2) Construcción nuevo juego de la serpiente.
constructor SnakeGame new() {
// Creates a 16 by 16 pixels snake
let snake = Snake.new(0, 0, 16);
let fruit = Fruit.new(128, 128, 16);
let score = 0;
let scoreInc = 50;
return this;
}
3) Ejecuta el juego: lógica principal del juego.
method void run() {
var char key;
var boolean exit;
let exit = false;
while (~exit) {
4) Espera a que se presione una tecla.
let key = Keyboard.keyPressed();
do snake.move();
if (~(snake.crashed()) & ~((key = 81)) ) {
5) Nueva direccion de movimiento.
if ((key > 129) & (key < 134)) {
do snake.setDirection(key - 129);
}
if (snake.crashesWith(fruit)) {
if (score = 0) { do Random.seed(scoreInc); }
let score = score + Math.max(5, scoreInc);
let scoreInc = 50;
do snake.incrementLength();
do fruit.place();
}
let scoreInc = scoreInc - 1;
do snake.draw();
do Sys.wait(150);
}
else {
let exit = true;
}
}
do Output.moveCursor(11, 26);
do Output.printString("SCORE: ");
do Output.printInt(score);
return;
}
6) Elimina este juego.
method void dispose() {
do snake.dispose();
do Memory.deAlloc(this);
return;
}
}
Video:
Page updated
Google Sites
Report abuse