NRP: 05111740000097
Kelas: PBO-A
Ini adalah tugas 2B PBO saya dengan menggambar menggunakan bangunan 2D dan menggunakan bahasa Java
Berikut merupakan formatted source code saya:
a) Picture
a) Picture
public class Picture
{
private Square background;
private Circle moon;
private Square wall;
private Square wall1;
private Square wall2;
private Square wall3;
private Square wall4;
private Circle tree;
private Square house1;
private Square window11;
private Square window12;
private Square door1;
private Triangle roof1;
private Square house2;
private Square window21;
private Square window22;
private Square door2;
private Triangle roof2;
private Square grass;
private Circle cloud1;
private Circle cloud2;
private Circle cloud3;
private Circle cloud4;
private Circle cloud5;
private Circle cloud6;
private Circle tree6;
/**
* Draw this picture.
*/
public void draw()
{
background=new Square();
background.changeColor("very dark blue");
background.changeSize(500);
background.moveHorizontal(-50);
background.moveVertical(-50);
background.makeVisible();
moon=new Circle();
moon.changeColor("yellow");
moon.changeSize(80);
moon.moveHorizontal(360);
moon.moveVertical(-40);
moon.makeVisible();
grass=new Square();
grass.changeColor("green");
grass.changeSize(500);
grass.moveHorizontal(-50);
grass.moveVertical(230);
grass.makeVisible();
house1=new Square();
house1.changeColor("light green");
house1.changeSize(120);
house1.moveHorizontal(5);
house1.moveVertical(150);
house1.makeVisible();
window11=new Square();
window11.changeColor("black");
window11.changeSize(30);
window11.moveHorizontal(90);
window11.moveVertical(175);
window11.makeVisible();
window12=new Square();
window12.changeColor("black");
window12.changeSize(30);
window12.moveHorizontal(10);
window12.moveVertical(175);
window12.makeVisible();
door1=new Square();
door1.changeColor("purple");
door1.changeSize(40);
door1.moveHorizontal(45);
door1.moveVertical(210);
door1.makeVisible();
roof1=new Triangle();
roof1.changeColor("brown");
roof1.changeSize(100,120);
roof1.moveHorizontal(65);
roof1.moveVertical(85);
roof1.makeVisible();
house2=new Square();
house2.changeColor("red");
house2.changeSize(150);
house2.moveHorizontal(200);
house2.moveVertical(150);
house2.makeVisible();
window21=new Square();
window21.changeColor("black");
window21.changeSize(30);
window21.moveHorizontal(210);
window21.moveVertical(175);
window21.makeVisible();
window22=new Square();
window22.changeColor("black");
window22.changeSize(30);
window22.moveHorizontal(315);
window22.moveVertical(175);
window22.makeVisible();
door2=new Square();
door2.changeColor("purple");
door2.changeSize(50);
door2.moveHorizontal(255);
door2.moveVertical(210);
door2.makeVisible();
roof2=new Triangle();
roof2.changeColor("brown");
roof2.changeSize(120,150);
roof2.moveHorizontal(275);
roof2.moveVertical(65);
roof2.makeVisible();
cloud1=new Circle();
cloud1.changeColor("blue");
cloud1.changeSize(50);
cloud1.moveHorizontal(200);
cloud1.moveVertical(-20);
cloud1.makeVisible();
cloud2=new Circle();
cloud2.changeColor("blue");
cloud2.changeSize(30);
cloud2.moveHorizontal(180);
cloud2.moveVertical(-10);
cloud2.makeVisible();
cloud5=new Circle();
cloud5.changeColor("blue");
cloud5.changeSize(30);
cloud5.moveHorizontal(240);
cloud5.moveVertical(-10);
cloud5.makeVisible();
cloud3=new Circle();
cloud3.changeColor("blue");
cloud3.changeSize(50);
cloud3.moveHorizontal(60);
cloud3.moveVertical(-20);
cloud3.makeVisible();
cloud4=new Circle();
cloud4.changeColor("blue");
cloud4.changeSize(30);
cloud4.moveHorizontal(40);
cloud4.moveVertical(-10);
cloud4.makeVisible();
cloud5=new Circle();
cloud5.changeColor("blue");
cloud5.changeSize(30);
cloud5.moveHorizontal(100);
cloud5.moveVertical(-10);
cloud5.makeVisible();
}
}
b) Canvas
import javax.swing.*;
import java.awt.*;
import java.util.List;
import java.util.*;
/**
* Canvas is a class to allow for simple graphical drawing on a canvas.
* This is a modification of the general purpose Canvas, specially made for
* the BlueJ "shapes" example.
*
* @author: Bruce Quig
* @author: Michael K�lling (mik)
*
* @version 2011.07.31
*/
public class Canvas
{
// Note: The implementation of this class (specifically the handling of
// shape identity and colors) is slightly more complex than necessary. This
// is done on purpose to keep the interface and instance fields of the
// shape objects in this project clean and simple for educational purposes.
private static Canvas canvasSingleton;
/**
* Factory method to get the canvas singleton object.
*/
public static Canvas getCanvas()
{
if(canvasSingleton == null) {
canvasSingleton = new Canvas("BlueJ Picture Demo", 500, 300, Color.white);
}
canvasSingleton.setVisible(true);
return canvasSingleton;
}
// ----- instance part -----
private JFrame frame;
private CanvasPane canvas;
private Graphics2D graphic;
private Color backgroundColor;
private Image canvasImage;
private List<Object> objects;
private HashMap<Object, ShapeDescription> shapes;
/**
* Create a Canvas.
* @param title title to appear in Canvas Frame
* @param width the desired width for the canvas
* @param height the desired height for the canvas
* @param bgColor the desired background color of the canvas
*/
private Canvas(String title, int width, int height, Color bgColor)
{
frame = new JFrame();
canvas = new CanvasPane();
frame.setContentPane(canvas);
frame.setTitle(title);
frame.setLocation(30, 30);
canvas.setPreferredSize(new Dimension(width, height));
backgroundColor = bgColor;
frame.pack();
objects = new ArrayList<Object>();
shapes = new HashMap<Object, ShapeDescription>();
}
/**
* Set the canvas visibility and brings canvas to the front of screen
* when made visible. This method can also be used to bring an already
* visible canvas to the front of other windows.
* @param visible boolean value representing the desired visibility of
* the canvas (true or false)
*/
public void setVisible(boolean visible)
{
if(graphic == null) {
// first time: instantiate the offscreen image and fill it with
// the background color
Dimension size = canvas.getSize();
canvasImage = canvas.createImage(size.width, size.height);
graphic = (Graphics2D)canvasImage.getGraphics();
graphic.setColor(backgroundColor);
graphic.fillRect(0, 0, size.width, size.height);
graphic.setColor(Color.black);
}
frame.setVisible(visible);
}
/**
* Draw a given shape onto the canvas.
* @param referenceObject an object to define identity for this shape
* @param color the color of the shape
* @param shape the shape object to be drawn on the canvas
*/
// Note: this is a slightly backwards way of maintaining the shape
// objects. It is carefully designed to keep the visible shape interfaces
// in this project clean and simple for educational purposes.
public void draw(Object referenceObject, String color, Shape shape)
{
objects.remove(referenceObject); // just in case it was already there
objects.add(referenceObject); // add at the end
shapes.put(referenceObject, new ShapeDescription(shape, color));
redraw();
}
/**
* Erase a given shape's from the screen.
* @param referenceObject the shape object to be erased
*/
public void erase(Object referenceObject)
{
objects.remove(referenceObject); // just in case it was already there
shapes.remove(referenceObject);
redraw();
}
/**
* Set the foreground color of the Canvas.
* @param newColor the new color for the foreground of the Canvas
*/
public void setForegroundColor(String colorString)
{
if(colorString.equals("red")) {
graphic.setColor(new Color(235,25,25));
}
else if(colorString.equals("blue")) {
graphic.setColor(new Color(0,0,255));
}
else if(colorString.equals("very dark blue")) {
graphic.setColor(new Color(30,75,153));
}
else if(colorString.equals("yellow")) {
graphic.setColor(new Color(255, 204, 0));
}
else if(colorString.equals("light green")) {
graphic.setColor(new Color(0,255,51));
}
else if(colorString.equals("green")) {
graphic.setColor(new Color(80, 160, 60));
}
else if(colorString.equals("brown")) {
graphic.setColor(new Color(102,51,0));
}
else if(colorString.equals("white")) {
graphic.setColor(Color.white);
}
else if(colorString.equals("purple")){
graphic.setColor(new Color(102,0,153));
}
else if(colorString.equals("black")) {
graphic.setColor(Color.black);
}
else {
graphic.setColor(Color.black);
}
}
/**
* Wait for a specified number of milliseconds before finishing.
* This provides an easy way to specify a small delay which can be
* used when producing animations.
* @param milliseconds the number
*/
public void wait(int milliseconds)
{
try
{
Thread.sleep(milliseconds);
}
catch (Exception e)
{
// ignoring exception at the moment
}
}
/**
* Redraw ell shapes currently on the Canvas.
*/
private void redraw()
{
erase();
for(Object shape : objects) {
shapes.get(shape).draw(graphic);
}
canvas.repaint();
}
/**
* Erase the whole canvas. (Does not repaint.)
*/
private void erase()
{
Color original = graphic.getColor();
graphic.setColor(backgroundColor);
Dimension size = canvas.getSize();
graphic.fill(new Rectangle(0, 0, size.width, size.height));
graphic.setColor(original);
}
/************************************************************************
* Inner class CanvasPane - the actual canvas component contained in the
* Canvas frame. This is essentially a JPanel with added capability to
* refresh the image drawn on it.
*/
private class CanvasPane extends JPanel
{
public void paint(Graphics g)
{
g.drawImage(canvasImage, 0, 0, null);
}
}
/************************************************************************
* Inner class CanvasPane - the actual canvas component contained in the
* Canvas frame. This is essentially a JPanel with added capability to
* refresh the image drawn on it.
*/
private class ShapeDescription
{
private Shape shape;
private String colorString;
public ShapeDescription(Shape shape, String color)
{
this.shape = shape;
colorString = color;
}
public void draw(Graphics2D graphic)
{
setForegroundColor(colorString);
graphic.fill(shape);
}
}
}
c) Circle
import java.awt.*;
import java.awt.geom.*;
public class Circle
{
private double diameter;
private double xPosition,yPosition;
private String color;
private boolean isVisible;
public Circle()
{
diameter=30;
xPosition=20;
yPosition=60;
color="blue";
isVisible=false;
}
public void makeVisible()
{
isVisible=true;
draw();
}
public void makeInVisible()
{
erase();
isVisible=false;
}
public void moveRight()
{
moveHorizontal(20);
}
public void moveLeft()
{
moveHorizontal(-40);
}
public void moveUp()
{
moveVertical(20);
}
public void moveDown()
{
moveVertical(-40);
}
public void moveHorizontal(int distance)
{
erase();
xPosition+=distance;
draw();
}
public void moveVertical(int distance)
{
erase();
yPosition+=distance;
draw();
}
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
xPosition += delta;
draw();
}
}
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
yPosition += delta;
draw();
}
}
public void changeSize(int newDiameter)
{
erase();
diameter = newDiameter;
draw();
}
/**
* Change the color. Valid colors are "red", "yellow", "blue", "green",
* "magenta" and "black".
*/
public void changeColor(String newColor)
{
color = newColor;
draw();
}
/*
* Draw the circle with current specifications on screen.
*/
private void draw()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition,diameter,diameter));
canvas.wait(10);
}
}
private void erase()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}
d) Square
import java.awt.*;
public class Square
{
private int size;
private int xPosition;
private int yPosition;
private String color;
private boolean isVisible;
/**
* Create a new square at default position with default color.
*/
public Square()
{
size = 125;
xPosition = 50;
yPosition = 50;
color = "green";
isVisible = false;
}
/**
* Make this square visible. If it was already visible, do nothing.
*/
public void makeVisible()
{
isVisible = true;
draw();
}
/**
* Make this square invisible. If it was already invisible, do nothing.
*/
public void makeInvisible()
{
erase();
isVisible = false;
}
/**
* Move the square a few pixels to the right.
*/
public void moveRight()
{
moveHorizontal(20);
}
/**
* Move the square a few pixels to the left.
*/
public void moveLeft()
{
moveHorizontal(-20);
}
/**
* Move the square a few pixels up.
*/
public void moveUp()
{
moveVertical(20);
}
/**
* Move the square a few pixels down.
*/
public void moveDown()
{
moveVertical(-20);
}
/**
* Move the square horizontally by 'distance' pixels.
*/
public void moveHorizontal(int distance)
{
erase();
xPosition += distance;
draw();
}
/**
* Move the square vertically by 'distance' pixels.
*/
public void moveVertical(int distance)
{
erase();
yPosition += distance;
draw();
}
/**
* Slowly move the square horizontally by 'distance' pixels.
*/
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
xPosition += delta;
draw();
}
}
/**
* Slowly move the square vertically by 'distance' pixels.
*/
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
yPosition += delta;
draw();
}
}
/**
* Change the size to the new size (in pixels). Size must be >= 0.
*/
public void changeSize(int newSize)
{
erase();
size = newSize;
draw();
}
/**
* Change the color. Valid colors are "red", "yellow", "blue", "green",
* "magenta" and "black".
*/
public void changeColor(String newColor)
{
color = newColor;
draw();
}
/*
* Draw the square with current specifications on screen.
*/
private void draw()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.draw(this, color,
new Rectangle(xPosition, yPosition, size, size));
canvas.wait(10);
}
}
/*
* Erase the square on screen.
*/
private void erase()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}
e) Triangle
import java.awt.*;
/**
* A triangle that can be manipulated and that draws itself on a canvas.
*
* @author Michael Kolling and David J. Barnes
* @version 2008.03.30
*/
public class Triangle
{
private int height;
private int width;
private int xPosition;
private int yPosition;
private String color;
private boolean isVisible;
/**
* Create a new triangle at default position with default color.
*/
public Triangle()
{
height = 60;
width = 80;
xPosition = 50;
yPosition = 15;
color = "green";
isVisible = false;
}
/**
* Make this triangle visible. If it was already visible, do nothing.
*/
public void makeVisible()
{
isVisible = true;
draw();
}
/**
* Make this triangle invisible. If it was already invisible, do nothing.
*/
public void makeInvisible()
{
erase();
isVisible = false;
}
/**
* Move the triangle a few pixels to the right.
*/
public void moveRight()
{
moveHorizontal(40);
}
/**
* Move the triangle a few pixels to the left.
*/
public void moveLeft()
{
moveHorizontal(-20);
}
/**
* Move the triangle a few pixels up.
*/
public void moveUp()
{
moveVertical(40);
}
/**
* Move the triangle a few pixels down.
*/
public void moveDown()
{
moveVertical(-20);
}
/**
* Move the triangle horizontally by 'distance' pixels.
*/
public void moveHorizontal(int distance)
{
erase();
xPosition += distance;
draw();
}
/**
* Move the triangle vertically by 'distance' pixels.
*/
public void moveVertical(int distance)
{
erase();
yPosition += distance;
draw();
}
/**
* Slowly move the triangle horizontally by 'distance' pixels.
*/
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
xPosition += delta;
draw();
}
}
/**
* Slowly move the triangle vertically by 'distance' pixels.
*/
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
yPosition += delta;
draw();
}
}
/**
* Change the size to the new size (in pixels). Size must be >= 0.
*/
public void changeSize(int newHeight, int newWidth)
{
erase();
height = newHeight;
width = newWidth;
draw();
}
/**
* Change the color. Valid colors are "red", "yellow", "blue", "green",
* "magenta" and "black".
*/
public void changeColor(String newColor)
{
color = newColor;
draw();
}
/**
* Draw the triangle with current specifications on screen.
*/
private void draw()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
int[] xpoints = { xPosition, xPosition + (width/2), xPosition - (width/2) };
int[] ypoints = { yPosition, yPosition + height, yPosition + height };
canvas.draw(this, color, new Polygon(xpoints, ypoints, 3));
canvas.wait(10);
}
}
/**
* Erase the triangle on screen.
*/
private void erase()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}
Berikut ini adalah bagannya dan gambar hasil compile
No comments:
Post a Comment