Functions animation scripting csc 233 Functions breakdown Functions

Functions animation scripting csc 233

Functions breakdown: Functions purpose Modularity Declaring and defining a function Calling a function Parameter passing Returning a value Reusability 2

Functions are a means of taking the parts of our program and separating them out into modular pieces, making our code easier to read, as well as revise. Functions can go by other names such as: procedures methods subroutines � We have been somewhat limited to two main functions : setup(); draw(); 3

Why use functions? Isn't your draw()method getting a bit long? Two key principles of good programming: 1) Modularity: The break down of code into smaller parts *The code becomes more manageable and readable *Also reduces the number of local variables inside a module 2) Reusability Duplicated code (copy/paste? ) is not good Because you must maintain it in multiple places Wouldn't it be better to put duplicate code in a new function and ‘call’ it from multiple places 4

Modularity What is a function? Simply, it's a named block of code Some examples that you already know are: setup() background() draw() ellipse() mouse. Pressed() rect() There are more to these functions, but it has been tucked away out of sight. We simply use them by adding in values that the function uses within itself. i. e. background(R, G, B); But we have not been too concerned with that part. . Until now. 5

Pseudocode to Functions Before writing a function, think about the different parts or key actions of your program. If we were to write a simple game like space invaders we could break down the code into smaller key parts such as: Each time through draw: Erase background Draw Spaceship Draw enemies Move spaceship Get keyboard command Move spaceship Move enemies Some functions are ‘built-in’ like we have seen The good news is you can write your own functions! 6

Pseudocode to Functions This is how it might look after you have broken down your program into functions: // Modularized void draw() { background(0); draw. Space. Ship(); draw. Emenies(); move. Ship(); move. Enemies(); } All the code for each function is "tucked away" out of sight. This makes for cleaner more organized code and easier to debug! 7

Try this: Modular ‘Pong’ Planning Let's think about what functions might be used in the game of pong? 1) Decide on the ‘rules’ One player or two player? One player example Two player example 2) Write Pong pseudocode (or flow chart) 3) Decide on function names For user-defined functions 4) Think about variables you will need Local (inside a function) or ‘global’? Create names you can remember 8

The Function ‘Definition’ The parts of a function Return type Function name Parameters area start block void draw. Ship ( ) { // Variables and code go here } // end block This is also called ‘declaring’ the function You are ‘telling’ the compiler that there is a new named block of code and how it works Other Rules: Define function outside all other functions below draw() Name with the same rules as variables (letters, digits, _) Do not use ‘reserved’ words or already used names 9

Calling a Function Now that we have a function, let’s use it: void draw() { draw. Ship(); } // note the semicolon! You ‘Call’ functions from ‘inside’ other functions In this case, inside draw() You call functions by using the function name: draw. Ship( ); // this calls the function 10

Try this: Let's write our first function void draw. Black. Circle ( ) { // this declares and names the functions and begins the bock of code fill(0); ellipse ( 250, 150, 75); } // end block draw. Black. Circle function The function will be declared outside of setup() and draw() but it has to be called from within a function. void setup(){ size(500, 500); } void draw(){ background( 150); draw. Black. Circle ( ); // calls the function } // end draw block The entire code // declares the function void draw. Black. Circle ( ) { //declared outside of the function fill(0); ellipse ( 250, 150, 75); } 11

Bouncing Ball without Functions Group code into related ‘chunks’ 12

Bouncing Ball with Functions // Declare all global variables (stays the same) int x = 0; int speed = 1; // Setup does not change void setup() { size(200, 200); smooth(); } void draw() { background(255); move(); // Instead of writing out all the code in draw(), we simply call three functions. bounce(); display(); } // Where should functions be placed? // You can define your functions anywhere in the code outside of setup() and draw(). // However, the convention is to place your function definitions below draw(). // Declare functions below draw() // A function to move the ball void move() { // Change the x location by speed x = x + speed; } // A function to bounce the ball void bounce() { // If we have reached an edge, reverse speed if ((x > width) || (x < 0)) { speed = speed * - 1; } } // A function to display the ball void display() { stroke(0); fill(175); ellipse(x, 100, 32); } 13

debugging Another great benefit functions have is the ease of debugging. We can simply turn off, by commenting out, parts of the program to determine if that particular function is working properly. void draw(){ background(0); // move(); // bounce(0); display(); } By adding function calls one by one and executing the sketch each time, we can more easily deduce the location of the problematic code. 14

draw a rocket ship using function example see web notes for example 15

Functions with Arguments and Parameters What if you wanted to use a function to do slightly different things? Some examples you have seen pass arguments to functions such as: size(200, 200); color(100, 150, 0); ellipse(x, y, width, height); More? What if you wanted to write your own function that receives parameters? See example: 16

Functions with Arguments and Parameters code example on website /* this will take different arguments for color and size and send to function makecircle*/ void setup(){ size (500, 500); smooth(); } void draw(){ background(255); draw. Circle(? , ? , ? ); // fill in the arguments: color is a hexidecimal or 8 bit grey value //make other versions of the elllipse } //function definition void draw. Circle(int x, int y, int its. Width, int its. Height, color c){ fill (c); ellipse (x, y, its. Width, its. Height); } /*once you have created a single ellipse use the function over and over again to create more ellipses but with difference */ 17

Keys to Passing Arguments You must pass the same number of arguments as defined in the function parameter list. When an argument is passed, it must be of the same type as declared within the parameters in the function definition. An integer must be passed into an integer a floating point into a floating point. . The value you pass as an argument to a function can be a: Literal value (20, 5, 4. 3, etc. ), Variable (x, y, size, etc. ) The result of an expression (8 + 3, 4 * x/2, random(0, 10), etc. ) Parameters act as local variables inside the receiving function They are only accessible within that function 18

Return types Up until now, you have used a mysterious keyword named void before all of your functions void setup() { draw() { by. Value(int num) { draw. Car(int x, int y, int thesize, color c) { Remember the parts of a function definition? Return type Function name Parameters area start block void draw. Ship ( ) { Here is an example that ‘return’ an int: int sum(int a, int b, int c) { int total = a + b + c; return total; // Return a copy of a local variable }

Assigning the return value to a variable void draw() { int answer; (5)answer = (1) sum( 17, 42, 52 ); println(answer); no. Loop(); } (2) int sum(int a, int b, int c) { int total = a + b + c; (3) return total; (4) } 1. 2. 3. 4. 5. draw calls sum with arguments sum receives values into parameters sum method calculates local total sum method returns copy of total draw assigns returned value to answer

You try: sales tax calculator /* write your own function that calculates sales tax*/ // define global variable float your. Charge; void setup(){ your. Charge = tax( 1. 00, 3. 00, 5. 00); // calls tax function and passes arguments to function println ("Your total charge is = " + your. Charge); } // define function for sales tax/////// float tax( float a, float b, float c){ // receives the arguments and runs the method to solve Yousubtotal write the above info. float = afunction + b + c; //using total items cost float tax. Rate =. 0625; // tax rate float tax = subtotal * tax. Rate; //total tax amount needed float total. Charge = subtotal + tax; return total. Charge; } 21

Summary Functions are useful for many tasks 1) Break code into smaller ‘named’ chunks 2) Prevent duplication of code 3) Make useful ‘utilities’ that can be reused Processing is really a ‘function library’ Provides functions such as line(), ellipse(), rect() You can write code inside functions that Processing calls ▪ setup() and draw() You can define your own functions Pass ‘arguments’ to functions to tell them what to do They are received as ‘parameters’ Primitive types are passed by value Functions can return values Learning Processing: Slides by Don Smith 22