java / Lab1_1

import javax.swing.*;
import java.awt.*;
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
public class Sklad {

    public static void main(String[] args)
    {
        MainFrame frame = new MainFrame();
        frame.setResizable(false);
        Toolkit kit = Toolkit.getDefaultToolkit();
        Dimension screenSize = kit.getScreenSize();
        frame.setLocation(screenSize.width / 4, screenSize.height / 4);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
        try
        {
            frame.start();
        } catch (Exception e)
        {
            e.printStackTrace();
        }

    }
}

class MainFrame extends JFrame{
    public static final int WIDTH = 1000;
    public static final int HEIGHT = 1000;
    private JButton carSand;
    private JButton carWater;
    private JButton carFast;
    private JButton sklad ;
    private JButton sostav;

    // Объекты для поезда
    private JLabel labelTrainCountSand;
    private JTextField txtTrainCountSand;
    private JLabel labelTrainCountSandMax;
    private JTextField txtTrainCountSandMax;

    private JLabel labelTrainCountWater;
    private JTextField txtTrainCountWater;
    private JLabel labelTrainCountWaterMax;
    private JTextField txtTrainCountWaterMax;

    private JLabel labelTrainCountFast;
    private JTextField txtTrainCountFast;
    private JLabel labelTrainCountFastMax;
    private JTextField txtTrainCountFastMax;


    // Объекты для склада
    private JLabel labelSkladCountSand;
    private JTextField txtSkladCountSand;
    private JLabel labelSkladCountSandMax;
    private JTextField txtSkladCountSandMax;

    private JLabel labelSkladCountWater;
    private JTextField txtSkladCountWater;
    private JLabel labelSkladCountWaterMax;
    private JTextField txtSkladCountWaterMax;

    private JLabel labelSkladCountFast;
    private JTextField txtSkladCountFast;
    private JLabel labelSkladCountFastMax;
    private JTextField txtSkladCountFastMax;

    // Объекты для машин
    private JLabel labelCarCountSand;
    private JTextField txtCarCountSand;
    private JLabel labelCarCountSandMax;
    private JTextField txtCarCountSandMax;

    private JLabel labelCarCountWater;
    private JTextField txtCarCountWater;
    private JLabel labelCarCountWaterMax;
    private JTextField txtCarCountWaterMax;

    private JLabel labelCarCountFast;
    private JTextField txtCarCountFast;
    private JLabel labelCarCountFastMax;
    private JTextField txtCarCountFastMax;


    private static final int SKLAD_SAND = 10;  //склад сыпучих
    private static final int SKLAD_WATER = 10; // склад жидких
    private static final int SKLAD_FAST = 10; // склад скоропортящихся

    private static final int VAGON_SAND_WEIGHT = 50;    // вес вагона с сыпучим грузом в тоннах
    private static final int VAGON_WATER_VOLUME = 50;    //объем вагона с жижким грузом в кубометрах
    private static final int VAGON_FAST_WEIGHT = 50;    // вес вагона с скоропортящимися продуктами

    private static final int CAR_SAND_WEIGHT = 20;   //  вес автомобиля с сыпучим грузом в тоннах
    private static final int CAR_WATER_VOLUME = 20;   //  объем авто с жижким грузом в кубометрах
    private static final int CAR_FAST_WEIGHT = 20;   // вес авто  с скоропортящимися продуктами

    private int iCountVagonSand; //количество вагонов в текущем поезде
    private int iCountVagonWater;
    private int iCountVagonFast;

    private int iTrainCountSandMax; // сколько в поезд влезет сыпучих
    private int iTrainCountWaterMax;
    private int iTrainCountFastMax;

    private int iTrainCountSand; // сколько в поезд загружено сыпучих на данный момент
    private int iTrainCountWater;
    private int iTrainCountFast;

    private int iCarCountSand; // сколько в машине осталось сыпучих на данный момент
    private int iCarCountWater;
    private int iCarCountFast;

    private int iSkladCountSand; // сколько на склад загружено сыпучих на данный момент
    private int iSkladCountWater;
    private int iSkladCountFast;

    private ArrayBlockingQueue<Sand> sandContain;
    private ArrayBlockingQueue<Water> waterContain;
    private ArrayBlockingQueue<Fast> fastContain;

    private boolean TrainIsFull;
    private boolean CarSandIsEmpty;
    private boolean CarWaterIsEmpty;
    private boolean CarFastIsEmpty;

    public MainFrame()
    {
     //   Loader loader = new Loader();
        setTitle("SKLAD");
        setSize(WIDTH, HEIGHT);
        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(null);

        sandContain = new ArrayBlockingQueue<Sand>(SKLAD_SAND);
        waterContain = new ArrayBlockingQueue<Water>(SKLAD_WATER);
        fastContain = new ArrayBlockingQueue<Fast>(SKLAD_FAST);

        carSand = new JButton("SAND");
        carWater = new JButton("WATER");
        carFast = new JButton("FAST");
        sklad = new JButton("SKLAD");
        sostav = new JButton("TRAIN");


        // Инициализация объектов для поезда
        labelTrainCountSand = new JLabel("Сыпучие: ");
        txtTrainCountSand= new JTextField(25);
        labelTrainCountSandMax = new JLabel(" из ");
        txtTrainCountSandMax= new JTextField(25);

        labelTrainCountSand.setBounds(10,10,100,20);
        txtTrainCountSand.setBounds(115,10,30,20);
        labelTrainCountSandMax.setBounds(150,10,30,20);
        txtTrainCountSandMax.setBounds(185,10,30,20);

        labelTrainCountWater = new JLabel("Жидкие: ");
        txtTrainCountWater= new JTextField(25);
        labelTrainCountWaterMax = new JLabel(" из ");
        txtTrainCountWaterMax= new JTextField(25);

        labelTrainCountWater.setBounds(10,35,100,20);
        txtTrainCountWater.setBounds(115,35,30,20);
        labelTrainCountWaterMax.setBounds(150,35,30,20);
        txtTrainCountWaterMax.setBounds(185,35,30,20);

        labelTrainCountFast = new JLabel("Быстро порт.: ");
        txtTrainCountFast= new JTextField(25);
        labelTrainCountFastMax = new JLabel(" из ");
        txtTrainCountFastMax= new JTextField(25);

        labelTrainCountFast.setBounds(10,65,100,20);
        txtTrainCountFast.setBounds(115,65,30,20);
        labelTrainCountFastMax.setBounds(150,65,30,20);
        txtTrainCountFastMax.setBounds(185,65,30,20);


        // Инициализация объектов склада
        labelSkladCountSand = new JLabel("Сыпучие: ");
        txtSkladCountSand= new JTextField(25);
        labelSkladCountSandMax = new JLabel(" из ");
        txtSkladCountSandMax= new JTextField(25);

        labelSkladCountSand.setBounds(360,10,100,20);
        txtSkladCountSand.setBounds(465,10,30,20);
        labelSkladCountSandMax.setBounds(500,10,30,20);
        txtSkladCountSandMax.setBounds(535,10,30,20);

        labelSkladCountWater = new JLabel("Жидкие: ");
        txtSkladCountWater= new JTextField(25);
        labelSkladCountWaterMax = new JLabel(" из ");
        txtSkladCountWaterMax= new JTextField(25);

        labelSkladCountWater.setBounds(360,35,100,20);
        txtSkladCountWater.setBounds(465,35,30,20);
        labelSkladCountWaterMax.setBounds(500,35,30,20);
        txtSkladCountWaterMax.setBounds(535,35,30,20);

        labelSkladCountFast = new JLabel("Быстро порт.: ");
        txtSkladCountFast= new JTextField(25);
        labelSkladCountFastMax = new JLabel(" из ");
        txtSkladCountFastMax= new JTextField(25);

        labelSkladCountFast.setBounds(360,65,100,20);
        txtSkladCountFast.setBounds(465,65,30,20);
        labelSkladCountFastMax.setBounds(500,65,30,20);
        txtSkladCountFastMax.setBounds(535,65,30,20);

        txtSkladCountSandMax.setText(Integer.toString(SKLAD_SAND));
        txtSkladCountWaterMax.setText(Integer.toString(SKLAD_WATER));
        txtSkladCountFastMax.setText(Integer.toString(SKLAD_FAST));

        // Инициализация объектов машин
        labelCarCountSand = new JLabel("Сыпучие: ");
        txtCarCountSand= new JTextField(25);
        labelCarCountSandMax = new JLabel(" из ");
        txtCarCountSandMax= new JTextField(25);

        labelCarCountSand.setBounds(710,10,100,20);
        txtCarCountSand.setBounds(815,10,30,20);
        labelCarCountSandMax.setBounds(850,10,30,20);
        txtCarCountSandMax.setBounds(885,10,30,20);

        labelCarCountWater = new JLabel("Жидкие: ");
        txtCarCountWater= new JTextField(25);
        labelCarCountWaterMax = new JLabel(" из ");
        txtCarCountWaterMax= new JTextField(25);

        labelCarCountWater.setBounds(710,35,100,20);
        txtCarCountWater.setBounds(815,35,30,20);
        labelCarCountWaterMax.setBounds(850,35,30,20);
        txtCarCountWaterMax.setBounds(885,35,30,20);

        labelCarCountFast = new JLabel("Быстро порт.: ");
        txtCarCountFast= new JTextField(25);
        labelCarCountFastMax = new JLabel(" из ");
        txtCarCountFastMax= new JTextField(25);

        labelCarCountFast.setBounds(710,65,100,20);
        txtCarCountFast.setBounds(815,65,30,20);
        labelCarCountFastMax.setBounds(850,65,30,20);
        txtCarCountFastMax.setBounds(885,65,30,20);

        carSand.setBounds(WIDTH / 2 + 100, 100, 100, 100);
        carWater.setBounds(WIDTH / 2 + 100, 250, 100, 100);
        carFast.setBounds(WIDTH / 2 + 100, 400, 100, 100);
        sostav.setBounds(WIDTH / 2 - 500, 250, 400, 100);
        sklad.setBounds(WIDTH / 2 - 100, 150, 200, 300);

        carSand.setVisible(false);
        carWater.setVisible(false);
        carFast.setVisible(false);
        sostav.setVisible(false);
        sklad.setVisible(false);


        buttonPanel.add(carSand);
        buttonPanel.add(carWater);
        buttonPanel.add(carFast);
        buttonPanel.add(sklad);
        buttonPanel.add(sostav);

        buttonPanel.add(labelTrainCountSand);
        buttonPanel.add(txtTrainCountSand);
        buttonPanel.add(labelTrainCountSandMax);
        buttonPanel.add(txtTrainCountSandMax);

        buttonPanel.add(labelTrainCountWater);
        buttonPanel.add(txtTrainCountWater);
        buttonPanel.add(labelTrainCountWaterMax);
        buttonPanel.add(txtTrainCountWaterMax);

        buttonPanel.add(labelTrainCountFast);
        buttonPanel.add(txtTrainCountFast);
        buttonPanel.add(labelTrainCountFastMax);
        buttonPanel.add(txtTrainCountFastMax);


        buttonPanel.add(labelSkladCountSand);
        buttonPanel.add(txtSkladCountSand);
        buttonPanel.add(labelSkladCountSandMax);
        buttonPanel.add(txtSkladCountSandMax);

        buttonPanel.add(labelSkladCountWater);
        buttonPanel.add(txtSkladCountWater);
        buttonPanel.add(labelSkladCountWaterMax);
        buttonPanel.add(txtSkladCountWaterMax);

        buttonPanel.add(labelSkladCountFast);
        buttonPanel.add(txtSkladCountFast);
        buttonPanel.add(labelSkladCountFastMax);
        buttonPanel.add(txtSkladCountFastMax);

        buttonPanel.add(labelCarCountSand);
        buttonPanel.add(txtCarCountSand);
        buttonPanel.add(labelCarCountSandMax);
        buttonPanel.add(txtCarCountSandMax);

        buttonPanel.add(labelCarCountWater);
        buttonPanel.add(txtCarCountWater);
        buttonPanel.add(labelCarCountWaterMax);
        buttonPanel.add(txtCarCountWaterMax);

        buttonPanel.add(labelCarCountFast);
        buttonPanel.add(txtCarCountFast);
        buttonPanel.add(labelCarCountFastMax);
        buttonPanel.add(txtCarCountFastMax);

        add(buttonPanel);

        TrainIsFull=false;
        CarSandIsEmpty=false;
        CarWaterIsEmpty=false;
        CarFastIsEmpty=false;
    }

    public void start (){
        sostav.setText("Я ПОЕЗД");
        sklad.setText("СКЛАД");
        sklad.setVisible(true);
        sostav.setVisible(false);
        carSand.setVisible(false);
        carWater.setVisible(false);

        Thread loader1 = new Loader1();
        loader1.start();

        Thread loader2 = new Loader2();
        loader2.start();

        Thread loader3 = new Loader3();
        loader3.start();

        Thread unloader = new Unloader();
        unloader.start();

    }

    public void trainIn(){
        sostav.setVisible(true);
        for(int i = 0; i < 501; i++) {
            //Thread.sleep(new Random().nextInt(400));
            sostav.setBounds(WIDTH / 2 - (1000-i), 250, 400, 100);
        }
        //Thread.sleep(new Random().nextInt(400));
        //myDelay();
        sostav.setText("I'm TRAIN! HELLO!");
        for (int k=0;k<5;k++) {
            for (int i = 0; i < 51; i++) {
                //Thread.sleep(new Random().nextInt(10));
               // myDelay();
                sostav.setBounds(WIDTH / 2 - 500, 250, 400-i, 100);
            }
            for (int i = 0; i < 51; i++) {
                //Thread.sleep(new Random().nextInt(10));
               // myDelay();
                sostav.setBounds(WIDTH / 2 - 500, 250, 350+i, 100);
            }
        }

        iCountVagonSand = new Random().nextInt(4);
        iCountVagonWater = new Random().nextInt(4);
        iCountVagonFast = new Random().nextInt(4);

        // сколько в поезд влезет
        iTrainCountSandMax=iCountVagonSand*VAGON_SAND_WEIGHT;
        iTrainCountWaterMax=iCountVagonWater*VAGON_WATER_VOLUME;
        iTrainCountFastMax=iCountVagonFast*VAGON_FAST_WEIGHT;

        // сколько в поезд загружено на данный момент
        iTrainCountSand=0;
        iTrainCountWater=0;
        iTrainCountFast=0;

        txtTrainCountSandMax.setText(Integer.toString(iTrainCountSandMax));
        txtTrainCountWaterMax.setText(Integer.toString(iTrainCountWaterMax));
        txtTrainCountFastMax.setText(Integer.toString(iTrainCountFastMax));

        txtTrainCountSand.setText(Integer.toString(iTrainCountSand));
        txtTrainCountWater.setText(Integer.toString(iTrainCountWater));
        txtTrainCountFast.setText(Integer.toString(iTrainCountFast));

    }

    public void trainOut(){
        for(int i = 0; i < 501; i++) {
            //Thread.sleep(new Random().nextInt(20));
            sostav.setBounds(WIDTH / 2 - (500 + i), 250, 400, 100);
        }
    }


    public void carSandIn(){
        carSand.setVisible(true);
        iCarCountSand=CAR_SAND_WEIGHT;
        txtCarCountSandMax.setText(Integer.toString(CAR_SAND_WEIGHT));
        txtCarCountSand.setText(Integer.toString(iCarCountSand));
    }

    public void carWaterIn(){
        carWater.setVisible(true);
        iCarCountWater=CAR_WATER_VOLUME;
        txtCarCountWaterMax.setText(Integer.toString(CAR_WATER_VOLUME));
        txtCarCountWater.setText(Integer.toString(iCarCountWater));
    }

    public void carFastIn(){
        carFast.setVisible(true);
        iCarCountFast=CAR_FAST_WEIGHT;
        txtCarCountFastMax.setText(Integer.toString(CAR_FAST_WEIGHT));
        txtCarCountFast.setText(Integer.toString(iCarCountFast));
    }

    public void carSandOut(){
        carSand.setVisible(false);
    }

    public void carWaterOut(){
        carWater.setVisible(false);
    }

    public void carFastOut(){
        carFast.setVisible(false);
    }


    public class Sand {
        private int number;

        public Sand(int number)
        {
            super();
            this.number = number;
        }

        public int getNumber()
        {
            return number;
        }
    }

    public class Water{
        private int number;

        public Water(int number)
        {
            super();
            this.number = number;
        }

        public int getNumber()
        {
            return number;
        }
    }

    public class Fast {
        private int number;

        public Fast(int number)
        {
            super();
            this.number = number;
        }

        public int getNumber()
        {
            return number;
        }
    }



    public class Unloader extends Thread {
        public void run()
        {
            try
            {
                while (true)      //бесконечный цикл
                {
                  trainIn();
                  TrainIsFull = false;

                  while (!TrainIsFull)      //Пока поезд не загружен полностью
                  {
                      // загружаем сыпучий товар в поезд
                      if (iTrainCountSand < iTrainCountSandMax)
                      {
                        Sand sand;
                        sand = sandContain.poll();
                        if (sand != null)
                        {
                          iTrainCountSand++;
                          iSkladCountSand--;
                        }
                        txtTrainCountSand.setText(Integer.toString(iTrainCountSand));
                        txtSkladCountSand.setText(Integer.toString(iSkladCountSand));
                      }

                      // загружаем жидкий товар в поезд
                      if (iTrainCountWater < iTrainCountWaterMax)
                      {
                          Water water;
                          water = waterContain.poll();
                          if (water != null)
                          {
                              iTrainCountWater++;
                              iSkladCountWater--;
                          }
                          txtTrainCountWater.setText(Integer.toString(iTrainCountWater));
                          txtSkladCountWater.setText(Integer.toString(iSkladCountWater));
                      }

                      // загружаем быстропортящийся товар в поезд
                      if (iTrainCountFast < iTrainCountFastMax)
                      {
                          Fast fast;
                          fast = fastContain.poll();
                          if (fast != null)
                          {
                              iTrainCountFast++;
                              iSkladCountFast--;
                          }
                          txtTrainCountFast.setText(Integer.toString(iTrainCountFast));
                          txtSkladCountFast.setText(Integer.toString(iSkladCountFast));
                      }

                      Thread.sleep(200);

                      if ((iTrainCountSand == iTrainCountSandMax) &&(iTrainCountWater == iTrainCountWaterMax)
                              &&(iTrainCountFast == iTrainCountFastMax)) {TrainIsFull=true;}

                  }
                  trainOut();
                  Thread.sleep(2000);
                }
            } catch (InterruptedException e) {

            }
            System.out.println("Разгрузка товаров окончена");
        }
    }

    public class Loader1 extends Thread {
        public void run()
        {
            try
            {
                // Зацикливаем загрузку склада с машин
                while (true)
                {
                    if(iCarCountSand==0)
                    {
                        carSandOut();
                        Thread.sleep(2000);
                        carSandIn();
                    }
                    else
                    {
                        Sand sand = new Sand(iSkladCountSand+1);
                        sandContain.put(sand);
                        iSkladCountSand++;
                        iCarCountSand--;
                        txtSkladCountSand.setText(Integer.toString(iSkladCountSand));
                        txtCarCountSand.setText(Integer.toString(iCarCountSand));
                        Thread.sleep(250);
                    }
                }
            }
            catch (Exception e) {

            }

        }
    }

    public class Loader2 extends Thread {
        public void run()
        {
            try
            {
                // Зацикливаем загрузку склада с машин
                while (true)
                {
                    if(iCarCountWater==0)
                    {
                        carWaterOut();
                        Thread.sleep(2000);
                        carWaterIn();
                    }
                    else
                    {
                        Water water = new Water(iSkladCountWater+1);
                        waterContain.put(water);
                        iSkladCountWater++;
                        iCarCountWater--;
                        txtSkladCountWater.setText(Integer.toString(iSkladCountWater));
                        txtCarCountWater.setText(Integer.toString(iCarCountWater));
                        Thread.sleep(200);
                    }

                }
            }
            catch (Exception e) {

            }

        }
    }

    public class Loader3 extends Thread {
        public void run()
        {
            try
            {
                // Зацикливаем загрузку склада с машин
                while (true)
                {
                    if(iCarCountFast==0)
                    {
                        carFastOut();
                        Thread.sleep(2000);
                        carFastIn();
                    }
                    else
                    {
                        Fast fast = new Fast(iSkladCountFast+1);
                        fastContain.put(fast);
                        iSkladCountFast++;
                        iCarCountFast--;
                        txtSkladCountFast.setText(Integer.toString(iSkladCountFast));
                        txtCarCountFast.setText(Integer.toString(iCarCountFast));
                        Thread.sleep(300);
                    }

                }
            }
            catch (Exception e) {

            }

        }
    }
}