Borrar carpeta

Elimina un archivo específico, o más importante, una carpeta/directorio con todo su contenido(sub-carpetas y archivos).
NO elimina archivos que esté en uso actualmente por una aplicación externa.

#if !defined(KILLFOLDER_H__)
#define KILLFOLDER_H__

//includes
#include <rc_class/msgbox.h>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

//Atributos de carpetas.
#define FOLDER_NORMAL (FILE_ATTRIBUTE_DIRECTORY)
#define FOLDER_WINSYS (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN)
#define FOLDER_READONLY (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_READONLY)
#define FOLDER_HIDDEN (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_HIDDEN)
#define FOLDER_NOTMOVE (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN)
#define FOLDER_COMPRESSED (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_COMPRESSED)
#define FOLDER_TEMP (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_TEMPORARY)

//Mensajes de errores.
#define MSG_CAPTION "A ocurrido un error"
//#define MSG_ERROR_MTX "Se ha superado el máximo de 2000 carpetas. Algunos archivos se han eliminado."
#define MSG_ERROR_HANDLE "La dirección no es válida:\n%s"
#define MSG_ERROR_FILE "El archivo %s está siendo utilizado por una aplicación.\nNo se puede continuar."

//propiedades
#define ALLFILES "\\*.*" //Atributo: todos los archivos.
#define ROOTBACK ".." //Carpeta superior.No raiz.
//#define MTX_SIZE 2000 //Máximo tamaño de carpetas almacenadas.



/*
* 'CKillFolder' - Definicion de la clase.-
*/
class CKillFolder
{
private:
HWND m_hWnd;
public:
//int m_iPos_Mtx;
int  Run(char*);
CKillFolder(HWND hWndParent) {m_hWnd = hWndParent;};
};

/*
* 'Run' - Inicia el proceso de eliminación.
* En ésta función se resaltan 5 bloques: A,B,C,D,E.-
*/
int CKillFolder::Run(char* lpszInitPath)
{
HANDLE hFile; //Controlador del archivo.
BOOL bNextFile = true; //Continuar buscando?.
WIN32_FIND_DATA tdataFind; //Estructura para FindFirstFile.
string lpszTemp; //template class.
vector<string> lpszDirectory; //template class.
DWORD dwType; //tipo de archivo.
INT iPos; //posición en lpszDirectory.

// BLOQUE A: Detecta si es archivo o carpeta.
dwType = GetFileAttributes(lpszInitPath);
if(dwType != (dwType | FILE_ATTRIBUTE_DIRECTORY) )
{
//Quita el atributo del archivo.
SetFileAttributes(lpszInitPath ,(DWORD)0);
//Elimina el archivo.
if(!DeleteFile(lpszInitPath))
{
MsgOut(m_hWnd,MB_ICONEXCLAMATION,MSG_ERROR_FILE,lpszInitPath);
return 0;
}
return 1;
}

// BLOQUE B: Inicia la búsqueda de sub carpetas.
lpszDirectory.push_back(lpszInitPath);
lpszDirectory[0] = lpszDirectory[0] + ALLFILES;

iPos = 0;
while(iPos < lpszDirectory.size() )
{
hFile = FindFirstFile((char*)lpszDirectory[iPos].c_str() ,&tdataFind);
if(hFile == INVALID_HANDLE_VALUE)
{
MsgOut(m_hWnd,MB_ICONEXCLAMATION,MSG_CAPTION,MSG_ERROR_HANDLE,lpszDirectory[iPos].c_str());
FindClose(hFile);
return 0;
}
while((TRUE) == bNextFile)
{
bNextFile = FindNextFile(hFile,&tdataFind);
if(bNextFile && strcmp(tdataFind.cFileName,ROOTBACK))
{
switch(tdataFind.dwFileAttributes)
{
// BLOQUE C: Almacena nombre de sub carpeta.
case FOLDER_NORMAL:
case FOLDER_HIDDEN:
case FOLDER_WINSYS:
case FOLDER_READONLY:
case FOLDER_COMPRESSED:
case FOLDER_TEMP:
case FOLDER_NOTMOVE:
lpszTemp = lpszDirectory[iPos].substr(0,lpszDirectory[iPos].length()-3)  + tdataFind.cFileName + ALLFILES;
lpszDirectory.push_back(lpszTemp);
break;
default:
// BLOQUE D: Elimina el archivo.
lpszTemp = lpszDirectory[iPos].substr(0,lpszDirectory[iPos].length()-3) + tdataFind.cFileName;
SetFileAttributes((LPCTSTR)lpszTemp.c_str() ,(DWORD)0);
if(!DeleteFile((LPCTSTR)lpszTemp.c_str()))
{
MsgOut(m_hWnd,MB_ICONEXCLAMATION,MSG_ERROR_FILE,tdataFind.cFileName);
FindClose(hFile);
return 0;
}
break;

}
}
}
FindClose(hFile);
bNextFile = true;
iPos = iPos + 1;
  }
// BLOQUE E: Elimina sub carpetas encontradas en bloque C.
while(iPos > 0)
{
iPos = iPos - 1;
lpszTemp = lpszDirectory[iPos].substr(0,lpszDirectory[iPos].length()-4);
RemoveDirectory((char*)lpszTemp.c_str());
}
return 1;
}
#endif//_KILLFOLDER_

Codigo De Huffman

Realiza la codificación de Huffman


#include <iostream.h>
#include <stdio.h>
#include <conio.h>
const int maxsize = 100;
const int null = 0;

struct huff_node
{
  char symbol;
  int freq;
  huff_node *parent;
  char childtype;
};

typedef huff_node *ptr;
ptr node[maxsize];

void create(int k);
void print(int k);    
void twosmall(ptr &p, ptr &q, int numnode);  
                                             
                                             

int main()
{
  int numsymbols;
  ptr p, q, r;
  cout << "Introduce el numero de simbolos: ";
  cin >> numsymbols;
  for (int i = 0; i < numsymbols; i++)
    create(i);


  for (int j = numsymbols; j < 2*numsymbols - 1; j++)
    {
      r = new huff_node;
      node[j] = r;
      r->parent = null;
      twosmall(p, q, j);  
      p->parent = r;
      q->parent = r;
      p->childtype = 'L';
      q->childtype = 'R';
      r->symbol = ' ';
      r->freq = p->freq + q->freq;
    }
  cout << endl << endl;
  cout <<"simbolo *-------* codigo: " << endl;
  for (int k = 0; k < numsymbols; k++)
    print(k);
    getch();
  return 0;
}

void create(int k)
{
  ptr t = new huff_node;
  cout << "introduce el simbolo numero " << k+1 << ": ";
  cin >> t->symbol;
  cout << "introduce su frecuencia: ";
  cin >> t->freq;
  t->parent = null;
  node[k] = t;
}

void print(int k)
{
  ptr t = node[k];
  char code[10];
  int size = 0;
  cout << t->symbol << " - ";

  while (t->parent != null)
    {
      if (t->childtype == 'L')
code[size] = '0';
      else
code[size] = '1';
      t = t->parent;
      size++;
    }

  for (int j = size-1; j >= 0; j--)
    cout << code[j];
  cout << endl;
}

void twosmall(ptr &p, ptr &q, int numnodes)
{
  int min1 = 9999;
  int min2 = 9999;
  p = null;
  q = null;

  for (int i = 0; i < numnodes; i++)
    {
      if (node[i]->parent == null)
{
 if (node[i]->freq < min1)
   {
     min2 = min1;
     min1 = node[i]->freq;
     q = p;
     p = node[i];
   }
 else
   if (node[i]->freq < min2)
     {
min2 = node[i]->freq;
q = node[i];
     }
}
    }
}

Agenda Telefonica

Puede dar de alta, baja , modificar registros; ordenar por nombre, apellidos , edad. Guarda los contenidos en un archivos binario y los puede leer también puede exportar en csv. corre perfecto en linux, pero para que funcione en windows hay que quitar la funcion sleep.

# include <stdio.h>

# include <string.h>

# define FICHERO "datos"

# define MAX 25

# define ESCAPE ((char)27)

FILE *fichero;



struct agenda{ //*************************

int clave; // Esctructura con   *

char nom[20]; // la forma de  *

char ApPat[15]; // los datos registro*

char ApMat[15]; //*************************

int edad;

long int tel;

long int cel;

char calle[15];

char col[15];

char mun[15];

char estado[15];

int sw;

char mail[25];

}r[MAX];



int  menu (void);

void agregar(void);

void mostrar(struct agenda);

void buscarnom(char[]);

void buscaredad(int); //********************

void apertura(void); //Prototipos de las

void m_todo(void); // Funciones

void borrar(int); //********************

void borrartodo(void);

void ordena(void);

void SaveToDisk(struct agenda);

struct agenda ReadToDisk(int);

int ReadAllToDisk(void);

void OrdenaOnMemory(int,int);

void clavesdisponibles(void);

void actualizar(struct agenda,int);

void exportar(void);



int main (){

int op,opc=0,opcls=0,clave=0,edades=0,i;

int numreg=0;

char expresion[20];

struct agenda reg;
printf("Hola mundo");

apertura();

menu:

op = menu();

switch (op){

case 1:

agregar(); //*********

goto menu; //AGREGAR

break; //*********

case 2:

printf("Dame la clave a borrar: ");

scanf ("%d",&clave); //*********

borrar(clave); //BORRAR

printf("tRegistro Borrado: %d",clave); //*********

goto menu;

break;

case 3:

printf ("t Como prefiere hacer la busqueda ?");

printf ("n");

printf ("tt1. Por Nombre, Apellido Paterno y Materno");

printf ("n"); //***********

printf ("tt2. Por Edad"); //BUSQUEDA

printf("ntOpcion: "); //***********

scanf("%d",&opc);

if(opc==1){

printf ("Escribe el Nombre o Apellidos a buscar: ");

scanf  ("%s",expresion);

buscarnom(expresion);

}else if(opc=2){

printf ("Escribe la edad para buscar ");

scanf  ("%d",&edades);

buscaredad(edades);

}

goto menu;

break;

case 4:

m_todo(); //*************

goto menu; //MOSTRAR_TODO

break; //*************

case 5:

ordena();

goto menu;

break;

case 6:

printf("n 1)Nombret2)Ap. Paternot3)Ap. Maternot4)Edadt5)Calle");

printf("nOpcion: ");

scanf("%d",&opcls);

numreg=ReadAllToDisk(); //******************

OrdenaOnMemory(numreg,opcls); //LISTAR

for(i=0;i<numreg;i++) //******************

mostrar(r[i]);

goto menu;

break;

case 7:

printf("nQue registro va actualizar (clave): ");

scanf("%d",&clave); //***************

reg=ReadToDisk(clave); //ACTUALIZAR

mostrar(reg); //***************

printf("nQue dato desea actualizar");

printf("n 1)Nombret2)Ap. Paternot3)Ap. Maternot4)Edadt5)Callet6)Telefonot7)Celulart8)Email ");

printf("n Opcion: ");

scanf("%d",&opcls);

actualizar(reg,opcls);

printf("nRegistro Actualizado");

goto menu;

break;

case 8:

exportar(); //****************

goto menu; //EXPORTAR EN CSV

break; //****************

case 9:

printf("n Ha terminado el programa..n");

break;

}

fclose(fichero);

return 1;

}

///////////////////////////////////////////////////////////////////////

void ordena(void){

int i,c;

c=ReadAllToDisk();

OrdenaOnMemory(c,1); //*******************************

borrartodo(); //Funcion que Ordena el Archivo

for(i=0;i<c;i++){ //Por Nombre

r[i].clave=i+1; //*******************************

SaveToDisk(r[i]);

}

printf("nArchivo Ordenadon");

}

///////////////////////////////////////////////////////////////////////

void OrdenaOnMemory(int c,int tipo){

int pas,i;

struct agenda aux={0};

for(pas=1;pas<c;pas++)

for(i=0;i<c-1;i++){

if(strcmp(r[i].nom,r[i+1].nom)>0 && tipo==1){

aux=r[i];

r[i]=r[i+1]; //*******************

r[i+1]=aux; //esta funcion

}else if(strcmp(r[i].ApPat,r[i+1].ApPat)>0 && tipo==2){ //ordena en memoria

aux=r[i]; //recibe el numero de

r[i]=r[i+1]; //registros c

r[i+1]=aux; //Y tipo que sirve

}else if(strcmp(r[i].ApMat,r[i+1].ApMat)>0 && tipo==3){ //para saber sobre

aux=r[i]; //que campo ordenar

r[i]=r[i+1]; //*******************

r[i+1]=aux;

}else if(r[i].edad >= r[i+1].edad && tipo==4){

aux=r[i];

r[i]=r[i+1];

r[i+1]=aux;

}else if(strcmp(r[i].calle,r[i+1].calle)>0 && tipo==5){

aux=r[i];

r[i]=r[i+1];

r[i+1]=aux;

}

}

}

///////////////////////////////////////////////////////////////////////

void apertura(void){ //*********************************

if((fichero=fopen(FICHERO,"r+"))==NULL) //Metodo para abrir el archivo

fichero=fopen(FICHERO,"w"); //En caso de error crea el archivo

} //*********************************

///////////////////////////////////////////////////////////////////////

int menu(void){

int opmenu=0;

printf("%c[1;34m",ESCAPE); //*********************************

printf ("ntM E N U"); //Fucion que muestra el Menu

printf("n"); //retorna un entero con el valor

printf("%c[2;36m",ESCAPE); //de la opcion elegida

printf ("1)Agregar"); //*********************************

printf (" 2)Borrar");

printf (" 3)Buscar");

printf (" 4)M.Todo");

printf (" 5)OrdenarArchivo");

printf (" 6)Listar");

printf (" 7)Modificar Registro");

printf (" 8)Exportar");

printf (" 9)Salir");

printf ("n");

printf ("Opcion: ");

scanf("%d",&opmenu);

printf("%c[0m",ESCAPE);

return opmenu;

}

///////////////////////////////////////////////////////////////////////

void SaveToDisk(struct agenda registro){ //****************************************

fseek(fichero,(registro.clave-1)*sizeof(registro),SEEK_SET); //Funcion para Salvar 1 registro en disco

fwrite(®istro,sizeof(registro),1,fichero); //recibe el registro y lo guarda dependiendo de su

} //clave en el archivo

//////////////////////////////////////////////////////////////////////  //**********************************************

void agregar(void){

int clave;

struct agenda registro,aux;

printf("%c[31m",ESCAPE);

clavesdisponibles();

printf("%c[0m",ESCAPE);

do{

printf (" Dame tu clave: "); //******************************

scanf  ("%d",&clave); //Codigo para validar la clave

if(clave>MAX) { //debe de ser menor que MAX

printf("%c[31m",ESCAPE); //Y no puede usar una con datos

printf("Tu clave debe ser menor que %dn",MAX); //asociados

printf("%c[0m",ESCAPE); //******************************

}

aux=ReadToDisk(clave);

if(aux.sw==1){

printf("%c[31m",ESCAPE);

printf("La clave ya esta en uso n");

printf("%c[0m",ESCAPE);

}

}while(clave>MAX || aux.sw==1);

registro.clave=clave;

printf (" Cual es tu nombre ? "); //******************************

scanf  ("%s",registro.nom); //Metodo para Pedir datos

printf (" Cual es tu Apellido Paterno ? "); //y despues agregarlos a disco

scanf  ("%s",registro.ApPat); //******************************

printf (" Cual es tu Apellido Materno ? ");

scanf  ("%s",registro.ApMat);

printf (" Cual es tu edad ? ");

scanf  ("%d",®istro.edad);

printf (" Cual es tu telefono ? ");

scanf  ("%ld",®istro.tel);

printf (" Cual es tu telefono celular? ");

scanf  ("%ld",®istro.cel);

printf (" Cual es tu calle ? ");

scanf  ("%s",registro.calle);

printf (" Cual es tu colonia ? ");

scanf  ("%s",registro.col);

printf (" Cual es tu Municipio ? ");

scanf  ("%s",registro.mun);

printf (" En que Estado vives ? ");

scanf  ("%s",registro.estado);

printf (" Cual es tu e-mail ? ");

scanf  ("%s",registro.mail);

registro.sw=1;

SaveToDisk(registro);

printf ("Se ha agregado otro elemento a la agenda");

}

///////////////////////////////////////////////////////////////////////

void buscarnom(char expresion[20]){ //************************************

int i=2; //Funcion que sirve para buscar una expresion (NOMBRE)

struct agenda registro; //en todos los registros.

registro = ReadToDisk(1); //************************************

do{

if((strcmp(registro.nom,expresion))==0 || (strcmp(registro.ApPat,expresion))==0 || (strcmp(registro.ApMat,expresion))==0)

mostrar(registro);

registro=ReadToDisk(i);

i++;

}while(!feof(fichero));

}

///////////////////////////////////////////////////////////////////////

void buscaredad(int edades){

int i=2;

struct agenda registro; //*********************************

registro=ReadToDisk(1); //Funcion que sirve para buscar

do{ //una edad en todos los registros

if(registro.edad == edades) //*********************************

mostrar(registro);

registro=ReadToDisk(i);

i++;

}while(!feof(fichero));

}

///////////////////////////////////////////////////////////////////////

int ReadAllToDisk(void){

struct agenda registro;

int i=2,c=0;

registro=ReadToDisk(1);

do{

if(registro.sw==1){ //*************************************

r[c]=registro; //Funcion que lee todos los registros

c++; //del archivo

} //*************************************

registro=ReadToDisk(i);

i++;

}while(!feof(fichero));

return c;

}

///////////////////////////////////////////////////////////////////////

struct agenda ReadToDisk(int clave){

struct agenda registro; //*********************************************

fseek(fichero,(clave-1)*sizeof(registro),SEEK_SET); //funcion que recibe una clave ,se diige a ella

fread(®istro,sizeof(registro),1,fichero); //en el archivo la lee y retorna la estructura

return registro; //*********************************************

}

///////////////////////////////////////////////////////////////////////

void m_todo(void){

int i=2;

struct agenda registro;

registro=ReadToDisk(1); //**************************

do{ //Metodo para mostrar todos

if(registro.sw==1) //los registros del archivo

mostrar(registro); //***************************

registro=ReadToDisk(i);

i++;

}while(!feof(fichero));

}

///////////////////////////////////////////////////////////////////////

void mostrar(struct agenda registro){

printf ("n");

printf (" Clave: tt %d ",registro.clave);

printf ("n");

printf (" Nombre: tt %s",registro.nom);

printf ("n");

printf (" Apellido Paterno: t %s",registro.ApPat);

printf ("n");

printf (" Apellido Materno: t %s",registro.ApMat); //*******************************

printf ("n"); //Funcion que recibe un registro

printf (" Edad: ttt %d",registro.edad); //y muestra sus campos

printf ("n"); //*******************************

printf (" Telefono: tt %ld",registro.tel);

printf ("n");

printf (" Telefono Celular:t %ld",registro.cel);

printf ("n");

printf (" Calle: tt %s",registro.calle);

printf ("n");

printf (" Colonia: tt %s",registro.col);

printf ("n");

printf (" Municipio: tt %s",registro.mun);

printf ("n");

printf (" Estado: tt %s",registro.estado);

printf ("n");

printf (" Mail: ttt %s",registro.mail);

printf ("n");

sleep(1);

}

///////////////////////////////////////////////////////////////////////

void borrar(int clave){

struct agenda aux={0,"","","",0,0,0,"","","","",0,""}; //******************************

fseek (fichero,(clave-1)*sizeof(aux),SEEK_SET); //Funcion que guarda un registro

fwrite(&aux,sizeof(aux),1,fichero); //vacio para borrar el anterior

} //******************************

///////////////////////////////////////////////////////////////////////

void borrartodo(void){

int i; //*****************************

for (i=1;i<=MAX;i++) //Metodo que deja el Archivo

borrar(i); //en blanco (borra todo)

} //*****************************

///////////////////////////////////////////////////////////////////////

void clavesdisponibles(void){

struct agenda registro;

int i=2;

registro=ReadToDisk(1);

printf("Las claves disponibles son: "); //***********************

do{ //Metodo que visualiza

if(registro.sw!=1) //todas las claves

printf("%d ",i-1); //disponibles

registro=ReadToDisk(i); //***********************

i++;

}while(!feof(fichero));

for(;i<=MAX+1;i++)

printf("%d ",i-1);

printf("n");

}

///////////////////////////////////////////////////////////////////////

void actualizar(struct agenda registro,int opcion){

switch(opcion){

case 1:

printf (" Nombre ? ");

scanf  ("%s",registro.nom);

break;

case 2:

printf (" Apellido Paterno ? ");

scanf  ("%s",registro.ApPat);

break; //**********************************

case 3: //Funcion que recibe un registro

printf (" Apellido Materno ? "); //y modifica segun "opcion"

scanf  ("%s",registro.ApMat); //el campo correspondiente

break; //**********************************

case 4:

printf (" Edad ? ");

scanf  ("%d",®istro.edad);

break;

case 5:

printf (" Calle ? ");

scanf  ("%s",registro.calle);

break;

case 6:

printf (" Telefono ? ");

scanf  ("%ld",®istro.tel);

break;

case 7:

printf (" Telefono celular? ");

scanf  ("%ld",®istro.cel);

break;

case 8:

printf (" Cual es tu e-mail ? ");

scanf  ("%s",registro.mail);

break;

}

SaveToDisk(registro);

}

///////////////////////////////////////////////////////////////////////

void exportar(void){

FILE *archivo;

char nombre[20]; //********************************

int c,i; //Metodo que sirve para

c=ReadAllToDisk(); //crear un archivo de texto

OrdenaOnMemory(c,1); //con valores separados por comas

printf("Nombre del Archivo: "); //********************************

scanf("%s",nombre);

if((archivo=fopen(nombre,"w"))==NULL)

archivo=fopen(nombre,"w");

for(i=0;i<c;i++)

fprintf(archivo,"%d,%s,%s,%s,%d,%d,%d,%s,%s,%s,%s,%s,n",r[i].clave,r[i].nom,r[i].ApPat,r[i].ApMat,r[i].edad,r[i].tel,r[i].cel,r[i].calle,r[i].col,r[i].mun,r[i].estado,r[i].mail);

fclose(archivo);

}

///////////////////////////////////////////////////////////////////////

Pruebas PacMan

Primeras pruebas a color del juego del Comecocos. Sólo está implementado el movimiento del PacMan comiendo los círculos y las frutas y el paso de un lado al otro por el pasillo. Faltan los fantasmas y la dinámica de persecución y choques... 
Desarrollado para LINUX en Code::Blocks. No os correrá correctamente en Wine...
///Carrega de llibreries
#include<stdio.h>
#include<stdlib.h>
#include <termios.h>

static struct termios old, new;

///variables globals
int punts=0,vides=2,nivell=1,atac=0;
int matriu[24][28]={
35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,
35,46,46,46,46,46,46,46,46,46,46,46,46,35,35,46,46,46,46,46,46,46,46,46,46,46,46,35,
35,67,35,35,35,35,46,35,35,35,35,35,46,35,35,46,35,35,35,35,35,46,35,35,35,35,67,35,
35,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,35,
35,46,35,35,35,35,46,35,35,46,35,35,35,35,35,35,35,35,46,35,35,46,35,35,35,35,46,35,
35,46,46,46,46,46,46,35,35,46,46,46,46,35,35,46,46,46,46,35,35,46,46,46,46,46,46,35,
35,35,35,35,35,35,46,35,35,35,35,35,32,35,35,32,35,35,35,35,35,46,35,35,35,35,35,35,
32,32,32,32,32,35,46,35,35,32,32,32,32,32,32,32,32,32,32,35,35,46,35,32,32,32,32,32,
32,32,32,32,32,35,46,35,35,32,35,35,35,32,32,35,35,35,32,35,35,46,35,32,32,32,32,32,
35,35,35,35,35,35,46,35,35,32,35,32,32,32,32,32,32,35,32,35,35,46,35,35,35,35,35,35,
101,32,32,32,32,32,46,32,32,32,35,32,32,32,32,32,32,35,32,32,32,46,32,32,32,32,32,101,
35,35,35,35,35,35,46,35,35,32,35,32,32,32,32,32,32,35,32,35,35,46,35,35,35,35,35,35,
32,32,32,32,32,35,46,35,35,32,35,35,35,35,35,35,35,35,32,35,35,46,35,32,32,32,32,32,
32,32,32,32,32,35,46,35,35,32,32,32,32,32,32,32,32,32,32,35,35,46,35,32,32,32,32,32,
35,35,35,35,35,35,46,35,35,32,35,35,35,35,35,35,35,35,32,35,35,46,35,35,35,35,35,35,
35,46,46,46,46,46,46,46,46,46,46,46,46,35,35,46,46,46,46,46,46,46,46,46,46,46,46,35,
35,46,35,35,35,35,46,35,35,35,35,35,46,35,35,46,35,35,35,35,35,46,35,35,35,35,46,35,
35,67,46,46,35,35,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,35,35,46,46,67,35,
35,35,35,46,35,35,46,35,35,46,35,35,35,35,35,35,35,35,46,35,35,46,35,35,46,35,35,35,
35,46,46,46,46,46,46,35,35,46,46,46,46,35,35,46,46,46,46,35,35,46,46,46,46,46,46,35,
35,46,35,35,35,35,35,35,35,35,35,35,46,35,35,46,35,35,35,35,35,35,35,35,35,35,46,35,
35,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,35,
35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35};
int X,Y,V,Z;
int punts,vides,nivell;

/// Declaració de funcions
/* Initialize new terminal i/o settings */
void initTermios(int echo){
  tcgetattr(0, &old); /* grab old terminal i/o settings */
  new = old; /* make new settings same as old settings */
  new.c_lflag &= ~ICANON; /* disable buffered i/o */
  new.c_lflag &= echo ? ECHO : ~ECHO; /* set echo mode */
  tcsetattr(0, TCSANOW, &new); /* use these new terminal i/o settings now */
}
/* Restore old terminal i/o settings */
void resetTermios(void){
  tcsetattr(0, TCSANOW, &old);
}
/* Read 1 character - echo defines echo mode */
char getch_(int echo){
  char ch;
  initTermios(echo);
  ch = getchar();
  resetTermios();
  return ch;
}
/* Read 1 character without echo */
char getch(void){
  return getch_(0);
}
/* Read 1 character with echo */
char getche(void){
  return getch_(1);
}
/* Funció que reemplaça el gotoxy de conio.h */
void gotoxy(int x, int y){
    printf("%c[%d;%df",0x1B,y,x);
}
/* Funció que reemplaça l'ordre delay o retard */
void delay(int del){
    int c,d;
    for (c=1;c<= del;c++) {
        for (d=1;d <=del;d++){
        }
    }
}
/* Funció per presentar la pantalla */
void mostra(){
int i,j;

for(i=0;i<24;i++){
        printf("ntt");
        for(j=0;j<28;j++){
            if(matriu[i][j]==35){
                printf("e[104m e[0m");
            }
            if(matriu[i][j]==46){
                printf("e[96m*e[0m");
            }
            if(matriu[i][j]==64){
if(atac>0){
printf("e[5me[93m@e[0m");
                }
                else{
printf("e[93m@e[0m");
                }
            }
            if(matriu[i][j]==111){
                printf(" ");
            }
            if(matriu[i][j]==32||matriu[i][j]==101){
                printf(" ");
            }
            if(matriu[i][j]==67){
                printf("e[96m█e[0m");
            }
        }
    }
    gotoxy(49,2);
    printf("e[93m+---------------+e[0m");
    gotoxy(49,3);
    printf("e[93m│   COMECOCOS   │e[0m");
    gotoxy(49,4);
    printf("e[93m+---------------+e[0m");
    gotoxy(49,5);
    printf("Punts:  %d",punts);
    gotoxy(49,6);
    printf("Vides:  %d",vides);
    gotoxy(49,7);
    printf("Nivell: %d",nivell);
    gotoxy(49,10);
    printf("e[90mPosició X=%d Y=%de[0m",X,Y);
    gotoxy(49,11);
    printf("e[90mCaracter: %ce[0m",matriu[X][Y]);
    gotoxy(100,29);
}
/* Funcio dreta */
void dreta(){

    if(matriu[X][Y+1]!=35){
        system("clear");
        if(matriu[X][Y+1]==46){
            punts++;
        }
        if(matriu[X][Y+1]==67){
            atac=1;
            punts=punts+10;
        }
        matriu[X][Y+1]=matriu[X][Y];
        matriu[X][Y]=32;
        Y++;
        if(matriu[10][27]==64){
            matriu[10][27]=32;
            matriu[10][0]=64;
            X=10;
            Y=0;
            atac=0;
        }
        mostra();
    }

}
/* Funcio esquerra */
void esquerra(){
    if(matriu[X][Y-1]!=35){
        system("clear");
        if(matriu[X][Y-1]==46){
            punts++;
        }
        if(matriu[X][Y-1]==67){
            atac=1;
            punts=punts+10;
        }
        matriu[X][Y-1]=matriu[X][Y];
        matriu[X][Y]=32;
        Y--;
        if(matriu[10][0]==64){
            matriu[10][0]=32;
            matriu[10][27]=64;
            X=10;
            Y=27;
            atac=0;
        }
        mostra();
    }
}
/* Funcio adalt */
void adalt(){
    if(matriu[X-1][Y]!=35){
        system("clear");
        if(matriu[X-1][Y]==46){
            punts++;
        }
        if(matriu[X-1][Y]==67){
            atac=1;
            punts=punts+10;
        }
        matriu[X-1][Y]=matriu[X][Y];
        matriu[X][Y]=32;
        X--;
        mostra();
    }
}
/* Funcio baix */
void baix(){
    if(matriu[X+1][Y]!=35){
        system("clear");
        if(matriu[X+1][Y]==46){
            punts++;
        }
        if(matriu[X+1][Y]==67){
            atac=1;
            punts=punts+10;
        }
        matriu[X+1][Y]=matriu[X][Y];
        matriu[X][Y]=32;
        X++;
        mostra();
    }
}
/* Funció MAIN del programa */
int main(void){
int i,j,x,y,m;
char opcio;

X=13;Y=14;
matriu[X][Y]=64;
    mostra();
    while(opcio!='q'&&opcio!='Q'){
        opcio=getch();///scanf("%c",&opcio);
        switch(opcio){
        case 'd':
            dreta();
        break;
        case'C':
            dreta();
        break;
        case 'e':
            esquerra();
        break;
        case'D':
            esquerra();
        break;
        case 'a':
            adalt();
        break;
        case'A':
            adalt();
        break;
        case 'b':
            baix();
        break;
        case'B':
            baix();
        break;
        }
    }
    return 0;
}