Visualizzazione dei risultati da 1 a 7 su 7
  1. #1

    [JAVA] Scacchi 3D e/o Costruzione di una figura/superficie geometrica 3D

    Mi è balenata in mente l'ipotesi di una scacchiera 3D;
    tuttavia rendere visibile e contemporaneamente chiaro il movimento delle pedine in 3D non risulta pratico e facile.
    Il codice lo condivido volentieri per chi volesse aiutarmi a miglioralo.

    E' chiaro che lo stesso codice con opportune modifiche(apportate) è in grado di disegnare una superficie(ad esempio parametrica, qui un toro).

    Il mio scopo è di migliorare il codice per 2 fini:
    1) Rendere chiare le superfici 3D (ammesso che l'esempio qui di seguito risulta valido in termini di memoria utilizzata)
    2) Trovare idee per rappresentare delle pedine nello spazio al fine di realizzare un semplice gioco di scacchi 3D(Cioè in cui le pedine si possano muovere nello spazio e non come nello scacchi usuale su 2 dimensioni)

    Di seguito il codice:

    codice:
        
        import java.awt.*;    
        import java.awt.Graphics;
        import java.awt.Image;
        import javax.swing.*;
        import javax.imageio.ImageIO;
        import java.awt.image.BufferedImage;
        import java.io.File;
        import java.io.FileNotFoundException;
        import java.awt.event.*;
          
        public class Draw extends JFrame {
        
        
           public static void main(String [] args) {                           
                    
                    SwingUtilities.invokeLater(() -> new Draw().setVisible(true));
                                     
    
           }  
          
           
           public Draw(){
           
            setSize(800, 800);                  
                                        
            setVisible(true); 
            
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                            
            add(new Pannello());
    
                    
           } 
           
     
       }
       
      
       //Classe Pedina è l'elemento che si sposta nelle 3 Dimensioni a scatti.    
       class Pedina{ 
           
           //Valori di riferimento relativi al poligono(vedere immagine assonometria-isometrica)
         private int LX = 52;
            private int LY = 52;                                   
            private int LZ = 60;
            
            private double X; private double Y; private double Z;
            
            private String Name = "";
           
           private Color Col;
           
           private Polygon p;
           
           private Point[] P = new Point[4];
           private Point[] A = new Point[4];
           
           String getName() {
               return Name;
        }
        
        double getX() {
               return X;
        }
        double getY() {
               return Y;
        }
        double getZ() {
               return Z;
        }
        Point[] getP() {
               return P;
        }
        //Serve a centrare il poligono
        Point getC() {
               return new Point((P[0].x+P[2].x)/2,(P[0].y+P[2].y)/2);
        }
            
        void setX(double X) {
               this.X = X;
        }
         void setY(double Y) {
               this.Y = Y;
        }
        void setZ(double Z) {
               this.Z = Z;
        }
        
        void setXYZ(double X, double Y, double Z) {
            this.X = X;
            this.Y = Y;
            this.Z = Z;
        }
    
    
        void Scala(int n){
        
                for(int k=0; k<n; k++){
            
                A[1].x=A[0].x/2+A[1].x/2;
                   A[1].y=A[0].y/2+A[1].y/2;               
                   
                   A[3].x=A[0].x/2+A[3].x/2;
                   A[3].y=A[0].y/2+A[3].y/2;
                   
                   A[2].x=A[0].x/2+A[2].x/2;
                   A[2].y=A[0].y/2+A[2].y/2;
               
                   
                   }
            
        }
           
           Pedina(String name, double X, double Y, double Z, Color col){
           
                         
                   //I punti A[] sono gli estremi del parallelogramma(poligono/pedina) 
                   //rappresentato
                       
                     A[0] = new Point(222,250);
                   A[1] = new Point(275,275);
                   A[2] = new Point(222,300);
                   A[3] = new Point(170,275);                                
                   
                   Scala(4); //Scala la pedina di n=4(in tal caso) fattori
                          
                   setX(X); setY(Y); setZ(Z);
    
                    
                P[0] = new Point((int)(A[0].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[0].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ));  
                         
                    P[1] = new Point((int)(A[1].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[1].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ));  
                             
                    P[2] = new Point((int)(A[2].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[2].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ)); 
                             
                      P[3] = new Point((int)(A[3].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[3].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ));  
                             
                    p = new Polygon();
                    
                    
                    p.addPoint(P[0].x,P[0].y);   
                    p.addPoint(P[1].x,P[1].y); 
                    p.addPoint(P[2].x,P[2].y); 
                    p.addPoint(P[3].x,P[3].y); 
                    
                    Col = col;
                    Name = name;
                    
        }      
        
        //Funzione che cambia la posizione della pedina:
        
        void changePosition(){
        
            
                P[0] = new Point((int)(A[0].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[0].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ));  
                         
                    P[1] = new Point((int)(A[1].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[1].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ));  
                             
                    P[2] = new Point((int)(A[2].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[2].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ)); 
                             
                      P[3] = new Point((int)(A[3].x-LX*(X-1)+(Y-1)*LX),
                         (int)(A[3].y+(X-1)*LY/2+LY/2*(Y-1)-(Z-1)*LZ));  
                        
                    p = new Polygon();
                    
                          p.addPoint(P[0].x,P[0].y);   
                    p.addPoint(P[1].x,P[1].y); 
                    p.addPoint(P[2].x,P[2].y); 
                    p.addPoint(P[3].x,P[3].y);
        }
        
        //Funzioni per il recupero del poligono/colore
        public Polygon getPXYZ(){return p; }
        public Color getCol(){return Col; }
           
       }
       
       class Pannello extends JPanel {
       
        Pedina Pedina;
       
        //Campi di testo per modifica posizione pedina manualmente(per uso in scacchi)
        JTextField TX;
        JTextField TY;
        JTextField TZ;
        
        JButton B;
           
        double X0 = 1.0; double Y0 = 1.0; double Z0 = 1.0;    
         
       
            Pannello(){
            
                JLabel     LX = new JLabel("X:");
                            LX.setVisible(true);
                            LX.setLocation(400,500);    
                            LX.setSize(100,25);
                            
                          TX = new JTextField("1.0");
                            TX.setVisible(true);
                            TX.setLocation(500,500);    
                            TX.setSize(100,25);
    
            JLabel     LY = new JLabel("Y:");   
                        LY.setVisible(true);
                            LY.setLocation(400,535);    
                            LY.setSize(100,25);    
                                            
                         TY = new JTextField("1.0");
                            TY.setVisible(true);
                            TY.setLocation(500,535);    
                            TY.setSize(100,25);
    
            JLabel     LZ = new JLabel("Z:");    
                        LZ.setVisible(true);
                            LZ.setLocation(400,570);    
                            LZ.setSize(100,25);
                                                
                         TZ = new JTextField("1.0");
                            TZ.setVisible(true);
                            TZ.setLocation(500,570);    
                            TZ.setSize(100,25);     
                            
                    B = new JButton("Imposta");
                            B.setVisible(true);
                            B.setLocation(500,590);    
                            B.setSize(100,25);           
                
                this.setLayout(null);       
                
                this.add(LX);
                this.add(LY);
                this.add(LZ);
                
                this.add(TX);
                this.add(TY);
                this.add(TZ); 
    
                                                  
                B.addActionListener(new load_XYZ());                       
                
                this.add(B);
                
                Pedina = new Pedina("Pedina", X0,Y0,Z0, new Color(0,0,255));
                                           
            
            }
            
            private class load_XYZ implements ActionListener {
                
            public void actionPerformed(ActionEvent e) { 
            
                X0 = Double.parseDouble(TX.getText());    
                Y0 = Double.parseDouble(TY.getText());
                Z0 = Double.parseDouble(TZ.getText());
                
                Pedina.setXYZ(X0,Y0,Z0);
                Pedina.changePosition();        
                    
                repaint();                    
                                                                                                            
            }
                
          }
     
       
            @Override
            protected void paintComponent(Graphics g) {
            
                super.paintComponent(g);                                    
                                    
                //Percorso File immagine Isometrica(allegata)              
            String fileName = "/cartella_immagini/.../ass-isometrica.png";
            
            BufferedImage image = new
            BufferedImage(800,800,BufferedImage.TYPE_INT_RGB);
            
            try { 
            
            image = ImageIO.read(new File(fileName));
            
            g.drawImage(image, 0, 0, null);
            
            } catch(Exception e) {
                System.out.println(e);
            }
            
            double k=0.0628;
            double j=0.0628;
            int n=100; 
            int m=0;
            int q=0; 
            
            double r=0.25; double R=1;
            
            for(double v=0; v<=6.28; v+=j){                    
                                            
                for(double u=0; u<=6.28; u+=k){    
                                                
                    //Cordinate parametriche per rappresentare il toro:
                    X0 = (R+r*Math.cos(v))*Math.cos(u);
                    Y0 = (R+r*Math.cos(v))*Math.sin(u);
                    Z0 = r*Math.sin(v);
                                                                    
                          Pedina.setXYZ(X0,Y0,Z0);
                        
                        Pedina.changePosition();  
                                       
                        //*Esempio di vaiazione del colore(da migliorare):                        
                        g.setColor(new Color(m%255,n%255,0));    
                                                               
                        n++;  
                                          
                        g.fillPolygon(Pedina.getPXYZ()); 
                        
                                                     
                         
                    }       
                    
                    m++;
                    
                  
                        
                }
                
     
                
            }
                    
    
            
        }
    https://ibb.co/Cm2BpCG //link immagine

    Spero di migliorarlo col vostro aiuto
    Ultima modifica di jabjoint; 23-06-2022 a 17:40
    jabjoint

  2. #2
    Utente di HTML.it L'avatar di linoma
    Registrato dal
    Mar 2010
    Messaggi
    1,346
    intanto cambierei scacchi in dama. Se vuoi fare un engine 3d piuttosto che un gioco proverei ad usare trinagoli cm mesh. In alternativa userei un engine 3d bello e pronto
    Per gli Spartani e Sparta usa spartan Il mio github

  3. #3
    Quote Originariamente inviata da linoma Visualizza il messaggio
    intanto cambierei scacchi in dama. Se vuoi fare un engine 3d piuttosto che un gioco proverei ad usare trinagoli cm mesh. In alternativa userei un engine 3d bello e pronto
    .
    Ciao e grazie,
    I triangoli rendono un miglior effetto dei poligoni pensi?
    Hai testato il codice?
    Inoltre penso che sarebbe da colorare in modo appropriato per dare un buon effetto.
    Dama o scacchi, non trovo differenza per rappresentarli.
    jabjoint

  4. #4
    Utente di HTML.it L'avatar di linoma
    Registrato dal
    Mar 2010
    Messaggi
    1,346
    Triangolo o quadrato anche nel dettaglio del modello da renderizzare ha un peso differente. Nell'egne vero e proprio ancora di più solo a pensare che un quadrato sn 2 triangoli gia riesci a farti un idea. Il cambio gioco è x facilitare appunto i modelli da utilizzare. Considera che poi ce la sovrapposizione degli oggetti anche nella terza dimensione che va fatto via software che in 2d volgarmente viene fatto da una sovrascrittura quindi l'obbligo di riordinare prima le meshs e poi renderizzare. Cmq ripeto il mio consiglio se vuoi fare qualcosa di 3d devi utilizzare un engine che ti faciliti perlomeno nella gestione dei diversi tipi di vertici e meshs e loro attributi a proposito puoi usare mesa ma io ho rinunciato ��

    Certo ho provato il codice...compilato e provato velocemente..preferivo una vera scacchiera ma capire solo il codice è un lavoraccio uso java solo ch il catasto ��
    Ultima modifica di linoma; 24-06-2022 a 11:09
    Per gli Spartani e Sparta usa spartan Il mio github

  5. #5
    Se vedi il codice ti accordi che il 3D è fatto.
    Quel che è difficile per scacchi è di visualizzare piu' pedine.
    Forse intendi ruotare la grafica tu per facilitarmi?
    Ultima modifica di jabjoint; 24-06-2022 a 20:50
    jabjoint

  6. #6
    Utente di HTML.it L'avatar di linoma
    Registrato dal
    Mar 2010
    Messaggi
    1,346
    ...per ruotare un punto su un piano 2d anni fa usai https://github.com/linoma/fb4nds/blo...source/draws.c
    dsalla linea 797


    codice:
     
    y2 = yc + (((x1 * sn) + (y1 * cs)));
    x2 = xc + (((x1 * cs) - (y1 * sn)));
    dove cs e sn sono coseno e seno
    Per gli Spartani e Sparta usa spartan Il mio github

  7. #7
    Quote Originariamente inviata da linoma Visualizza il messaggio
    ...per ruotare un punto su un piano 2d anni fa usai https://github.com/linoma/fb4nds/blo...source/draws.c
    dsalla linea 797


    codice:
     
    y2 = yc + (((x1 * sn) + (y1 * cs)));
    x2 = xc + (((x1 * cs) - (y1 * sn)));
    dove cs e sn sono coseno e seno
    Lo testerò ok, in effetti basta applicare correttamente una semplice matematica.
    Grazie, chissà perché nemmeno ci ho pensato...
    jabjoint

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.