Hello,

D'après ton algo, je vois que la quantité de feuille et de racines est fixée au départ et ne bouge plus, j'ai donc retiré de mon code, les méthodes qui permettaient à la plante de créer feuilles et racines.

J'ai juste ajouté une méthode qui simule le comportement de vie d'une plante.
En gros la simulation se résume à ceci :
Toutes les unités de temps, la plante absorbe des ressources, et décide si elle doit faire grandir ses feuilles ou ses racines en fonction des quantités d'azote et carbone disponibles.
Ensuite la méthode affiche juste à chaque période, la quantité d'azote et de carbone dispo dans la plante.
Par rapport à ton besoin il faudrait aussi ajouter les surfaces des feuilles et des racines, je te laisserais le soin de faire ca.

Une petite chose que je n'ai pas bien compris, tu as parlé de feux facteurs supplémentaires, eau et lumière, or dans ton algo, il n'est nul part mentionné leur impact sur la plante. Pour l'instant donc je n'en ai pas tenu compte.

Voici l'implémentation :

Feuille

package bean;

public class Feuille {
	
	private static double sCoefficientAbsorbCarbone = 1;
	private static double sNeededAzotePourGrandir = 1;
	private static double sNeededCarbonePourGrandir = 1;
	
	private double mSurface;

	public Feuille() {
		mSurface = 0;
	}
	
	public double getSurface() {
		return mSurface;
	}

	public void setSurface(Double surface) {
		mSurface = surface;
	}
	
	public double absorbeCarbone() {
		return mSurface * sCoefficientAbsorbCarbone;
	}
	
	public void faireGrandirFeuille(double pQuantiteAzoteDispo, double pQuantiteCarboneDispo) {
		pQuantiteAzoteDispo = pQuantiteAzoteDispo - sNeededAzotePourGrandir;
		pQuantiteCarboneDispo = pQuantiteCarboneDispo - sNeededCarbonePourGrandir;
		mSurface += 1;
	}
	
}

Racine

package bean;

public class Racine {
	
	private static double sCoefficientAbsorbAzote = 1;
	private static double sNeededAzotePourGrandir = 1;
	private static double sNeededCarbonePourGrandir = 1;
	
	private double mSurface;

	public Racine() {
		mSurface = 0;
	}
	
	public double getSurface() {
		return mSurface;
	}

	public void setSurface(Double surface) {
		mSurface = surface;
	}
	
	public double absorbeAzote() {
		return sCoefficientAbsorbAzote * mSurface;
	}
	
	public void faireGrandirRacine(double pQuantiteAzoteDispo, double pQuantiteCarboneDispo) {
		pQuantiteAzoteDispo = pQuantiteAzoteDispo - sNeededAzotePourGrandir;
		pQuantiteCarboneDispo = pQuantiteCarboneDispo - sNeededCarbonePourGrandir;
		mSurface += 1;
	}
	
}

Plante

package bean;

import java.util.ArrayList;
import java.util.List;

public class Plante {
	
	private double mQuantiteAzote;
	
	private double mQuantiteCarbone;
	
	private double mTempEcoule;
	
	private List<Feuille> mFeuilles;
	
	private List<Racine> mRacines;

	public Plante() {
		mTempEcoule = 0;
		mQuantiteAzote = 0;
		mQuantiteCarbone = 0;
		mFeuilles = new ArrayList<Feuille>();
		mRacines = new ArrayList<Racine>();
	}
	
	public List<Feuille> getFeuilles() {
		return mFeuilles;
	}

	public void setFeuilles(List<Feuille> feuilles) {
		mFeuilles = feuilles;
	}

	public List<Racine> getRacines() {
		return mRacines;
	}

	public void setRacines(List<Racine> racines) {
		mRacines = racines;
	}
	
	public double getQuantiteAzote() {
		return mQuantiteAzote;
	}

	public double getQuantiteCarbone() {
		return mQuantiteCarbone;
	}
	
	private void absorbeRessources() {
		for (Feuille vFeuilleTmp : mFeuilles) {
			mQuantiteCarbone += vFeuilleTmp.absorbeCarbone();
		}
		
		for (Racine vRacineTmp : mRacines) {
			mQuantiteAzote += vRacineTmp.absorbeAzote();
		}
	}
	
	private void faireGrandirFeuilles() {
		for (Feuille vFeuilleTmp : mFeuilles) {
			vFeuilleTmp.faireGrandirFeuille(mQuantiteAzote, mQuantiteCarbone);
		}
	}
	
	private void faireGrandirRacines() {
		for (Racine vRacineTmp : mRacines) {
			vRacineTmp.faireGrandirRacine(mQuantiteAzote, mQuantiteCarbone);
		}
	}
	
	public void simulePlanteLife() {
		for(int i = 0; i < 200; i++) {
			displayPlanteStatus();
			absorbeRessources();
			
			if (mQuantiteAzote == mQuantiteCarbone) {
				faireGrandirFeuilles();
				faireGrandirRacines();
			} else if (mQuantiteAzote > mQuantiteCarbone) {
				faireGrandirFeuilles();
			} else {
				faireGrandirRacines();
			}
			
			mTempEcoule++;
		}
	}
	
	private void displayPlanteStatus() {
		System.out.println(
				"Seconde : " + mTempEcoule +
				" Quantite Carbone : " + mQuantiteCarbone +
				" Quantite Azote : " + mQuantiteAzote);
	}
	
	public static Plante buildSamplePlante() {
		Plante vPlante = new Plante();
		List<Feuille> vFeuilles = new ArrayList<Feuille>();
		List<Racine> vRacines = new ArrayList<Racine>();
		
		Feuille vFeuille0 = new Feuille();
		vFeuille0.setSurface(1d);
		vFeuilles.add(vFeuille0);
		
		Feuille vFeuille1 = new Feuille();
		vFeuille1.setSurface(1d);
		vFeuilles.add(vFeuille1);
		
		Racine vRacine0 = new Racine();
		vRacine0.setSurface(1d);
		vRacines.add(vRacine0);
		
		vPlante.setFeuilles(vFeuilles);
		vPlante.setRacines(vRacines);
		
		return vPlante;
	}
	
}

Program

import bean.Plante;


public class Program {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Plante.buildSamplePlante().simulePlanteLife();
	}

}

Dans mon program j'ai crée une Plante à deux feuilles et une racine, si tu veux avoir un comportement moins "linéaire", il faut jouer sur les coefficient d'absorbtion des racines et des feuilles.

Bonne chance,
Niroken