/* 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.*;
import java.awt.image.*;
import java.awt.geom.*;
/**
* This class implements an organism.
* The body of the organism is drawn inside the Rectangle from which it inherits.
*/
public class Organism extends Rectangle {
/**
* The version of this class
*/
private static final long serialVersionUID = Utils.FILE_VERSION;
/**
* A reference to the genetic code of this organism
*/
protected GeneticCode _geneticCode;
/**
* If this organism has been infected by a white segment, here we have the
* genetic code that this organism will reproduce.
*/
protected GeneticCode _infectedGeneticCode = null;
/**
* Number of children that this organism will produce at once. This
* is the number of yellow segments in its genetic code with a
* maximum of 8 and a minimum of 1.
*/
protected int _nChildren;
/**
* Reference to the world where the organism lives.
*/
protected World _world;
/**
* Reference to the visual part of the world where the organism lives.
*/
transient protected VisibleWorld _visibleWorld;
/**
* Identification number of this organism's parent.
*/
protected int _parentID;
/**
* Identification number of this organism.
*/
protected int _ID;
/**
* Generation number
*/
protected int _generation;
/**
* Number of children it has produced.
*/
protected int _nTotalChildren=0;
/**
* Number of organism that has killed
*/
protected int _nTotalKills=0;
/**
* Number of organism that has infected
*/
protected int _nTotalInfected=0;
/**
* X coordinates of the starting point of each organism's segments.
*/
protected int[] _startPointX;
/**
* Y coordinates of the starting point of each organism's segments.
*/
protected int[] _startPointY;
/**
* X coordinates of the ending point of each organism's segments.
*/
protected int[] _endPointX;
/**
* Y coordinates of the ending point of each organism's segments.
*/
protected int[] _endPointY;
/**
* Precalculated distance from the origin to the starting point of each segment.
* Used to calculate rotations.
*/
protected double[] _m1;
/**
* Precalculated distance from the origin to the ending point of each segment.
* Used to calculate rotations.
*/
protected double[] _m2;
/**
* Precalculated modulus of each segment.
*/
protected double[] _m;
/**
* X coordinate of this organim's center of gravity.
*/
protected int _centerX;
/**
* Y coordinate of this organim's center of gravity.
*/
protected int _centerY;
/**
* Like _centerX but with double precision to be able to make movements slower than a pixel.
*/
protected double _dCenterX;
/**
* Like _centerY but with double precision to be able to make movements slower than a pixel.
*/
protected double _dCenterY;
/**
* Effective segment colors, taken from the genetic code if alive or brown if dead.
*/
protected Color[] _segColor;
/**
* The total number of segments of the organism
*/
protected int _segments;
/**
* Growth ratio of the organism. Used to calculate segments when the organism is not
* fully grown.
*/
protected int _growthRatio;
/**
* Total mass of this organism. The mass is calculated as the sum of all segment lengths.
* Used to calculate the effect of collisions.
*/
protected double _mass = 0;
/**
* Moment of inertia of this organism, used to calculate the effect of collisions.
*/
protected double _I = 0;
/**
* Chemical energy stored by this organism
*/
protected double _energy;
/**
* Organism size independent on its position in the world.
* Let p be a point in the organism. Then, p.x + x - _sizeRect.x is the x coordinate
* of p representation in the world.
*/
protected Rectangle _sizeRect = new Rectangle();
/**
* Rotation angle that this organism has at a given moment.
*/
protected double _theta;
/**
* Last frame angle, used to avoid calculating point rotations when the angle doesn't
* change between two consecutive frames.
*/
protected double _lastTheta = -1;
/**
* Rotated segments of the last frame, to use when _theta == _lastTheta
*/
protected int x1[],y1[],x2[],y2[];
/**
* Speed. Variation applied to organism coordinates at every frame.
*/
protected double dx=0d, dy=0d;
/**
* Angular speed. Organism angle variation at every frame.
*/
protected double dtheta = 0d;
/**
* Number of frames of life of this organism
*/
protected int _age=0;
/**
* Color used to draw the organism when a collision occurs. We save the color that
* should be shown and the number of frames that it should be shown. If the number
* if frames is 0, each segment is shown in its color.
*/
protected Color _color;
/**
* Number of frames in which the organism will be drawn in _color.
*/
protected int _framesColor = 0;
/**
* Number of frame that need to pass between two reproductions, even they are not
* successfully.
*/
protected int _timeToReproduce = 0;
/**
* Indicates if the organism has grown at the last frame. If it has grown it is
* necessary to recalculate its segments.
*/
protected int hasGrown;
/**
* Indicates if it has moved at the last frame. If it has moved it is necessary
* to repaint it.
*/
protected boolean hasMoved = true;
/**
* The place that this organism occupies at the last frame. If the organism
* moves, this rectangle must be painted too.
*/
protected Rectangle lastFrame = new Rectangle();
/**
* Indicates if the organism is alive.
*/
protected boolean alive = true;
private static transient Vector2D v = new Vector2D();
/**
* Returns true if this organism is alive, false otherwise.
*
* @return true if this organism is alive, false otherwise.
*/
public boolean isAlive() {
return alive;
}
/**
* Returns the amount of chemical energy stored by this organism.
*
* @return The amount of chemical energy stored by this organism.
*/
public double getEnergy() {
return _energy;
}
/**
* Returns the identification number of this organism.
*
* @return The identification number of this organism.
*/
public int getID() {
return _ID;
}
/**
* Returns the identification number of this organism's parent.
*
* @return The identification number of this organism's parent.
*/
public int getParentID() {
return _parentID;
}
/**
* Returns the generation number of this organism.
*
* @return The generation number of this organism.
*/
public int getGeneration() {
return _generation;
}
/**
* Returns the age of this organism.
*
* @return The age of this organism, in number of frames.
*/
public int getAge() {
return _age;
}
/**
* Returns the number of children that this organism produced.
*
* @return The number of children that this organism produced.
*/
public int getTotalChildren() {
return _nTotalChildren;
}
/**
* Returns the number of organisms killed by this organism.
*
* @return The number of organisms killed by this organism.
*/
public int getTotalKills() {
return _nTotalKills;
}
/**
* Returns the number of organisms infected by this organism.
*
* @return The number of organisms infected by this organism.
*/
public int getTotalInfected() {
return _nTotalInfected;
}
/**
* Returns a reference to this organism's genetic code.
*
* @return A reference to this organism's genetic code.
*/
public GeneticCode getGeneticCode() {
return _geneticCode;
}
/**
* Returns the total mass of this organism.
*
* @return The total mass of this organism calculated as the sum
* of all its segments length.
*/
public double getMass() {
return _mass;
}
/**
* Basic constructor. Doesn't initialize it: use {@link randomCreate}
* or {@link inherit} to do this.
*
* @param world A reference to the world where this organism is in.
*/
public Organism(World world) {
_world = world;
_visibleWorld = world._visibleWorld;
_theta = Utils.random.nextDouble() * Math.PI * 2d;
}
/**
* Construct an organism with a given genetic code. Doesn't initialize it:
* use {@link pasteOrganism} to do it. Use {@link World.addOrganism} to add
* it to the world.
*
* @param world A reference to the world where this organism is in.
* @param geneticCode A reference to the genetic code of this organism.
*/
public Organism(World world, GeneticCode geneticCode) {
_world = world;
_visibleWorld = world._visibleWorld;
_theta = Utils.random.nextDouble() * Math.PI * 2d;
_geneticCode = geneticCode;
}
/**
* Creates all data structures of this organism. Must be used after the organism
* has a genetic code assigned.
*/
protected void create() {
_segments = _geneticCode.getNGenes() * _geneticCode.getSymmetry();
_segColor = new Color[_segments];
for (int i = 0; i < _segments; i++)
_segColor[i] = _geneticCode.getGene(i%_geneticCode.getNGenes()).getColor();
_startPointX = new int[_segments];
_startPointY = new int[_segments];
_endPointX = new int[_segments];
_endPointY = new int[_segments];
_m1 = new double[_segments];
_m2 = new double[_segments];
_m = new double[_segments];
x1 = new int[_segments];
y1 = new int[_segments];
x2 = new int[_segments];
y2 = new int[_segments];
}
/**
* Initializes variables for a new random organism and finds a place
* to put it in the world.
*
* @return true if it found a place for this organism or false otherwise.
*/
public boolean randomCreate() {
// Generates a random genetic code
_geneticCode = new GeneticCode();
// it has no parent
_parentID = -1;
_generation = 1;
_growthRatio = 16;
// initial energy
_energy = Math.min(Utils.INITIAL_ENERGY,_world.getCO2());
_world.decreaseCO2(_energy);
_world.addO2(_energy);
// initialize
create();
symmetric();
// put it in the world
return placeRandom();
}
/**
* Initializes variables for a new organism born from an existing
* organism. Generates a mutated genetic code based on the parent's one
* and finds a place in the world to put it.
*
* @param parent The organism from which this organism is born.
* @return true if it found a place for this organism or false otherwise.
*/
public boolean inherit(Organism parent, boolean first) {
GeneticCode inheritGeneticCode;
boolean ok = true;
// Create the inherited genetic code
if (parent._infectedGeneticCode != null)
inheritGeneticCode = parent._infectedGeneticCode;
else
inheritGeneticCode = parent._geneticCode;
_geneticCode = new GeneticCode(inheritGeneticCode);
// Take a reference to the parent
_parentID = parent.getID();
_generation = parent.getGeneration() + 1;
_growthRatio = 16;
// Initial energy: minimum energy required to reproduce is divided
// between all children and the parent.
_energy = Math.min((inheritGeneticCode._reproduceEnergy / (double)(parent._nChildren + 1)), parent._energy);
if (first || parent._energy >= _energy+Utils.YELLOW_ENERGY_CONSUMPTION) {
// Initialize
create();
symmetric();
// Put it in the world, near its parent
ok = placeNear(parent);
if (ok && !first)
parent.useEnergy(Utils.YELLOW_ENERGY_CONSUMPTION);
} else
ok = false;
return ok;
}
/**
* Places the organism at the specified position in the world and initializes its
* variables. The organism must has an assigned genetic code.
*
* @param posx The x coordinate of the position in the world we want to put this organism.
* @param posy The y coordinate of the position in the world we want to put this organism.
* @return true if there were enough space to put the organism, false otherwise.
*/
public boolean pasteOrganism(int posx, int posy) {
_parentID = -1;
_generation = 1;
_growthRatio = 16;
create();
symmetric();
_dCenterX = _centerX = posx;
_dCenterY = _centerY = posy;
calculateBounds(true);
// Check that the position is inside the world
if (isInsideWorld()) {
// Check that the organism will not overlap other organisms
if (_world.fastCheckHit(this) == null) {
// Generem identificador
_ID = _world.getNewId();
_energy = Math.min(Utils.INITIAL_ENERGY,_world.getCO2());
_world.decreaseCO2(_energy);
_world.addO2(_energy);
return true;
}
}
// It can't be placed
return false;
}
/**
* Translates the genetic code of this organism to its segments representation in the world.
* Also, calculates some useful information like segments length, inertia, etc.
* This method must be called when an organism is firstly displayed on the world and every
* time it changes its size.
* inherit, randomCreate and pasteOrganism are the standard ways to add an organism to a world
* and they already call this method.
*/
public void symmetric() {
int i,j,segment=0;
int symmetry = _geneticCode.getSymmetry();
int mirror = _geneticCode.getMirror();
int sequence = _segments / symmetry;
int left=0, right=0, top=0, bottom=0;
int centerX, centerY;
double cx, cy;
for (i=0; i<symmetry; i++) {
for (j=0; j<sequence; j++,segment++) {
// Here, we take the vector that forms the segment, scale it depending on
// the relative size of the organism and rotate it depending on the
// symmetry and mirroring.
v.setModulus(_geneticCode.getGene(j).getLength()/Utils.scale[_growthRatio-1]);
if (j==0) {
_startPointX[segment] = 0;
_startPointY[segment] = 0;
if (mirror == 0 || i%2==0)
v.setTheta(_geneticCode.getGene(j).getTheta()+i*2*Math.PI/symmetry);
else {
v.setTheta(_geneticCode.getGene(j).getTheta()+(i-1)*2*Math.PI/symmetry);
v.invertX();
}
} else {
_startPointX[segment] = _endPointX[segment - 1];
_startPointY[segment] = _endPointY[segment - 1];
if (mirror == 0 || i%2==0)
v.addDegree(_geneticCode.getGene(j).getTheta());
else
v.addDegree(-_geneticCode.getGene(j).getTheta());
}
// Apply the vector to the starting point to get the ending point.
_endPointX[segment] = (int) Math.round(v.getX() + _startPointX[segment]);
_endPointY[segment] = (int) Math.round(v.getY() + _startPointY[segment]);
// Calculate the bounding rectangle of this organism
left = Math.min(left, _endPointX[segment]);
right = Math.max(right, _endPointX[segment]);
top = Math.min(top, _endPointY[segment]);
bottom = Math.max(bottom, _endPointY[segment]);
}
}
_sizeRect.setBounds(left, top, right-left+1, bottom-top+1);
// image center
centerX = (left+right)>>1;
centerY = (top+bottom)>>1;
_mass = 0;
_I = 0;
for (i=0; i<_segments; i++) {
// express points relative to the image center
_startPointX[i]-=centerX;
_startPointY[i]-=centerY;
_endPointX[i]-=centerX;
_endPointY[i]-=centerY;
// calculate points distance of the origin and modulus
_m1[i] = Math.sqrt(_startPointX[i]*_startPointX[i]+_startPointY[i]*_startPointY[i]);
_m2[i] = Math.sqrt(_endPointX[i]*_endPointX[i]+_endPointY[i]*_endPointY[i]);
_m[i] = Math.sqrt(Math.pow(_endPointX[i]-_startPointX[i],2) +
Math.pow(_endPointY[i]-_startPointY[i],2));
_mass += _m[i];
// calculate inertia moment
// the mass center of a segment is its middle point
cx = (_startPointX[i] + _endPointX[i]) / 2d;
cy = (_startPointY[i] + _endPointY[i]) / 2d;
// add the effect of this segment, following the parallel axis theorem
_I += Math.pow(_m[i],3)/12d +
_m[i] * cx*cx + cy*cy;// mass * length^2 (center is at 0,0)
}
}
/**
* Given a vector, calculates the resulting vector after a rotation, a scalation and possibly
* after mirroring it.
* The rotation degree and the mirroring is found using the Utils.degree array, where parameter
* mirror is the row and step is the column. The step represents the repetition of this vector
* following the organism symmetry.
* The scalation is calculated using the Utils.scale coefficients, using the organism's
* _growthRatio to find the appropriate value.
*
* @param p The end point of the vector. The starting point is (0,0).
* @param step The repetition of the vectors pattern we are calculating.
* @param mirror If mirroring is applied to this organism 1, otherwise 0.
* @return The translated vector.
*/
/* private Vector2D translate(Point p, int step, int mirror) {
if (p.x == 0 && p.y == 0)
return new Vector2D();
double px = p.x;
double py = p.y;
px /= Utils.scale[_growthRatio - 1];
py /= Utils.scale[_growthRatio - 1];
Vector2D v = new Vector2D(px,py);
v.addDegree(Utils.degree[mirror][step]);
if (Utils.invertX[mirror][step] != 0)
v.invertX();
if (Utils.invertY[mirror][step] != 0)
v.invertY();
return v;
}*/
/**
* Tries to find a spare place in the world for this organism and place it.
* It also generates an identification number for the organism if it can be placed
* somewhere.
*
* @return true if a suitable place has been found, false if not.
*/
private boolean placeRandom() {
/* We try to place the organism in 12 different positions. If all of them
* are occupied, we return false.
*/
for (int i=12; i>0; i--) {
/* Get a random point for the top left corner of the organism
* making sure it is inside the world.
*/
Point origin = new Point(
Utils.random.nextInt(_world.getWidth()-_sizeRect.width),
Utils.random.nextInt(_world.getHeight()-_sizeRect.height));
setBounds(origin.x,origin.y,_sizeRect.width,_sizeRect.height);
_dCenterX = _centerX = origin.x + (_sizeRect.width>>1);
_dCenterY = _centerY = origin.y + (_sizeRect.height>>1);
// Check that the position is not occupied.
if (_world.fastCheckHit(this) == null) {
// Generate an identification
_ID = _world.getNewId();
return true;
}
}
// If we get here, we haven't find a place for this organism.
return false;
}
/**
* Tries to find a spare place near its parent for this organism and place it.
* It also generates an identification number for the organism if it can be placed
* somewhere and substracts its energy from its parent's energy.
*
* @return true if a suitable place has been found, false if not.
*/
private boolean placeNear(Organism parent) {
int nPos = Utils.random.nextInt(8);
// Try to put it in any possible position, starting from a randomly chosen one.
for (int nSide = 0; nSide < 8; nSide++) {
// Calculate candidate position
_dCenterX = parent._dCenterX + (parent.width / 2 + width / 2+ 1) * Utils.side[nPos][0];
_dCenterY = parent._dCenterY + (parent.height / 2 + height / 2 + 1) * Utils.side[nPos][1];
_centerX = (int) _dCenterX;
_centerY = (int) _dCenterY;
calculateBounds(true);
// Check this position is inside the world.
if (isInsideWorld()) {
// Check that it doesn't overlap with other organisms.
if (_world.fastCheckHit(this) == null) {
if (parent._geneticCode.getDisperseChildren()) {
dx = Utils.side[nPos][0];
dy = Utils.side[nPos][1];
} else {
dx = parent.dx;
dy = parent.dy;
}
// Generate an identification
_ID = _world.getNewId();
// Substract the energy from the parent
parent._energy -= _energy;
return true;
}
}
nPos = (nPos + 1) % 8;
}
// It can't be placed.
return false;
}
/**
* Draws this organism to a graphics context.
* The organism is drawn at its position in the world.
*
* @param g The graphics context to draw to.
*/
public void draw(Graphics g) {
int i;
if (_framesColor > 0) {
// Draw all the organism in the same color
g.setColor(_color);
_framesColor--;
for (i=0; i<_segments; i++)
g.drawLine(
x1[i] + _centerX,
y1[i] + _centerY,
x2[i] + _centerX,
y2[i] + _centerY);
} else {
if (alive) {
for (i=0; i<_segments; i++) {
g.setColor(_segColor[i]);
g.drawLine(
x1[i] + _centerX,
y1[i] + _centerY,
x2[i] + _centerX,
y2[i] + _centerY);
}
} else {
g.setColor(Utils.ColorBROWN);
for (i=0; i<_segments; i++) {
g.drawLine(
x1[i] + _centerX,
y1[i] + _centerY,
x2[i] + _centerX,
y2[i] + _centerY);
}
}
}
}
/**
* Calculates the position of all organism points in the world, depending on
* its rotation. It also calculates the bounding rectangle of the organism.
* This method must be called from outside this class only when doing
* manual drawing.
*
* @param force To avoid calculations, segments position are only calculated
* if the organism's rotation has changed in the last frame. If it is necessary
* to calculate them even when the rotation hasn't changed, assign true to this
* parameter.
*/
public void calculateBounds(boolean force) {
double left=java.lang.Double.MAX_VALUE, right=java.lang.Double.MIN_VALUE,
top=java.lang.Double.MAX_VALUE, bottom=java.lang.Double.MIN_VALUE;
double theta;
for (int i=_segments-1; i>=0; i--) {
/* Save calculation: if rotation hasn't changed and it is not forced,
* don't calculate points again.
*/
if (_lastTheta != _theta || force) {
theta=_theta+Math.atan2(_startPointY[i] ,_startPointX[i]);
x1[i]=(int)(_m1[i]*Math.cos(theta));
y1[i]=(int)(_m1[i]*Math.sin(theta));
theta=_theta+Math.atan2(_endPointY[i], _endPointX[i]);
x2[i]=(int)(_m2[i]*Math.cos(theta));
y2[i]=(int)(_m2[i]*Math.sin(theta));
}
// Finds the rectangle that comprises the organism
left = Utils.min(left, x1[i]+ _dCenterX, x2[i]+ _dCenterX);
right = Utils.max(right, x1[i]+ _dCenterX, x2[i]+ _dCenterX);
top = Utils.min(top, y1[i]+ _dCenterY, y2[i]+ _dCenterY);
bottom = Utils.max(bottom, y1[i]+ _dCenterY, y2[i]+ _dCenterY);
}
setBounds((int)left, (int)top, (int)(right-left+1)+1, (int)(bottom-top+1)+1);
_lastTheta = _theta;
}
/**
* If its the time for this organism to grow, calculates its new segments and speed.
* An alive organism can grow once every 8 frames until it gets its maximum size.
*/
private void grow() {
if (_growthRatio > 1 && (_age & 0x07) == 0x07 && alive && _energy >= _mass/10) {
_growthRatio--;
double m = _mass;
double I = _I;
symmetric();
// Cynetic energy is constant. If mass changes, speed must also change.
m = Math.sqrt(m/_mass);
dx *= m;
dy *= m;
dtheta *= Math.sqrt(I/_I);
hasGrown = 1;
} else {
if (_growthRatio < 15 && _energy < _mass/12) {
_growthRatio++;
double m = _mass;
double I = _I;
symmetric();
// Cynetic energy is constant. If mass changes, speed must also change.
m = Math.sqrt(m/_mass);
dx *= m;
dy *= m;
dtheta *= Math.sqrt(I/_I);
hasGrown = -1;
} else
hasGrown = 0;
}
}
/**
* Makes this organism reproduce. It tries to create at least one
* child and at maximum 8 (depending on the number of yellow segments
* of the organism) and put them in the world.
*/
public void reproduce() {
Organism newOrg;
for (int i=0; i < Utils.between(_nChildren,1,8); i++) {
newOrg = new Organism(_world);
if (newOrg.inherit(this, i==0)) {
// It can be created
_nTotalChildren++;
_world.addOrganism(newOrg,this);
_infectedGeneticCode = null;
}
_timeToReproduce = 20;
}
}
/**
* Executes the organism's movement for this frame.
* This includes segments upkeep and activation,
* movement, growth, collision detection, reproduction,
* respiration and death.
*/
public boolean move() {
boolean collision = false;
hasMoved = false;
lastFrame.setBounds(this);
if (Math.abs(dx) < Utils.tol) dx = 0;
if (Math.abs(dy) < Utils.tol) dy = 0;
if (Math.abs(dtheta) < Utils.tol) dtheta = 0;
// Apply segment effects for this frame.
segmentsFrameEffects();
// Apply rubbing effects
rubbingFramesEffects();
// Check if it can grow or shrink
grow();
// Movement
double dxbak=dx, dybak=dy, dthetabak=dtheta;
offset(dx,dy,dtheta);
calculateBounds(hasGrown!=0);
if (hasGrown!=0 || dx!=0 || dy!=0 || dtheta!=0) {
hasMoved = true;
// Check it is inside the world
collision = !isInsideWorld();
// Collision detection with biological corridors
if (alive) {
OutCorridor c = _world.checkHitCorridor(this);
if (c != null && c.canSendOrganism()) {
if (c.sendOrganism(this))
return false;
}
}
// Collision detection with other organisms.
if (_world.checkHit(this) != null)
collision = true;
// If there is a collision, undo movement.
if (collision) {
hasMoved = false;
offset(-dxbak,-dybak,-dthetabak);
if (hasGrown!=0) {
_growthRatio+=hasGrown;
symmetric();
}
calculateBounds(hasGrown!=0);
}
}
// Substract one to the time needed to reproduce
if (_timeToReproduce > 0)
_timeToReproduce--;
// Check if it can reproduce: it needs enough energy and to be adult
if (_energy > _geneticCode.getReproduceEnergy() + Utils.YELLOW_ENERGY_CONSUMPTION*(_nChildren-1)
&& _growthRatio==1 && _timeToReproduce==0 && alive)
reproduce();
// Check that it don't exceed the maximum chemical energy
if (_energy > 2*_geneticCode.getReproduceEnergy())
useEnergy(_energy - 2*_geneticCode.getReproduceEnergy());
// Maintenance
breath();
// Check that the organism has energy after this frame
return _energy > Utils.tol;
}
/**
* Makes the organism spend an amount of energy using the
* respiration process.
*
* @param q The quantity of energy to spend.
* @return true if the organism has enough energy and there are
* enough oxygen in the atmosphere, false otherwise.
*/
public boolean useEnergy(double q) {
if (_energy < q) {
return false;
}
double respiration = _world.respiration(q);
_energy -= respiration;
if (respiration < q)
return false;
return true;
}
/**
* Realize the respiration process to maintain its structure.
* Aging is applied here too.
*/
public void breath() {
if (alive) {
_age++;
// Respiration process
boolean canBreath = useEnergy(Math.min(_mass / Utils.SEGMENT_COST_DIVISOR, _energy));
if ((_age >> 8) > _geneticCode.getMaxAge() || !canBreath) {
// It's dead, but still may have energy
die(null);
} else {
if (_energy <= Utils.tol) {
alive = false;
_world.decreasePopulation();
_world.organismHasDied(this, null);
}
}
} else {
// The corpse slowly decays
useEnergy(Math.min(_energy, Utils.DECAY_ENERGY));
}
}
/**
* Kills the organism. Sets its segments to brown and tells the world
* about the event.
*
* @param killingOrganism The organism that has killed this organism,
* or null if it has died of natural causes.
*/
public void die(Organism killingOrganism) {
alive = false;
hasMoved = true;
for (int i=0; i<_segments; i++) {
_segColor[i] = Utils.ColorBROWN;
}
_world.decreasePopulation();
if (killingOrganism != null)
killingOrganism._nTotalKills++;
_world.organismHasDied(this, killingOrganism);
}
/**
* Infects this organism with a genetic code.
* Tells the world about this event.
* Not currently used.
*
* @param infectingCode The genetic code that infects this organism.
*/
public void infectedBy(GeneticCode infectingCode) {
_infectedGeneticCode = infectingCode;
_world.organismHasBeenInfected(this, null);
}
/**
* Infects this organism with the genetic code of another organism.
* Tells the world about this event.
*
* @param infectingOrganism The organism that is infecting this one.
*/
public void infectedBy(Organism infectingOrganism) {
infectingOrganism._nTotalInfected++;
_infectedGeneticCode = infectingOrganism.getGeneticCode();
_world.organismHasBeenInfected(this, infectingOrganism);
}
/**
* Calculates the resulting speeds after a collision between two organisms, following
* physical rules.
*
* @param org The other organism in the collision.
* @param p Intersection point between the organisms.
* @param l Line that has collided. Of the two lines, this is the one that collided
* on the center, not on the vertex.
* @param thisOrganism true if l is a line of this organism, false if l is a line of org.
*/
private final void touchMove(Organism org, Point2D.Double p, Line2D l, boolean thisOrganism) {
// Distance vector between centers of mass and p
double rapx = p.x - _dCenterX;
double rapy = p.y - _dCenterY;
double rbpx = p.x - org._dCenterX;
double rbpy = p.y - org._dCenterY;
// Speeds of point p in the body A and B, before collision.
double vap1x = dx - dtheta * rapy + hasGrown*rapx/10d;
double vap1y = dy + dtheta * rapx + hasGrown*rapy/10d;
double vbp1x = org.dx - org.dtheta * rbpy;
double vbp1y = org.dy + org.dtheta * rbpx;
// Relative speeds between the two collision points.
double vab1x = vap1x - vbp1x;
double vab1y = vap1y - vbp1y;
// Normal vector to the impact line
//First: perpendicular vector to the line
double nx = l.getY1() - l.getY2();
double ny = l.getX2() - l.getX1();
//Second: normalize, modulus 1
double modn = Math.sqrt(nx * nx + ny * ny);
nx /= modn;
ny /= modn;
/*Third: of the two possible normal vectors we need the one that points to the
* outside; we choose the one that its final point is the nearest to the center
* of the other line.
*/
if (thisOrganism) {
if ((p.x+nx-org._dCenterX)*(p.x+nx-org._dCenterX)+(p.y+ny-org._dCenterY)*(p.y+ny-org._dCenterY) <
(p.x-nx-org._dCenterX)*(p.x-nx-org._dCenterX)+(p.y-ny-org._dCenterY)*(p.y-ny-org._dCenterY)) {
nx = -nx;
ny = -ny;
}
} else {
if ((p.x+nx-_dCenterX)*(p.x+nx-_dCenterX)+(p.y+ny-_dCenterY)*(p.y+ny-_dCenterY) >
(p.x-nx-_dCenterX)*(p.x-nx-_dCenterX)+(p.y-ny-_dCenterY)*(p.y-ny-_dCenterY)) {
nx = -nx;
ny = -ny;
}
}
// This is the j in the parallel axis theorem
double j = (-(1+Utils.ELASTICITY) * (vab1x * nx + vab1y * ny)) /
(1/_mass + 1/org._mass + Math.pow(rapx * ny - rapy * nx, 2) / _I +
Math.pow(rbpx * ny - rbpy * nx, 2) / org._I);
// Final speed
dx = Utils.between(dx + j*nx/_mass, -Utils.MAX_VEL, Utils.MAX_VEL);
dy = Utils.between(dy + j*ny/_mass, -Utils.MAX_VEL, Utils.MAX_VEL);
org.dx = Utils.between(org.dx - j*nx/org._mass, -Utils.MAX_VEL, Utils.MAX_VEL);
org.dy = Utils.between(org.dy - j*ny/org._mass, -Utils.MAX_VEL, Utils.MAX_VEL);
dtheta = Utils.between(dtheta + j * (rapx * ny - rapy * nx) / _I, -Utils.MAX_ROT, Utils.MAX_ROT);
org.dtheta = Utils.between(org.dtheta - j * (rbpx * ny - rbpy * ny) / org._I, -Utils.MAX_ROT, Utils.MAX_ROT);
}
/**
* Checks if the organism is inside the world. If it is not, calculates its
* speed after the collision with the world border.
* This calculation should be updated to follow the parallel axis theorem, just
* like the collision between two organisms.
*
* @return true if the organism is inside the world, false otherwise.
*/
private final boolean isInsideWorld() {
// Check it is inside the world
if (x<0 || y<0 || x+width>=_world.getWidth() || y+height>=_world.getHeight()) {
// Adjust direction
if (x < 0 || x + width >= _world.getWidth())
dx = -dx;
if (y < 0 || y + height >= _world.getHeight())
dy = -dy;
dtheta = 0;
return false;
}
return true;
}
/**
* Moves the organism and rotates it.
*
* @param offsetx displacement on the x axis.
* @param offsety displacement on the y axis.
* @param offsettheta rotation degree.
*/
private final void offset(double offsetx, double offsety, double offsettheta) {
_dCenterX += offsetx; _dCenterY += offsety; _theta += offsettheta;
_centerX = (int)_dCenterX; _centerY = (int)_dCenterY;
}
/**
* Finds if two organism are touching and if so applies the effects of the
* collision.
*
* @param org The organism to check for collisions.
* @return true if the two organisms are touching, false otherwise.
*/
public final boolean contact(Organism org) {
int i,j;
ExLine2DDouble line = new ExLine2DDouble();
ExLine2DDouble bline = new ExLine2DDouble();
// Check collisions for all segments
for (i = _segments-1; i >= 0; i--) {
// Consider only segments with modulus greater than 1
if (_m[i]>=1) {
line.setLine(x1[i]+_centerX, y1[i]+_centerY, x2[i]+_centerX, y2[i]+_centerY);
// First check if the line intersects the bounding box of the other organism
if (org.intersectsLine(line)) {
// Do the same for the other organism's segments.
for (j = org._segments-1; j >= 0; j--) {
if (org._m[j]>=1) {
bline.setLine(org.x1[j] + org._centerX, org.y1[j] + org._centerY,
org.x2[j] + org._centerX, org.y2[j] + org._centerY);
if (intersectsLine(bline) && line.intersectsLine(bline)) {
// If we found two intersecting segments, apply effects
touchEffects(org,i,j,true);
// Intersection point
Point2D.Double intersec= line.getIntersection(bline);
/* touchMove needs to know which is the line that collides from the middle (not
* from a vertex). Try to guess it by finding the vertex nearest to the
* intersection point.
*/
double dl1, dl2, dbl1, dbl2;
dl1 = intersec.distanceSq(line.getP1());
dl2 = intersec.distanceSq(line.getP2());
dbl1 = intersec.distanceSq(bline.getP1());
dbl2 = intersec.distanceSq(bline.getP2());
// Use this to send the best choice to touchMove
if (Math.min(dl1, dl2) < Math.min(dbl1, dbl2))
touchMove(org,intersec,bline,false);
else
touchMove(org,intersec,line,true);
// Find only one collision to speed up.
return true;
}
}
}
}
}
}
return false;
}
/**
* Applies the effects produced by two touching segments.
*
* @param org The organism which is touching.
* @param seg Index of this organism's segment.
* @param oseg Index of the other organism's segment.
* @param firstCall Indicates if this organism is the one that has detected the collision
* or this method is called by this same method in the other organism.
*/
private final void touchEffects(Organism org, int seg, int oseg, boolean firstCall) {
if ((_parentID == org._ID || _ID == org._parentID) && org.alive)
return;
double takenEnergy = 0;
switch (getTypeColor(_segColor[seg])) {
case RED:
// Red segment: try to get energy from the other organism
// If the other segment is blue, it acts as a shield
switch (getTypeColor(org._segColor[oseg])) {
case BLUE:
if (org.useEnergy(Utils.BLUE_ENERGY_CONSUMPTION)) {
org.setColor(Color.BLUE);
} else {
// Doesn't have energy to use the shield
if (useEnergy(Utils.RED_ENERGY_CONSUMPTION)) {
// Get energy depending on segment length
takenEnergy = Utils.between(_m[seg] * Utils.ORGANIC_OBTAINED_ENERGY, 0, org._energy);
// The other organism will be shown in yellow
org.setColor(Color.YELLOW);
}
}
break;
case RED:
if (useEnergy(Utils.RED_ENERGY_CONSUMPTION)) {
// Get energy depending on segment length
takenEnergy = Utils.between(_m[seg] * Utils.ORGANIC_OBTAINED_ENERGY, 0, org._energy);
// The other organism will be shown in red
org.setColor(Color.RED);
}
break;
default:
if (useEnergy(Utils.RED_ENERGY_CONSUMPTION)) {
// Get energy depending on segment length
takenEnergy = Utils.between(_m[seg] * Utils.ORGANIC_OBTAINED_ENERGY, 0, org._energy);
// The other organism will be shown in yellow
org.setColor(Color.YELLOW);
}
}
// energy interchange
org._energy -= takenEnergy;
_energy += takenEnergy;
double CO2freed = takenEnergy * Utils.ORGANIC_SUBS_PRODUCED;
useEnergy(CO2freed);
// This organism will be shown in red
setColor(Color.RED);
break;
case WHITE:
// White segment: try to infect the other organism
switch (getTypeColor(org._segColor[oseg])) {
case BLUE:
if (org.useEnergy(Utils.BLUE_ENERGY_CONSUMPTION)) {
setColor(Color.WHITE);
org.setColor(Color.BLUE);
} else {
if (org._infectedGeneticCode != _geneticCode) {
if (useEnergy(Utils.WHITE_ENERGY_CONSUMPTION)) {
org.infectedBy(this);
org.setColor(Color.YELLOW);
setColor(Color.WHITE);
}
}
}
break;
case BROWN:
break;
default:
if (org._infectedGeneticCode != _geneticCode) {
if (useEnergy(Utils.WHITE_ENERGY_CONSUMPTION)) {
org.infectedBy(this);
org.setColor(Color.YELLOW);
setColor(Color.WHITE);
}
}
}
break;
case GRAY:
switch (getTypeColor(org._segColor[oseg])) {
case BLUE:
if (org.useEnergy(Utils.BLUE_ENERGY_CONSUMPTION)) {
org.setColor(Color.BLUE);
setColor(Color.GRAY);
} else {
if (useEnergy(Utils.GRAY_ENERGY_CONSUMPTION)) {
org.die(this);
setColor(Color.GRAY);
}
}
break;
case BROWN:
break;
default:
if (useEnergy(Utils.GRAY_ENERGY_CONSUMPTION)) {
org.die(this);
setColor(Color.GRAY);
}
}
break;
}
// Check if the other organism has died
if (org.isAlive() && org._energy < Utils.tol) {
org.die(this);
}
if (firstCall)
org.touchEffects(this, oseg, seg, false);
}
/*
* Perd velocitat pel fregament.
*/
private final void rubbingFramesEffects() {
dx *= Utils.RUBBING;
if (Math.abs(dx) < Utils.tol) dx=0;
dy *= Utils.RUBBING;
if (Math.abs(dy) < Utils.tol) dy = 0;
dtheta *= Utils.RUBBING;
if (Math.abs(dtheta) < Utils.tol) dtheta = 0;
}
/*
* Perd el cost de manteniment dels segments
* Aplica l'efecte de cadascun dels segments
*/
private final void segmentsFrameEffects() {
if (alive) {
int i;
// Energy obtained through photosynthesis
double photosynthesis = 0;
_nChildren = 1;
for (i=_segments-1; i>=0; i--) {
// Manteniment
switch (getTypeColor(_segColor[i])) {
// Segments cilis
case CYAN:
if (Utils.random.nextInt(100)<8 && useEnergy(Utils.CYAN_ENERGY_CONSUMPTION)) {
dx=Utils.between(dx+12d*(x2[i]-x1[i])/_mass, -Utils.MAX_VEL, Utils.MAX_VEL);
dy=Utils.between(dy+12d*(y2[i]-y1[i])/_mass, -Utils.MAX_VEL, Utils.MAX_VEL);
dtheta=Utils.between(dtheta+Utils.randomSign()*_m[i]*Math.PI/_I, -Utils.MAX_ROT, Utils.MAX_ROT);
}
break;
// Segments fotosint�tics
case GREEN:
if (useEnergy(Utils.GREEN_ENERGY_CONSUMPTION))
photosynthesis += _m[i];
break;
// Segments que obtenen energia de subs1
// Segments relacionats amb la fertilitat
case YELLOW:
_nChildren++;
break;
}
}
// Photosynthesis process
//Get sun's energy
_energy += _world.photosynthesis(photosynthesis);
}
}
private static final int NOCOLOR=-1;
private static final int GREEN=0;
private static final int RED=1;
private static final int CYAN=2;
private static final int BLUE=3;
private static final int MAGENTA=4;
private static final int PINK=5;
private static final int ORANGE=6;
private static final int WHITE=7;
private static final int GRAY=8;
private static final int YELLOW=9;
private static final int BROWN=10;
private static final int getTypeColor(Color c) {
if (c.equals(Color.RED) || c.equals(Utils.ColorDARK_RED))
return RED;
if (c.equals(Color.GREEN) || c.equals(Utils.ColorDARK_GREEN))
return GREEN;
if (c.equals(Color.CYAN) || c.equals(Utils.ColorDARK_CYAN))
return CYAN;
if (c.equals(Color.BLUE) || c.equals(Utils.ColorDARK_BLUE))
return BLUE;
if (c.equals(Color.MAGENTA) || c.equals(Utils.ColorDARK_MAGENTA))
return MAGENTA;
if (c.equals(Color.PINK) || c.equals(Utils.ColorDARK_PINK))
return PINK;
if (c.equals(Color.ORANGE) || c.equals(Utils.ColorDARK_ORANGE))
return ORANGE;
if (c.equals(Color.WHITE) || c.equals(Utils.ColorDARK_WHITE))
return WHITE;
if (c.equals(Color.GRAY) || c.equals(Utils.ColorDARK_GRAY))
return GRAY;
if (c.equals(Color.YELLOW) || c.equals(Utils.ColorDARK_YELLOW))
return YELLOW;
if (c.equals(Utils.ColorBROWN))
return BROWN;
return NOCOLOR;
}
private final void setColor(Color c) {
_color = c;
_framesColor = 10;
}
public BufferedImage getImage() {
BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
g.setBackground(Color.BLACK);
g.clearRect(0,0,width,height);
for (int i=_segments-1; i>=0; i--) {
g.setColor(_segColor[i]);
g.drawLine(x1[i] -x + _centerX, y1[i] - y + _centerY, x2[i] - x + _centerX, y2[i] - y+_centerY);
}
return image;
}
}
