Usar AllegroGL

AllegroGL Allegro es un add-on que permite el uso de OpenGL junto con Allegro. Muy difundida su práctica para el desarrollo de videojuegos.

Descarga e Instalación: Para nosotros que utilizamos Devc++. Ir a [Herramientas -> Actualizaciones -> Chek for Updates] . Marcamos la casilla "Allegro". La instalamos y listo.

La versión que nos descargará es la 4.0. Actualmente hay una versión 4.2 Beta.

Testando la instalacion: Vamos a probar un código sencillito para ver como se ve.

1. Crear un Proyecto Nuevo: Elegir Windows Aplication. Y luego borrar el código por omisión que no genera.

2. Enlazar: Ir a Proyecto -> Opciones de Proyecto, y en la pestaña Argumentos para el programa "Agregamos una nueva librería (/Dev-Cpp/lib/liballeg.a)".

Es importante que en la carpeta donde guardemos el proyecto y los archivos, tambien siempre incluyamos la librería dinámica "alleg40.dll".

3. Codigo:

/***************************************************
Autor: ElBoludo
Version: 1.0
Descripcion: Pequeño tutorial de introducción a 
Allegro.

El programa se ejecuta con una resolucion de 
640x480,una vez cargado, debemos pulsar 
cualquier tecla para ver el textopor pantalla. 

Finalizará cuando pulsemos la tecla de 
Escape [ESC].

Obs: Es un claro ejemplo de juegos que te 
mostraban los diálogos
entre personajes o te detallaban los 
objetivos.
*************************************************/

//En ella ya se incluye la "windows.h"
#include <allegro.h> 

//no hace falta, lo puse por constumbre
using namespace std; 

/* Constantes. Posición inicial del texto.*/

int x = 10;
int y = 10;

// ------------------------------------------
//                Programa Principal                 
// ----------------- [ CODE ] ---------------
// ------------------------------------------

int main()
{
    //Es la forma de declarar una variable entera. 
    //Aun no me explico que hace 
    // el 'register'
    register int i = 0; 

    //Inicializa el hardware
    install_allegro(SYSTEM_AUTODETECT,
 &errno, atexit); 

    //Inicializa el teclado
    install_keyboard(); 
    
    //Inicializa la pantalla en una resolucion 
    //640 x 480.
    set_gfx_mode( GFX_AUTODETECT, 640, 480, 0, 0); 
   
    //Nos preparamos para leer una tecla 
    //cualquiera.
    readkey(); 
   
    //Mientras esa tecla no sea la de escapa, 
    //nos quedamos en el programa
    while (!key[KEY_ESC] ){ 
   
        //Por cada iteración,  limpiamos el 
        //bufer de teclado
        clear_keybuf(); 
       
        // Tomamos a la pantalla.
        acquire_screen(); 
        
        //textout es una funcion para mostrar por 
        //pantalla de 6 parametros 
        // (donde, fuente, "Mensaje", posicionX, 
        //posicionY, IDcolor).
        textout(screen, font,("       Bienvenido. \
        Soy fuente por omision y color blanco."
), x, y, -1); 
       
        //Liberar, limpiar, etx
        release_screen();

        //no lo sé :D
        rest(50); 
    }

    return 0;
}
//con Allegro es necesario que finalicemos 
//de esta manera
END_OF_MAIN(); 

Leer más…

Ejercicio Número 2 de Colas.
No incluyo Cola.cpp ni Cola.h. Doy por hecho que ya lo tendrán.

Determina el máximo de una cola de elementos de tipo Valor, sobre los que está definida la
operación ‘MAYOR(Valor, Valor) -> Boolean’ (que compara los valores y devuelve
Verdadero si el primero es mayor o igual que el segundo y Falso si el primero es menor que
el segundo) utilizando para ello únicamente las funciones definidas sobre Colas. La cola
puede tener elementos repetidos. Utiliza sólo las operaciones definidas sobre colas.

#include <cstdlib>
#include <iostream>

#include "colas.h"

using namespace std;
typedef int Valor;
bool Mayor (Valor x, Valor y);



int main()
{
    Cola p;
    Valor x, mayor, a, b;
    
    //Cargamos la cola
    for (int i=0; i<=20; i++)
    {
        if (p.Encolar(i))
        cout << "Agregando.. " << i << " a la cola" <<  endl;   
    }
    
    mayor=0;
    
    while (p.PrimeroCola(a))
    {
        p.Desencolar();
        p.PrimeroCola(b);
        if (Mayor(a,b))
            mayor=a;
        else 
            mayor=b;
    }
    cout << "Mayor: " << mayor << endl;
    
    //Prueba Desencolar

    /*for (int i=0; i<5; i++)
    {
        p.PrimeroCola(x);
        cout << "Desencolando " << x << endl;
        p.Desencolar();
    }*/
    system("PAUSE");
    return 0;
}


//################################################################
//================================================================
//                 Mayor(Valor x, Valor y) -->
//
//       Mayor. Si 'a' es mayor o igual que 'b' --> Booleano
//
//========================= CODE =================================
//################################################################

bool Mayor(Valor x, Valor y)
{
     bool ok;
     
     if (x>=y) ok=true;
     else ok=false;
     
     return ok;
}

Leer más…

Abrir archivo desdesl Dev C++

/**********************************************
Nonbre:Pablo Mora Murie
Ejercicio: gran descubrimientoXD
Descripción: ejecuita i ya me diras
**********************************************/
#include
#include
#include
using namespace std;

int main ()
{
ofstream g;
string fichero, fichero2, a;
cout <<"Introduce el nombre del documento a guadar: ";
getline(cin, fichero2);
fichero = fichero2 + ".txt";//podia aver sido otra extension
a = "call " + fichero;
cout<< "a= "<
g.open(fichero.c_str());
if (!g)
cout<<"error al abrir fichero"< else
{
g << "texto k kiere k aparezca el el documento"< g.close();
}
system (a.c_str());
system ("pause");
return 0;
}

Leer más…

[Código Fuente] Pila Dinámica

/*******************************/
// pila_dinamica.h
/********************************/

#ifndef _PILA_H
#define _PILA_H

class Pila
{
     private:
             bool Copiar(const Pila& p);
             void Pila::Vaciar();
             struct Nodo;
             typedef Nodo* Puntero;
            
             struct Nodo
             {
                    TipoDato info;
                    Puntero sig;
             };
             Puntero cima;
            
     public:
            Pila();
            Pila (const Pila&); /* COnstructor de copia que se ejecuta cada vez
             que se pasa un parametro a una funcion*/

             ~Pila ();
            typedef int TipoDato;
            const Pila& operator= (const Pila&);
            bool Apilar(TipoDato elemento);
            bool Desapilar();
            bool CimaPila(TipoDato &elemento);    
            bool PilaVacia();
       
};


#endif

/*********************/
// pila_dinamica.cpp
/*********************/

#include <iostream>
#include "pila.h"

using namespace std;

Pila::Pila()
{
           cima = NULL;              
}

Pila::Pila(const Pila& p)
{
if(!Copiar(p))
    cerr << "Error de memoria al copiar pila." << endl;
}

Pila::~Pila()
{
            Vaciar();
}


bool Pila::Copiar(const Pila& p)
{
    bool ok=true;
    Puntero p_aux, dup, fin;
  
    Vaciar();
    p_aux = p.cima;
          while( (p_aux != NULL) && ok)
          {
                 dup = new Nodo;
                 if (dup == NULL)
                    ok = false;
                 else

                  {
                 dup -> info = p_aux -> info;
                 dup -> sig = NULL;
                 if (cima == NULL) //Si Cima = NULL entonces es la primera copia del nodo.
                     cima = dup;
                 else
                      fin-> sig = dup;
                 fin = dup;
                 p_aux = p_aux->sig;
                 }
          }
}    

return ok;
   
   
}
void Pila::Vaciar()
{
    while(Desapilar());
    cima = NULL;
}

const Pila& Pila::operator= (const Pila& p)
{
     if(! Copiar(p))
    cerr << "Error de memoria al copiar pila." << endl;
  return (*this);
}


bool Pila::PilaVacia()
{
    return (cima == NULL);    
}

bool Pila::Apilar(TipoDato elemento)
{
    Puntero p;
    p= new Nodo; //Creamos un nuevo puntero
     p -> info = elemento; // Este le añadimos el valor pasado

     p -> sig = cima; // Y apuntamos cima apunta a siguiente
     cima = p;
   
}

bool Pila::Desapilar()
{
    bool ok;
   Puntero p_aux;
   p_aux = cima;
   if(cima == NULL)
           ok = false;
   else

        {
           cima = cima -> sig;
           delete p_aux;
           ok=true;
       }
   return ok;
   
   
}

bool Pila::CimaPila(TipoDato &elemento)
{
    bool ok=true;
    if(cima==NULL)
                  ok=false;
    else

         elemento = cima -> info;
       
        return ok;    
   
}

Leer más…

[Codigo Fuente] Ejercicio 3 UT9

//#================================================================
//#Nombre:
//#Autor: Ernesto Lezcano
//#Descripcion:
//#================================================================
//# -------------------------[C O D E]-----------------------------
//#================================================================
#include <iostream>

const int TAM=50;

class Pila
{
    public:
           typedef int Valor;
           Pila();
           //Pila(Pila x);

             bool Apilar(Valor);
           bool Desapilar();
           bool CimaPila(Valor &);
           bool PilaVacia();
           //void MostrarPila(void);
             bool Primeros(int x, Pila p1);
           bool Ultimos(int x, Pila p1);
    private:
            int cima;
            Valor v[TAM];
};

#include <iostream.h>
#include "pila.h"

//#================================================================
//# -----------------------[Constructor]---------------------------
//#================================================================

Pila::Pila()
{
  cima=-1;
}

//#================================================================
//# --------------------------[Apilar]-----------------------------
//#================================================================

bool Pila::Apilar(Valor num)
{
  bool apila;

  if (cima == TAM)
  {
      apila=false;
  }
  else

    {
      cima++;
      v[cima]=num;
      apila=true;
  }

  return apila;
}

//#================================================================
//# ------------------------[Desapilar]----------------------------
//#================================================================

bool Pila::Desapilar()
{
   bool desapila;
 
   if (cima==-1)
   {
       desapila=false;
   }
   else

     {
       desapila=true;
       cima--;
   }
   return desapila;
}

//#================================================================
//# -------------------------[CimaPila]----------------------------
//#================================================================

bool Pila::CimaPila(Valor &num)
{
   bool cimapila;
 
   if (PilaVacia())
   {
       cimapila=false;
   }
   else

     {
       cimapila=true;
       num=v[cima];
   }
 
   return cimapila;
}

//#================================================================
//# -------------------------[PilaVacia]---------------------------
//#================================================================

bool Pila::PilaVacia()
{
   return (cima == -1);
}
/*
//#================================================================
//# -----------------------[MostrarPila]---------------------------
//#================================================================

void Pila::MostrarPila()
{
   for (int i=0; i<=cima; i++)
   {
       cout << v[i] << endl;
   }
}
*/

//#================================================================
//# ---------------------[SubPilaPrimeros]-------------------------
//#================================================================


bool Pila::Primeros(int x, Pila p1)
{  
   int i;
   bool primero=false;
 
   if (!p1.PilaVacia())
   {
       for (i=0; i<x && i<p1.cima; i++)
           v[i]=p1.v[i];
       cima=x-1;
       primero=true;
   }
 
   return primero;
}


//#================================================================
//# ---------------------[SubPilaUltimos]--------------------------
//#================================================================

bool Pila::Ultimos(int x, Pila p1)
{
   int i;
   bool ultimo=false;
 
   if(!p1.PilaVacia()&&x<p1.cima)
   {
       for (i=p1.cima-x; i<p1.cima; i++)
       {
           v[i-x]=p1.v[i];
           cout << v[i-x]<<endl;
       }
       cima=x-1;
       ultimo=true;
   }
 
   return ultimo;
}

Leer más…

Colas

Fundamentos:

Las colas son una estructura de datos similar a las pilas, pero en las colas se insertan elementos por un extremo y se retiran elementos por el otro extremo.

Una cola se puede representar como la cola del PCBOX. Entra “A” a la tienda y se pone el primero de la cola despues entra "B" y asi hasta "K", el primero en ser atendido es "A", después "B" y asi hasta "K". La cola es como un tubo que entran por la izquierda y salen por la derecha.

La cola a diferencia de la pila tiene una estructura lineal de tipo “FIFO” (First input Firt Output) Primero en entrar, primero en salir.

Una cola puede estar vacia (sin ningun elemento) o llena (En el caso que tengamos un tamaño fijo (Vector)).

Especificacion de una cola:

Estas son las especificaciones de una clase "Cola":

• Tipo de Dato: Dato que se almacenara en la cola.
• Insertar: Insertar un elemento a la cola.
  
• Eliminar: Eliminar un elemento de la cola.
  
• BorrarCola: Borrar la cola.
  
• Frente: Acceso a la cola.

Leer más…

[Código Fuente] Pila Estática

/*************************************************************/
//                      pila.cpp
/*************************************************************/

#include <iostream>
#include "pila.h"

using namespace std;

Pila::Pila()
{              cima = -1;        
}

bool Pila::Apilar(TipoDato &elemento)
{
bool res;
if(cima == MAX-1)
{   cerr << "Desbordamiento de Pila (Overflow)" << endl;
  res=false;
}else

     {cima++;
pila[cima] = elemento;
res = true;
}
return res;


}

bool Pila::Desapilar()
{
bool res;
if(cima == -1)
{   cerr << "Se esta intentando quitar un elemento de una pila vacia (underflow)" << endl;
  res=false;
}else

     {cima--;
res = true;
}
return res;


}

void Pila::VerPila()
{
for(int i=0;i<=cima;i++)
cout << pila[i] << endl;

}


bool Pila::CimaPila(TipoDato &elemento)
{
bool res;
if(PilaVacia())//(cima == -1)
{cerr << "Se esta intentando quitar un elemento de una pila vacia (underflow)" << endl;
res = false;
}else

     { pila[cima];
cima--;
res = true;
}

return res;


}

bool Pila::PilaVacia()
{
return cima == -1;
}

void Pila::LimpiarPila()
{
cima = -1;
}


bool Pila::Iguales(Pila p)
{
TipoDato a , b;
TipoDato array[MAX];

bool iguales=false;

int i=cima;
while (p.CimaPila(b) && array[i--]==b)
{
    p.Desapilar();
}
if(i<0 && p.PilaVacia())
iguales=true;

return iguales;
}

/*************************************************************/
//                      pila.h
/*************************************************************/
#ifndef _PILA_H
#define _PILA_H

class Pila
{
   private:
           static const int MAX = 100;
           typedef int TipoDato;
           TipoDato pila[MAX];
           int cima;
        
   public:
          Pila();
          bool Apilar(TipoDato &elemento);
          bool Desapilar();
          bool CimaPila(TipoDato &elemento);
          void LimpiarPila();
          void VerPila();          
          bool PilaVacia();
          bool Iguales(Pila p);
   
};


#endif

Leer más…

Pilas

Fundamentos:

Una lista de elementos caracterizada porque las operaciones de insercion y extraccion de elementos se realiza solamente en un extremo de la estructura (cima).

Una pila se puede representar como un tubo de pastillas. “a” esta en el fondo de la pila y es la mas inaccesible y “k” la primera accesible.

La pila tiene una estructura lineal de tipo “LIFO” (Last input Firt Output).

Una pila puede estar vacia (sin ningun elemento) o llena (En el caso que tengamos un tamaño fijo (Vector)).

Si un programa intenta sacar un elemento de una pila vacia se produce un desbordamiento negativo (underflow) y si la pila esta llena y se quiere añadir un elemento más se produce un desbordamiento (overflow).

Especificacion de una pila:

Estas son las especificaciones de una clase "Pila":

• Tipo de Dato: Dato que se almacenara en la pila.
• Apilar (push): Insertar un dato de pila.
  
• Desapilar (pop): Resta 1 a cima.
  
• CimaPila:
  
• Pila vacia: Comprueba si esta vacia.
  
• Pila llena: Comprueba si esta llena.
  
• Limpiar Pila: Pone cima a cero.
  

Leer más…

Estructuras de datos dinámicas

Existen dos tipos de estructuras de datos dinámicas:

• Lineales: Pilas, Colas, Listas.
• No lineales: Arboles, Grafos.
  

Leer más…