particle life
Particle Life (C++)
Um programa simples para simular a Vida Artificial primitiva usando regras simples de atração ou repulsão entre partículas semelhantes a átomos, produzindo padrões complexos de auto-organização semelhantes a vida. Excluindo os elementos da GUI, o código é menor que uma página. O tutorial em vídeo e o passo a passo estão disponíveis abaixo.
https://youtu.be/0Kx4Y9TVMGg
Clique aqui para uma demonstração ao vivo (JavaScript):
Você não precisa ser exato com os parâmetros para reproduzir esses padrões. A melhor maneira de obter padrões interessantes é primeiro tentar explorações de parâmetros aleatórios. Depois de encontrar um padrão interessante, tente ajustá-lo gradualmente. Para evitar ficar preso em um máximo local, você pode fazer alguns grandes saltos ocasionais de parâmetros. Desta forma, padrões interessantes e diferentes continuarão aparecendo.
Baixe este repositório. descompacte o arquivo, vá para a pasta /particle_life/bin/ e clique em partícula_life.exe
O código-fonte está disponível em C++, JavaScript e Python. Assista a este vídeo do YouTube para um tutorial passo a passo: https://youtu.be/0Kx4Y9TVMGg
Se você quiser contribuir com o programa C++, o algoritmo principal são as primeiras 100 linhas de código em: "/particle_life/src/ofApp.cpp". O resto são componentes GUI e controles de renderização que são fornecidos pela biblioteca openFrameworks, uma biblioteca de renderização de imagens de código aberto e fácil de usar.
Para começar, baixe este repositório e depois baixe a biblioteca openFrameworks aqui: https://openframeworks.cc/. Use o projectGenerator do openFramework e importe a pasta /particle_life/ para o projeto.
Alternativamente, gere um novo projeto openFramework e adicione ofxGui. Assim que os arquivos do projeto forem gerados, substitua a pasta /src/ pela fornecida aqui.
Agora você pode compilar o código C++ em sua máquina.
Além disso, consulte o arquivo partícula_life.html para obter uma versão mais otimizada - obrigado a quem contribuiu.
< canvas id =" life " width =" 500 " height =" 500 " > </ canvas >
< script >
//Hunar Ahmad @ brainxyz
m = document . getElementById ( "life" ) . getContext ( "2d" ) ;
draw = ( x , y , c , s ) => {
m . fillStyle = c ;
m . fillRect ( x , y , s , s ) ;
} ;
atoms = [ ] ;
atom = ( x , y , c ) => {
return { x : x , y : y , vx : 0 , vy : 0 , color : c } ;
} ;
random = ( ) => {
return Math . random ( ) * 400 + 50 ;
} ;
create = ( number , color ) => {
group = [ ] ;
for ( let i = 0 ; i < number ; i ++ ) {
group . push ( atom ( random ( ) , random ( ) , color ) ) ;
atoms . push ( group [ i ] ) ;
}
return group ;
} ;
rule = ( atoms1 , atoms2 , g ) => {
for ( let i = 0 ; i < atoms1 . length ; i ++ ) {
fx = 0 ;
fy = 0 ;
for ( let j = 0 ; j < atoms2 . length ; j ++ ) {
a = atoms1 [ i ] ;
b = atoms2 [ j ] ;
dx = a . x - b . x ;
dy = a . y - b . y ;
d = Math . sqrt ( dx * dx + dy * dy ) ;
if ( d > 0 && d < 80 ) {
F = ( g * 1 ) / d ;
fx += F * dx ;
fy += F * dy ;
}
}
a . vx = ( a . vx + fx ) * 0.5 ;
a . vy = ( a . vy + fy ) * 0.5 ;
a . x += a . vx ;
a . y += a . vy ;
if ( a . x <= 0 || a . x >= 500 ) { a . vx *= - 1 ; }
if ( a . y <= 0 || a . y >= 500 ) { a . vy *= - 1 ; }
}
} ;
yellow = create ( 200 , "yellow" ) ;
red = create ( 200 , "red" ) ;
green = create ( 200 , "green" ) ;
update = ( ) => {
rule ( green , green , - 0.32 ) ;
rule ( green , red , - 0.17 ) ;
rule ( green , yellow , 0.34 ) ;
rule ( red , red , - 0.1 ) ;
rule ( red , green , - 0.34 ) ;
rule ( yellow , yellow , 0.15 ) ;
rule ( yellow , green , - 0.2 ) ;
m . clearRect ( 0 , 0 , 500 , 500 ) ;
draw ( 0 , 0 , "black" , 500 ) ;
for ( i = 0 ; i < atoms . length ; i ++ ) {
draw ( atoms [ i ] . x , atoms [ i ] . y , atoms [ i ] . color , 5 ) ;
}
requestAnimationFrame ( update ) ;
} ;
update ( ) ;
</ script > Simulação de vida de partículas, Sopa Primordial - Evolução, Jogo da vida de Conway, Autômatos celulares, Padrões de auto-organização,
Este projeto foi inspirado em: Clusters de Jeffery Ventrella http://www.ventrella.com/Clusters/. Não tenho acesso ao código do Ventrella, mas acho que a principal diferença deste projeto em relação aos outros projetos de vida de partículas é que não implementei a detecção de colisão e isso possibilitou a simulação de milhares de partículas em tempo real. Além disso, adicionei controles GUI para alterar os parâmetros em tempo real, permitindo fácil ajuste e exploração, portanto, consegui encontrar alguns padrões nunca vistos antes que surgiram de alguns modelos de relações extremamente simples. O código aqui é provavelmente uma ordem de magnitude mais simples do que qualquer outro código de Vida Artificial por aí, porque comecei esse código apenas como um material educacional para não programadores e para o público em geral, para provar que a complexidade pode surgir da simplicidade.
