Snake part_1

En este capitulo comenzaremos con una serie de tutoriales para crear el clásico juego de Snake, por el momento será solo en javascript, dibujando los frames en la etiqueta canvas.

En esta entrada comenzamos con la parte de html y css con el enlace a JS.

index.html

<canvas class="mcv" height="600" id="canvas" width="400"></canvas>

Por el momento el código html lo dejamos de con eso damas, mientras que el apartado css 

estilo.css

.mcv {
    border: solid 0px;
    box-shadow: 0px 0px 5px 2px #404040;
    float: left;
}

Comenzamos con el javascript de la siguiente manera.

Para este punto quiero mencionar que en este caso estoy comenzando a usar los objetos de tipo clase en javaScript.

El codigo comienza en con lo siguiente.

Game.js

class Game{
     //constructor de la clase
     constructor(){
          this.c = document.getElementById("canvas");
          this.ctx = this.c.getContext("2d");
     }
     //evento inicial de la clase
     //nos ayudara a iniciar los demas objetos
     init(){
          var ts = this;
          this.interval = setInterval(function() {
               ts.update();
          }, 500);
     }
     //evento que pintara lo que veremos
     draw(){
          this.ctx.clearRect(0,0,this.c.width,this.c.height);
          this.ctx.beginPath();
          this.ctx.font = "12px Verdana";
          this.ctx.fillStyle="green";
          this.ctx.fillText('inovania.blogspot.com', 50, 50);
          this.ctx.stroke();
     }
     //evento que actualiza el estado del juego.
     update(){
          this.draw();
     }
}
//llamado de la clase
new Game().init();

Dejamos hasta aquí la entrada.

No olvides seguirme para ser de los primeros en recibir las notificaciones de la continuidad del juego.

El Manejo de Arreglos en Java: Implementación del Método Slice

El manejo de arreglos es una característica fundamental en prácticamente cualquier lenguaje de programación. Algunos lenguajes permiten agregar y eliminar elementos de un arreglo fácilmente, y en este artículo veremos cómo implementar una función similar en Java. En particular, crearemos un método slice para trabajar con arreglos.

Para este ejemplo, usaremos un arreglo de tipo String.

Implementación del Método Slice

La función slice permite eliminar un elemento de un arreglo, ya sea por valor o por índice. A continuación se presenta el código:

    /**
     * Méthod slice, permite eliminar un elemento del arreglo
     * 
     * @param value variable de tipo Object en formato arreglo
     * @return arreglo de tipo String que contiene el nuevo arreglo
     */
    public String[] slice(Object... value){
        String[] arr=null;
        int pos=-1;
        String element = null;
        for (Object value1 : value) {
            if (value1 instanceof java.lang.String)
                element = value1.toString();
            if (value1 instanceof java.lang.Integer)
                pos=(int) value1;
            if (value1 instanceof java.lang.String[])
                arr = (String[]) value1;
        }
        String[]temp = new String[arr.length-1];
        int i=0,x=0;
        for(String a : arr){
            if(element!=null&&!a.equalsIgnoreCase(element)){
                temp[i]=a;
                i++;
            }
            if(pos>-1){
                if(i!=pos){
                    temp[x]=a;
                    x++;
                }
                i++;
            }
        }
        return temp;
    }

Uso del Método Slice

A continuacion muestro como se usa el metodo.

        
public static void main(String[] args) {
    // Creación del arreglo inicial
    String[] b = {"uno", "dos", "tres", "cuatro", "cinco", "seis", "siete"};
    
    // Eliminación del elemento "cuatro"
    b = slice(b, "cuatro");
    // Eliminación del elemento en la posición 1
    b = slice(b, 1);
    
    // Imprimir el arreglo resultante
    for (String b1 : b) {
        System.out.println(b1);
    }
}

Explicación del Código

Declaración del Método:

    El método slice acepta una lista variable de argumentos (Object... value), permitiendo flexibilidad en los parámetros

Identificación de Parámetros:

    Se identifica si cada parámetro es un String, un Integer, o un arreglo de String

Creación del Nuevo Arreglo:

    Se crea un nuevo arreglo (temp) de tamaño reducido para almacenar los elementos restantes después de la eliminación

Eliminación por Valor o Índice

• Si se proporciona un String, se eliminan todas las apariciones de ese valor.
• Si se proporciona un Integer, se elimina el elemento en esa posición

Impresión del Resultado

    El arreglo resultante se imprime en la consola

Conclusión

En este artículo, hemos implementado un método slice en Java que permite eliminar elementos de un arreglo por valor o por índice. Este tipo de manipulación de arreglos es común en muchos lenguajes de programación y puede ser muy útil en diversos contextos.

Espero que encuentres útil este método y que puedas integrarlo en tus proyectos. Si tienes alguna pregunta o comentario, no dudes en dejar un comentario a continuación. ¡Gracias por leer!

Metodo Push en Java

 El método push nos ayuda en la construcción de arreglo en JavaScript a diferencia del desarrollo en java, este método aparte de agregar elementos al arreglo incrementa en 1 la longitud del mismo. sin embargo en Java no existe tal método así que es necesario construirlo para ello vamos al código.

Para este ejemplo será un código push para un arreglo de tipo String.

Sin mas les dejo aquí el código.

/**
     * Autor<b>innovania.blogspot.com</b><br />
     * <br />
     * Metodo <b>push</b>: permite agregar un elemento al arreglo ya existente<br />
     * @param arr arreglo que se esta agregando el elemento value<br />
     * @param value valor a agregar <br />
     * @return nuevo arreglo con elemento value en la posicion final del arreglo
     */
public String[] push(String[] arr,String value){
    String[] temp = new String[arr.length];
    System.arraycopy(arr, 0, temp, 0, arr.length);
    arr= new String[temp.length+1];
    System.arraycopy(temp, 0, arr, 0, temp.length);
    arr[temp.length]=value;
    return arr;
}

Explicación del código. 

Comienza creando un arreglo igualando la longitud al arreglo que esta entrando.

Copia el arreglo entrante al temporal.

Construye un nuevo arreglo tomando la longitud del arreglo temporal mas 1.

Copia el contenido del arreglo temporal en el nuevo arreglo.

Agrega el valor del push en la ultima posición de ahora nuevo arreglo.

Retorna el nuevo arreglo con el nuevo valor agregado.

Ya por ultimo queda el llamado. 

    IncrementArray app = new IncrementArray();
        String[] a ={"uno","dos","tres"};
        a=app.push(a,"cuatro");
        a=app.push(a,"cinco");
        for (String a1 : a) {
            System.out.println(a1);
        }

Sin mas por el momento me despido, espero les ayude, si tienes dudas deja tu comentario y con gusto resolvemos juntos las dudas.