[Release] Polygons rotating, translating, dilating

[OreansSucks]

import javax.swing.JFrame;
import javax.swing.JOptionPane;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.Polygon;

@SuppressWarnings("serial")
public class Display extends JFrame implements MouseListener, MouseMotionListener {
    private Color GRID_COLOR = Color.BLACK;
    private Color SHAPE_COLOR = Color.RED;
    private Color BACKGROUND_COLOR = Color.BLACK;
    private Color BOX_COLOR = Color.GRAY;
    private int speed = 10;
    private double rate = 100;
    private double status = 0;
    private double frame = 0;
    private int DISPLAY_WIDTH = 900;
    private int DISPLAY_HEIGHT = 800;
    private int XG_OFFSET = 14;
    private int YG_OFFSET = 40;
    private int GRID_WIDTH = 500;  //only even numbers
    private int GRID_HEIGHT = 500; //only even numbers
    private int X_ZERO = XG_OFFSET + (GRID_HEIGHT / 2);
    private int Y_ZERO = YG_OFFSET + (GRID_WIDTH / 2);
    private int GRID_LINE = 3;
    int dragX = 608;
    int dragY = 608;
    private boolean first = true;
    private boolean fill = true;
    public static int MAX_POINTS = 100;
    private int run = 1;
    private NewPolygon save = new NewPolygon();
    public static String rotateFile = "rotate.png";
    public static String background = "background.jpg";
    public static String edwardpic = "edward.jpg";
    public int firstIt = 0;
    private boolean fat=true;
    String lol2,lol3;
    public String lol = JOptionPane.showInputDialog("What new matrix do you want? Format [x y]");
 
    public Display() {
        setSize(DISPLAY_WIDTH, DISPLAY_HEIGHT);
        getContentPane().setLayout(null);
        addMouseListener(this);
        addMouseMotionListener(this);
    }

    public void paint(Graphics g) {
        try {
            Thread.sleep(speed);
        } catch (InterruptedException e) {
        }
        drawLoop(g);
        drawComponents(g);
        nextGeneration();
    }
 
    void drawComponents(Graphics g) {
        if (fat)
        drawRotateButton(600, 600, g);
        else reset(g);
    }
   
    void reset(Graphics g) {
        drawRotateButton(0,0,g);
    }

    void drawLoop(Graphics g) {
        if (first) drawBackground(g);
        first = false;
        drawBox(g);
        if(fill) {drawShape(g); drawGrid(g);}
        else {drawGrid(g); drawShape(g);}
    }
 
    void drawBackground(Graphics g) {
        g.setColor(BACKGROUND_COLOR);
        g.fillRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT);
    }

   
    void drawBox(Graphics g) {
        g.setColor(BOX_COLOR);
        g.fillRect(XG_OFFSET, YG_OFFSET, GRID_WIDTH, GRID_HEIGHT);
        g.fillRect(****650,300,100);
    }

    void drawGrid(Graphics g) {
        g.setColor(GRID_COLOR);
        g.drawLine(XG_OFFSET, Y_ZERO, XG_OFFSET + GRID_WIDTH - 1, Y_ZERO);
        g.drawLine(X_ZERO, YG_OFFSET, X_ZERO, YG_OFFSET + GRID_HEIGHT - 1);
        for (int n = 0; n <= 10; n++) {
            g.drawLine(X_ZERO - GRID_LINE, YG_OFFSET + roundInt((GRID_HEIGHT - 1) * n * 0.1),
                       X_ZERO + GRID_LINE, YG_OFFSET + roundInt((GRID_HEIGHT - 1) * n * 0.1));
            g.drawLine(XG_OFFSET + roundInt((GRID_WIDTH - 1) * n * 0.1), Y_ZERO - GRID_LINE,
                       XG_OFFSET + roundInt((GRID_WIDTH - 1) * n * 0.1), Y_ZERO + GRID_LINE);
        }
    }
 
    void drawShape(Graphics g) {
        NewPolygon p = new NewPolygon();
        if (run == 1) p = firstPolygon();
        else p = loadPolygon();
        switch (run) {
        case 1: drawTranslate(p, -25, 50); break;
        case 2: drawReflect(p, true); break;
        case 3: drawRotate(p, 2 * Math.PI); break;
        case 4:drawDilate(p, 0.5); break;
        }
        drawFinal(p, g);
    }

    NewPolygon firstPolygon() {
        NewPolygon p = new NewPolygon();
        p.addPoint(50, 50);
        p.addPoint(0, 0);
        p.addPoint(0, 100);
        lol2 = "" + lol.charAt(1);
        lol3 = "" + lol.charAt(3);
        if (lol2 != null && lol3 != null) {
        	p.addPoint(Integer.parseInt(lol2), Integer.parseInt(lol3));
        }
        System.out.println(lol2+lol3);
        return p;
    }
 
    NewPolygon loadPolygon() {
        NewPolygon p = new NewPolygon();
        for(int n = 0; n < save.index; n++) {
            p.addPoint(save.getX(n), save.getY(n));
        }
        return p;
    }
 
    void savePolygon(NewPolygon p) {
        save = p;
    }

    void drawFinal(NewPolygon p, Graphics g) {
        Polygon p2 = new Polygon();
        for(int n = 0; n < p.index; n++) {
            p2.addPoint(roundInt(p.getX(n)), roundInt(p.getY(n)));
        }
        p2.translate(X_ZERO, Y_ZERO);
        g.setColor(SHAPE_COLOR);
        if (fill) g.fillPolygon(p2);
        else g.drawPolygon(p2);
        if(status==rate) savePolygon(p);
        repaint();
    }
 
    void drawTranslate(NewPolygon p, double xtrav, double ytrav) {
        for (int n = 0; n < p.index; n++) {
            double x = p.getX(n);
            double y = p.getY(n);
            p.setPoint(x + frame * xtrav, y + frame * ytrav, n);
        }
    }
 
    void drawRotateButton(int x, int y, Graphics g) {
        Image img2 = Toolkit.getDefaultToolkit().getImage(background);
        Image img = Toolkit.getDefaultToolkit().getImage(rotateFile);
        g.drawImage(img2, dragX + img2.getWidth(null), dragY + img2.getHeight(null), null);
        g.drawImage(img, dragX - img.getWidth(null) / 2, dragY
                - img.getHeight(null) / 2, null);
    }
   
    void drawReflect(NewPolygon p, boolean axis) {
        for (int n = 0; n < p.index; n++) {
            double x = p.getX(n);
            double y = p.getY(n);
            double deltax = (2 * Math.abs(x) * frame);
            double deltay = (2 * Math.abs(y) * frame);
            double xfinal = x, yfinal = y;
            if (x > 0 && !axis) xfinal = x - deltax;
            if (x < 0 && !axis) xfinal = x + deltax;
            if (y > 0 &&  axis) yfinal = y - deltay;
            if (y < 0 &&  axis) yfinal = y + deltay;
            p.setPoint(xfinal, yfinal, n);
        }
    }

    void drawRotate(NewPolygon p, double theta) {
        double t = theta * frame;
        for (int n = 0; n < p.index; n++) {
            double x = p.getX(n);
            double y = p.getY(n);
            p.setPoint(x * Math.cos(t) - y * Math.sin(t),
                      (x * Math.sin(t) + y * Math.cos(t)), n);
        }
    }

    void drawDilate(NewPolygon p, double size) {
        double s = size - 1;
        for (int n = 0; n < p.index; n++) {
            double x = p.getX(n);
            double y = p.getY(n);
            p.setPoint(x + s * frame * x, y + s * frame * y, n);
        }
    }

    int roundInt(double n) {
        return (int) Math.round(n);
    }

    public void mouseClicked(MouseEvent e) {
        if (e.getX()>500 & e.getY()>500){
        }
    }
 
    boolean contains(Image img, MouseEvent e) {
        return ((e.getX()>(dragX - img.getWidth(null)))&&(e.getX()<(dragX + img.getWidth(null)))&&(e.getY()<(dragY + img.getHeight(null)))&&(e.getY()>(dragY - img.getHeight(null))));
    }
   
    public void mouseDragged(MouseEvent e) {
        Image img = Toolkit.getDefaultToolkit().getImage(rotateFile);
        if(contains(img, e)) {
            dragX = e.getX();
            dragY = e.getY();
        }
    }
   
    public void mousePressed(MouseEvent e) {}
   
    public void mouseReleased(MouseEvent e) {
        if(dragX < 400 && dragY < 750 && dragY > 650 && dragX>100){
            fat=true;
        } else fat=false;
        System.out.println(fat);
        painter();
    }
    public void mouseEntered(MouseEvent arg0) {}
    public void mouseExited(MouseEvent arg0) {}
    public void mouseMoved(MouseEvent arg0) {}
 
    void nextGeneration() {
        if (status < rate){
            status++;
            frame = status/rate;
        } else {
            status = 0;
            frame = 0;
            run++;
        }
    }
   
    void painter() {
        repaint();
    }
}

public class NewPolygon {
    int MAX_POINTS = Display.MAX_POINTS;
    public int index = 0;
    public double[] x;
    public double[] y;
   
    public NewPolygon() {
        x = new double[MAX_POINTS];
        y = new double[MAX_POINTS];
    }
   
    void addPoint(double x, double y) {
        this.x[index] = x;
        this.y[index] = y;
        index++;
    }
   
    void setPoint(double x, double y, int n) {
        this.x[n] = x;
        this.y[n] = y;
    }
   
    double getX(int n) {return x[n];}
   
    double getY(int n) {return y[n];}
}

import javax.swing.JFrame;

public class Main {      
    public static Display display = new Display();
  
    public static void main(String[] args) {                      
        display.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        display.setVisible(true);
    }
}

 

[X-Tasis]

wow nice, I can do polygamy :O

 

[OreansSucks]

That's not what it is.

 

[xJvlaplex]

awesome release, using it for Renoria =)

 

[steerclear]

I'm only a freshman in highschool lol

 

[X-Tasis]

That's not what it is.

Squaregamy? :$

 

[dragonbIood]

wow nice, I can do polygamy :O

Isnt that the practice of havibg many wives...

 

[~Sex~]

nice shapes?