JUEGO EN JAVA MINI TENIS CON MENU Y CONFIGURACION

main
/////////////////////////////////////////////////////////////////////////////////////////////////////

package minitenis;

import Listeners.ListenerBoton7;
import Listeners.ListenerBoton4;
import Listeners.ListenerBoton3;
import Listeners.ListenerBoton5;
import Listeners.ListenerBoton6;
import Listeners.ListenerBoton2;
import Listeners.ListenerBoton1;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javazoom.jl.decoder.JavaLayerException;
import javazoom.jl.player.Player;


@SuppressWarnings("serial")
public class Game2 extends JPanel {

//TRAE EL LIENZO
        ////ATRIBUTOS GAME2////
        String sonido1 ="C:/Users/Laurencio/Documents/NetBeansProjects/JUEGO/src/sonidos2/sonido1.mp3";
        String sonido2 = "C:/Users/Laurencio/Documents/NetBeansProjects/JUEGO/src/sonidos2/gameover.wav";
        static int DifiConf;
        boolean GameOver;
        int i=0;
        static int AlturaP=600;
        static int AnchoP=600;
Ball ball = new Ball(this, (float) (AnchoP/(Math.random()*100)),0,0,0);   
        Raqueta raquet = new Raqueta(this,0,0,0,0,DifiConf);
       
        public static void main(String[] args) throws InterruptedException {
               
               
           
                ////////////////////////////////// FRAME MENU ////////////////////////
                JFrame frame2 = new JFrame("Menu");
                JButton boton1 = new JButton();
                ListenerBoton1 LB1 = new ListenerBoton1(false);
                JButton boton2 = new JButton();
                ListenerBoton2 LB2 = new ListenerBoton2(false);
                JButton boton3 = new JButton();
                ListenerBoton3 LB3 = new ListenerBoton3(false);
               
                frame2.setSize(Game2.AlturaP,Game2.AnchoP);
                frame2.setVisible(true);
                frame2.setLocationRelativeTo(null);
                frame2.setResizable(false);
                frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame2.setLayout(null);
         
                ////////////////////////////////// MENU ///////////////////////////////
               
                Panel p = new Panel();
                frame2.add(p);
               
                boton1.addActionListener(LB1);
               
                boton1.setText("Play");
                boton1.setBounds(240, 150, 130, 50);
                frame2.add(boton1);
               
                     
                boton2.addActionListener(LB2);
               
                boton2.setText("Settings");
                boton2.setBounds(240,250,130,50);
                frame2.add(boton2);
               
                boton3.addActionListener(LB3);
                boton3.setText("Exit");
                boton3.setBounds(240,350,130,50);       
                frame2.add(boton3);

               
                //////////////////////////////////// ELECCION DE FRAMES ////////////////////////////////////
                int opc = 0;
                boolean CancelDecision = true;
               
                while (true){
                   
                    while (CancelDecision){
                        System.out.println("loading");
                            if (LB1.PLAYboolean) {
                                    opc = 1;
                                    System.out.println("OPC 1");
                                    CancelDecision = false;
                            }
                            if (LB2.CONFboolean) {
                                    opc = 2;
                                    System.out.println("OPC 2");
                                    CancelDecision = false;                         
                                     } 
                            if (LB3.exit){
                                System.out.println("OPC 3");
                                System.exit(ABORT);
                            }
                           Thread.sleep(300);
                    }
                    LB1.PLAYboolean = false;
                    LB2.CONFboolean = false;
                    switch (opc){
                            case 1:
                    ////////////////////////////////// FRAME JUEGO ///////////////////////
                                Game2 game = new Game2();
                                game.RandomP();
                                JFrame frame = new JFrame("Pelota Rebotin v. 2.0"); //TRAE EL MARCO

                    ////////////////////////////////// CARGA DE JUEGO ///////////////////
                                frame.add(game);
                                frame.setSize(AlturaP, AnchoP);
                                frame.setLocationRelativeTo(null);
                                frame.setResizable(false);
                               
                                frame.setVisible(true);   

                    ////////////////////////////////// INICIO DE JUEGO /////////////////
                                boolean SetJuego = true;
                                            while (SetJuego){
                                                ExecutorService executor = Executors.newSingleThreadExecutor();
                                                executor.submit(() ->  {
                                                    game.move();
                                                    game.repaint();
                                                    game.Dificultad();
                                                });   
                                                ExecutorService executor2 = Executors.newSingleThreadExecutor();
                                                executor.submit(() ->  {
                                                    try {   
                                                        game.sonido();
                                                    } catch (FileNotFoundException ex) {
                                                        Logger.getLogger(Game2.class.getName()).log(Level.SEVERE, null, ex);
                                                    } catch (JavaLayerException ex) {
                                                        Logger.getLogger(Game2.class.getName()).log(Level.SEVERE, null, ex);
                                                 
                                                    }});
                                                ExecutorService executor3 = Executors.newSingleThreadExecutor();
                                                executor.submit(() ->  {
                                                    try {
                                                        game.sonidoEndGame();
                                                    } catch (UnsupportedAudioFileException ex) {
                                                        Logger.getLogger(Game2.class.getName()).log(Level.SEVERE, null, ex);
                                                    } catch (LineUnavailableException ex) {
                                                        Logger.getLogger(Game2.class.getName()).log(Level.SEVERE, null, ex);
                                                    } catch (IOException ex) {
                                                        Logger.getLogger(Game2.class.getName()).log(Level.SEVERE, null, ex);
                                                    } catch (InterruptedException ex) {
                                                        Logger.getLogger(Game2.class.getName()).log(Level.SEVERE, null, ex);
                                                    }
                                                });
                                               
                                                Thread.sleep(8);
                                                if (game.GameOver){
                                                    opc=0;
                                                    SetJuego = false;
                                                    CancelDecision = true;
                                                    frame.setVisible(false);
                                                   
                                                }
                                                }
                            break;
                        case 2:
                                ////////////////////////////////////FRAME CONFIGURACION/////////////////////////////
                               
                                JFrame frame3 = new JFrame("Settings");
                                ListenerBoton4 LB4 = new ListenerBoton4(true);
                                ListenerBoton5 LB5 = new ListenerBoton5(false);
                                ListenerBoton6 LB6 = new ListenerBoton6(false);
                                ListenerBoton7 LB7 = new ListenerBoton7(false);

                                frame3.setSize(Game2.AlturaP,Game2.AnchoP);
                                frame3.setVisible(true);
                                frame3.setLocationRelativeTo(null);
                                frame3.setResizable(false);
                                frame3.setLayout(null);
                               
                                ////////////////BOTONERA //////////////
                               
                                JButton boton4 = new JButton();
                                JButton boton5 = new JButton();
                                JButton boton6 = new JButton();
                                JButton botonATRAS = new JButton();
                               
                                boton4.setText("Facil");
                                boton4.setBounds(50,50,90,50);
                                frame3.add(boton4);
                               
                                boton5.setText("Intermedio");
                                boton5.setBounds(150, 50, 130, 50);
                                frame3.add(boton5);
                               
                                boton6.setText("Dificil");
                                boton6.setBounds(290,50, 90, 50);
                                frame3.add(boton6);
                               
                                botonATRAS.setText("ATRAS");
                                botonATRAS.setBounds(10 ,500 , 90, 50);
                                frame3.add(botonATRAS);
                               
                                boton4.addActionListener(LB4);
                                boton5.addActionListener(LB5);
                                boton6.addActionListener(LB6);
                                botonATRAS.addActionListener(LB7);
                               
                                /////////////////TEXTO A MOSTRAR ////////////////
                             
                                JLabel texto = new JLabel();
                                texto.setText("Dificultad");
                                texto.setBounds(190, 10, 90, 50);
                                frame3.add(texto);
                               
                                JLabel texto2 = new JLabel();
                                frame3.add(texto2);
                                texto2.setBounds(440,50,200,50);
                               
                                while (LB7.BotAtras != true){
                               
                                if (LB4.Facil){
                                    LB5.intermedio = false;
                                    LB6.dificil = false;
                                    DifiConf = 120;
                                    texto2.setText("DIFICULTAD EN FACIL");
                                }
                                if (LB5.intermedio){
                                    LB4.Facil = false;
                                    LB6.dificil = false;
                                    DifiConf = 90;
                                    texto2.setText("DIFICULTAD EN INTERMEDIO");
                                }
                                if (LB6.dificil){
                                    LB4.Facil = false;
                                    LB5.intermedio = false;
                                    DifiConf = 75;
                                    texto2.setText("DIFICULTAD EN DIFICIL");
                                }
                                }
                                opc=0;
                                CancelDecision = true;
                                frame3.setVisible(false);
                            break;
                    }
        }}
       
       
        ////////////////////////////////// SENSOR DE TECLAS //////////////////////////////////
        public Game2() {
        addKeyListener(new KeyListener() {
@Override
            public void keyTyped(KeyEvent e) {
}

@Override
            public void keyPressed(KeyEvent e) {
System.out.println("keyPressed="+KeyEvent.getKeyText(e.getKeyCode()));
                                raquet.keyPressed(e);
}

@Override
            public void keyReleased(KeyEvent e) {
System.out.println("keyReleased="+KeyEvent.getKeyText(e.getKeyCode()));
                                raquet.keyReleased(e);
}
            });
setFocusable(true);
}
       
        ////////////////////////////////// OBJETOS CARGADOS EN PANTALLA FRAME1 //////////////////////////////////
         @Override //PINTADO DE PANTALLA
public void paint(Graphics g) {
super.paint(g); //BORRA LA PANTALLA               
Graphics2D g2d = (Graphics2D) g;
                Graphics2D g3d = (Graphics2D) g;
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
ball.paint(g2d); // OBJETO A PINTAR 
                raquet.paint(g2d);
                g2d.setColor(Color.GRAY);
g2d.setFont(new Font("Verdana", Font.BOLD, 30));
g2d.drawString(String.valueOf(Contador()), 10, 30);
               
                g3d.setFont(new Font("Verdana", Font.BOLD, 10));
                g3d.drawString("Usar las flechas para moverse.  ", 400, 30);
                g3d.drawString("Mantener apretado para ganar mas velocidad.", 312, 42);
                g3d.drawString("Made by: Laurencio P. ", 450, 550);
}
       


        ////////////////////////////////// SONIDO DEL JUEGO FRAME 1 //////////////////////////////////
       
        public void sonido() throws FileNotFoundException,JavaLayerException {
            if (ball.collision()){
                Player apl = new Player(new FileInputStream(sonido1));
                apl.play();
                }
        }   
        public void sonidoEndGame() throws UnsupportedAudioFileException, LineUnavailableException, IOException, InterruptedException {
            if (ball.GameOverB){
                try (Clip sonido3 = AudioSystem.getClip()) {
                    sonido3.open(AudioSystem.getAudioInputStream(new File(sonido2)));
                    sonido3.start();
                    Thread.sleep(1000);
                }
             
        }}
       
        ////////////////////////////////////METODOS /////////////////////////////
        private void Dificultad(){
            if (ball.collision()){
            ball.xa= (float) (0.5+ball.xa);
            ball.ya=(float) (ball.ya+0.5);
            }
        }
           
private void move() {
ball.move(); 
                raquet.move();
}

         private int Contador(){
            if (ball.collision()){
                i=i+1;
            }
            return i;
        }
       
        public void GameOverMessage(){
            JOptionPane.showMessageDialog(this, "your score is: " + Contador(),
"Game Over", JOptionPane.YES_NO_OPTION);
           
           
            GameOver = true;
           // System.exit(ABORT);
        }

       
        public void RandomP(){
            if (Math.random()*100 < 50){
                ball.xa=2;
                System.out.println("VelX Randomize Act");
                if (Math.random()*100 < 50){
                    ball.ya = -1;
                    System.out.println("VelY Randomize Neg");
                } else {
                    ball.ya = 1;
                    System.out.println("VelY Randomize Pos");
                }
            } else {
                ball.ya=2;
                System.out.println("VelY Randomize Act");
                if (Math.random()*100 <50 p="">                    ball.xa = -1;
                    System.out.println("VelX Randomize Neg");
                } else {
                    ball.xa = 1;
                    System.out.println("VelX Randomize Pos");
                }
            }
        }
}

//////////////////////////////////////////////////////objetos de botones/////////////////////////////////////////////////
package Listeners;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ListenerBoton1 implements ActionListener {
   
    public boolean PLAYboolean;

   
    //CONSTRUCTOR ///
    public ListenerBoton1(boolean PLAYboolean) {
        this.PLAYboolean = PLAYboolean;
    }

    public void actionPerformed (ActionEvent e){
        System.out.println("BOTON 1 FUE PULSADO");
        PLAYboolean = true;
    }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////

package Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class ListenerBoton2 implements ActionListener  {

    

    public boolean CONFboolean;

    public ListenerBoton2(boolean CONFboolean) {

        this.CONFboolean = CONFboolean;

    }

    public void actionPerformed (ActionEvent e){

        System.out.println("BOTON 2 FUE PULSADO");

        CONFboolean = true;

     }

    

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

package Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class ListenerBoton7 implements ActionListener{

    public boolean BotAtras;

    public ListenerBoton7(boolean BotAtras) {

        this.BotAtras = BotAtras;

    }

    

    

    

    @Override

    public void actionPerformed(ActionEvent e) {

        System.out.println(" BOTON ATRAS ");

        BotAtras = true;

        

    }

    

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

package Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class ListenerBoton6 implements ActionListener{

    

    public boolean dificil;

    public ListenerBoton6(boolean dificil) {

        this.dificil = dificil;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        System.out.println("BOTON 6");

        dificil = true;

    }

    

    

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

package Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class ListenerBoton5 implements ActionListener {

    

    public boolean intermedio;

    public ListenerBoton5(boolean intermedio) {

        this.intermedio = intermedio;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        System.out.println("BOTON 5 ");

        intermedio = true;

    }

    

    

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

package Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class ListenerBoton4 implements ActionListener{

    

    public boolean Facil;

    public ListenerBoton4(boolean Facil) {

        this.Facil = Facil;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        System.out.println("BOTON 4");

        Facil = true;

    }

    

    

    

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

package Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class ListenerBoton3 implements ActionListener  {

    

    public boolean exit;

    public ListenerBoton3(boolean exit) {

        this.exit = exit;

    }

    

    

    

    

        public void actionPerformed (ActionEvent e){

            System.out.println("BOTON 3 FUE PULSADO");

            exit=true;

     }

    

}

 

////////////////////////////////////////////////////////////////////////////////////////////////////// OBJETO BALL

package minitenis;

import minitenis.Game2;

import java.awt.Graphics2D;

import java.awt.Rectangle;

public class Ball {

        boolean GameOverB= false;

        private static final int DIAMETER = 30;

float x ;

        float y;

float xa;

float ya;

private Game2 game;

    Ball(Game2 game,float x, float y, float xa, float ya) {

        this.game= game;

        this.x= x;

        this.xa=xa;

        this.y=y;

        this.ya=ya;

    }

    public float getX() {

        return x;

    }

    public float getY() {

        return y;

    }

    public float getXa() {

        return xa;

    }

    public float getYa() {

        return ya;

    }   

  

    public void move() { //METODO DE MOVIMIENTO

        int c=1,d=1;

        if (Ball.this.getXa() < 0) {

            c=-1;

        }

        if (Ball.this.getYa()<0 div="">

            d=-1;

        }

if (Ball.this.getX() + Ball.this.getXa() < 0){

Ball.this.xa = c*Ball.this.getXa();

                }

if (Ball.this.getX() + Ball.this.xa > game.getWidth() - 30) {

Ball.this.xa = -1*Ball.this.getXa();

                }

if (Ball.this.getY() + Ball.this.getYa() < 0) {

                    Ball.this.ya=  d*Ball.this.getYa();

                }

                

if (Ball.this.getY() + Ball.this.getYa() > game.getHeight() - 30) {

                        Ball.this.x=0;

                        Ball.this.xa=0;

                        Ball.this.y=0;

                        Ball.this.ya=0;

                        GameOverB = true;

                        game.GameOverMessage();

                        

                }

                if (collision()){

Ball.this.ya = -1*Ball.this.getYa();

y = game.raquet.getTopY() - DIAMETER;

                }

                

                Ball.this.x = Ball.this.getX() + Ball.this.xa;

                Ball.this.y = Ball.this.getY() + Ball.this.ya;

}    

  

public void paint(Graphics2D g) {

g.fillOval(Math.round(Ball.this.x),Math.round(Ball.this.y), DIAMETER, DIAMETER);                

               

}

        public boolean collision() {

return game.raquet.getBounds().intersects(getBounds());

}

        

        public Rectangle getBounds() {

return new Rectangle(Math.round(x), Math.round(y), DIAMETER, DIAMETER);

}

        

}

////////////////////////////////////////////////////////////////////////////////////////////////////// PANEL

package minitenis;

import java.awt.Dimension;

import java.awt.Graphics;

import javax.swing.ImageIcon;

public class Panel extends javax.swing.JPanel {

    

    ImageIcon imagen;

    String nombre="/imagenes2/FONDO.jpg";

    

    public Panel(){ 

    this.setSize(600,600); 

}     

    @Override 

    public void paint(Graphics g){ 

        Dimension tamanio = getSize(); 

        imagen = new ImageIcon(getClass().getResource(nombre)); 

        g.drawImage(imagen.getImage(),0,0,tamanio.width, tamanio.height, null); 

        setOpaque(false); 

        super.paint(g);

    } 

    

    

}

////////////////////////////////////////////////////////////////////////////////////////////////////// OBJETO RAQUETA

package minitenis;

import minitenis.Game2;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.event.KeyEvent;

public class Raqueta {

    private static final int Y = 520;

    public int WITH ;

    private static final int HEIGHT = 10;

    int x;

    int xa;

    int ContadorLeft=0, ContadorRight=0;

    private Game2 game;

    public Raqueta(Game2 game,int x, int xa,int ContadorLeft,int ContadorRight,int WITH) {

        this.x = x;

        this.xa = xa;

        this.game = game;

        this.ContadorLeft = ContadorLeft;

        this.ContadorRight = ContadorRight;

        this.WITH = WITH;

    }

    public int getContadorLeft() {

        return ContadorLeft;

    }

    public int getContadorRight() {

        return ContadorRight;

    }

    

    public void move() {

if (x + xa > 0 && x + xa < game.getWidth()-60)

x = x + xa;

}

    public void paint(Graphics2D g) {

g.fillRect(x, Y, WITH, HEIGHT);

}

    public void keyReleased(KeyEvent e) {

xa = 0;

}

    public void keyPressed(KeyEvent e) {

if (e.getKeyCode() == KeyEvent.VK_LEFT) {

                        Raqueta.this.ContadorRight = 0;

                        Raqueta.this.ContadorLeft = Raqueta.this.ContadorLeft+1;

                        if (Raqueta.this.ContadorLeft >= 2){

                            xa = -6;

                            System.out.println("Velocidad Aumentada");

                        } else {

                            xa = -4;

                        }

                }            

if (e.getKeyCode() == KeyEvent.VK_RIGHT) {

                        Raqueta.this.ContadorLeft = 0;

                        Raqueta.this.ContadorRight =  Raqueta.this.ContadorRight+1;

                        Raqueta.this.ContadorLeft = 0;

                        if (Raqueta.this.ContadorRight>=2){

                            xa = 6;

                            System.out.println("Velocidad Aumentada");

                        } else {

                            xa = 4;

                        }

                }

}

    

    public Rectangle getBounds() {

return new Rectangle(x, Y, WITH, HEIGHT);

}

    public int getTopY() {

return Y - HEIGHT;

}

       

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

JAVA - 3 pelotitas rebotando en la pantalla

3 PELOTITAS REBOTANDO EN LA PANTALLA

--------------------------------------------------------------------------------------------------------------------------

package pelotas.rebotando;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JFrame;
import javax.swing.JPanel;

@SuppressWarnings("serial")
public class Game2 extends JPanel { //TRAE EL LIENZO
   
Ball ball = new Ball(this,0,0,4,5);   
        Ball ball2 = new Ball(this,100,100,5,4);
        Ball ball3 = new Ball(this,150,150,4,7);
       
private void move() {
                Movimiento();
ball.move(); 
                ball2.move();
                ball3.move();
}
       
@Override //PINTADO DE PANTALLA
public void paint(Graphics g) {
super.paint(g); //BORRA LA PANTALLA               
Graphics2D g2d = (Graphics2D) g;

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
                Graphics2D g3d = (Graphics2D) g;

g3d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
                Graphics2D g4d = (Graphics2D) g;

g4d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
ball.paint(g2d); // OBJETO A PINTAR 
                ball2.paint(g3d); 
                ball3.paint(g4d);
}
       
        public void Movimiento() {
            if (ball.colision()) {
                switch (ball.colision2()){
                    case 1:
                        ball.xa=-1*ball.getXa();
                        ball.ya=-1*ball.getYa();
                        ball2.xa=-1*ball2.getXa();
                        ball2.ya=-1*ball2.getYa();
                        break;
                    case 2:
                        ball.xa=-1*ball.getXa();
                        ball.ya=-1*ball.getYa();
                        ball3.xa=-1*ball3.getXa();
                        ball3.ya=-1*ball3.getYa();
                        break;
                    case 3:
                        ball2.xa=-1*ball2.getXa();
                        ball2.ya=-1*ball2.getYa();
                        ball3.xa=-1*ball3.getXa();
                        ball3.ya=-1*ball3.getYa();
                        break;
                }
            }
        }
       

public static void main(String[] args) throws InterruptedException {
JFrame frame = new JFrame("Pelotas Rebotando"); //TRAE EL MARCO
Game2 game = new Game2();
frame.add(game);
frame.setSize(500, 500);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


                // LLAMA AL METODO PAINT PARA ACTUALIZARZ LA PANTALLA
while (true) {
game.move();// PRIMERO MUEVE
game.repaint();  // DESPUES PINTA
Thread.sleep(10); // TIEMPO DE ESPERA EN MILISEGUNDOS
}
}
}

--------------------------------------------------------------------------------------------------------------------------

package pelotas.rebotando;

import java.awt.Graphics2D;
import java.awt.Rectangle;

public class Ball {
        private static final int DIAMETER = 30;
int x ;
        int y;
int xa;
int ya;
private Game2 game;

     Ball(Game2 game,int x, int y, int xa, int ya) {
        this.game= game;
        this.x= x;
        this.xa=xa;
        this.y=y;
        this.ya=ya;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getXa() {
        return xa;
    }

    public int getYa() {
        return ya;
    } 
 
    public void move() { //METODO DE MOVIMIENTO
        int c=1,d=1;
        if (Ball.this.getXa() < 0) {
            c=-1;
        }
        if (Ball.this.getYa()<0 p="">            d=-1;
        }
if (Ball.this.getX() + Ball.this.getXa() < 0){
Ball.this.xa = c*Ball.this.getXa();
                }
if (Ball.this.getX() + Ball.this.xa > game.getWidth() - 30) {
Ball.this.xa = -1*Ball.this.getXa();
                }
if (Ball.this.getY() + Ball.this.getYa() < 0) {
                    Ball.this.ya=  d*Ball.this.getYa();
                }
               
if (Ball.this.getY() + Ball.this.getYa() > game.getHeight() - 30) {
Ball.this.ya= -1*Ball.this.getYa();
                }
               
                Ball.this.x = Ball.this.getX() + Ball.this.xa;
                Ball.this.y = Ball.this.getY() + Ball.this.ya;
}
   
 
public void paint(Graphics2D g) {
            g.fillOval(Ball.this.x, Ball.this.y, DIAMETER, DIAMETER);               
             
}
        public Rectangle getRECTANGULO() {
            return new Rectangle(Ball.this.getX(), Ball.this.getY(), DIAMETER, DIAMETER);
}
       
        public boolean colision() {
if (game.ball.getRECTANGULO().intersects(game.ball2.getRECTANGULO())){
                    return true; 
                } else {
                if (game.ball.getRECTANGULO().intersects(game.ball3.getRECTANGULO())){
                   return true;
                } else {
            if(game.ball2.getRECTANGULO().intersects(game.ball3.getRECTANGULO())){
                return true;
                 }else{
                return false;
            }}}
}
                     
        public int colision2() {
if (game.ball.getRECTANGULO().intersects(game.ball2.getRECTANGULO())){
                    return 1;
                } else {
                if (game.ball.getRECTANGULO().intersects(game.ball3.getRECTANGULO())){
                   return 2;
                } else {
            if(game.ball2.getRECTANGULO().intersects(game.ball3.getRECTANGULO())){
               return 3;
               
           }else{
               return 0;
            }}}
}}

Java / Software de calculo de Área de Polígonos (Triángulos y rectángulos)

Hacer un programa para calcular el area de poligonos (triangulos y rectangulos). El programa debe ser capaz de almacenar en un arreglo N triangulos y rectangulos, y al final mostrar el area y los datos de cada uno.

- Una Super clase llamada Poligono.
- Una sub clase llamada Rectangulo.
- Una sub clase llmada Triangulo.

--------------------------------------------------------------------------------------------------------------------------

PROGRAMA MAIN

package calculo;


import java.util.ArrayList;
import java.util.Scanner;

public class Calculo {
   
    static ArrayList poligono = new ArrayList();
    static Scanner entrada = new Scanner(System.in);
   
    public static void main(String[] args) {
      llenarPoligono();
     
      Recorrer();
    }
   
    public static void llenarPoligono(){
        char respuesta;
        int opcion;
        do{
            do{
                System.out.println("Digite que poligono desea: Triangulo o Rectangulo."
                    + "1 para triangulo "
                    + "2 para rectangulo ");
            System.out.println("Opcion: ");
            opcion = entrada.nextInt();
            }while(opcion<1 opcion="">2);
         
           
            switch (opcion) {
                case 1: llenarTriangulo();
                    break;
                case 2: llenarRectangulo();
                    break;
            }
            System.out.println("Desea ingresar otro poligono (s/n)");
            respuesta = entrada.next().charAt(0);
        }while(respuesta=='s' || respuesta=='S');
     
    }
   
    public static void llenarTriangulo(){
        double lado1 = 0,lado2 = 0,lado3 = 0;
        for (int i=1; i<=3; i++){
            System.out.println("Ingrese lado "+ i+" del triangulo");
            switch (i) {
                case 1: lado1 = entrada.nextDouble();
                    break;
                case 2: lado2 = entrada.nextDouble();
                    break;
                case 3: lado3 = entrada.nextDouble();
                    break;
            }
        }
        Triangulo triangulo = new Triangulo(lado1,lado2,lado3);
        poligono.add(triangulo);
    }
   
    public static void llenarRectangulo(){
        double lado1 = 0,lado2 = 0;
        for (int i=1; i<=2; i++){
            System.out.println("Ingrese lado "+ i+" del rectangulo");
            switch (i) {
                case 1: lado1 = entrada.nextDouble();
                    break;
                case 2: lado2 = entrada.nextDouble();
                    break;
            }
        }
        Rectangulo rectangulo = new Rectangulo(lado1,lado2);
        poligono.add(rectangulo);
    }
   
    public static void Recorrer(){
        poligono.stream().map((poli) -> {
            System.out.println(poli.toString());
            return poli;
        }).forEachOrdered((poli) -> {
            System.out.println("Area= "+poli.Area());
        });
    }
}

=======================================================================

SUPER CLASE

package calculo;

public abstract class Poligono {
    //atributos
    protected int NumeroLados;
   
    // Constructor

    public Poligono(int NumeroLados) {
        this.NumeroLados = NumeroLados;
    }

    public int getNumeroLados() {
        return NumeroLados;
    }
   
    // Metodos

   
    @Override
    public String toString() {
        return "Poligono{" + "NumeroLados=" + NumeroLados + '}';
    }
   
    public abstract double Area();

}

========================================================================

SUB CLASE TRIANGULO

package calculo;

public class Triangulo extends Poligono{

    private final double lado1;

    private final double lado2;

    private final double lado3;

    // Constructor

    public Triangulo(double lado1, double lado2, double lado3) {

        super(3);

        this.lado1 = lado1;

        this.lado2 = lado2;

        this.lado3 = lado3;

    }

    public double getLado1() {

        return lado1;

    }

    public double getLado2() {

        return lado2;

    }

    public double getLado3() {

        return lado3;

    }

    @Override

    public String toString() {

        return "Triangulo{" + "lado1=" + lado1 + ", lado2=" + lado2 + ", lado3=" + lado3 + '}';

    }

    @Override

    public double Area() {

        double p= (lado1+lado2+lado3)/2;

        return Math.sqrt(p*(p-lado1)*(p-lado2)*(p-lado3));              

    }   

}

========================================================================

SUB CLASE RECTANGULO

package calculo;

public class Rectangulo extends Poligono{

    private double lado1;

    private double lado2;

    //Constructor

    public Rectangulo(double lado1, double lado2) {

        super(4);

        this.lado1 = lado1;

        this.lado2 = lado2;

    }

    public double getLado1() {

        return lado1;

    }

    public double getLado2() {

        return lado2;

    }

    @Override

    public String toString() {

        return "Rectangulo{" + "lado1=" + lado1 + ", lado2=" + lado2 + '}';

    }

    @Override

    public double Area() {

      return lado1*lado2;

    }

}

========================================================================

Salida por pantalla:

run:

Digite que poligono desea: Triangulo o Rectangulo.1 para triangulo 2 para rectangulo 

Opcion: 

1

Ingrese lado 1 del triangulo

2

Ingrese lado 2 del triangulo

3

Ingrese lado 3 del triangulo

4

Desea ingresar otro poligono (s/n)

s

Digite que poligono desea: Triangulo o Rectangulo.1 para triangulo 2 para rectangulo 

Opcion: 

2

Ingrese lado 1 del rectangulo

3

Ingrese lado 2 del rectangulo

5

Desea ingresar otro poligono (s/n)

n

Triangulo{lado1=2.0, lado2=3.0, lado3=4.0}

Area= 2.9047375096555625

Rectangulo{lado1=3.0, lado2=5.0}

Area= 15.0

BUILD SUCCESSFUL (total time: 21 seconds)

Ejercicio en Java / Calculo de area y perimetro con uso de POO

Escribir un programa que calcule el área y el perímetro de un cuadrilátero dada la longitud de sus dos lados. Los valores deberán introducirse por linea de ordenes.


package javaapplication5;

import java.util.Scanner;

public class JavaApplication5 {

    public static void main(String[] args) {
      Scanner Entrada = new Scanner(System.in);
      int x = 0,y = 0;
      Cuadrilatero obj = new Cuadrilatero( x, y);
     
        System.out.println("Ingrese lado 1 y lado 2 del cuadrilatero");
        obj.Altura = Entrada.nextInt();
        obj.Longitud = Entrada.nextInt();
       
        System.out.println("El perimetro es: "+obj.Perimetro(obj.Longitud, obj.Altura)+" y el area es: "+obj.Area(obj.Longitud, obj.Altura));
       
    }
   
}

----------------------------------------------------------------------

package javaapplication5;

public class Cuadrilatero{

    

    int Longitud;

    int Altura;

    public Cuadrilatero (int Longitud, int Altura) {

        this.Longitud = Longitud;

        this.Altura = Altura;

    }

   public int Area (int Longitud, int Altura){

       int area;

       area=Longitud*Altura;

       return area;

   }

    

   public int Perimetro (int Longitud, int Altura){

       int perim;

       perim=Longitud*2+Altura*2;

       return perim;

   }

    

}

EXCEL

https://www.universoformulas.com/

https://exceltotal.com/

http://www.tutorialesytrucos.com/

FUNCIONES BASICAS EN EXCEL

• Suma
• Resta
• Producto
• División
• Porcentaje  .
• Máximo y Mínimo
• Promedio

Funciones Básicas en Excel

Suma: Con esta función lo que calculamos es la suma de todos los números de un conjunto de datos (también denominado rango) Se representa en la hoja de Excel: 

=SUMA(celda(s):celda(s))

Resta: Análogamente a la suma, pero con el signo - en vez del signo:. Y será:

=RESTA(celda(s)-celda(s))

Producto: Multiplica todos los números obteniendo el producto de dichos números. Aparecerá:

=PRODUCTO(celda(s);celda(s))

División: De forma similar al producto. La formula aparecerá:

=DIVIDIR((celda(s)/celda(s))

Porcentaje(%): Excel nos calcula el tanto por ciento de una serie de datos, dividiendo la cantidad entre el total. La expresión de esta función es ​​

= PRODUCTO(%; celda(s))

Máximo y Mínimo: Con esta función Excel nos va a indicar el valor máximo y mínimo de un conjunto de valores. Así:

=MAX(rango) y=MIN(rango)

Promedio: Devuelve la media aritmética de una serie de valores. Con la expression

=PROMEDIO(rango)

La función SI en Excel

La función SI en Excel es parte del grupo de funciones Lógicas y nos permite evaluar una condición para determinar si es falsa o verdadera. La función SI es de gran ayuda para tomar decisiones en base al resultado obtenido en la prueba lógica.

               https://youtu.be/3PdIJwbqrqs (video explicativo)

         Sintaxis:

Para llamar a la fórmula SI utilizamos el siguiente comando:

=SI (prueba_lógica; valor_si_verdadero; valor_si_falso)

Donde:

§  prueba_lógica: Obligatoria. Puede ser desde una fórmula lógica matemática, como B1>2 o A3=0, una comparación con un texto o una cadena alfanumérica, como C3<>”SI” o bién D5=”CONSTITUCION” hasta una fórmula de cadenas de Excel. Si se cumple la prueba lógica, se considera verdadera y la función asigna el valor_si_verdadero. En caso de que sea falsa se asigna el valor_si_falso.

§  valor_si_verdadero: Opcional. Es el valor que asignará la función SI en el caso de que la prueba lógica sea verdadera. Puede ser un valor numérico como 7, una cadena como “Verdadero” o incluso otra fórmula de Excel. En el caso de omitir esta variable, dejando la función como =SI(B2<5 also="" span="">, su valor será 0 por defecto.

§  valor_si_falso: Opcional. Se le asignará este valor a la función si de Excel la prueba_lógica da falso. Al igual que el valor_si_verdadero, puede tomar cualquier tipo de valor o fórmula. Si se omite este valor en la sintaxis, como por ejemplo =SI(B2=”Ramón”;3;), se le asignará por defecto el valor 0.

La función Y en Excel

La función Y en Excel es una función lógica que nos permitirá evaluar varias expresiones lógicas y saber si todas ellas son verdaderas. Será suficiente con que cualquiera de las expresiones sea falsa para que el resultado de la función también sea FALSO.

Sintaxis:

La fórmula Y se llama por la siguiente sintaxis:

=Y (valor_lógico1; valor_lógico2)

Pueden haber tantas pruebas lógicas como queramos, solo tendríamos que añadirlas por orden separadas por “;”. Se pueden poner entre 1 y 255 pruebas lógicas.

Donde:

§  valor_lógico1: Obligatorio. Es obligatoria al menos una prueba lógica. Esta prueba puede ser desde una desigualdad matemática, B3>=1, hasta una prueba de cadenas o más complejo: LARGO(A2)>7. Esta prueba lógica será VERDADERO si se cumple y FALSO en caso contrario.

§  valor_lógico2: Opcional. El segundo valor lógico es opcional, aunque no tiene mucho sentido la función Y con solo una prueba lógica.

§  … Opcional. Podemos utilizar tantas pruebas lógicas como queramos, con los únicos requisitos de que no pueden ser más de 255 y que tienen que ir separadas en la sintaxis por “;”

La función O en Excel

La función O es una de las funciones lógicas de Excel y como cualquier otra función lógica solamente devuelve los valores VERDADERO o FALSO después de haber

Sintaxis:

La sintaxis de la fórmula O es la siguiente:

=O (valor_lógico1; valor_lógico2)

Se pueden utilizar tantas pruebas lógicas como queramos (hasta un límite de 255). Todas las pruebas lógicas deben ir separadas por un punto y coma: “;”.

Donde:

§  valor_lógico1: Obligatorio. Es obligatoria al menos una prueba lógica. Podemos utilizar cualquier función, desde una desigualdad de una otra celda a una función de cadena o incluso una igualdad interior 2+2=4. Esta prueba lógica será VERDADERO si se cumple y FALSO en caso contrario.

§  valor_lógico2: Opcional. El segundo valor lógico es opcional, aunque no tiene mucho sentido la función O de Excel con solo una prueba lógica.

§  … Opcional. Podemos utilizar tantas pruebas lógicas como queramos, con los únicos requisitos de que no pueden ser más de 255 y que tienen que ir separadas en la sintaxis por “;”

evaluado las expresiones lógicas que se hayan colocado como argumentos.

La función CONTAR.SI en Excel

La función CONTAR.SI en Excel nos da la oportunidad de contar el número de celdas de un rango que cumplan con un criterio establecido. Solamente cuando el valor de dichas celdas cumple la condición es considerada dentro de la cuenta.

La función contar.si en excel se escribe con la siguiente sintaxis:

=CONTAR.SI(rango,criterio)

El rango es el conjunto de celdas que serán consideradas para realizar la cuenta, es decir aquellas que tiene los valores que desamos contabilizar siempre y cuando cumplan con el criterio es la condición que deberá cumplir una celda para ser contabilizada.