Increible tetris en 19 líneas escrito en c
Código ganador del “The International Obfuscated C Code Contest“ del 2007 hecho en México.
¡Completamente inspirador!
=0,i=276,j,k,q[276],Q[276],*n=q,*m,x=17,f[]={7,-13,-12,1,8,-11,-12,-1,9,-1,1,
12,3,-13,-12,-1,12,-1,11,1,15,-1,13,1,18,-1,1,2,0,-12,-1,11,1,-12,1,13,10,-12,
1,12,11,-12,-1,1,2,-12,-1,12,13,-12,12,13,14,-11,-1,1,4,-13,-12,12,16,-11,-12,
12,17,-13,1,-1,5,-12,12,11,6,-12,12,24};u(){for(i=11;++i<264;)if((k=q[i])-Q[i]
){Q[i]=k;if(i-++I||i%12<1)printf("\033[%d;%dH",(I=i)/12,i%12*2+28);printf(
"\033[%dm "+(K-k?0:5),k);K=k;}Q[263]=c=getchar();}G(b){for(i=4;i--;)if(q[i?b+
n[i]:b])return 0;return 1;}g(b){for(i=4;i--;q[i?x+n[i]:x]=b);}main(C,V,a)char*
*V,*a;{h[3]=1000000/(l=C>1?atoi(V[1]):2);for(a=C>2?V[2]:"jkl pq";i;i--)*n++=i<
25||i%12<2?7:0;srand(getpid());system("stty cbreak -echo stop u");sigvec(14,v,
0);t();puts("\033[H\033[J");for(n=f+rand()%7*4;;g(7),u(),g(0)){if(c<0){if(G(x+
12))x+=12;else{g(7);++w;for(j=0;j<252;j=12*(j/12+1))for(;q[++j];)if(j%12==10){
for(;j%12;q[j--]=0);u();for(;--j;q[j+12]=q[j]);u();}n=f+rand()%7*4;G(x=17)||(c
=a[5]);}}if(c==*a)G(--x)||++x;if(c==a[1])n=f+4**(m=n),G(x)||(n=m);if(c==a[2])G
(++x)||--x;if(c==a[3])for(;G(x+12);++w)x+=12;if(c==a[4]||c==a[5]){s=sigblock(
8192);printf("\033[H\033[J\033[0m%d\n",w);if(c==a[5])break;for(j=264;j--;Q[j]=
0);while(getchar()-a[4]);puts("\033[H\033[J\033[7m");sigsetmask(s);}}d=popen(
"stty -cbreak echo stop \023;sort -mnr -o HI - HI;cat HI","w");fprintf(d,
"%4d from level %1d by %s\n",w,l,getlogin());pclose(d);}
Para verlo en acción abran una terminal, compilen y ejecuten:
$ gcc tetris.c -o tetris
$ ./tetris
Python: Hallar el punto de intersección entre dos segmentos
Este segmento de código devuelve el punto de intersección entre dos rectas, no se consideran el caso de que no exista o exista más de uno (lineas paralelas). Depende del valor de la variable det, si es igual a cero, es necesario verificar que las lineas sean paralelas, si no lo son, entonces nunca se tocan.
#interseccion EN UN UNICO PUNTO entre segmentos
class punto:
def __init__(self,x,y):
self.x = x
self.y = y
def __str__(self):
return "("+str(self.x)+","+str(self.y)+")"
class linea:
def __init__(self, p0, p1):
self.p0 = p0
self.p1 = p1
self.A = p1.x - p0.x
self.B = p1.y - p0.y
self.C = p1.x*p0.y - p0.x*p1.y
def intersecta(self, otro):
det = self.A*otro.B - otro.A*self.B
x = otro.A*self.C-self.A*otro.C
y = otro.B*self.C-self.B*otro.C
return punto(x/det,y/det)
def __str__(self):
return str(self.p0) + "," + str(self.p1)
if __name__=="__main__":
l1 =linea(punto(0,0),punto(10,10))
l2 =linea(punto(10,0),punto(0,10))
print l1,l2
print l1.intersecta(l2)
Animación orgánica con Context Free
Me quedé con la curiosidad de cómo generar una animación del programa en Context Free sin la interfaz de usuario que existe en otras plataformas como güindous y mac.
Esta es la solución que encontre:
- Suponiendo que el código fuente document.cfdg se encuentra en el directorio_actual, y que tenemos la siguiente estructura de directorios:
directorio_actual
|
+----animation
|
+-----frames - Instalar las herramientas de consola ffmpeg y convert.
- Generar los cuadros de nuestra animación, en mi caso 50, con la siguiente línea:
cfdg -w 500 -h 500 document.cfdg ./animation/art.png -a 500
- Como el cfdg solo genera imágenes png y ffmpeg (que convierte una secuencia de imágenes en video) sólo acepta imágenes jpg, realizamos la conversión de las imágenes con la siguiente línea:
cd animation
convert * ./frames/anima.jpg - Generamos el video con el comando ffmpeg:
cd frames
ffmpeg -f image2 -i anima-%d.jpg video.mpeg
sudo apt-get install ffmpeg
¡Listo!, ya tenemos una animación de nuestro programa.
Construir patrones orgánicos con gramáticas libres del contexto
Context Free es un
programa que genera imágenes a partir de una serie de instrucciones conocidas como gramáticas. El programa sigue las instrucciones y en pocos segundos crea imágenes que pueden contener millones de formas.
En esta galería podrás encontrar miles de trabajos creados por artistas de todo el mundo.
Vamos a crear el famoso “hola mundo”, primero hay que bajar la el software aquí.
Afortunadamente existe una paquete para Debian (también funciona para ubuntu), lo que nos ahorra compilarlo desde el fuente.
¿Cómo instalarlo?
- Abrimos el archivo /etc/apt/sources.list como super-usuario y agregamos las siguientes lineas:
deb http://ftp.us.debian.org/debian/ unstable main non-free contrib
deb-src http://ftp.us.debian.org/debian/ unstable main non-free contrib - Guardamos el archivo y actualizamos los paquetes con la siguiente línea:
apt-get update
- Instalamos el software con:
apt-get install cfdg
- Abrimos nuestro editor favorito (geany en mi caso) y guardamos el archivo con el nombre documento.cfdg y comenzamos a escribir las instrucciones.
Escribimos el código
Este es el diminuto código que genera la imagen arriba:
background{a-1}
rule TENDRILS{
ARM{}
ARM{flip 90}
}
rule ARM 98{
CIRCLE{}
CIRCLE{size 0.9 brightness 1 }
ARM{ y 0.2 size 0.99 rotate 3 }
}
rule ARM 2 {
CIRCLE{size 0.9 brightness 1 }
ARM{ y 0.2 size 0.99 flip 90 }
ARM{ y 0.2 size 0.6 brightness 0.2}
}
El código se compone de una forma principal etiquetada como TENDRIL, y esta a su vez se compone de dos formas definidas por una solo regla ARM. Se puede observar que esta última regla esta “sobrecargada”, es decir, existen dos versiones de la misma regla, solo que una tiene .98 de probabilidad de ser llamada mientras que la otra solo tiene el 0.2 (esta distribución permite que el algoritmo sea aleatorio).
Puedes echarle un ojo al artículo del Volumen 17 de la revista Make, para una mejor descripción del código.
¿Cómo compilar?
Ya que todo es desde consola, puedes usar la siguiente línea para compilar:
y esta para visualizar la imagen de 500×500 px que genera:
Tirador de penales en Processing
No se parece ni remotamente al Winning Eleven, pero describe muy bien el tiro parabólico. La barra degrada de potencia y el selector del ángulo de disparon son sólo caprichos que quise agregar.
La parte divertida es la forma de controlar el disparo:
- con click derecho se posiciona el punto de tiro.
- con la posición del puntero del mouse en el eje y se controla la medida del ángulo [0,90]
- y la fuerza del disparo se mide en relación al tiempo que se mantiene presionado el botón izquierdo del mouse.
!Me gustó el resultado final!
Va, les dejo el código y los ejecutables para güindous, linux y mac.
//06/08/09
PImage bg,balon,mira,flecha;
float teta = 0;
int x_ini,y_ini,c_x,c_y;
float delta_t = 0;
float vel_ini;
float aceleracion_y = -1.8;
boolean lanzar = false;
boolean mira_enable=false;
int mira_x,mira_y;
int colores[];
void setup(){
size(600,327);
bg = loadImage("background.jpg");
balon = loadImage("balon.png");
mira = loadImage("mira.png");
flecha = loadImage("flecha.png");
background(255);
colores =new int[25];
// frameRate(1);
x_ini = 0;
y_ini = height;
c_x = x_ini;
c_y = y_ini;
//aceleracion constante
vel_ini = 5;
fill(255,0,0);
smooth();
// image(balon,c_x,c_y);
colorMode(HSB, 100);
for (int i = 0;i<colores.length ;i++){
colores[i] =color(colores.length-i, 100, 100);
}
colorMode(RGB);
}
void draw(){
if (mira_enable==true){
background(bg);
teta = map(mouseY,mira_y,mira_y-100,0,HALF_PI);
teta = constrain(teta,0,HALF_PI);
image(mira,mira_x-mira.width/2,mira_y-mira.height/2);
fill(255,234,0,50);
noStroke();
arc(mira_x,mira_y, 90, 90, -teta,0);
stroke(0);
strokeWeight(4);
pushMatrix();
translate(mira_x,mira_y);
rotate(-teta);
image(flecha,0,0-flecha.height/2);
// line(mira_x,mira_y,mira_x+50*cos(teta),mira_y-50*sin(teta));
popMatrix();
}
if (lanzar == true){
delta_t +=1;
c_x = x_ini + int(vel_ini*cos(teta)*delta_t);
c_y = y_ini - int(vel_ini*sin(teta)*delta_t + 0.5*aceleracion_y*delta_t*delta_t);
image(balon,c_x,c_y);
if (c_x > width || c_y > height){
lanzar = false;
vel_ini = 5;
}
}
else{
if (mousePressed==true && mouseButton==LEFT){
lanzar = false;
if (vel_ini < 40)
vel_ini+=2;
int ancho = int(map(vel_ini,5,40,0,25));
for(int i=0; i< ancho; i++){
//int index = int(map(i,0,ancho,0,colores.length));
fill(colores[i]);
noStroke();
//line(i,height-10,i,height-5);
rect(10+i*5,height-10,5,5);
}
}
delta_t=0;
x_ini= mira_x-balon.width/2;
y_ini =mira_y-balon.height/2;
}
}
void mouseReleased(){
if (mouseButton==RIGHT){
mira_enable = true;
mira_x = mouseX;
mira_y = mouseY;
}
else{
lanzar = true;
mira_enable=false;
}
}
eXitium: mini mod del Juego Left4Dead
Daniel Reynoso nos cuenta desde su página, sobre la modificación que le hizo al juego de acción Left4Dead. Se trata de un juego en primera persona que tiene como escenario el anexo a la Facultad de Ingeniería de la UNAM, México. Daniel nos cuenta de cómo surgió la iniciativa de este proyecto:
Después de jugar HalfLife 2 un par de veces, decidí probar las herramientas de desarrollo. Así que construí un mapa aleatorio, coloqué una esfera roja y pensé: “mmm, esta podría ser la Leonardita (la escultura roja del Anexo de Ingeniería, UNAM) sería excelente hacer el mapa completo” Y así, un nuevo mod para el HL2 había nacido.
¿Cuál es la historia? Bueno, es el mismo inexplicable apocalipsis de zombies, pero en otro país (México). Mismo concepto, distintas circunstancias.
Mas información en la página oficial, gracias Daniel!
Librería msound para Mobile Processing en acción
Existen un grupo de librerías para Mobile Processing que no pertenecen al nucleo, hechas por terceros para extender sus funcionalidades. Existe en un apartado de Referencias en la página oficial de Mobile Processing en donde se detallan estas librearías.
En esta ocasión se mostrarán los midlets corriendo en un n95, para ejemplificar el uso de la librería msound.
Cada tecla está asociada a una frecuencia diferente.
Importar contactos a partir de un .txt
Aquí esta el complemento, muy útil cuando cambiamos de teléfono. En el archivo de entrada, cada línea es un contacto, el primer campo es el nombre del contacto y el segundo el número telefónico correspondiente. Los campos se separan por tabuladores, este es un ejemplo del archivo de entrada “contactos.txt”:
pzo{phrrdw 3645688357
dwhvotiuul 9827914405
vfltjdlakf 0544231692
dkiimtwktg 2587469846
cdxibeuhgb 8662069239
jtjivwksvb 2151870224
dpbnjfpgzt 2950363356
esaooqfoun 9590050987
swmilkrg{d 0705686048
pdjzcgioeb 7049194677
{gvqwsmtmw 3441362136
ztqcnwibxg 1054659213
yblbwcebog 7803351735
n{qogrgwbd 8184444490
El código del midlet, es el siguiente:
/*Importa contactos
por Dennys Regalado Díaz
Utilidad, 4 de Abril del 2009
*/
import mjs.processing.mobile.mfiles.*;
import mjs.processing.mobile.mpim.*;
String fileName = "file:///root1/contactos.txt";
// Create the PIM object
MPIM mPIM;
MContact mContact;
MContactList mContactList;
String lines[];
PFont fuente;
int i;
// Open the contact list in read mode and get all the contacts
MContact[] contacts;
void setup(){
fuente = loadFont();
textFont(fuente);
textAlign(LEFT);
// For each contact show name an phone number
fill(0);
i=0;
try{
lines = MFiles.loadStrings(fileName);
}
catch(Exception e){
text("Error al intentar leer \"contactos.txt\"",width/2,height/2);
}
mPIM = new MPIM();
mContactList = mPIM.contactList(MPIM.WRITE);
}
void draw(){
background(255);
if(i< length(lines)){
mContact= mContactList.createContact();
String items[] = split(lines[i],"\t");
mContact.name(items[0]);
mContact.tel(items[1]);
mContact.save();
int value = (i*(width-20))/length(lines);
int percent = (i*100)/length(lines);
text(items[0]+"...",20,15);
text(percent+"%",width/2,height/2-40);
rect(10,height/2-30,value,10);
i++;
}
else{
textAlign(CENTER);
text("Hecho.",width/2,height/2);
text("Se importaron " +length(lines) + " contacto(s)",width/2,height/2 + 15);
text("de \"contactos.txt\"",width/2,height/2 + 35);
noLoop();
}
}
Exportar los contactos de mi teléfono a un archivo .txt
Aquí les dejo un pequeño sketch escrito en mobile processing para exportar la lista de contactos a un archivo de texto. La idea es que luego puedan enviar este archivo a su PC para respaldarlo.
Nota: cambien las variable fileName con la ruta de su teléfono!!!
Este es el código usando las librerias mfiles y mpim de Marlon:
por Dennys Regalado Díaz
Utilidades, 4 de Abril del 2009
*/
import mjs.processing.mobile.mfiles.*;
import mjs.processing.mobile.mpim.*;
String fileName = "file:///root1/contactos.txt";
// Create the PIM object
MPIM mPIM = new MPIM();
String lines[];
PFont fuente;
int i;
// Open the contact list in read mode and get all the contacts
MContact[] contacts;
void setup(){
fuente = loadFont();
textFont(fuente);
textAlign(LEFT);
// For each contact show name an phone number
fill(0);
i=0;
contacts = mPIM.contactList(MPIM.READ).contacts();
lines = new String[length(contacts)];
}
void draw(){
background(255);
if(i< length(contacts)){
lines[i] = contacts[i].name() + "\t"+contacts[i].tel();
int value = (i*(width-20))/length(contacts);
int percent = (i*100)/length(contacts);
text(contacts[i].name()+"...",20,15);
text(percent+"%",width/2,height/2-40);
rect(10,height/2-30,value,10);
// text(contacts[i].name(),10,15*i);
i++;
}
else{
textAlign(CENTER);
try{
MFiles.saveStrings(fileName,lines);
text("Hecho.",width/2,height/2);
text("Se exportaron " +length(contacts) + " contacto(s)",width/2,height/2 + 15);
text("a \"contactos.txt\"",width/2,height/2 + 35);
}
catch(Exception e){
text("Ocurrio un error en la escritura",width/2,height/2);
}
noLoop();
}
}
Cómo leer píxeles de una imagen y mostrarlos con un LED RGB
La idea de escribir este sketch surgió por un comentario de Pedro que recibí hace una semana. Después de ver unos ejemplos (Examples->Topics->Image Processing->PixelArray) me dí cuenta que el programa era muy sencillo de escribir.
El objetivo cargar una imagen en Processing y de acuerdo a la posición del cursor del mouse, leer ese pixel y enviarlo al Arduino para que éste lo muestre usando un LED RGB.
El código para el Arduino es el mismo que usé en el post Controlando led RGB al ritmo de la música, solo se encarga de descomponer el color (enviado en hexadecimal) y luego escribir los valores Red, Green, Blue a las salidas PWM 9, 10, 11.
Este es un extracto del código en el que se asignan los pines de salida al LED RGB:
#define G_LED 9
#define B_LED 10
El código en Processing es el siguiente:
* PixelArray
* por Dennys Regalado Díaz
*
* Posiciona el cursor del raton sobre la imagen, obtiene el color del pixel,
* lo envía al Arduino y lo muestra con un LED RGB
* 2 de Mayo del 2009
*/
import processing.serial.*;
PImage a;
int[] aPixels;
float signal;
String cs;
int last_color = -1;
Serial port;
void setup()
{
a = loadImage("test.jpg");
size(a.width, a.height);
aPixels = new int[a.width*a.height];
noFill();
stroke(255);
frameRate(10);
//configura puerto serial
println(Serial.list());
port = new Serial(this, Serial.list()[0], 9600);
}
void draw()
{
image(a,0,0);
if(mouseY > height-1)
mouseY = height-1;
if(mouseY < 0)
mouseY = 0;
signal = mouseY*a.width + mouseX;
rect(signal%a.width-5, int(signal/a.width)-5, 10, 10);
point(signal%a.width, int(signal/a.width));
color c = a.pixels[int(signal)];
// println(red(c)+","+green(c)+","+blue(c));
//Envia datos al arduino
if(c!=last_color){
cs = "#" + hex(c,6); // Prepare a string to be sent to Arduino
port.write(cs);
last_color=c;
}
fill(c);
rect(width-20,height-20,20,20);
noFill();
}