OLIMPIADAS

El archivo está en los websites de los compañeros....

Implementación del programa de la cámara

//ARCHIVO main.cpp de la implementacion del programa de transformaciones de matrices para la representación de una imágen//

#include <cstdlib>
#include <iostream>
#include <math.h>
#include "Camara.hpp"
#define PI 3.14159265
using namespace std;

void title_head (){
    cout<<"*********************************************************"<<endl;
    cout<<endl;
    cout<<"*******************C*A*M*A*R*I*T*A***********************"<<endl;
    cout<<endl;
    cout<<"*********************************************************"<<endl;
    cout<<endl;
    cout<<"*********************************************************"<<endl;
    cout<<"********************-----------------**********************"<<endl;
    cout<<"********************|             º |*********************"<<endl;
    cout<<"********************|       o       |*********************"<<endl;
    cout<<"********************|               |*********************"<<endl;
    cout<<"*********************---------------*********************"<<endl;
    cout<<"*********************************************************"<<endl;

    cout<<"*********************************************************"<<endl;
    cout<<"              Joanna Dulima Ochoa Mancipe                "<<endl;
    cout<<"                  COD.:258050                "<<endl;
    cout<<"   Departamento de Ingeniería de Sistemas e Industrial   "<<endl;
    cout<<"*********************************************************"<<endl;
    }
int main(int argc, char *argv[])
{
        double IMAGEN[3][0];
        double m_translacion[3][0];
        double m_rotacion[3][3];
        double m_perspectiva[3][3];
        double centrocamara[2];
        double centroobjeto[3];
        double xd;
        double yd;
        double zd;
        int k;
        char centro[3]={'x','y','z'};
title_head();
system ("pause");
system ("cls");
cout<<endl;
cout<<"Programa que implementa las transformaciones necesarias para la "<<endl;
cout<<"       representación de la imagen de una camara"<<endl;
cout<<endl;
cout<<"Ingreso de centros de camara y objeto"<<endl;
cout<<"Ingrese las coordenadas el centro del objeto a enfocar: "<<endl;
//Camara= new Camara cam;
for (int j=0;j<3;j++)
{
    cout<<"Coordenada "<< centro[j] <<" = ";
    cin>>centroobjeto[j];
}
cout<<"Ingrese las coordenadas del centro de la camara: "<<endl;
for (int h=0;h<3;h++)
{
    cout<<"Coordenada "<<centro [h]<<"= ";
    cin>>centrocamara[h];
}
//matriztranslacion();
    system("PAUSE");
    return 0;
}

CLASE CAMARA

//ARCHIVO Camara.hpp de la implementacion del programa de transformaciones de matrices para la representación de una imágen//
#include <iostream>
#include <math.h>
#define PI 3.14159265
using namespace std;

class Camara
{
    private:
        double imagen[3];
        double m_translacion[3];
        double m_rotacion[3][3];
        double m_perspectiva[3][3];
        double centro_camara[2];
        double centro_objeto[2];
        int k;
        double distanciacentros;
        double catad;
        double catop;
        double teta, beta, alfa;
        double mrotmtrans[3];
    public:
        Camara(){
            for(int h=0;h<4;h++)
            {
                imagen[h]= 0;
                m_translacion[h]=0;
            }
            for(int h=0;h<4;h++)
            {
                for(int k=0;k<4;k++)
                {
                double m_rotacion[h][k];
                double m_perspectiva[h][k];
                }
            }
             for(int l=0;l<2;l++)
             {
/*                double centro_camara[l]={0};
                double centro_objeto[l]={0};
             }
             k=1;*/
        }
        public:
        void matriztranslacion ();
        void matrizrotacion ();
        void matrizpespectiva ();
        void mrotacionportranslacion ();
        void ImagenCamara ();
        double Teta();
        double Beta ();
        double Alfa ();
};
void matriztranslacion (double centro_camara, double centro_objeto, double m_translacion){
for (int k=0;k<3;k++)
{
    m_translacion[k]=centro_camara[k]-centro_objeto[k];
}
    cout<<endl;
    cout<<"LA MATRIZ DE TRANSLACION ES: "<<endl;
    cout<<endl;
    for (int j=0;j<4;j++)
    {
        for (int k=0;k<4;k++)
        {
            cout<<m_translacion<<" ";
        }
        cout<<endl;
    }
}
void matrizrotacion (double m_rotacion, double teta, double beta, double alfa){
    m_rotacion [0][0]=cos(teta)*cos(beta);
    m_rotacion [0][1]=sen(teta);
    m_rotacion [0][2]=-sen(beta)*cos(teta);
    m_rotacion [1][0]=-sen(teta)*cos(beta)*cos(alfa)+sen(alfa)*sen(beta);
    m_rotacion [1][1]=cos(alfa)*cos(teta);
    m_rotacion [1][2]=sen(alfa)*sen(teta)*sen(beta);
    m_rotacion [2][0]=sen(teta)*cos(beta)*sen(alfa)+cos(alfa)*sen(beta);
    m_rotacion [2][1]=-sen(alfa)*cos(teta);
    m_rotacion [2][2]=cos(alfa)*cos(beta)-sen(alfa)*sen(teta)*sen(beta);
    m_rotacion [3][3]=1;
    for (int d=0;d<4;d++)
    {
        m_rotacion [d][0]=0;
        m_rotacion [3][d]=0;
    }
    cout<<endl;
    cout<<"LA MATRIZ DE ROTACION ES: "<<endl;
    cout<<endl;
    for (int j=0;j<4;j++)
    {
        for (int k=0;k<4;k++)
        {
            cout<<m_rotacion<<" ";
        }
        cout<<endl;
    }
    }
void matrizperspectiva(double m_perspectiva, double lambda) {
    for (int g=0;g<4;g++)
    {
        for (int q=0;q<4;q++)
        {
            if(g==3 && q==2)
            {
            m_perspectiva=-1/Camara.lambda;
            }
            else if (g=q)
            {
            m_perspectiva=1;
            }else
            {
            m_perspectiva=0;
            }
        }
    }
    cout<<endl;
    cout<<"LA MATRIZ DE PERSPECTIVA ES: "<<endl;
    cout<<endl;
    for (int j=0;j<4;j++)
    {
        for (int k=0;k<4;k++)
        {
            cout<<m_perspectiva<<" ";
        }
        cout<<endl;
    }
    }

void mrotacionpormtranslacion (double m_translacion, double m_rotacion){
for (int m=0;m<4;m++)
{
mrotmtrans[0]=(m_translacion[0])*cos(teta)*cos(beta)+(m_trasnlacion[1])*sen(teta)-(mtranslacion[2])*sen(teta)*cos(beta);
mrotmtrans[1]=(m_translacion[0])*sen(alfa)*sen(beta)-sen(teta)*cos(beta)*cos(alfa)+(m_trasnlacion[1])*cos(alfa)*cos(teta)+(mtranslacion[2])*cos(alfa)*sen(teta)*sen(beta)+sen(alfa)*cos(beta);
mrotmtrans[2]=(m_translacion[0])*cos(alfa)*sen(beta)+cos(teta)*sen(alfa)+(m_trasnlacion[1])(-sen(alfa)*cos(teta))+(m_trasnlacion[2])(cos(alfa)*cos(beta)-sen(alfa)*sen(teta)*sen(beta));
mrotmtrans[3]=1;
}

}

Propuesta Proyecto en Java

CALCULADORA GRAFICADORA

Proponemos este proyecto ya que es interesante y con él podemos desarrollar buenas habilidades de pensamiento, así como aplicar y desarrollar también habilidades en la POO, en particular aplicando el lenguaje Java, a través de sus bondades como lenguaje “simple, orientado a objetos, distribuido,

interpretado, robusto, seguro, de arquitectura neutra, portable, de altas prestaciones, multitarea y

dinámico”, como lo describe la compañía Sun, creadora del mismo, en especial, implementando sus Clases Math y Graphics.

¿Qué es Unicode?

Unicode proporciona un número único para cada carácter,
sin importar la plataforma,
sin importar el programa,
sin importar el idioma.

Básicamente, las computadoras sólo trabajan con números. Almacenan letras y otros caracteres mediante la asignación de un número a cada uno. Antes de que se inventara Unicode, existían cientos de sistemas de codificación distintos para asignar estos números. Ninguna codificación específica podía contener caracteres suficientes: por ejemplo, la Unión Europea, por sí sola, necesita varios sistemas de codificación distintos para cubrir todos sus idiomas. Incluso para un solo idioma como el inglés, no había un único sistema de codificación que se adecuara a todas las letras, signos de puntuación y símbolos técnicos de uso común.

Además, estos sistemas de codificación presentan problemas entre ellos. Es decir, dos sistemas de codificación pueden utilizar el mismo número para dos caracteres distintos o bien utilizar números distintos para el mismo carácter. Toda computadora (especialmente los servidores) necesita ser compatible con muchos sistemas de codificación distintos; sin embargo, cada vez que los datos se traspasan entre distintos sistemas de codificación o plataformas, dichos datos siempre corren el riesgo de sufrir daños.

¡Unicode está cambiando todo eso!

Unicode proporciona un número único para cada carácter, sin importar la plataforma, sin importar el programa, sin importar el idioma. Líderes de la industria tales como Apple, HP, IBM, JustSystem, Microsoft, Oracle, SAP, Sun, Sybase, Unisys y muchos otros han adoptado la norma Unicode. Unicode es un requisito para los estándares modernos tales como XML, Java, ECMAScript (JavaScript), LDAP, CORBA 3.0, WML, etc., y es la manera oficial de aplicar la norma ISO/IEC 10646. Es compatible con muchos sistemas operativos, con todos los exploradores actuales y con muchos otros productos. La aparición de la norma Unicode y la disponibilidad de herramientas que la respaldan, se encuentran entre las más recientes e importantes tendencias en tecnología de software.

La incorporación de Unicode en sitios Web y en aplicaciones de cliente-servidor o de múltiples niveles permite disminuir ostensiblemente los costos del uso de juegos de caracteres heredados. Unicode permite que un producto de software o sitio Web específico se oriente a múltiples plataformas, idiomas y países sin necesidad de rediseñarlo. Además permite que los datos se trasladen a través de muchos sistemas distintos sin sufrir daños.

Acerca del consorcio Unicode

El consorcio Unicode es una organización sin fines de lucro creada para desarrollar, difundir y promover el uso de la norma Unicode, que especifica la representación del texto en productos y estándares de software modernos. El consorcio está integrado por una amplia gama de corporaciones y organizaciones de la industria de la computación y del procesamiento de la información. El consorcio se financia únicamente a través de las cuotas de sus socios. La afiliación al consorcio Unicode está abierta a organizaciones e individuos de cualquier parte del mundo que apoyen la norma Unicode y que deseen colaborar en su difusión y aplicación.

 Tomado de  http://unicode.org/standard/translations/spanish.html

INFORME LABORATORIO PACMAN TETRIS

INFORME LABORATORIO "PACMAN-TETRIS"

Joanna Ochoa – 258050

Pedro Valderrama – 258031

Andrés Bernal – 258029

RESUMEN EJECUTIVO

El problema inicial planteado era el de desarrollar un pacman, en el cual se modelara el movimiento a nuestro gusto, sin fantasmas y con una matriz de galletas especificada por nosotros. El grid sugerido de 6x7 se aumentó a uno de de 15x15 (incluyendo pared exterior). Se hicieron varios cambios respecto a las clases anteriores. En la clase pacman, se definieron el constructor y el destructor, y se añadieron nuevas funciones como las de dibujar_pacman (), imprimirGalletas (), borrar (), que se describirán en la parte de este informe destinada para eso. En la clase Tablero, se conservaron los atributos, pero en la parte de las funciones miembro se añadieron también el constructor y el destructor, y la única función miembro (imprimirTablero ()) siguió vigente. Para la visualización del juego, añadimos la librería graphics.h, con la cual dibujamos la interfaz de juego, el pacman, el laberinto y las galletas. Ésta tuvo uso en una función miembro de la clase pacman (dibujar_pacman ()) y en la clase Tablero, en su única función. En especial, se usó la función de dicha librería, denominada pieslice, la cual tiene respectivamente los siguientes parámetros: cordenada "x" del centro, cordenada "y" del centro,angulo de inicio de la boca del pacman, ángulo final de la boca del pacman, radio en pixeles del circulo; además llamando la función intiwindow (), para abrir la ventana de 1024 x 768 pixeles. También incluimos la librería time.h la cual es usada explícitamente en la función miembro de la clase pacman limit-time (), que se explicará después.
Para el caso del tetris, como sólo se pide realizar los diagramas de clases, se ideó lo siguiente: una clase base llamada rectángulo, la cual contiene las características de cada figura que encontramos en el popular juego tetris, la cual tiene como atributos arreglos de 3 campos, los cuales tienen los nombres de int pos_cuadrado1_arriba [2],int pos_cuadrado2_arriba[2], int pos_cuadrado3_arriba[2], int pos_cuadrado1_abajo[2], int pos_cuadrado2_abajo[2], int pos_cuadrado3_abajo[2], y como sus nombres lo indican contienen las posiciones de cada figura del tetris, y en la parte de las funciones miembro se definieron constructor y destructor necesarios (rectángulo(), ~rectangulo(), respectivamente), además, una función void verificador (), que verifica…, una función void puntaje (), que como se indica, calcula el puntaje del jugador según las líneas que va completando el usuario con las figuras, y tres funciones que operan con las figuras, que son void dibujar_figura(), void mover_figura(), void girar_figura(), que desarrollan lo que dicen sus nombres, actuando según la forma de cada figura, la primera de éstas, también se apoyará en el uso de la librería graphics.h con la función pieslice así como en el pacman, y especificando el color de cada figura para diferenciarlas también por este criterio y basándose en el conocimiento de la posición de cada figura y actualizando dichos datos, excepto el color; la segunda función también tendría una estrecha relación con la primera, como el caso del pacman (mov_pacman () y dibujar_pacman()) y realizaría el trabajo de el movimiento de la figura, como su nombre lo especifica, realizando también actualización de datos de posiciones actuales y finales; y para la tercera función también se trabajaría con líneas de validación para el movimiento según la matriz del tablero y de las demás figuras y con opciones diferentes de movimiento según la figura modelados por teclado. También consideraríamos el uso de la librería time. H, dependiendo la modalidad de juego de tetris que se proponga, si es que se fuera a implementar en un futuro.

MARCO TEORICO

Herencia:

Se puede construir una clase a partir de otra mediante el mecanismo de la herencia. Para indicar que una clase deriva de otra se utiliza la palabra extends, como por ejemplo:

class CirculoGrafico extends Circulo {...}

Cuando una clase deriva de otra, hereda todas sus variables y métodos. Estas funciones y variables miembro pueden ser redefinidas (overridden) en la clase derivada, que puede tambiéndefinir o añadir nuevas variables y métodos. En cierta forma es como si la sub-clase (la clase derivada) "contuviera" un objeto de la super-clase; en realidad lo "amplía" con nuevas variables y métodos.

Java permite múltiples niveles de herencia, pero no permite que una clase derive de varias (no es posible la herencia múltiple). Se pueden crear tantas clases derivadas de una misma clase como se quiera.

Todas las clases de Java creadas por el programador tienen una super-clase. Cuando no se indica explícitamente una super-clase con la palabra extends, la clase deriva de java.lang.Object, que es la clase raíz de toda la jerarquía de clases de Java. Como consecuencia, todas las clases tienen algunos métodos que han heredado de Object.

Tomado de GARCÍA DE JALÓN, Javier, RODRÍGUEZ, Jose Ignacio y otros. Aprenda Java como si estudviera en primero. Universidad de Navarra. Escuela superior de ingenieros. San Sebastián. Enero 2000. Disponible en http://www.tecnun.es/asignaturas/Informat1/ayudainf/aprendainf/Java/Java2.pdf

Encapsulamiento:

El encapsulamiento (o encapsulación), u ocultación de la información, es el proceso de ocultar todos los detalles de un objeto que no contribuyen a sus características esenciales. Esencialmente, significa que aquello que está en el interior de la clase está oculto; sólo las interfaces externas se pueden ver por otros objetos. El usuario de un objeto nunca necesitará conocer el interior de la clase.

Una de las ventajas principales del encapsulamiento es que proporciona al programador libertad en la implementación de los detalles de un sistema. La única restricción que tendrá el programador es mantener la interfaz abstracta que ven los usuarios externos.

En realidad, es el mecanismo que enlaza juntos código y los datos que los manipulan y los mantienen seguros de interferencias externas y el mal uso.

En Java, los fundamentos de la encapsulación están en la clase. Una clase define la estructura y el comportamiento (datos y código) que se compartirá por un conjunto de objetos. Por esta razón, los objetos se conocen como a veces como instancias de una clase. Por consiguiente, una clase es una construcción lógica; un objeto tiene una realidad física.

JOYANES AGUILAR, Luis. McGRAW-HILL. ISBN: 8448132904 ISBN-13: 9788448132903. España, 2002. Págs. 71-72.

DIAGRAMAS DE CLASES

//
Convenciones de modificadores de ámbito.
+: público.
-:privado.
#: protegido.
//

Pacman:

Tetris:

DESCRIPCION DE METODOS Y ATRIBUTOS

Pacman:

void limit time(); - da el límite del tiempo para que el usuario termine de hacer que el pacman consuma las galletas. Implementado con la librería time.h.

void mov_pacman(tablero screen,char tecla); - Por los valores numéricos asignados a las operaciones de flechas del movimiento del pacman, se verifica cuál de éstas teclea el usuario. El pacman siempre se mueve en direcciones posibles desde que no llegue a una pared, el usuario debe cambiar si dirección cuando el pacman llegue a una pared o cuando desee desviar por donde el laberinto permita. Se crea un objeto tipo tablero, el cual toma valores de la matriz forma, desde la cual se verificará el camino posible. Según los criterios anteriores se va dibujando el pacman y quitándolo de su posición anterior; se dibuja ayudado de la librería graphics.h. Cuando la ubicación en la matriz del tablero inmediatamente posterior a la actual del pacman es ocupada por la pared (en este caso se especificó como de valor cero si hay pared), el pacman conserva su posición actual, mejor dicho, creamos el objeto tabla de la clase tablero que tiene como argumentos 5 galletas, la matriz forma (del laberinto (1: camino;0:pared)) y la matriz galletero (de galletas(0:no hay galleta, no hay camino posible; 1:galleta pequeña; 2: galleta grande)). Además la función mov_pacman () tiene una estrecha relación con la función dibujar_pacman (), ya que, como dijimos anteriormente, según se pueda avanzar, se cambia la posición del pacman y se dibuja.

int puntaje(tablero tabla2,int puntos); esta función define el puntaje según la cantidad y el tamaño de galletas que coma el pacman hasta el tiempo límite, según las siguientes asignaciones:

Galleta pequeña: 5 puntos.

Galleta grande: 10 puntos.

Ninguna galleta: 0 puntos.

Del objeto tabla 2, se toma en específico la tabla de posición de galletas para verificar que tipo de galleta se consume el pacman y la posición del pacman para comparar lo ya dicho, también se hace la actualización de datos, tanto la eliminación de la galleta en el tablero como la suma de puntos según el tipo de galleta (grande, pequeña).

void dibujar_pacman(int x, int y,char direccion); - como se vió en la función mov_pacman, con la función dibujar_pacman () hay una estrecha relación, pero en el caso de esta función se toman de parámetros la posición del pacman y el carácter dirección, que va a validar hacia qué lado desea mover el usuario el pacman y soportado por la librería graphics.h tanto fija el color del pacman (antes de la validación de la dirección) como en sí como el nombre de la función lo dice, dibujar el pacman en la posición correcta con sus características innatas.

void imprimirGalletas(); - muestra las galletas en el laberinto, también usando la función pieslice de la librería graphipcs.

void borrar(int pos[]); - cuando pacman se mueve lo borra de su posición anterior.
void  imprime_galletero (tablero pantalla); - imprime la matriz de las galletas mostrando los cambios de éstas cuando el pacman se las come, y mostrando el tipo de galleta según lss convenciones anteriores.

void imprimirTablero (); - esta es hasta ahora la única función miembro de la clase Tablero, la cual define el color del tablero con soporte de la función graphics.h nuevamente, la cual verifica en la matriz tabla, si el valor de cada dato de la misma es 1 entonces dibuja el laberinto que delimita el camino del pacman.

CONCLUSIONES

• Para representar en pantalla el pacman utilizamos el encapsulamiento para ocultar las características del pacman y reflejarlas en el gráfico sin que éstas puedan ser modificadas, para evitar que el pacman atraviese paredes y no salte en el mapa sin recorrer el camino debido y aparezca graficado solamente una vez.
• Al ser el trabajo tan extenso, nos permitió comprender de una forma las propiedades de encpasulamiento y herencia y ver sus ventajas y desventajas.
• Al idear el tetris, fué más evidente la herencia y su utilidad puesto que las figuras tienen unas características comunes, lo cual requiere de esta propiedad.
  

BIBLIOGRAFIA

• 
  
  Herencia: GARCÍA DE JALÓN, Javier, RODRÍGUEZ, Jose Ignacio y otros. Aprenda Java como si estudviera en primero. Universidad de Navarra. Escuela superior de ingenieros. San Sebastián. Enero 2000. Disponible en http://www.tecnun.es/asignaturas/Informat1/ayudainf/aprendainf/Java/Java2.pdf
  
• 
  
  Encapsulamiento: JOYANES AGUILAR, Luis. McGRAW-HILL. ISBN: 8448132904 ISBN-13: 9788448132903. España, 2002. Págs. 71-72.
  

CÓDIGO HASTA AHORA DE PACMAN (SIN FANTASMAS)

#include <cstdlib>
#include <conio.h>
#include <dos.h>
#include <iostream>

//#include "pacman.h"
#define ARRIBA 72
#define DERECHA 77
#define ABAJO 80
#define IZQUIERDA 75
#define ESC 27
using namespace std;

class tablero
{
    private:
        int tabla[15][15];
        friend void pacman::mov_pacman();
    public:
        int n_galletas;
        int pos_galletas[15][15];
        void imprimirTablero ();      
};

class tablero *screen=new tablero;
class pacman
{
    private:
        int pos_pacman[1][1];
        int next_pos_pacman[1][1];
    public:
        void mov_pacman(int actual[], int proxima[], tablero *screen::tabla)
        {
            char tecla;
            do
            {
                if(tecla==ARRIBA)
                {
                    proxima[1]=actual[1]--;
                }
                else if(tecla==DERECHA)
                {
                    proxima[0]=actual[0]++;
                }
                else if(tecla==ABAJO)
                {
                    proxima[1]=actual[1]++;
                }
                else
                {
                    proxima[0]=actual[0]--;
                }
              
               if(tablero::tabla[proxima[0]][proxima[1]]==0)
               {
                    for(int h=0;h<2;h++)
                    {
                        actual[h]=proxima[h];
                    }
                }
              
                tecla=getch();
                kbhit();
            }
            while(tecla!=ESC);
        }
        void limit_time()
        {
            for (int time=1;time<=120;)
            {
                delay(1000);
                time++;
            }
        }
      
        void puntaje(int actual[], int siguiente[],tablero::pos_galletas)
        {
            int puntos=0;
            if(tablero::pos_galletas[proxima[0]][proxima[1]]==1)
            {
                puntos+=5;
                tablero::pos_galletas[proxima[0]][proxima[1]]=0;
            }
            else if(tablero::pos_galletas[proxima[0]][proxima[1]]==2)
            {
                puntos+=10;
                tablero::pos_galletas[proxima[0]][proxima[1]]=0;
            }
        }
};


void titlepage(){
cout<<endl;
cout<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"-\t"<<"              1111        1111    11111111111111                      -"<<endl;
cout<<"-\t"<<"              1111        1111    111111111111111                     -"<<endl;
cout<<"-\t"<<"              1111        1111    1111       1111                     -"<<endl;
cout<<"-\t"<<"              1111        1111    1111       1111                     -"<<endl;
cout<<"-\t"<<"              1111        1111    1111       1111                     -"<<endl;
cout<<"-\t"<<"              1111        1111    1111       1111                     -"<<endl;
cout<<"-\t"<<"              1111        1111    1111       1111                     -"<<endl;
cout<<"-\t"<<"              1111        1111    1111       1111                     -"<<endl;
cout<<"-\t"<<"               111111111111111    1111       1111                     -"<<endl;
cout<<"-\t"<<"                 1111111111111    1111       1111                     -"<<endl;
cout<<"-\t"<<"                                                                      -"<<endl;
cout<<"-\t"<<"                                                                      -"<<endl;
cout<<"-                        UNIVERSIDAD NACIONAL DE COLOMBIA                     -"<<endl;
cout<<"-                             FACULTAD DE INGENIERIA                          -"<<endl;
cout<<"-                        PROGRAMACION ORIENTADA A OBJETOS                     -"<<endl;
cout<<"-                       Andrés Gerardo Bernal Arias-258029                    -"<<endl;
cout<<"-                       Joanna Dulima Ochoa Mancipe-258050                    -"<<endl;
cout<<"-                     Pedro Alejadro Valderrama Tapias-258031                 -"<<endl;
cout<<"-                      Estudiantes de Ingenieria de Sistemas                  -"<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;  
cout<<endl;
cout<<endl;
}
int main(int argc, char *argv[])
{
    titlepage ();
    system("PAUSE");
    return EXIT_SUCCESS;
}

#include <iostream>

#include <iomanip>

using namespace std;

#define filas 6

#define col 7

void ImprimirTablero(char bitArray[filas][col]){

char galleta='*'; // caracter iniciado en a para el indice de las columnas//

int k=1; //indice para las filas//

cout<<"\n"; //fin de linea//

    cout<<"\t  "; // tabulacion//

    //imprimimos la letras de las columnas //

for(int i=0; i<col; i++){

    cout<<setw(4)<<galleta;

}

cout<<"\n\t  ------------------------------"<<endl;

for(int i=0; i<filas; i++){

    cout<<"\t"<<i+1<<" | ";

    for(int j=0; j<col; j++){

cout<<setw(2)<<bitArray[i][j]<<" |";   

   }

        cout<<"\n\t  ------------------------------"<<endl;

     }

}

void class pacman

{

public:

int x,y;

char simbolo_pacman='@';

pacman(int xx,int yy,direccion d)

{

x=xx;

y=yy;

dibujarPacman();

}

};

void dibujarPacman (char pacman, char bitArray)

{

}

/*void movimiento_pacman (char u, char h, char j, char n, char pacman)

{

if (mover==u)

    {

    

    }

}*/

int proximaPosPacman (char pacman, char bitArray,char mpacman, char u, char h, char j, char n, char pacman)

    {

    if (char mpacman==u)

        {

        coordenadaActualPacman(bitArray);

        }

    }*/

int main ()

{

cout<<"****************************PaCmAn MiNi*********************"<<endl;

char galleta='*';

//char pacman='@'; clase pacman

char mpacman=getchar ();

char u;// h, j,n; //teclas de movimiento

/*u->arriba

h->izquierda

j->derecha

n->abajo*/

char bitArray[filas][col];

for (int i=0;i<filas;i++)

{

        for (int j=0;j<col;j++)

        {

            bitArray[i][j]=' ';

        } 

} 

            bitArray[0][0]=galleta;

            bitArray[0][2]=galleta;

            bitArray[0][5]=galleta;

            bitArray[1][1]=galleta;

            bitArray[2][0]=galleta;

            bitArray[2][3]=pacman;

            bitArray[2][5]=galleta;

            bitArray[3][1]=galleta;

            bitArray[4][2]=galleta;

            bitArray[5][0]=galleta;

            bitArray[5][3]=galleta;

            bitArray[5][5]=galleta;

ImprimirTablero(bitArray);

cin>>mpacman;

system ("pause");

return 0;

}

PREINFORME PAC-MAN

INTEGRANTES: Andrés G. Bernal A.CÓD.: 258029
                               Joanna D. Ochoa M. CÓD.: 258050
                               Pedro A. Valderrama T. CÓD.: 258031

Descripción del Problema

El problema que se nos plantea en esta ocasión se trata de crear un "pac-man" en un grid de 6x7, se debe mover el personaje por medio del teclado para ir recogiendo las "galletas" pequeñas y grandes, también debemos mostrar el efecto que tiene este movimiento en la matriz de "galletas", suprimiendo la presencia de fantasmas, desarrollándolo a través del paradigma de orientación a objetos, es decir, definiendo los siguientes diagramas de clases.

Además, se nos pidió indagar sobre la técnica de situar datos en objetos de manera que no se pueda acceder directamente a ellos, la cual, según lo entendido es el llamado encapsulamiento, el cual consiste en unir en la clase las variables y métodos. Es tener todo esto en una sola entidad, esto se logra gracias a la abstracción y el ocultamiento que tiene que ver con la facilidad para manejar la complejidad, ya que tendremos a las clases como cajas negras donde sólo se conoce el comportamiento pero no los detalles internos, y esto es conveniente porque nos interesará será conocer qué hace la clase pero no será necesario saber cómo lo hace, es decir los datos que maneja y los procedimientos que emplea. (Con base en http://java.ciberaula.com/articulo/tecnologia_orientada_objetos/)

QUIZ INDUVIDUAL SORPRESA

Se modificaron los ámbitos como se muestra a continuación por los siguientes motivos:
suponiendo que hayan unas clases Pacman y Ghosts, y que las misma no sean amigas, se declaró el atributo int[][][] cordenadasActualesGhosts como protejida para que pueda interactuar con la función int proximaPos Ghosts (), y el atributo

int[][] coordenadaActualPaCman como private y la función int proximaPosPacman (), porque a partir de la suposición de que dichas clases no son amigas no pueda la función int proximaPos Ghosts () interactuar con proximaPosPacman (), y así, en la práctica no pasen los fantasmas por encima de Pacman.

********************************************************************************************

 entidad:mapaPacman

bitArray[][]:pastillas 

private:

int[][] coordenadaActualPaCman

protected:

int[][][] cordenadasActualesGhosts

***************************************************************

mapaPacman::mapaPacman() 

mapaPacman::~mapaPacman() 

private:

int proximaPosPacman ()

protected:

int proximaPos Ghosts ()

 ***************************************************************

Código Taller 1

// Stack v2.0.cpp: define el punto de entrada de la aplicación de consola.
//
/********************************************************
* Stack                                                                                                   *
* A set of routines to implement a simple integer                                       *
* stack.                                                                                                   *
* Procedures                                                                                           *
* stack_init -- initalize the stack.                                                               *
* stack_push -- put an item on the stack.                                                  *
* stack_pop -- remove an item from the stack.                                         * 
********************************************************/
//#include "stdafx.h"
#include <assert.h>
#include <cstdlib>
#include <iostream>
using namespace std;
const int STACK_SIZE = 100; // Maximum size of a stack
struct array
{
    double matriz;
    array *proximo;
    array *anterior;
};
// The stack itself
struct stack 
{  
       double count; // Number of items in the stack
       stack *siguiente;    //Punteros de navegacion
       stack *anterior;     //Puntero de navegacion
       array *posicion;     
       /*public:
              stack(){cout<<"\n\tCONSTRUYENDO...";};
              ~stack(){cout<<"\n\tDESTRUYENDO...";};*/
}; 
struct stack *primero;
struct stack *ultimo;


struct array *first;
struct array *last;


void ingreso(int numero, int pila,int guardar, int &x)
{
    array *nuevo = new array;
    stack *atras = new stack;
    int a=0;
    
    if(nuevo==NULL)
    {
        cout<<"Error\n";
    }
else
{
(*nuevo).matriz=numero;
nuevo->proximo=NULL;


   if(first==NULL)
   {
    cout<<"Primer elemento\n";
    first=nuevo;
    first->anterior=NULL;
    last=nuevo;
    last->anterior=first;
   }
   else
   {
//if(pila<2)
//{
last->proximo=nuevo;
nuevo->anterior=last;
last=nuevo;
last->proximo=NULL;
//}
//else
//{


//}
   }
}
//while (x<=guardar)
//{
        if(x==guardar)
   {
            atras->posicion=last;
            atras->siguiente=NULL;
//atras->anterior=NULL;
            
            if(pila<2)
            {     
if(primero==NULL)
{
cout<<"Nuevo registro...\n";
primero=atras;
ultimo=atras;
}
/*else
{
ultimo->siguiente=atras;
atras->anterior=ultimo;
ultimo=atras;
ultimo->siguiente=NULL;
}*/
            }
            else
            {
                ultimo->siguiente=atras;
                atras->anterior=ultimo;
                ultimo=atras;
                ultimo->siguiente=NULL;
            }
        }
        //else
        //{
            //x++;
        //}
    //}
}
/********************************************************
* stack_init -- initialize the stack. *
* *
* Parameters *
* the_stack -- stack to initalize *
********************************************************/
inline void stack_init(struct stack *the_stack)
{
    the_stack->count = 0; // Zero the stack
}
/********************************************************
* stack_push -- push an item on the stack. *
* *
* Warning: We do not check for overflow. *
* *
* Parameters *
* the_stack -- stack to use for storing the item *
* item -- item to put in the stack *
********************************************************/
inline void stack_push(struct stack *the_stack,const int item, int des, int guardar, int k)
{    
    assert(((*the_stack).count >= 0)&&((*the_stack).count<sizeof(first->matriz)/sizeof(first->matriz)));
    ingreso(item,des,guardar,k); 
}
/********************************************************
* stack_pop -- get an item off the stack. *
* *
* Warning: We do not check for stack underflow. *
* *
* Parameters *
* the_stack -- stack to get the item from *
* *
* Returns *
* The top item from the stack. *
********************************************************/
void stack_pop(struct stack *the_stack, int ciclos, int &pila)
{
    //int dato;
    char desicion;
    assert(((*the_stack).count >= 0)&&((*the_stack).count<sizeof(first->matriz)/sizeof(first->matriz)));// Then we return the top value


    struct array *auxiliar = new array;
    struct array *nuevo = new array;
    struct stack *nuevo2= new stack;
    int i=0; 
    
    if(auxiliar==NULL||nuevo==NULL||nuevo2==NULL)
    {
        cout<<"error...\n";
    }
    
nuevo2=primero;
//nuevo2->siguiente=NULL;
do
{
//nuevo=nuevo2->posicion;
nuevo2=nuevo2->siguiente;
pila--;
}
while(nuevo!=NULL&&pila>0);


auxiliar=nuevo2->posicion;
    cout<<"Expulsando...\n";
    system("pause");
    system("cls");
    
    do
    {
        cout<<"\aDesea visualizar los datos? S/N\t";
        cin>>desicion;
        if(desicion=='s'||desicion=='S')
        {
            cout<<"Expect a "<<auxiliar->matriz<<"-> "<<auxiliar->matriz<<"\n";
auxiliar=auxiliar->anterior;
            i++;
            ciclos--;
        }
        else
        {
            auxiliar=auxiliar->anterior;
            i++;
            ciclos--;
        }
    }
    while(auxiliar!=NULL&&ciclos!=0);
    if(i==0)
    {
        cout<<"La lista esta vacia\n";
    }
    //return (salida);

}
int definir_dato()
{
    int datos;
    
    cout<<"Determine el numero total de datos que desea ingresar\n";
    cin>>datos;
    return datos;
}
int* definir_datos1(int ciclos)
{      
    int* datos1=new int[100];


    for(int j=0;j<ciclos;j++)
    {
        cout<<"Ingrese el "<< j+1<<" dato\n";
        cin>>datos1[j];
    }
    return datos1;
}
// A short routine to test the stack


int main(int argc, char *argv[])
{
    int numeros,pilas=1, posicion;
    int n_datos, *datos_1;
    char desicion,pila;


    struct stack a_stack; // Stack we want to use
    struct stack *point= &a_stack;    
    stack_init(point);
    
    n_datos=definir_dato();
    datos_1=definir_datos1(n_datos);
    
    //point->stack_init(point);
    // Push three value on the stack
   
    for(int k=0;k<n_datos;k++)
    {
        numeros=datos_1[k];
        stack_push(point, numeros,pilas,n_datos,k);
           
        //point->stack_push(point, numeros); 
    }
    system("cls");
    /*stack_push(a_stack, 2);
    stack_push(a_stack, 3);*/
    // Pop the item from the stack 
    
    do
    {   
        b:
        cout<<"Que desea hacer?\n";
        cout<<"A-Expulsar una pila\n";
        cout<<"B-Crear otra pila\n";
        cout<<"C-Salir\n";
        cin>>pila;
        
        if(pila=='A')
        {
            if(pilas>1)
            {
                cout<<"Cual pila desea ver\n";
                cout<<"Seleccione un numero del 1 al "<<pilas<<"\n";
                cin>>posicion;
                stack_pop(point,n_datos,posicion);
            }
            else
            {
                stack_pop(point,n_datos,pilas);
                system("pause");
                system("cls");
            }
        }
        else if(pila=='B')
        {
            pilas++;
            n_datos=definir_dato();
            datos_1=definir_datos1(n_datos);
            for( int j=0;j<n_datos;j++)
            {
numeros=datos_1[j];
                stack_push(point, numeros,pilas,n_datos,j);
            }
        }
        else if(pila=='C')
        {
            return 0;
        }
        else
        {
            cout<<"Seleccione una opcion\n";
            system("pause");
            system("cls");
            goto b;
        }
    }
    while(pila=='A'||pila=='B');
    
    //point->stack_pop(point,datos);    
    /*cout << "Expect a 2 ->" << stack_pop(a_stack) << "\n";
    cout << "Expect a 1 ->" << stack_pop(a_stack) << "\n";*/
    system("pause");
    return (0);   
}