En ocasiones, por motivos del protocolo utilizado en una comunicación, por la forma de acceder a la capa física o por cualquier otra razón similar, no podemos manejar directamente enteros de 4 bytes en nuestro programa, sino que debemos manejar valores de 1 sólo byte. No debemos preocuparnos, al fin y al cabo, podemos enviar un vector de 4 elementos de un tipo de dato que tenga 1 byte, por ejemplo, un carácter sin signo.
Esta entrada es una recopilación de los atajos de teclado que más uso en gedit, el editor de texto por defecto de Gnome y, en consecuencia, de Ubuntu. Personalmente prefiero Geany, pero cuando no tengo otra opción, gedit es más que aceptable.
| Acción | Combinación |
| Cambiar una pestaña a la izquierda | Ctrl + Alt + Re Pág |
| Cambiar una pestaña a la derecha | Ctrl + Alt + Av Pág |
| Cerrar pestaña actual | Ctrl + W |
| Guardar todas las pestañas abierta | Ctrl + Mayús. + L |
| Cerrar todas las pestañas. | Ctrl + Mayús. + W |
| Saltar a la enésima pestaña | Alt + n |
| Crear un documento nuevo | Ctrl + N |
| Abrir un documento | Ctrl + O |
| Guardar el documento actual | Ctrl + S |
| Guardar el documento actual con un nombre nuevo | Ctrl + Mayús. + S |
| Imprimir el documento actual | Ctrl + P |
| Vista previa de impresión | Ctrl + Mayús. + P |
| Cerrar el documento actual | Ctrl + W |
| Salir de gedit | Ctrl + Q |
| Deshacer la última acción | Ctrl + Z |
| Rehacer la última acción deshecha | Ctrl + Mayús. + Z |
| Cortar el texto o región seleccionada y ubicarlo en el portapapeles | Ctrl + X |
| Copiar el texto o región seleccionado al portapapeles | Ctrl + C |
| Pegar el contenido del portapapeles | Ctrl + V |
| Seleccionar todo el texto en el archivo | Ctrl + A |
| Eliminar la línea actual | Ctrl + D |
| Mover la línea seleccionada una línea arriba | Alt + flecha arriba |
| Y línea abajo | Alt + flecha abajo |
| Buscar una cadena | Ctrl + F |
| Seguir buscando la misma cadena hacia delante | Ctrl + G |
| Y hacia atrás | Ctrl + Mayús. + G |
| Buscar y reemplazar | Ctrl + H |
| Ir a la línea | Ctrl + I |
Si queréis más, tenéis el listado entero en la página “Teclas rápidas” dentro de la sección de gedit en Gnome.
El otro día manejando señales me preguntaba las diferencias que existen entre señales que manejo de forma muy habitual para proceder con la terminación de procesos que se están ejecutando, ya sea dentro de código, con manejadores y la función kill() o directamente desde la terminal con la orden kill.
SIGINT
Se produce cuando el usuario presiona la combinación de teclas Control+C. (o en su defecto la equivalente) para matar un proceso. Puede ser controlada o ignorada por un manejador de señales.
Lo sé, este blog se llama Linux Hispano y esta entrada no es la más apropiada aquí, pero tengo excusa, soy entre otras cosas, administrador de sistemas y algunos de los equipos que mantengo ejecutan Windows Server 2008.
La virtualización tiene enormes ventajas pero también tiene sus inconvenientes. Uno de los más frecuentes a la vez que importantes que he encontrado (aunque pueda parecer lo contrario), es los problemas de hora. Debido al modelo de ejecución de las máquinas virtuales, es muy frecuentes que éstas soporten problemas de puntualidad en la hora mostrada.
Habréis podido observar que los aviones parpadean al moverse por la pantalla. Esto se produce porque dibujamos directamente sobre la pantalla, es decir sobre lo que hemos llamado screen, de manera que dibujamos antes unos objetos y luego otros. Este problema es bien sencillo de solucionar con SDL gracias a la llamada técnica del doble búfer que nos ofrece. Mediante esta técnica dibujaremos sobre un búfer en el que una vez dibujados todos lo necesario, pasaremos a dibujar sobre el screen, de esta manera eliminaremos el parpadeo que creaba la técnica anterior.
Estaba ya un poco cansado de esta red. Me intrigó bastante al principio, pero luego me di cuenta de que no era más que otro Facebook o Tuenti, algo que no me aporta nada.
Créanme, prefiero continuar con mi cuenta de Twitter y la de LinkedIn, mucho menos intrusivas y más profesionales.
Bien, para proceder con la eliminación de nuestra cuenta en Google Plus, nos dirigimos a la barra superior (una vez logueados) a nuestra dirección de mail y accedemos a Account Settings (sí, prefiero tenerlo todo en inglés).
¿Qué sería de un videojuego de este tipo sin enemigos? La verdad es que es difícil de imaginar por lo que aunque de una manera no demasiado cuidada vamos a incluirlos. Sabiendo ya incluir imágenes y moverlas, la operación es sencilla:
for(i=0;i<numeroEnemigos;i++)
{
enemigos[i]=SDL_LoadBMP(“enemigo.bmp”);
SDL_SetColorKey (enemigos[i], SDL_SRCCOLORKEY, SDL_MapRGB (enemigos[i]->format, MASK));
posicionesEnemigos[i].x=rand()%590+1;
posicionesEnemigos[i].y=60-rand()%40+1;
}
Veamos en una imagen cómo queda:
Y el código completo serían el siguiente:
#include <stdio.h> #include <stdlib.h> #include <SDL/SDL.h> #include <time.h> #define MASK 255, 255, 255 struct posicion{ int x; int y; }; int main() { SDL_Surface *screen; SDL_Surface *fondo; SDL_Surface *jugador; SDL_Surface **enemigos; struct posicion *posicionesEnemigos; SDL_Event event; SDL_Rect posicion; int terminar=0; int numeroEnemigos=10; int i, j; int posicionJugadorX=290, posicionJugadorY=430; Uint8* teclas; srand(time(NULL)); if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("No se pudo inicializar SDL: %s\n", SDL_GetError()); exit(1); } /*creando vector para contener enemigos*/ enemigos=(SDL_Surface**)malloc(sizeof(SDL_Surface*)*numeroEnemigos); /*y vector para posiciones de los mismos*/ posicionesEnemigos=(struct posicion*)malloc(sizeof(struct posicion) *numeroEnemigos); fondo = SDL_LoadBMP("fondo.bmp"); jugador = SDL_LoadBMP("avion.bmp"); SDL_SetColorKey (jugador, SDL_SRCCOLORKEY, SDL_MapRGB (jugador->format, MASK)); /*cargando graficos para enemigos y generando posiciones iniciales para los enemigos*/ for(i=0;i<numeroEnemigos;i++) { enemigos[i]=SDL_LoadBMP("enemigo.bmp"); SDL_SetColorKey (enemigos[i], SDL_SRCCOLORKEY, SDL_MapRGB (enemigos[i]->format, MASK)); posicionesEnemigos[i].x=rand()%590+1; posicionesEnemigos[i].y=60-rand()%40+1; } screen = SDL_SetVideoMode( 640, 480, 16, SDL_HWSURFACE ); if( screen == NULL ) { printf( "Error al entrar a modo grafico: %s\n", SDL_GetError() ); SDL_Quit(); return -1; } SDL_WM_SetCaption( "Incluyendo enemigos", "Incluyendo enemigos" ); while(!terminar) { for (i=0; i<10; i++) for (j=0; j<10; j++) { posicion.x=64*i; posicion.y=48*j; SDL_BlitSurface(fondo, NULL, screen, &posicion); } posicion.x=posicionJugadorX; posicion.y=posicionJugadorY; SDL_BlitSurface(jugador, NULL, screen, &posicion); for(i=0;i<numeroEnemigos;i++) { posicion.x=posicionesEnemigos[i].x; posicion.y=posicionesEnemigos[i].y; SDL_BlitSurface(enemigos[i], NULL, screen, &posicion); } SDL_Flip(screen); while ( SDL_PollEvent(&event) ) { if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE) terminar = 1; } teclas = SDL_GetKeyState(NULL); if (teclas[SDLK_UP]) { posicionJugadorY -= 2; } if (teclas[SDLK_DOWN]) { posicionJugadorY += 2;} if (teclas[SDLK_LEFT]) { posicionJugadorX -= 2; } if (teclas[SDLK_RIGHT]) { posicionJugadorX += 2; } for(i=0;i<numeroEnemigos;i++) { posicionesEnemigos[i].y+=2; } } SDL_Quit(); return 0; }
Cuando programamos en C, nos enseñan desde primera hora a usar las funciones típicas de entrada/salida presentes en stdio.h: printf(), scanf(), getchar(), gets()… pero normalmente se obvia el uso de funciones algo más avanzadas para detectar pulsaciones de teclas o interactuar de forma más directa con la terminal.
Hoy os explicaré para qué sirven dos funciones: getch() y getche(), disponibles en conio.h (como ya advierto en el título de la entrada, este código funciona en entornos Windows, en entornos Linux ya explicaré en otra entrada cómo se puede hacer).
Veamos un ejemplo en el que detectamos la pulsación de las flechas del teclado, la tecla ENTER y el tabulador:
#include <stdio.h> #include <conio.h> int main() { char cTecla; printf("\r\nPresione un Tecla ..."); while(cTecla != 27) { cTecla = getch(); if(cTecla == 0) cTecla = getch(); else switch(cTecla) { case 13: printf("\r\n Presiono ENTER"); break; case 9: printf("\r\n Presiono TAB"); break; case 72: printf("\r\n Presiono Flecha Arriba"); break; case 80: printf("\r\n Presiono Flecha Abajo"); break; case 75: printf("\r\n Presiono Flecha izquierda"); break; case 77: printf("\r\n Presiono Flecha derecha"); break; } } return 0; }
Acabamos de hablar hace nada de cómo reservar memoria para un vector unidimensional de forma dinámica con C. Hoy le toca el turno a las matrices o arrays bidimensionales. Los vectores se organizan de forma lineal, secuencial y con todos los elementos en posiciones correlativas en la memoria. Las matrices se almacenan en forma de vector de vectores.
Dimensiones fijas
Si es de dimensiones fijas (declarándolas como matriz[filas][columnas]), el vector de vectores se guardará también uno al lado del otro.
Por lo tanto, en una matriz del tipo:
| a00 | a01 | a02 |
| a10 | a11 | a12 |
| a20 | a21 | a22 |
En memoria (en la que los elementos los direccionamos en una sola dirección) los tendríamos de la siguiente forma (en cada lenguaje este criterio cambia, en Fotran se almacena en forma de vector de columnas):
| a00 | a01 | a02 | a10 | a11 | a12 | a20 | a21 | a22 |
Dimensiones variables
Sin embargo, en el caso de la memoria dinámica, las cosas cambian. El mecanismo será el siguiente:
Hay dos detalles a tener en cuenta:
Veamos un ejemplo con código real (no hace comprobaciones de que el malloc se ejecute correctamente):
#include <stdlib.h> #include <stdio.h> int main(void) { int filas = 2; int columnas = 3; int **x; int i; // Recorre filas int j; // Recorre columnas // Reserva de Memoria x = (int **)malloc(filas*sizeof(int*)); for (i=0;i<filas;i++) x[i] = (int*)malloc(columnas*sizeof(int)); // Damos Valores a la Matriz x[0][0] = 1; x[0][1] = 2; x[0][2] = 3; x[1][0] = 4; x[1][1] = 5; x[1][2] = 6; // Dibujamos la Matriz en pantalla for (i=0; i<filas; i++) { printf("\n"); for (j=0; j<columnas; j++) printf("\t%d", x[i][j] ); } return 0; }
