Pastebin.vip

Java billiard game -- simulated billiard strike processing and drawing

From , 3 Years ago, written in Java, viewed 192 times.
URL https://pastebin.vip/view/17c276c8
  1. import java.awt.Color;
  2. import java.awt.Frame;
  3. import java.awt.Graphics;
  4. import java.awt.Image;
  5. import java.awt.Panel;
  6. import java.awt.event.MouseEvent;
  7. import java.awt.event.MouseListener;
  8. import java.awt.event.MouseMotionListener;
  9. import java.awt.event.WindowAdapter;
  10. import java.awt.event.WindowEvent;
  11. import java.awt.image.BufferedImage;
  12.  
  13. /** */
  14. /**
  15.  * <p>
  16.  * Title: LoonFramework
  17.  * </p>
  18.  * <p>
  19.  * Description:Java桌球演示
  20.  * </p>
  21.  * <p>
  22.  * Copyright: Copyright (c) 2007
  23.  * </p>
  24.  * <p>
  25.  * Company: LoonFramework
  26.  * </p>
  27.  * http://cping1982.blog.51cto.com/601635/130098
  28.  * @author chenpeng
  29.  * @email：ceponline@yahoo.com.cn
  30.  * @version 0.1
  31.  */
  32.  
  33. public class JavaBilliards extends Panel implements Runnable, MouseListener,
  34.                 MouseMotionListener {
  35.  
  36.         /** */
  37.         /**
  38.      *
  39.      */
  40.         private static final long serialVersionUID = -5019885590391523441L;
  41.  
  42.         // 球
  43.         private double _ball;
  44.  
  45.         // 缓存用背景
  46.         private Image _screen;
  47.  
  48.         // 画布
  49.         private Graphics _graphics;
  50.  
  51.         // 台桌
  52.         private Image _table;
  53.  
  54.         private double c[];
  55.  
  56.         private double d[];
  57.  
  58.         private double e[];
  59.  
  60.         private double f[];
  61.  
  62.         private int countBall;
  63.  
  64.         private int h;
  65.  
  66.         private double i[];
  67.  
  68.         private double j[];
  69.  
  70.         private double k[];
  71.  
  72.         private double l[];
  73.  
  74.         private double m[];
  75.  
  76.         private double n[];
  77.  
  78.         private double o[];
  79.  
  80.         private double p[];
  81.  
  82.         private boolean q[];
  83.  
  84.         private double r;
  85.  
  86.         private int a;
  87.  
  88.         private int u;
  89.  
  90.         private int v;
  91.  
  92.         private int w;
  93.  
  94.         private int x;
  95.  
  96.         private boolean y;
  97.  
  98.         private int z;
  99.  
  100.         private int A;
  101.  
  102.         /** */
  103.         /**
  104.          * 初始化
  105.          *
  106.          */
  107.         public JavaBilliards() {
  108.                 a = 0;
  109.                 r = 10D;
  110.                 z = 300;
  111.                 A = 0;
  112.                 setBounds(50, 50, 700, 350);
  113.                 Frame frame = new Frame("Java桌球演示");
  114.                 frame.add(this);
  115.                 frame.setBounds(0, 0, 700, 380);
  116.                 frame.setResizable(false);
  117.                 frame.setVisible(true);
  118.                 frame.addWindowListener(new WindowAdapter() {
  119.                         public void windowClosing(WindowEvent e) {
  120.                                 System.exit(0);
  121.                         }
  122.                 });
  123.                 requestFocus();
  124.                 initialize();
  125.         }
  126.  
  127.         public void initialize() {
  128.                 // 基础数据
  129.                 base();
  130.                 // 注入实例
  131.                 immit();
  132.                 // 缓存背景
  133.                 _screen = new BufferedImage(this.getWidth(), this.getHeight(), 1);
  134.                 // 背景图形
  135.                 _graphics = _screen.getGraphics();
  136.                 // 绘制台桌
  137.                 makeTable();
  138.                 // 设置监听
  139.                 addMouseListener(this);
  140.                 addMouseMotionListener(this);
  141.                 // 启动
  142.                 new Thread(this).start();
  143.         }
  144.  
  145.         /** */
  146.         /**
  147.          * 初始化数据
  148.          *
  149.          */
  150.         public void base() {
  151.  
  152.                 // 球体
  153.                 _ball = 16D;
  154.                 c = (new double[] { 40D, (double) (getWidth() - 40) });
  155.                 d = (new double[] { c[0], (double) getHeight() - c[0] });
  156.                 e = (new double[] { c[0] + 20D, (double) (getWidth() / 2), c[1] - 20D });
  157.                 f = (new double[] { d[0] + 20D, d[1] - 20D });
  158.         }
  159.  
  160.         /** */
  161.         /**
  162.          * 注入实例
  163.          *
  164.          */
  165.         public void immit() {
  166.                 countBall = 16;
  167.                 i = new double[countBall];
  168.                 j = new double[countBall];
  169.                 k = new double[countBall];
  170.                 l = new double[countBall];
  171.                 m = new double[countBall];
  172.                 n = new double[countBall];
  173.                 o = new double[countBall];
  174.                 p = new double[countBall];
  175.                 q = new boolean[countBall];
  176.                 // 打击对象
  177.                 hitObject();
  178.                 // 打击用球
  179.                 hitBall();
  180.         }
  181.  
  182.         /** */
  183.         /**
  184.          * 打击用球数值
  185.          *
  186.          */
  187.         public void hitBall() {
  188.                 i[0] = (1.0D * (e[2] - e[0])) / 3D;
  189.                 j[0] = this.getHeight() / 2;
  190.                 k[0] = 0.0D;
  191.                 l[0] = 0.0D;
  192.                 q[0] = true;
  193.         }
  194.  
  195.         /** */
  196.         /**
  197.          * 打击对象
  198.          *
  199.          */
  200.         public void hitObject() {
  201.                 int il = 1;
  202.                 h = countBall - 1;
  203.                 // 求平方根
  204.                 double dl = Math.sqrt(3.5D);
  205.                 for (int j1 = 0; j1 < 5; j1++) {
  206.                         double d2 = ((double) getWidth() * 2D) / 3D + (double) j1 * dl * r;
  207.                         double d3 = (double) (getHeight() / 2) - (double) j1 * r;
  208.                         for (int k1 = 0; k1 <= j1; k1++) {
  209.                                 i[il] = d2;
  210.                                 j[il] = d3;
  211.                                 k[il] = 0.0D;
  212.                                 l[il] = 0.0D;
  213.                                 q[il] = true;
  214.                                 d3 += 2D * r;
  215.                                 il++;
  216.                         }
  217.  
  218.                 }
  219.  
  220.         }
  221.  
  222.         /** */
  223.         /**
  224.          * 绘制台球桌
  225.          *
  226.          */
  227.         public void makeTable() {
  228.                 _table = new BufferedImage(this.getWidth(), this.getHeight(), 1);
  229.                 Graphics g = _table.getGraphics();
  230.                 g.setColor(Color.GRAY);
  231.                 g.fillRect(0, 0, getWidth(), getHeight());
  232.                 g.setColor((new Color(200, 100, 50)).darker());
  233.                 g.fill3DRect((int) c[0], (int) d[0], (int) (c[1] - c[0]),
  234.                                 (int) (d[1] - d[0]), true);
  235.                 g.setColor(Color.BLACK);
  236.                 g.fill3DRect((int) e[0], (int) f[0], (int) (e[2] - e[0]),
  237.                                 (int) (f[1] - f[0]), false);
  238.                 g.setColor(Color.GREEN.darker());
  239.                 g.drawLine((int) ((1.0D * (e[2] - e[0])) / 3D), (int) f[0],
  240.                                 (int) ((1.0D * (e[2] - e[0])) / 3D), (int) f[1]);
  241.                 g.fillOval((int) ((1.0D * (e[2] - e[0])) / 3D) - 2,
  242.                                 (int) ((f[1] + f[0]) / 2D) - 2, 4, 4);
  243.                 g.drawArc((int) ((1.0D * (e[2] - e[0])) / 3D) - 20,
  244.                                 (int) ((f[1] + f[0]) / 2D) - 20, 40, 40, 90, 180);
  245.                 g.setColor(Color.BLACK);
  246.                 double d1 = _ball - 2D;
  247.                 for (int i1 = 0; i1 < 3; i1++) {
  248.                         for (int j1 = 0; j1 < 2; j1++) {
  249.                                 g.fillOval((int) (e[i1] - d1), (int) (f[j1] - d1),
  250.                                                 (int) (2D * d1), (int) (2D * d1));
  251.                         }
  252.                 }
  253.         }
  254.  
  255.         /** */
  256.         /**
  257.          * 线程处理
  258.          */
  259.         public void run() {
  260.                 long timeStart;
  261.                 timeStart = System.currentTimeMillis();
  262.                 // 死循环反复处理
  263.                 for (;;) {
  264.                         long timeEnd = System.currentTimeMillis();
  265.                         switch (a) {
  266.                         default:
  267.                                 break;
  268.  
  269.                         case 1:
  270.                                 // 根据时间换算运动轨迹
  271.                                 conversion(timeEnd - timeStart);
  272.                                 // 过程处理
  273.                                 course();
  274.                                 break;
  275.  
  276.                         case 2:
  277.                                 conversion(timeEnd - timeStart);
  278.                                 // 过程处理
  279.                                 course();
  280.                                 boolean flag = true;
  281.                                 for (int i1 = 0; flag && i1 < countBall; i1++)
  282.                                         flag = k[i1] == 0.0D && l[i1] == 0.0D;
  283.  
  284.                                 if (flag) {
  285.                                         a = 1;
  286.                                         // 击球
  287.                                         if (!q[0]) {
  288.                                                 hitBall();
  289.                                         }
  290.                                 }
  291.                                 if (h == 0)
  292.                                         a = 3;
  293.                                 break;
  294.  
  295.                         case 3:
  296.                                 hitObject();
  297.                                 hitBall();
  298.                                 a = 0;
  299.                                 break;
  300.                         }
  301.  
  302.                         repaint();
  303.                         timeStart = timeEnd;
  304.                         try {
  305.                                 Thread.sleep(10L);
  306.                         } catch (InterruptedException e1) {
  307.                                 e1.printStackTrace();
  308.                         }
  309.                 }
  310.  
  311.         }
  312.  
  313.         public void course() {
  314.                 // 限制区域
  315.                 limit();
  316.                 // 入袋处理
  317.                 pocket();
  318.                 // 运动演算
  319.                 play();
  320.                 for (int i1 = 0; i1 < countBall; i1++)
  321.                         if (q[i1]) {
  322.                                 i[i1] = m[i1];
  323.                                 j[i1] = n[i1];
  324.                         }
  325.         }
  326.  
  327.         /** */
  328.         /**
  329.          * 变换时间为动作数据
  330.          *
  331.          * @param value
  332.          */
  333.         public void conversion(long value) {
  334.                 double d1 = (double) value / 1000D;
  335.                 for (int i1 = 0; i1 < countBall; i1++)
  336.                         if (q[i1]) {
  337.                                 m[i1] = i[i1] + k[i1] * d1;
  338.                                 n[i1] = j[i1] + l[i1] * d1;
  339.                                 k[i1] *= 0.98999999999999999D;
  340.                                 l[i1] *= 0.98999999999999999D;
  341.                                 if (Math.abs(Math.hypot(k[i1], l[i1])) < 2D) {
  342.                                         k[i1] = 0.0D;
  343.                                         l[i1] = 0.0D;
  344.                                 }
  345.                         }
  346.  
  347.         }
  348.  
  349.         public void pocket() {
  350.                 for (int i1 = 0; i1 < countBall; i1++)
  351.                         if (q[i1]) {
  352.                                 for (int j1 = 0; j1 < 3; j1++) {
  353.                                         for (int k1 = 0; k1 < 2; k1++)
  354.                                                 if (Math.hypot(e[j1] - i[i1], f[k1] - j[i1]) < _ball) {
  355.                                                         q[i1] = false;
  356.                                                         if (i1 != 0) {
  357.                                                                 h--;
  358.                                                         }
  359.                                                         k[i1] = 0.0D;
  360.                                                         l[i1] = 0.0D;
  361.                                                 }
  362.  
  363.                                 }
  364.  
  365.                         }
  366.  
  367.         }
  368.  
  369.         public void play() {
  370.                 for (int i1 = 0; i1 < countBall; i1++)
  371.                         if (q[i1]) {
  372.                                 for (int j1 = i1 + 1; j1 < countBall; j1++) {
  373.                                         boolean flag;
  374.                                         if (q[j1] && (flag = randball(i1, j1))) {
  375.                                                 for (int k1 = 0; k1 < 10 && flag; k1++) {
  376.                                                         m[i1] = (m[i1] + i[i1]) / 2D;
  377.                                                         n[i1] = (n[i1] + j[i1]) / 2D;
  378.                                                         m[j1] = (m[j1] + i[j1]) / 2D;
  379.                                                         n[j1] = (n[j1] + j[j1]) / 2D;
  380.                                                         flag = randball(i1, j1);
  381.                                                 }
  382.  
  383.                                                 if (flag) {
  384.                                                         m[i1] = i[i1];
  385.                                                         n[i1] = j[i1];
  386.                                                         m[j1] = i[j1];
  387.                                                         n[j1] = j[j1];
  388.                                                 }
  389.                                                 double d1 = m[j1] - m[i1];
  390.                                                 double d2 = n[j1] - n[i1];
  391.                                                 double d3 = Math.hypot(m[i1] - m[j1], n[i1] - n[j1]);
  392.                                                 double d4 = d1 / d3;
  393.                                                 double d5 = d2 / d3;
  394.                                                 o[j1] = k[j1] - k[j1] * d4 * d4;
  395.                                                 o[j1] -= l[j1] * d4 * d5;
  396.                                                 o[j1] += k[i1] * d4 * d4;
  397.                                                 o[j1] += l[i1] * d4 * d5;
  398.                                                 p[j1] = l[j1] - l[j1] * d5 * d5;
  399.                                                 p[j1] -= k[j1] * d4 * d5;
  400.                                                 p[j1] += k[i1] * d4 * d5;
  401.                                                 p[j1] += l[i1] * d5 * d5;
  402.                                                 o[i1] = k[i1] - k[i1] * d4 * d4;
  403.                                                 o[i1] -= l[i1] * d4 * d5;
  404.                                                 o[i1] += k[j1] * d4 * d4;
  405.                                                 o[i1] += l[j1] * d4 * d5;
  406.                                                 p[i1] = l[i1] - l[i1] * d5 * d5;
  407.                                                 p[i1] -= k[i1] * d4 * d5;
  408.                                                 p[i1] += k[j1] * d4 * d5;
  409.                                                 p[i1] += l[j1] * d5 * d5;
  410.                                                 k[i1] = o[i1];
  411.                                                 l[i1] = p[i1];
  412.                                                 k[j1] = o[j1];
  413.                                                 l[j1] = p[j1];
  414.                                         }
  415.                                 }
  416.  
  417.                         }
  418.  
  419.         }
  420.  
  421.         public boolean randball(int i1, int j1) {
  422.                 // hypot随机决定两值之一
  423.                 return Math.hypot(m[i1] - m[j1], n[i1] - n[j1]) < 2D * r;
  424.         }
  425.  
  426.         /** */
  427.         /**
  428.          * 限制区域
  429.          *
  430.          */
  431.         public void limit() {
  432.                 for (int i = 0; i < countBall; i++)
  433.                         if (q[i]) {
  434.                                 if (m[i] - r < e[0]) {
  435.                                         m[i] = e[0] + r;
  436.                                         k[i] *= -1D;
  437.                                 } else if (m[i] + r > e[2]) {
  438.                                         m[i] = e[2] - r;
  439.                                         k[i] *= -1D;
  440.                                 }
  441.                                 if (n[i] - r < f[0]) {
  442.                                         n[i] = f[0] + r;
  443.                                         l[i] *= -1D;
  444.                                 } else if (n[i] + r > f[1]) {
  445.                                         n[i] = f[1] - r;
  446.                                         l[i] *= -1D;
  447.                                 }
  448.                         }
  449.  
  450.         }
  451.  
  452.         public void makeScreen(Graphics screenGraphics) {
  453.  
  454.                 screenGraphics.drawImage(_table, 0, 0, null);
  455.                 if (q[0]) {
  456.                         _graphics.setColor(Color.WHITE);
  457.                         _graphics.fillOval((int) (i[0] - r), (int) (j[0] - r),
  458.                                         (int) (r * 2D), (int) (r * 2D));
  459.                 }
  460.                 screenGraphics.setColor(Color.RED);
  461.                 for (int i1 = 1; i1 < countBall; i1++)
  462.                         if (q[i1])
  463.                                 screenGraphics.fillOval((int) (i[i1] - r), (int) (j[i1] - r),
  464.                                                 (int) (r * 2D), (int) (r * 2D));
  465.  
  466.                 screenGraphics.setColor(Color.BLACK);
  467.                 for (int j1 = 0; j1 < countBall; j1++)
  468.                         if (q[j1]) {
  469.                                 screenGraphics.drawOval((int) (i[j1] - r), (int) (j[j1] - r),
  470.                                                 (int) (r * 2D), (int) (r * 2D));
  471.                         }
  472.  
  473.                 if (a == 1) {
  474.                         makeHelper(screenGraphics);
  475.                 }
  476.                 if (a == 0) {
  477.                         int k1 = getWidth() / 2 - 85;
  478.                         int l1 = getHeight() / 2;
  479.                         screenGraphics.setColor(Color.BLACK);
  480.                         screenGraphics.drawString("点击画面开始", k1 + 2, l1 + 2);
  481.                         if ((System.currentTimeMillis() / 1000L & 1L) == 0L) {
  482.                                 screenGraphics.setColor(Color.YELLOW);
  483.                         } else {
  484.                                 screenGraphics.setColor(Color.CYAN);
  485.                         }
  486.                         screenGraphics.drawString("点击画面开始", k1, l1);
  487.                 }
  488.         }
  489.  
  490.         /** */
  491.         /**
  492.          * 绘制球杆及辅助线
  493.          *
  494.          * @param screenGraphics
  495.          */
  496.         public void makeHelper(Graphics screenGraphics) {
  497.                 double d1 = Math.hypot(i[0] - (double) u, j[0] - (double) v);
  498.                 double d2 = ((double) u - i[0]) / d1;
  499.                 double d3 = ((double) v - j[0]) / d1;
  500.                 double d4 = y ? n() / 10D : 1.0D;
  501.                 double d5 = i[0] + d2 * (r + d4);
  502.                 double d6 = i[0] + d2 * (r + (double) z + d4);
  503.                 double d7 = j[0] + d3 * (r + d4);
  504.                 double d8 = j[0] + d3 * (r + (double) z + d4);
  505.                 screenGraphics.setColor(Color.ORANGE);
  506.                 screenGraphics.drawLine((int) d5, (int) d7, (int) d6, (int) d8);
  507.                 int i1 = 0;
  508.                 int j1 = y ? (int) (150D * (d4 / 1000D)) : 15;
  509.                 double d9;
  510.                 double d10 = (d9 = 30D) * d2;
  511.                 double d11 = d9 * d3;
  512.                 double d12 = i[0] + (double) A * d2;
  513.                 double d13 = j[0] + (double) A * d3;
  514.                 A--;
  515.                 A %= d9;
  516.                 screenGraphics.setColor(Color.WHITE);
  517.                 for (; i1 < j1; i1++) {
  518.                         if (d12 < e[0]) {
  519.                                 d12 = e[0] - d12;
  520.                                 d12 = e[0] + d12;
  521.                                 d10 *= -1D;
  522.                         } else if (d12 > e[2]) {
  523.                                 d12 -= e[2];
  524.                                 d12 = e[2] - d12;
  525.                                 d10 *= -1D;
  526.                         }
  527.                         if (d13 < f[0]) {
  528.                                 d13 = f[0] - d13;
  529.                                 d13 = f[0] + d13;
  530.                                 d11 *= -1D;
  531.                         } else if (d13 > f[1]) {
  532.                                 d13 -= f[1];
  533.                                 d13 = f[1] - d13;
  534.                                 d11 *= -1D;
  535.                         }
  536.                         screenGraphics.fillOval((int) d12 - 2, (int) d13 - 2, 4, 4);
  537.                         d12 -= d10;
  538.                         d13 -= d11;
  539.                 }
  540.  
  541.         }
  542.  
  543.         public double n() {
  544.                 if (y) {
  545.                         return Math.min(1000D,
  546.                                         10D * Math.hypot(i[0] - (double) w, j[0] - (double) x));
  547.                 } else {
  548.                         return Math.min(1000D, 10D * Math.hypot(u - w, v - x));
  549.                 }
  550.         }
  551.  
  552.         public void update(Graphics g) {
  553.                 paint(g);
  554.         }
  555.  
  556.         public void paint(Graphics g) {
  557.                 makeScreen(_graphics);
  558.                 g.drawImage(_screen, 0, 0, null);
  559.         }
  560.  
  561.         public void mousePressed(MouseEvent mouseevent) {
  562.                 y = true;
  563.         }
  564.  
  565.         public void mouseReleased(MouseEvent mouseevent) {
  566.                 if (a == 1) {
  567.                         double d1 = Math.hypot(i[0] - (double) u, j[0] - (double) v);
  568.                         double d2 = (i[0] - (double) u) / d1;
  569.                         double d3 = (j[0] - (double) v) / d1;
  570.                         double d4;
  571.                         if ((d4 = n()) > 0.0D) {
  572.                                 a = 2;
  573.                                 k[0] = d4 * d2;
  574.                                 l[0] = d4 * d3;
  575.                         }
  576.                 }
  577.                 y = false;
  578.         }
  579.  
  580.         public void mouseClicked(MouseEvent mouseevent) {
  581.                 if (a == 0)
  582.                         a = 1;
  583.         }
  584.  
  585.         public void mouseEntered(MouseEvent mouseevent) {
  586.         }
  587.  
  588.         public void mouseExited(MouseEvent mouseevent) {
  589.         }
  590.  
  591.         public void mouseMoved(MouseEvent mouseevent) {
  592.                 w = mouseevent.getX();
  593.                 x = mouseevent.getY();
  594.                 u = w;
  595.                 v = x;
  596.         }
  597.  
  598.         public void mouseDragged(MouseEvent mouseevent) {
  599.                 w = mouseevent.getX();
  600.                 x = mouseevent.getY();
  601.         }
  602.  
  603.         public static void main(String args[]) {
  604.                 new JavaBilliards();
  605.         }
  606.  
  607. }

Reply to "Java billiard game -- simulated billiard strike processing and drawing"

Here you can reply to the paste above

captcha

https://burned.cc - Burn After Reading Website
Powered by Pastebin.vip paste tool since 2022!