/* Copyright (C) 2006-2010 Joan Queralt Molina
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
package biogenesis;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.io.*;
import java.util.List;
/**
* This class implements a full organism's genetic code. A genetic code is
* composed by a number of genes, a symmetry, optional mirroring, optional children
* dispersing, maximum life age, and energy needed to reproduce it.
*
* Genes are represented with segments that form the organism's body and are
* drawn one behind the other. This basic set is repeated symmetry times in one
* of two possible ways:
*
* If mirroring is not applied, each repetition is rotated so they are distributed
* in a uniform way around the central (starting) point.
*
* When mirrored, segments are calculated as follows:
* First, third, fifth and septh repetitions are applied a rotation of
* 0, 180, 90, 270 degrees respectively.
*
* Second repetition is like the first one with opposite x coordinate.
* Fourth repetition is like the third one with opposite x coordinate.
* Sixth repetition is like the fifth one with opposite y coordinate.
* Eigth repetition is like the septh one with opposite y coordinate.
*/
public class GeneticCode implements Cloneable, Serializable {
/**
* The version of this class
*/
private static final long serialVersionUID = Utils.FILE_VERSION;
/**
* Maximum number of segments that an organism can have.
* The genes number multiplied by the symmetry is the number
* of segments.
*/
static final int MAX_SEGMENTS = 64;
/**
* Minimum number of segments that an organism can have.
* The genes number multiplied by the symmetry is the number
* of segments.
*/
static final int MIN_SEGMENTS = 4;
/**
* Array with the genes. Every gene is represented by symmetry
* segments when drawing the organism.
*/
protected Gene[] _genes;
/**
* The symmetry used when drawing the organism. Possible values are
* 2, 4 or 8.
*/
protected int _symmetry;
/**
* Mirroring indicates if symmetric segments are drawn in the same
* way than the original, only changing their angle, or if they are
* drawn like in a mirror. 0 = not mirrored, 1 = mirrored
*/
protected int _mirror;
/**
* Indicates if children will be placed moving towards the same
* direction than the father or to a different direction to move
* away.
*/
protected boolean _disperseChildren;
/**
* Minimum required energy to reproduce this genetic code.
* More genes, means more energy is needed.
*/
protected int _reproduceEnergy;
/**
* The maximum time that the organism can be alive.
* At the moment, this is the same for all organisms.
*/
protected int _max_age;
// Getters
/**
* Returns the symmetry applied to organisms with this genetic code
*
* @return a value of 2, 4 or 8.
*/
public int getSymmetry() {
return _symmetry;
}
/**
* Returns if mirroring is applied to organisms with this genetic code
*
* @return 0 if no mirroring is applied, 1 if mirroring is applied.
*/
public int getMirror() {
return _mirror;
}
/**
* Returns if organisms with this genetic code will disperse their children or not.
*
* @return true if the organism disperses its children, false otherwise.
*/
public boolean getDisperseChildren() {
return _disperseChildren;
}
/**
* Returns the energy needed to replicate this genetic code.
* This energy is equal to 40 plus 3 for each segment.
*
* @return the energy needed to replicate this genetic code.
*/
public int getReproduceEnergy() {
return _reproduceEnergy;
}
/**
* Returns the maximum age that the organism can be.
* This is fixed at 30.
*
* @return The maximum age that the organism can be.
*/
public int getMaxAge() {
return _max_age;
}
/**
* Return a reference to a gene.
*
* @param i The index of the gene in the genetic code.
* @return A reference to the gene
*/
public Gene getGene(int i) {
return _genes[i];
}
/**
* Return the number of genes of this code
*
* @return The number of genes
*/
public int getNGenes() {
return _genes.length;
}
/**
* Gives mirror a random value (0 or 1)
*/
private void randomMirror() {
_mirror = Utils.random.nextInt(2);
}
/**
* Gives symmetry a random value (2, 4 or 8)
*/
private void randomSymmetry() {
_symmetry = Utils.random.nextInt(8)+1;
}
/**
* Create a random genes array making sure that there will be more or equal than
* MIN_SEGMENTS and less or equal than MAX_SEGMENTS segments.
* It needs symmetry to have a valid value.
*/
private void randomGenes() {
int nSegments = MIN_SEGMENTS + Utils.random.nextInt(MAX_SEGMENTS-MIN_SEGMENTS+1); // 4 - 64
if (nSegments % _symmetry != 0)
nSegments += (_symmetry - (nSegments % _symmetry));
int nGenes = nSegments / _symmetry;
_genes = new Gene[nGenes];
for (int i=0; i<nGenes; i++) {
_genes[i] = new Gene();
_genes[i].randomize();
}
}
/**
* Decide randomly if organisms with this genetic code will try to
* disperse their children or not.
*/
private void randomDisperseChildren() {
_disperseChildren = Utils.random.nextBoolean();
}
/**
* Calculates the energy required to reproduce this genetic code.
* This energy is 40 plus 3 for each segment.
*/
private void calculateReproduceEnergy() {
_reproduceEnergy = 40 + 3 * _genes.length * _symmetry;
}
/**
* Creates a new random genetic code.
*/
public GeneticCode() {
randomMirror();
randomSymmetry();
randomGenes();
randomDisperseChildren();
calculateReproduceEnergy();
_max_age = Utils.MAX_AGE;
}
/**
* Creates a genetic code given its content.
* No check about the validity of the information is done.
*
* @param genes A list containing the genes
* @param symmetry The symmetry that an organism with this genetic code will have.
* @param mirror 0 if the organism won't be mirrored, 1 if it will.
* @param disperseChildren true if the organism will disperse its children.
*/
public GeneticCode(List<Gene> genes, int symmetry, int mirror, boolean disperseChildren) {
int nGenes = genes.size();
_genes = new Gene[nGenes];
genes.toArray(_genes);
_max_age = Utils.MAX_AGE;
_mirror = mirror;
_symmetry = symmetry;
_disperseChildren = disperseChildren;
calculateReproduceEnergy();
}
/**
* Creates a new genetic code based on the father genetic code but
* applying random mutations to it.
*
* @param parentCode The genetic code that this code will be based on.
*/
public GeneticCode(GeneticCode parentCode) {
int i,j;
int addedGene = -1;
int removedGene = -1;
int nGenes;
boolean randomLength;
boolean randomTheta;
boolean randomColor;
boolean randomBack;
if (Utils.randomMutation())
randomMirror();
else
_mirror = parentCode.getMirror();
if (Utils.randomMutation()) {
// change symmetry
if (Utils.random.nextInt(10) < 2)
randomSymmetry();
else
_symmetry = Utils.between(_symmetry+Utils.randomSign(), 1, 8);
nGenes = parentCode.getNGenes();
if (nGenes * _symmetry > MAX_SEGMENTS) {
_symmetry = parentCode.getSymmetry();
}
} else {
// keep symmetry
_symmetry = parentCode.getSymmetry();
if (Utils.randomMutation()) {
// change number of segments
if (Utils.random.nextBoolean()) {
// increase segments
if (parentCode.getNGenes() * parentCode.getSymmetry() >= MAX_SEGMENTS)
nGenes = parentCode.getNGenes();
else {
nGenes = parentCode.getNGenes() + 1;
addedGene = Utils.random.nextInt(nGenes);
}
} else {
// decrease segments
if (parentCode.getNGenes() * parentCode.getSymmetry() <= MIN_SEGMENTS)
nGenes = parentCode.getNGenes();
else {
nGenes = parentCode.getNGenes() - 1;
removedGene = Utils.random.nextInt(parentCode.getNGenes());
}
}
} else {
// keep number of segments
nGenes = parentCode.getNGenes();
}
}
// Create genes
_genes = new Gene[nGenes];
for (i=0,j=0; i<nGenes; i++,j++) {
if (removedGene == j) {
i--;
continue;
}
if (addedGene == i) {
_genes[i] = new Gene();
_genes[i].randomize();
j--;
continue;
}
randomLength = randomTheta = randomColor = randomBack = false;
if (Utils.randomMutation())
randomLength = true;
if (Utils.randomMutation())
randomTheta = true;
if (Utils.randomMutation())
randomColor = true;
if (Utils.randomMutation())
randomBack = true;
if (randomLength || randomTheta || randomColor || randomBack) {
_genes[i] = new Gene();
if (randomLength)
_genes[i].randomizeLength();
else
_genes[i].setLength(parentCode.getGene(j).getLength());
if (randomTheta)
_genes[i].randomizeTheta();
else
_genes[i].setTheta(parentCode.getGene(j).getTheta());
if (randomColor)
_genes[i].randomizeColor();
else
_genes[i].setColor(parentCode.getGene(j).getColor());
} else
_genes[i] = parentCode.getGene(j);
}
if (Utils.randomMutation())
randomDisperseChildren();
else
_disperseChildren = parentCode.getDisperseChildren();
calculateReproduceEnergy();
_max_age = Utils.MAX_AGE;
}
/* (non-Javadoc)
* @see java.lang.Object#clone()
*/
@Override
public Object clone() {
GeneticCode newCode = null;
try {
newCode = (GeneticCode) super.clone();
newCode._genes = new Gene[_genes.length];
for (int i=0; i<_genes.length; i++)
newCode._genes[i] = (Gene) _genes[i].clone();
} catch (CloneNotSupportedException e) {// We should never reach this
}
return newCode;
}
/**
* Draws a representation of this genetic code. This representation
* is equivalent to draw an adult organism with this genetic code and
* no rotation.
*
* @param g The place where the representation is drawn.
* @param width The width of the available space.
* @param height The height of the available space.
*/
public void draw(Graphics g, int width, int height) {
int[][] x0 = new int[_symmetry][_genes.length];
int[][] y0 = new int[_symmetry][_genes.length];
int[][] x1 = new int[_symmetry][_genes.length];
int[][] y1 = new int[_symmetry][_genes.length];
int maxX = 0;
int minX = 0;
int maxY = 0;
int minY = 0;
double scale = 1.0;
Vector2D v = new Vector2D();
Graphics2D g2 = (Graphics2D) g;
for (int i=0; i<_symmetry; i++) {
for (int j=0; j<_genes.length; j++) {
v.setModulus(_genes[j].getLength());
if (j==0) {
x0[i][j]=y0[i][j]=0;
if (_mirror == 0 || i%2==0)
v.setTheta(_genes[j].getTheta()+i*2*Math.PI/_symmetry);
else {
v.setTheta(_genes[j].getTheta()+(i-1)*2*Math.PI/_symmetry);
v.invertX();
}
} else {
x0[i][j] = x1[i][j-1];
y0[i][j] = y1[i][j-1];
if (_mirror == 0 || i%2==0)
v.addDegree(_genes[j].getTheta());
else
v.addDegree(-_genes[j].getTheta());
}
x1[i][j] = (int) Math.round(v.getX() + x0[i][j]);
y1[i][j] = (int) Math.round(v.getY() + y0[i][j]);
maxX = Math.max(maxX, Math.max(x0[i][j], x1[i][j]));
maxY = Math.max(maxY, Math.max(y0[i][j], y1[i][j]));
minX = Math.min(minX, Math.min(x0[i][j], x1[i][j]));
minY = Math.min(minY, Math.min(y0[i][j], y1[i][j]));
}
}
g2.translate(width/2, height/2);
if (maxX-minX > width)
scale = (double)width/(double)(maxX-minX);
if (maxY-minY > height)
scale = Math.min(scale, (double)height/(double)(maxY-minY));
g2.scale(scale, scale);
for (int i=0; i<_symmetry; i++) {
for (int j=0; j<_genes.length; j++) {
x0[i][j]+=(-minX-maxX)/2;
x1[i][j]+=(-minX-maxX)/2;
y0[i][j]+=(-minY-maxY)/2;
y1[i][j]+=(-minY-maxY)/2;
g2.setColor(_genes[j].getColor());
g2.drawLine(x0[i][j],y0[i][j],x1[i][j],y1[i][j]);
}
}
}
}
