Hello!
I need some help with some code please!
I would like someone to comment on my code so I may correct it. Comment on anything I should have done differently or organized my code differently or if I have any useless code, anything!
If someone could please help I would apreciate it very much!
I actually need this with a little urgency!

Thank you!
Samantha


//variables//
final int FOLHAS = 10; // Number of leaves
final int COMPINI = 20; //Initial length
final int VARCOMP = 40; //Length variation
final int DIVCOMP = 20; //Length Division
final int LARG = 600; //width of the window
final int ALTU = 600; //hight of the window
//Calculates the center coordenates
final int XC = LARG / 2;
final int YC = ALTU / 2;
int xInicio = XC; //changes the initialx in the animation
int yInicio = YC; //changes the initialy in the animation
int xFim, yFim; //Line extremities coordenates
float comp = COMPINI; //Minimum line length
int varComp = VARCOMP; //Length variation
float angulo = 0; //Current angle
float varang;// = (float) (2 * PI / NLINHAS); //Calculates the angle increment in radians
color [] cores = new int[FOLHAS]; // saves the colours used for each leaf
int posFolha = 0; //indicates the leaf that is being drawn
int varCompInicio = 0; //length used to calculate the intial point of each line in the animation
boolean crescente = true; //indicates when the initial point is growing or not
boolean crescer = false; //indicates when the animation efects are executing or not
boolean rodar = false; //indicates if it is rotating or not
boolean explodir = false; //indicates if its exploding or not
float incAng = 0; //rotate the drawing
int nlinhasActuais = 0; //saves the number of lines that were drawn
int nlinhasJanela = 0; //counts how many vertical lines will be drawn on the screen
int xIniLinha; //saves the x of the initial and final point of the random lines
int yIniLinha; //saves the y of the initial and final point of the random lines
float angLinha; //saves the angle of the random lines
boolean finalFolhasAnimacao = false; //indicates that the leaf animations terminate
boolean finalLinhasAnimacao = false; //indicates that the line animations terminate
boolean ecraLimpoH = false; //terminates de horizontal clear
boolean ecraLimpoV = false; //terminates de vertical clear
boolean finalLinhasHAnimacao = false; //indicates that the horizontal animation of the vertical lines terminates
boolean finalAnimacao = false; //indicates that the animation terminates
boolean pararAnimacao = false; //indicates that the animation stops when clicking the mouse

continued code...


//restarts the animation variables
void reiniciaVariaveis(boolean limpa) {
   if(posFolha < FOLHAS) { //if not enough leaves were drawn more are created
       nlinhasActuais++;
       varang = (float) (2 * PI / nlinhasActuais); //and execute the angle between lines update
   }
   angulo = 0; //restarts the animation angle
   if (rodar && !finalAnimacao) { //Changes the angle to rotate the leaves. If it is on the last animation the dont rotate.
       angulo += incAng;
       incAng -= radians(1);
   }

   if (abs(incAng) > PI) { //When rotated 180 degrees it explodes
       explodir = true;
   }
   comp = COMPINI;
   varComp = VARCOMP;
   if(limpa && !pararAnimacao) { //Clears the screen and puts posFolha at 0 to reuse the colours from the start
       posFolha = 0;
       background(255);
   }
}

//Drws the various leaves and executes the animation
void desenhaFolhas() {
   stroke(cores[posFolha % FOLHAS]); // garanties that a position will always be read that exists in the colour table
   boolean terminar = true; //indicates when the screen is clear and the fist animation terminates
   float compCrescer; //saves the length used to calculate the initial point of each line in the animation
   //Draws the lines
   for (int linha = 0; linha < nlinhasActuais; linha++) {
       //Calculates the end point of the line (xFim, yFim)
       xFim = XC + (int) (comp * cos(angulo));
       yFim = YC - (int) (comp * sin(angulo));

       //Verifies if (xFim, yFim) are outside of the applet or if the length is negative
       //If it is, reduces the length, goes to
       //descending length and calculates new point
       if (xFim > LARG || yFim > ALTU || xFim < 0 || yFim < 0 || comp < 0) {
           if (comp < 0) { //In this situation because a leaf was drawn
               posFolha++;
               if (posFolha == FOLHAS) { //When all the leaves are drawn, the grow and rotate
                   rodar = true;
                   crescer = true;
                   break;
               }
               stroke(cores[posFolha % FOLHAS]); //Defines de line colour
           }

           varComp *= -1;
           comp += 2 * varComp;
           xFim = XC + (int) (comp * cos(angulo));
           yFim = YC - (int) (comp * sin(angulo));
       }

       compCrescer = (comp / DIVCOMP) * varCompInicio; //Used to calculate the initial point of each line

       if (compCrescer >= comp) { //If compCrescer is equal to comp indicates that the initial point will
           crescente = false;     //match the final one and then it will start decreasing
       } else if (compCrescer <= 0 ) { //If compCrescer is smaller or equal to zero it will start growing
           crescente = true;
       }

       if (crescer && !pararAnimacao) { //Calculates the initial point diferent from the center of the screen to give the effect that the
                                        //lines will be increasing and decreasing
           xInicio = XC + (int) (compCrescer * cos(angulo));
           yInicio = YC - (int) (compCrescer * sin(angulo));
           if (explodir && !finalAnimacao) { // Explodes. Makes the final point be calculated in relation to the initial point
                                             //and not in relation to the center of the screen so the lines can gradually disapear,
                                             //the initial point already automaticly always increases
               xFim = xInicio + (int) (comp * cos(angulo));
               yFim = yInicio - (int) (comp * sin(angulo));
               varCompInicio++; //Makes the explosion faster
           }
       } else { //In case the lines arent going to increase and decrease, the initial point will always be the center of the screen
           xInicio = XC;
           yInicio = YC;
       }

       if(pararAnimacao && finalAnimacao) { //In case the animation is stopped and its already on the last animation
                                            //move the leaves to the location of the mouse
           xInicio = mouseX;
           yInicio = mouseY;
           xFim = xFim - XC + mouseX; //End points of the calculated lines based on the mouse point and not in the center
           yFim = yFim - YC + mouseY;
       }
       //Draws the line
       line(xInicio, yInicio, xFim, yFim);
       //Updates the length
       comp += varComp;
       //Updates the angle
       angulo += varang;

       //Used to know when there arent any lines on the screen
       if(dentroJanela(xInicio, yInicio) || dentroJanela(xFim, yFim)) {
           terminar = false;
       }
   }
   //Makes the initial points grow or decrease (if they are getting close or far away from the final ones)
   if(crescente) {
       varCompInicio++;
   } else {
       varCompInicio--;
   }

   if(terminar) { //If there doesnt exist any line on the screen, terminates the animation
       finalFolhasAnimacao = true;
   }
}

//Used to verify if a determined point is in the boundries of the window or not
boolean dentroJanela(int x, int y) {
   if (x < 0 || y < 0 || x > LARG || y > ALTU) {
       return false;
   }

   return true;
}

I fear I haven't much time right now to analyse this long code, so  I will just give some general remarks, perhaps coming back later.

Note: this forum isn't well suited to show long code, you might take advantage of snippet sites like http://pastebin.com offering syntax highlighting out of the box and easy copy/paste without loss of formatting.
Do you have any issue on this code or is it working as expected and you only need some coding advices?

On the plus side, the use of final constants, looks like well parametrized, with minimal use of magic numbers in code.
It is well commented.
On the minus side, the Portuguese variable and method names is a bit on the way for people not knowing the language, and is a bit inconsistent with the English comments.
Not sure if it helps in any way, but Processing has TWO_PI and HALF_PI constants.

I like to point out that routines like dentroJanela can be simplified as:

boolean dentroJanela(int x, int y) {
   return !(x < 0 || y < 0 || x > LARG || y > ALTU);
}

OR

boolean dentroJanela(int x, int y) {
   return x >= 0 && y >= 0 && x <= LARG && y <= ALTU;
}


At least, unlike some people, you didn't put the return true in a else...
Similar remark for mouseReleased()

void mouseReleased() {
   //Stops or resumes the leaves animation when the mouse is clicked
   pararAnimacao = !pararAnimacao;
}

is a classic pattern.
That's all I found with a quick scan of the code.